func ProcessExternal(page *gostatic.Page, args []string) error {
if len(args) < 1 {
return errors.New("'external' rule needs a command name")
}
cmdName := args[0]
cmdArgs := args[1:]
path, err := exec.LookPath(cmdName)
if err != nil {
path, err = exec.LookPath(filepath.Join(page.Site.Base, cmdName))
if err != nil {
return fmt.Errorf("command '%s' not found", cmdName)
}
}
cmd := exec.Command(path, cmdArgs...)
cmd.Stdin = strings.NewReader(page.Content())
cmd.Dir = page.Site.Base
var stderr bytes.Buffer
cmd.Stderr = &stderr
data, err := cmd.Output()
if err != nil {
return fmt.Errorf("'%s' failed: %s\n%s",
strings.Join(args, " "), err, stderr.String())
}
page.SetContent(string(data))
return nil
}
func ProcessInnerTemplate(page *gostatic.Page, args []string) error {
//todo catch
defer func() {
if err := recover(); err != nil {
//return fmt.Sprintf("%s: %s", page.Source, err)
}
}()
t, err := page.Site.Template.Clone()
if err != nil {
return err
}
t, err = t.New("ad-hoc").Parse(page.Content())
if err != nil {
return errors.New(fmt.Sprintf("Page %s: %s", page.Source, err))
}
var buffer bytes.Buffer
err = t.ExecuteTemplate(&buffer, "ad-hoc", page)
if err != nil {
return errors.New(fmt.Sprintf("Page %s: %s", page.Source, err))
}
page.SetContent(buffer.String())
return nil
}
func ProcessExt(page *gostatic.Page, args []string) error {
if len(args) < 1 {
return errors.New(
"'ext' rule requires an extension prefixed with dot")
}
newExt := args[0]
ext := filepath.Ext(page.Path)
if ext == "" {
page.Path = page.Path + newExt
} else {
page.Path = page.Path[0:len(page.Path)-len(ext)] + newExt
}
return nil
}
func ProcessTemplate(page *gostatic.Page, args []string) error {
if len(args) < 1 {
return errors.New("'template' rule needs an argument")
}
pagetype := args[0]
//todo catch thiss
defer func() {
if err := recover(); err != nil {
//return err //errors.New(fmt.Sprintf("%s: %s", page.Source, err))
}
}()
var buffer bytes.Buffer
err := page.Site.Template.ExecuteTemplate(&buffer, pagetype, page)
if err != nil {
return errors.New(fmt.Sprintf("%s: %s", page.Source, err))
}
page.SetContent(buffer.String())
return nil
}
// Runs some checks against the parsed page.
func checkPage(t *testing.T, pageText string, page *gostatic.Page) {
if page.Content() != pageText {
t.Errorf("expected '%s', got '%s'", pageText, page.Content())
}
if len(page.PageHeader.Other) != 2 {
t.Errorf("expected length of 2, got '%d'", len(page.PageHeader.Other))
}
// Note: gostatic lib capitalizes the properties for some reason. So it
// converted 'salve' to 'Salve' etc.
salve := page.PageHeader.Other["Salve"]
if salve != "hello" {
t.Errorf("expected 'hello', got '%s'", salve)
}
munde := page.PageHeader.Other["Munde"]
if munde != "world" {
t.Errorf("expected 'world', got '%s'", munde)
}
}
func ProcessRelativize(page *gostatic.Page, args []string) error {
repl := `$1="` + page.Rel("/") + `$2"`
rv := RelRe.ReplaceAllStringFunc(page.Content(), func(inp string) string {
if NonProtoRe.MatchString(inp) {
return inp
}
return RelRe.ReplaceAllString(inp, repl)
})
page.SetContent(rv)
return nil
}
func ProcessConfig(page *gostatic.Page, args []string) error {
parts := gostatic.TrimSplitN(page.Content(), "\n----\n", 2)
if len(parts) != 2 {
// no configuration, well then...
page.PageHeader = *gostatic.NewPageHeader()
return nil
}
page.PageHeader = *gostatic.ParseHeader(parts[0])
page.SetContent(parts[1])
return nil
}
func ProcessMarkdown(page *gostatic.Page, args []string) error {
result := Markdown(page.Content())
page.SetContent(result)
return nil
}
func ProcessDirectorify(page *gostatic.Page, args []string) error {
if filepath.Base(page.Path) != "index.html" {
page.Path = strings.Replace(page.Path, ".html", "/index.html", 1)
}
return nil
}
func ProcessIgnore(page *gostatic.Page, args []string) error {
page.SetState(gostatic.StateIgnored)
return nil
}