func (i *include) Initialize(ctx goldsmith.Context) error {
var paths []string
err := filepath.Walk(i.src, func(path string, info os.FileInfo, err error) error {
if err == nil && !info.IsDir() {
paths = append(paths, path)
}
return err
})
if err != nil {
return err
}
for _, path := range paths {
srcRelPath, err := filepath.Rel(i.src, path)
if err != nil {
panic(err)
}
dstRelPath := filepath.Join(i.dst, srcRelPath)
f, err := goldsmith.NewFileFromAsset(dstRelPath, path)
if err != nil {
return err
}
ctx.DispatchFile(f)
}
return nil
}
func (*minify) Process(ctx goldsmith.Context, f goldsmith.File) error {
var (
buff bytes.Buffer
err error
)
switch m := min.New(); filepath.Ext(f.Path()) {
case ".css":
err = css.Minify(m, &buff, f, nil)
case ".html", ".htm":
err = html.Minify(m, &buff, f, nil)
case ".js":
err = js.Minify(m, &buff, f, nil)
case ".json":
err = json.Minify(m, &buff, f, nil)
case ".svg":
err = svg.Minify(m, &buff, f, nil)
case ".xml":
err = xml.Minify(m, &buff, f, nil)
}
if err != nil {
return err
}
nf := goldsmith.NewFileFromData(f.Path(), buff.Bytes())
nf.CopyValues(f)
ctx.DispatchFile(nf)
return nil
}
func (t *breadcrumbs) Finalize(ctx goldsmith.Context) error {
for _, n := range t.allNodes {
if len(n.parentName) == 0 {
continue
}
if parent, ok := t.namedNodes[n.parentName]; ok {
parent.Children = append(parent.Children, n)
n.Parent = parent
} else {
return fmt.Errorf("undefined parent: %s", n.parentName)
}
}
for _, n := range t.allNodes {
var ancestors []*bcNode
for c := n.Parent; c != nil; c = c.Parent {
ancestors = append([]*bcNode{c}, ancestors...)
}
n.File.SetValue(t.crumbsKey, bcInfo{ancestors, n})
ctx.DispatchFile(n.File)
}
return nil
}
func (c *collection) Finalize(ctx goldsmith.Context) error {
for _, files := range c.groups {
fg := &fileGroup{files, c.comp}
sort.Sort(fg)
}
for _, f := range c.files {
ctx.DispatchFile(f)
}
return nil
}
func cached(ctx goldsmith.Context, srcPath, dstPath string) bool {
srcPathFull := filepath.Join(ctx.SrcDir(), srcPath)
srcStat, err := os.Stat(srcPathFull)
if err != nil {
return false
}
dstPathFull := filepath.Join(ctx.DstDir(), dstPath)
dstStat, err := os.Stat(dstPathFull)
if err != nil {
return false
}
return dstStat.ModTime().Unix() >= srcStat.ModTime().Unix()
}
func (*frontmatter) Process(ctx goldsmith.Context, f goldsmith.File) error {
meta, body, err := fm.Parse(f)
if err != nil {
return err
}
nf := goldsmith.NewFileFromData(f.Path(), body.Bytes())
nf.CopyValues(f)
for name, value := range meta {
nf.SetValue(name, value)
}
ctx.DispatchFile(nf)
return nil
}
func (t *tags) Finalize(ctx goldsmith.Context) error {
for _, meta := range t.info {
sort.Sort(meta.Files)
}
if t.indexMeta != nil {
for _, f := range t.buildPages(ctx, t.info) {
ctx.DispatchFile(f)
}
}
for _, f := range t.files {
ctx.DispatchFile(f)
}
return nil
}
func (l *livejs) Process(ctx goldsmith.Context, f goldsmith.File) error {
doc, err := goquery.NewDocumentFromReader(f)
if err != nil {
return err
}
doc.Find("body").AppendHtml(l.js)
html, err := doc.Html()
if err != nil {
return err
}
nf := goldsmith.NewFileFromData(f.Path(), []byte(html))
ctx.DispatchFile(nf)
return nil
}
func (idx *index) Finalize(ctx goldsmith.Context) error {
for name, summary := range idx.dirs {
sort.Sort(summary.entries)
f := summary.index
if f == nil {
f = goldsmith.NewFileFromData(path.Join(name, idx.filename), make([]byte, 0))
for name, value := range idx.meta {
f.SetValue(name, value)
}
}
f.SetValue(idx.filesKey, summary.entries)
ctx.DispatchFile(f)
}
return nil
}
func (lay *layout) Process(ctx goldsmith.Context, f goldsmith.File) error {
var buff bytes.Buffer
if _, err := buff.ReadFrom(f); err != nil {
return err
}
if _, ok := f.Value(lay.layoutKey); ok {
f.SetValue(lay.contentKey, template.HTML(buff.Bytes()))
lay.filesMtx.Lock()
lay.files = append(lay.files, f)
lay.filesMtx.Unlock()
} else {
ctx.DispatchFile(f)
}
return nil
}
func (idx *index) Process(ctx goldsmith.Context, f goldsmith.File) error {
idx.dirsMtx.Lock()
defer idx.dirsMtx.Unlock()
curr := f.Path()
leaf := true
for {
if handled, _ := idx.handled[curr]; handled {
break
}
idx.handled[curr] = true
dir := path.Dir(curr)
base := path.Base(curr)
summary, ok := idx.dirs[dir]
if !ok {
summary = new(dirSummary)
idx.dirs[dir] = summary
}
if leaf {
if base == idx.filename {
summary.index = f
} else {
ctx.DispatchFile(f)
}
}
entry := DirEntry{Name: base, Path: curr, IsDir: !leaf, File: f}
summary.entries = append(summary.entries, entry)
if dir == "." {
break
}
curr = dir
leaf = false
}
return nil
}
func (m *markdown) Process(ctx goldsmith.Context, f goldsmith.File) error {
var buff bytes.Buffer
if _, err := buff.ReadFrom(f); err != nil {
return err
}
var data []byte
switch m.mdType {
case mdCommon:
data = blackfriday.MarkdownCommon(buff.Bytes())
case mdBasic:
data = blackfriday.MarkdownBasic(buff.Bytes())
}
name := strings.TrimSuffix(f.Path(), path.Ext(f.Path())) + ".html"
nf := goldsmith.NewFileFromData(name, data)
nf.CopyValues(f)
ctx.DispatchFile(nf)
return nil
}
func (t *thumbnail) Process(ctx goldsmith.Context, f goldsmith.File) error {
defer ctx.DispatchFile(f)
thumbPath, create := t.thumbName(f.Path())
if !create {
return nil
}
var (
fn goldsmith.File
err error
)
if cached(ctx, f.Path(), thumbPath) {
thumbPathDst := filepath.Join(ctx.DstDir(), thumbPath)
fn, err = goldsmith.NewFileFromAsset(thumbPath, thumbPathDst)
if err != nil {
return err
}
} else {
var err error
fn, err = t.thumbnail(f, thumbPath)
if err != nil {
return err
}
}
ctx.DispatchFile(fn)
return nil
}
func (lay *layout) Finalize(ctx goldsmith.Context) error {
for _, f := range lay.files {
name, ok := f.Value(lay.layoutKey)
if !ok {
ctx.DispatchFile(f)
continue
}
nameStr, ok := name.(string)
if !ok {
ctx.DispatchFile(f)
continue
}
var buff bytes.Buffer
if err := lay.tmpl.ExecuteTemplate(&buff, nameStr, f); err != nil {
return err
}
nf := goldsmith.NewFileFromData(f.Path(), buff.Bytes())
nf.CopyValues(f)
ctx.DispatchFile(nf)
}
return nil
}
func (a *abs) Process(ctx goldsmith.Context, f goldsmith.File) error {
doc, err := goquery.NewDocumentFromReader(f)
if err != nil {
return err
}
for _, attr := range a.attrs {
path := fmt.Sprintf("*[%s]", attr)
doc.Find(path).Each(func(index int, sel *goquery.Selection) {
baseUrl, err := url.Parse(f.Path())
val, _ := sel.Attr(attr)
currUrl, err := url.Parse(val)
if err != nil || currUrl.IsAbs() {
return
}
currUrl = baseUrl.ResolveReference(currUrl)
if a.baseUrl != nil {
currUrl = a.baseUrl.ResolveReference(currUrl)
}
sel.SetAttr(attr, currUrl.String())
})
}
html, err := doc.Html()
if err != nil {
return err
}
nf := goldsmith.NewFileFromData(f.Path(), []byte(html))
nf.CopyValues(f)
ctx.DispatchFile(nf)
return nil
}