/
processed_asset.go
148 lines (131 loc) · 3.53 KB
/
processed_asset.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
package paste
import "bufio"
import "io"
import "io/ioutil"
import "os"
import "path"
import "path/filepath"
import "regexp"
import "strings"
import "time"
type processedAsset struct {
static *staticAsset
dependencies []Asset
digest string
mtime time.Time
pathname string
}
var jsRequires = regexp.MustCompile(`^//=\s*require\s+(\S+)`)
func (s *processedAsset) Digest() string { return s.digest }
func (s *processedAsset) Pathname() string { return s.pathname }
func (s *processedAsset) ModTime() time.Time { return s.mtime }
func (s *processedAsset) LogicalName() string { return s.static.logical }
func (s *processedAsset) Stale() bool {
if s.static.Stale() { return true }
for _, d := range s.dependencies {
if d.Stale() {
return true
}
}
return false
}
func newProcessed(s *fileServer, logical, path string) (Asset, error) {
static, err := newStatic(s, logical, path)
if err != nil {
return nil, err
}
asset := &processedAsset{static: static, dependencies: make([]Asset, 0)}
/* Process and compress the asset */
processor, ok := processors[filepath.Ext(asset.static.pathname)]
src := asset.static.pathname
if ok {
dst, err := ioutil.TempFile("", "paste")
if err == nil {
dst.Close()
err = processor.Process(src, dst.Name())
src = dst.Name()
defer os.Remove(src)
}
if err != nil { return nil, err }
}
paths, err := asset.requiredPaths(jsRequires)
if err != nil {
return nil, err
}
/* collect the digests and mtimes into the processed version */
digest := asset.static.digest
asset.mtime = asset.static.mtime
for _, dep := range paths {
d, err := s.Asset(dep)
if err != nil {
return nil, err
}
asset.dependencies = append(asset.dependencies, d)
digest += d.Digest()
if d.ModTime().After(asset.mtime) {
asset.mtime = d.ModTime()
}
}
asset.digest = hexdigestString(s, digest)
/* Concatenate all assets into a temp file */
compiled := filepath.Join(s.config.TempDir, asset.digest)
compiled += filepath.Ext(logical)
os.MkdirAll(filepath.Dir(compiled), 0755)
file, err := os.Create(compiled)
if err != nil {
return nil, err
}
asset.pathname = file.Name()
for _, dep := range asset.dependencies {
copyFile(file, dep.Pathname())
file.Write([]byte{'\n'})
}
copyFile(file, src)
file.Close()
compressor, ok := compressors[filepath.Ext(asset.static.logical)]
if ok && s.config.Compressed {
dst, err := ioutil.TempFile("", "paste")
if err == nil {
dst.Close()
err = compressor.Process(compiled, dst.Name())
if err == nil {
os.Rename(dst.Name(), compiled)
}
}
if err != nil { return nil, err }
}
return asset, nil
}
func (s *processedAsset) requiredPaths(rx *regexp.Regexp) ([]string, error) {
f, err := os.Open(s.static.pathname)
if err != nil {
return nil, err
}
defer f.Close()
buf := bufio.NewReader(f)
paths := make([]string, 0)
for {
line, err := buf.ReadString('\n')
if err == io.EOF {
break
} else if err != nil {
return nil, err
}
if strings.TrimSpace(line) != "" && !strings.HasPrefix(line, "//") { break }
matches := rx.FindStringSubmatch(line)
if len(matches) > 1 {
match := matches[1]
if path.Ext(match) == "" {
match += path.Ext(s.static.logical)
}
paths = append(paths, match)
}
}
return paths, nil
}
func copyFile(w io.Writer, path string) {
f, err := os.Open(path)
if err != nil { panic(err) }
io.Copy(w, f)
f.Close()
}