|
0
|
1 package main
|
|
|
2
|
|
|
3 import (
|
|
|
4 "bytes"
|
|
|
5 "fmt"
|
|
|
6 "io"
|
|
|
7 "io/ioutil"
|
|
|
8 "log"
|
|
|
9 "os"
|
|
|
10 "os/exec"
|
|
|
11 "path"
|
|
|
12 "path/filepath"
|
|
|
13 "strings"
|
|
|
14 "time"
|
|
|
15
|
|
|
16 "github.com/russross/blackfriday"
|
|
|
17 )
|
|
|
18
|
|
|
19 const (
|
|
|
20 ZSDIR = ".zs"
|
|
|
21 PUBDIR = ".pub"
|
|
|
22 )
|
|
|
23
|
|
|
24 func split2(s, delim string) (string, string) {
|
|
|
25 parts := strings.SplitN(s, delim, 2)
|
|
|
26 if len(parts) == 2 {
|
|
|
27 return parts[0], parts[1]
|
|
|
28 } else {
|
|
|
29 return parts[0], ""
|
|
|
30 }
|
|
|
31 }
|
|
|
32
|
|
|
33 func md(s string) (map[string]string, string) {
|
|
|
34 v := map[string]string{}
|
|
2
|
35 if strings.Index(s, "\n\n") == -1 {
|
|
|
36 return map[string]string{}, s
|
|
|
37 }
|
|
0
|
38 header, body := split2(s, "\n\n")
|
|
|
39 for _, line := range strings.Split(header, "\n") {
|
|
|
40 key, value := split2(line, ":")
|
|
|
41 v[strings.ToLower(strings.TrimSpace(key))] = strings.TrimSpace(value)
|
|
|
42 }
|
|
|
43 return v, body
|
|
|
44 }
|
|
|
45
|
|
|
46 type EvalFn func(args []string, vars map[string]string) (string, error)
|
|
|
47
|
|
|
48 func render(s string, vars map[string]string, eval EvalFn) (string, error) {
|
|
|
49 b := []byte(s)
|
|
|
50 delim_open := []byte("{{")
|
|
|
51 delim_close := []byte("}}")
|
|
|
52
|
|
|
53 out := bytes.NewBuffer(nil)
|
|
|
54 for {
|
|
|
55 if from := bytes.Index(b, delim_open); from == -1 {
|
|
|
56 out.Write(b)
|
|
|
57 return out.String(), nil
|
|
|
58 } else {
|
|
|
59 to := bytes.Index(b, delim_close)
|
|
|
60 if to == -1 {
|
|
|
61 return "", fmt.Errorf("Close delim not found")
|
|
|
62 } else {
|
|
|
63 out.Write(b[:from])
|
|
|
64 cmd := b[from+len(delim_open) : to]
|
|
|
65 b = b[to+len(delim_close):]
|
|
|
66 m := strings.Fields(string(cmd))
|
|
|
67 if len(m) == 1 {
|
|
|
68 if v, ok := vars[m[0]]; ok {
|
|
|
69 out.Write([]byte(v))
|
|
|
70 continue
|
|
|
71 }
|
|
|
72 }
|
|
|
73 if res, err := eval(m, vars); err == nil {
|
|
|
74 out.Write([]byte(res))
|
|
|
75 } else {
|
|
|
76 log.Println(err) // silent
|
|
|
77 }
|
|
|
78 }
|
|
|
79 }
|
|
|
80 }
|
|
|
81 }
|
|
|
82
|
|
|
83 func eval(cmd []string, vars map[string]string) (string, error) {
|
|
|
84 var outbuf, errbuf bytes.Buffer
|
|
|
85 c := exec.Command(path.Join(ZSDIR, cmd[0]), cmd[1:]...)
|
|
|
86 env := []string{"ZS=" + os.Args[0]}
|
|
|
87 for k, v := range vars {
|
|
|
88 env = append(env, "ZS_"+strings.ToUpper(k)+"="+v)
|
|
|
89 }
|
|
|
90 c.Env = append(c.Env, env...)
|
|
|
91 c.Stdout = &outbuf
|
|
|
92 c.Stderr = &errbuf
|
|
|
93 if err := c.Run(); err != nil {
|
|
|
94 log.Println(err)
|
|
|
95 c := exec.Command(path.Join(cmd[0]), cmd[1:]...)
|
|
|
96 c.Env = append(c.Env, env...)
|
|
|
97 c.Stdout = &outbuf
|
|
|
98 c.Stderr = &errbuf
|
|
|
99 if err := c.Run(); err != nil {
|
|
|
100 return "", err
|
|
|
101 }
|
|
|
102 }
|
|
|
103 if errbuf.Len() > 0 {
|
|
|
104 log.Println(errbuf.String())
|
|
|
105 }
|
|
|
106 return outbuf.String(), nil
|
|
|
107 }
|
|
|
108
|
|
|
109 func buildMarkdown(path string) error {
|
|
|
110 b, err := ioutil.ReadFile(path)
|
|
|
111 if err != nil {
|
|
|
112 return err
|
|
|
113 }
|
|
|
114 v, body := md(string(b))
|
|
|
115 defaultVars(v, path)
|
|
|
116 content, err := render(body, v, eval)
|
|
|
117 if err != nil {
|
|
|
118 return err
|
|
|
119 }
|
|
|
120 v["content"] = string(blackfriday.MarkdownBasic([]byte(content)))
|
|
|
121 b, err = ioutil.ReadFile(filepath.Join(ZSDIR, v["layout"]))
|
|
|
122 if err != nil {
|
|
|
123 return err
|
|
|
124 }
|
|
|
125 content, err = render(string(b), v, eval)
|
|
|
126 if err != nil {
|
|
|
127 return err
|
|
|
128 }
|
|
|
129 err = ioutil.WriteFile(v["output"], []byte(content), 0666)
|
|
|
130 if err != nil {
|
|
|
131 return err
|
|
|
132 }
|
|
|
133 return nil
|
|
|
134 }
|
|
|
135
|
|
|
136 func defaultVars(vars map[string]string, path string) {
|
|
|
137 if _, ok := vars["file"]; !ok {
|
|
|
138 vars["file"] = path
|
|
|
139 }
|
|
|
140 if _, ok := vars["url"]; !ok {
|
|
|
141 vars["url"] = path[:len(path)-len(filepath.Ext(path))] + ".html"
|
|
|
142 if strings.HasPrefix(vars["url"], "./") {
|
|
|
143 vars["url"] = vars["url"][2:]
|
|
|
144 }
|
|
|
145 }
|
|
|
146 if _, ok := vars["outdir"]; !ok {
|
|
|
147 vars["outdir"] = PUBDIR
|
|
|
148 }
|
|
|
149 if _, ok := vars["output"]; !ok {
|
|
|
150 vars["output"] = filepath.Join(PUBDIR, vars["url"])
|
|
|
151 }
|
|
|
152 if _, ok := vars["layout"]; !ok {
|
|
|
153 vars["layout"] = "index.html"
|
|
|
154 }
|
|
|
155 }
|
|
|
156
|
|
|
157 func copyFile(path string) error {
|
|
|
158 if in, err := os.Open(path); err != nil {
|
|
|
159 return err
|
|
|
160 } else {
|
|
|
161 defer in.Close()
|
|
|
162 if stat, err := in.Stat(); err != nil {
|
|
|
163 return err
|
|
|
164 } else {
|
|
|
165 // Directory?
|
|
|
166 if stat.Mode().IsDir() {
|
|
|
167 os.Mkdir(filepath.Join(PUBDIR, path), 0755)
|
|
|
168 return nil
|
|
|
169 }
|
|
|
170 if !stat.Mode().IsRegular() {
|
|
|
171 return nil
|
|
|
172 }
|
|
|
173 }
|
|
|
174 if out, err := os.Create(filepath.Join(PUBDIR, path)); err != nil {
|
|
|
175 return err
|
|
|
176 } else {
|
|
|
177 defer out.Close()
|
|
|
178 _, err = io.Copy(out, in)
|
|
|
179 return err
|
|
|
180 }
|
|
|
181 }
|
|
|
182 }
|
|
|
183
|
|
|
184 func buildAll(once bool) {
|
|
|
185 lastModified := time.Unix(0, 0)
|
|
|
186 for {
|
|
|
187 os.Mkdir(PUBDIR, 0755)
|
|
|
188 err := filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
|
|
|
189 // ignore hidden files and directories
|
|
|
190 if filepath.Base(path)[0] == '.' || strings.HasPrefix(path, ".") {
|
|
|
191 return nil
|
|
|
192 }
|
|
|
193
|
|
|
194 if info.ModTime().After(lastModified) {
|
|
|
195 ext := filepath.Ext(path)
|
|
|
196 if ext == ".md" || ext == "mkd" {
|
|
|
197 log.Println("mkd: ", path)
|
|
|
198 return buildMarkdown(path)
|
|
|
199 } else {
|
|
|
200 log.Println("raw: ", path)
|
|
|
201 return copyFile(path)
|
|
|
202 }
|
|
|
203 }
|
|
|
204 return nil
|
|
|
205 })
|
|
|
206 if err != nil {
|
|
|
207 log.Println("ERROR:", err)
|
|
|
208 }
|
|
|
209 lastModified = time.Now()
|
|
|
210 if once {
|
|
|
211 break
|
|
|
212 }
|
|
|
213 time.Sleep(1 * time.Second)
|
|
|
214 }
|
|
|
215 }
|
|
|
216
|
|
|
217 func main() {
|
|
|
218 if len(os.Args) == 1 {
|
|
|
219 fmt.Println(os.Args[0], "<command> [args]")
|
|
|
220 return
|
|
|
221 }
|
|
|
222 cmd := os.Args[1]
|
|
|
223 args := os.Args[2:]
|
|
|
224 switch cmd {
|
|
|
225 case "build":
|
|
|
226 buildAll(true)
|
|
|
227 case "watch":
|
|
|
228 buildAll(false) // pass duration
|
|
|
229 case "var":
|
|
|
230 if len(args) == 0 {
|
|
|
231 // print error
|
|
|
232 return
|
|
|
233 }
|
|
|
234 if b, err := ioutil.ReadFile(args[0]); err == nil {
|
|
|
235 vars, _ := md(string(b))
|
|
|
236 defaultVars(vars, args[0])
|
|
|
237 if len(args) > 1 {
|
|
|
238 for _, a := range args[1:] {
|
|
|
239 fmt.Println(vars[a])
|
|
|
240 }
|
|
|
241 } else {
|
|
|
242 for k, v := range vars {
|
|
|
243 fmt.Println(k + ":" + v)
|
|
|
244 }
|
|
|
245 }
|
|
|
246 } else {
|
|
|
247 // print error
|
|
|
248 }
|
|
|
249 default:
|
|
|
250 cmd := exec.Command(path.Join(ZSDIR, cmd), args...)
|
|
|
251 cmd.Env = append(cmd.Env, "ZS="+os.Args[0])
|
|
|
252 cmd.Stdout = os.Stdout
|
|
|
253 cmd.Stderr = os.Stderr
|
|
|
254 if err := cmd.Run(); err != nil {
|
|
|
255 log.Println(err)
|
|
|
256 }
|
|
|
257 }
|
|
|
258 }
|
