Example #1
0
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
}
Example #2
0
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
}
Example #3
0
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
}
Example #4
0
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
}
Example #5
0
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()
}
Example #6
0
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
}
Example #7
0
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
}
Example #8
0
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
}
Example #9
0
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
}
Example #10
0
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
}
Example #11
0
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
}
Example #12
0
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
}
Example #13
0
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
}
Example #14
0
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
}
Example #15
0
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
}