source: code/trunk/zs.go@ 35

Last change on this file since 35 was 35, checked in by zaitsev.serge, 10 years ago

added explicit yaml separator, fixed amber compilation sequence
File size: 9.5 KB
RevLine 
[1]1package main
2
3import (
4 "bytes"
5 "fmt"
6 "io"
7 "io/ioutil"
8 "log"
9 "os"
[33]10 "os/exec"
[1]11 "path/filepath"
12 "strings"
[19]13 "text/template"
[1]14 "time"
15
[23]16 "github.com/eknkc/amber"
[1]17 "github.com/russross/blackfriday"
[18]18 "github.com/yosssi/gcss"
[35]19 "gopkg.in/yaml.v2"
[1]20)
21
22const (
23 ZSDIR = ".zs"
24 PUBDIR = ".pub"
25)
26
[18]27type Vars map[string]string
[4]28
[34]29// renameExt renames extension (if any) from oldext to newext
30// If oldext is an empty string - extension is extracted automatically.
31// If path has no extension - new extension is appended
32func renameExt(path, oldext, newext string) string {
33 if oldext == "" {
34 oldext = filepath.Ext(path)
[33]35 }
[34]36 if oldext == "" || strings.HasSuffix(path, oldext) {
37 return strings.TrimSuffix(path, oldext) + newext
[33]38 } else {
39 return path
40 }
41}
42
[34]43// globals returns list of global OS environment variables that start
44// with ZS_ prefix as Vars, so the values can be used inside templates
[33]45func globals() Vars {
46 vars := Vars{}
47 for _, e := range os.Environ() {
48 pair := strings.Split(e, "=")
49 if strings.HasPrefix(pair[0], "ZS_") {
50 vars[strings.ToLower(pair[0][3:])] = pair[1]
51 }
52 }
53 return vars
54}
55
[34]56// run executes a command or a script. Vars define the command environment,
57// each zs var is converted into OS environemnt variable with ZS_ prefix
58// prepended. Additional variable $ZS contains path to the zs binary. Command
59// stderr is printed to zs stderr, command output is returned as a string.
60func run(vars Vars, cmd string, args ...string) (string, error) {
61 // First check if partial exists (.amber or .html)
62 if b, err := ioutil.ReadFile(filepath.Join(ZSDIR, cmd+".amber")); err == nil {
63 return string(b), nil
64 }
65 if b, err := ioutil.ReadFile(filepath.Join(ZSDIR, cmd+".html")); err == nil {
66 return string(b), nil
67 }
68
69 var errbuf, outbuf bytes.Buffer
70 c := exec.Command(cmd, args...)
[33]71 env := []string{"ZS=" + os.Args[0], "ZS_OUTDIR=" + PUBDIR}
72 env = append(env, os.Environ()...)
[34]73 for k, v := range vars {
74 env = append(env, "ZS_"+strings.ToUpper(k)+"="+v)
[33]75 }
[34]76 c.Env = env
77 c.Stdout = &outbuf
[33]78 c.Stderr = &errbuf
79
80 err := c.Run()
81
82 if errbuf.Len() > 0 {
83 log.Println("ERROR:", errbuf.String())
84 }
85 if err != nil {
[34]86 return "", err
[33]87 }
[34]88 return string(outbuf.Bytes()), nil
[33]89}
90
[34]91// getVars returns list of variables defined in a text file and actual file
92// content following the variables declaration. Header is separated from
93// content by an empty line. Header can be either YAML or JSON.
94// If no empty newline is found - file is treated as content-only.
95func getVars(path string, globals Vars) (Vars, string, error) {
[18]96 b, err := ioutil.ReadFile(path)
97 if err != nil {
98 return nil, "", err
99 }
100 s := string(b)
[34]101
102 // Copy globals first
103 v := Vars{}
[30]104 for name, value := range globals {
105 v[name] = value
106 }
[34]107
108 // Override them by default values extracted from file name/path
[21]109 if _, err := os.Stat(filepath.Join(ZSDIR, "layout.amber")); err == nil {
110 v["layout"] = "layout.amber"
111 } else {
112 v["layout"] = "layout.html"
113 }
[30]114 v["file"] = path
[34]115 v["url"] = path[:len(path)-len(filepath.Ext(path))] + ".html"
116 v["output"] = filepath.Join(PUBDIR, v["url"])
[21]117
[35]118 delim := "\n---\n"
119 if sep := strings.Index(s, delim); sep == -1 {
[20]120 return v, s, nil
[34]121 } else {
122 header := s[:sep]
[35]123 body := s[sep+len(delim):]
124
[34]125 vars := Vars{}
126 if err := yaml.Unmarshal([]byte(header), &vars); err != nil {
127 fmt.Println("ERROR: failed to parse header", err)
[35]128 return nil, "", err
[34]129 } else {
130 for key, value := range vars {
131 v[key] = value
[35]132 log.Println(key, value)
[34]133 }
134 }
135 if strings.HasPrefix(v["url"], "./") {
136 v["url"] = v["url"][2:]
137 }
138 return v, body, nil
[3]139 }
[1]140}
141
[34]142// Render expanding zs plugins and variables
[33]143func render(s string, vars Vars) (string, error) {
[34]144 delim_open := "{{"
145 delim_close := "}}"
146
[19]147 out := &bytes.Buffer{}
[34]148 for {
149 if from := strings.Index(s, delim_open); from == -1 {
150 out.WriteString(s)
151 return out.String(), nil
152 } else {
153 if to := strings.Index(s, delim_close); to == -1 {
154 return "", fmt.Errorf("Close delim not found")
155 } else {
156 out.WriteString(s[:from])
157 cmd := s[from+len(delim_open) : to]
158 s = s[to+len(delim_close):]
159 m := strings.Fields(cmd)
160 if len(m) == 1 {
161 if v, ok := vars[m[0]]; ok {
162 out.WriteString(v)
163 continue
164 }
165 }
166 if res, err := run(vars, m[0], m[1:]...); err == nil {
167 out.WriteString(res)
168 } else {
169 fmt.Println(err)
170 }
171 }
172 }
[19]173 }
[34]174 return s, nil
[1]175}
176
[19]177// Renders markdown with the given layout into html expanding all the macros
[33]178func buildMarkdown(path string, w io.Writer, vars Vars) error {
[34]179 v, body, err := getVars(path, vars)
[1]180 if err != nil {
181 return err
182 }
[33]183 content, err := render(body, v)
[1]184 if err != nil {
185 return err
186 }
[32]187 v["content"] = string(blackfriday.MarkdownCommon([]byte(content)))
[24]188 if w == nil {
189 out, err := os.Create(filepath.Join(PUBDIR, renameExt(path, "", ".html")))
190 if err != nil {
191 return err
192 }
193 defer out.Close()
194 w = out
195 }
[19]196 if strings.HasSuffix(v["layout"], ".amber") {
[33]197 return buildAmber(filepath.Join(ZSDIR, v["layout"]), w, v)
[19]198 } else {
[33]199 return buildHTML(filepath.Join(ZSDIR, v["layout"]), w, v)
[19]200 }
[15]201}
202
[19]203// Renders text file expanding all variable macros inside it
[33]204func buildHTML(path string, w io.Writer, vars Vars) error {
[34]205 v, body, err := getVars(path, vars)
[1]206 if err != nil {
207 return err
208 }
[34]209 if body, err = render(body, v); err != nil {
210 return err
211 }
212 tmpl, err := template.New("").Delims("<%", "%>").Parse(body)
[1]213 if err != nil {
214 return err
215 }
[25]216 if w == nil {
217 f, err := os.Create(filepath.Join(PUBDIR, path))
218 if err != nil {
219 return err
220 }
221 defer f.Close()
222 w = f
[15]223 }
[34]224 return tmpl.Execute(w, vars)
[1]225}
226
[19]227// Renders .amber file into .html
[33]228func buildAmber(path string, w io.Writer, vars Vars) error {
[34]229 v, body, err := getVars(path, vars)
[18]230 if err != nil {
231 return err
232 }
[34]233 a := amber.New()
234 if err := a.Parse(body); err != nil {
[35]235 fmt.Println(body)
[34]236 return err
[25]237 }
238
[18]239 t, err := a.Compile()
240 if err != nil {
241 return err
242 }
[35]243
244 htmlBuf := &bytes.Buffer{}
245 if err := t.Execute(htmlBuf, v); err != nil {
246 return err
247 }
248
249 if body, err = render(string(htmlBuf.Bytes()), v); err != nil {
250 return err
251 }
252
[24]253 if w == nil {
254 f, err := os.Create(filepath.Join(PUBDIR, renameExt(path, ".amber", ".html")))
255 if err != nil {
256 return err
257 }
258 defer f.Close()
259 w = f
[18]260 }
[35]261 _, err = io.WriteString(w, body)
262 return err
[18]263}
264
[19]265// Compiles .gcss into .css
[24]266func buildGCSS(path string, w io.Writer) error {
[19]267 f, err := os.Open(path)
268 if err != nil {
269 return err
270 }
271 defer f.Close()
272
[24]273 if w == nil {
274 s := strings.TrimSuffix(path, ".gcss") + ".css"
275 css, err := os.Create(filepath.Join(PUBDIR, s))
276 if err != nil {
277 return err
[1]278 }
[24]279 defer css.Close()
280 w = css
[1]281 }
[24]282 _, err = gcss.Compile(w, f)
[8]283 return err
[1]284}
285
[24]286// Copies file as is from path to writer
287func buildRaw(path string, w io.Writer) error {
288 in, err := os.Open(path)
289 if err != nil {
290 return err
[19]291 }
[24]292 defer in.Close()
293 if w == nil {
294 if out, err := os.Create(filepath.Join(PUBDIR, path)); err != nil {
295 return err
296 } else {
297 defer out.Close()
298 w = out
[19]299 }
300 }
[24]301 _, err = io.Copy(w, in)
302 return err
[19]303}
304
[33]305func build(path string, w io.Writer, vars Vars) error {
[24]306 ext := filepath.Ext(path)
307 if ext == ".md" || ext == ".mkd" {
[33]308 return buildMarkdown(path, w, vars)
[24]309 } else if ext == ".html" || ext == ".xml" {
[33]310 return buildHTML(path, w, vars)
[24]311 } else if ext == ".amber" {
[33]312 return buildAmber(path, w, vars)
[24]313 } else if ext == ".gcss" {
314 return buildGCSS(path, w)
315 } else {
316 return buildRaw(path, w)
[21]317 }
318}
319
[24]320func buildAll(watch bool) {
[20]321 lastModified := time.Unix(0, 0)
322 modified := false
323
324 vars := globals()
[1]325 for {
326 os.Mkdir(PUBDIR, 0755)
327 err := filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
328 // ignore hidden files and directories
329 if filepath.Base(path)[0] == '.' || strings.HasPrefix(path, ".") {
330 return nil
331 }
[31]332 // inform user about fs walk errors, but continue iteration
333 if err != nil {
334 log.Println("ERROR:", err)
335 return nil
336 }
[1]337
[8]338 if info.IsDir() {
339 os.Mkdir(filepath.Join(PUBDIR, path), 0755)
340 return nil
341 } else if info.ModTime().After(lastModified) {
342 if !modified {
[34]343 // First file in this build cycle is about to be modified
344 run(vars, "prehook")
[8]345 modified = true
346 }
[34]347 log.Println("build:", path)
[33]348 return build(path, nil, vars)
[1]349 }
350 return nil
351 })
352 if err != nil {
353 log.Println("ERROR:", err)
354 }
[8]355 if modified {
[34]356 // At least one file in this build cycle has been modified
357 run(vars, "posthook")
[8]358 modified = false
359 }
[24]360 if !watch {
[1]361 break
362 }
[24]363 lastModified = time.Now()
[1]364 time.Sleep(1 * time.Second)
365 }
366}
367
[34]368func init() {
369 // prepend .zs to $PATH, so plugins will be found before OS commands
370 p := os.Getenv("PATH")
371 p = ZSDIR + ":" + p
372 os.Setenv("PATH", p)
373}
374
[1]375func main() {
376 if len(os.Args) == 1 {
377 fmt.Println(os.Args[0], "<command> [args]")
378 return
379 }
380 cmd := os.Args[1]
381 args := os.Args[2:]
382 switch cmd {
383 case "build":
[25]384 if len(args) == 0 {
385 buildAll(false)
386 } else if len(args) == 1 {
[33]387 if err := build(args[0], os.Stdout, globals()); err != nil {
[25]388 fmt.Println("ERROR: " + err.Error())
389 }
390 } else {
391 fmt.Println("ERROR: too many arguments")
392 }
[24]393 case "watch":
[1]394 buildAll(true)
[24]395 case "var":
[33]396 if len(args) == 0 {
397 fmt.Println("var: filename expected")
398 } else {
399 s := ""
[34]400 if vars, _, err := getVars(args[0], globals()); err != nil {
[33]401 fmt.Println("var: " + err.Error())
402 } else {
403 if len(args) > 1 {
404 for _, a := range args[1:] {
405 s = s + vars[a] + "\n"
406 }
407 } else {
408 for k, v := range vars {
409 s = s + k + ":" + v + "\n"
410 }
411 }
412 }
413 fmt.Println(strings.TrimSpace(s))
414 }
[1]415 default:
[34]416 if s, err := run(globals(), cmd, args...); err != nil {
417 fmt.Println(err)
418 } else {
419 fmt.Println(s)
[1]420 }
421 }
422}
Note: See TracBrowser for help on using the repository browser.