[pandoc] Allow page parameters to override site parameters.

This allows specifying things like this in the page frontmatter:

    ---
    title: Something
    bibliography:
      source: mybibliography.bib
    pandoc:
      filter:
        - make-diagrams.lua
    ...

These options are local to the page. Specifying the same under `markup`
in the site configuration applies those settings to all pages.

Paths (filters, bibliography, citation style) are resolved relative to
the page, site, and the `static` folder.

Author: asankah

Diff for: markup/pandoc/convert.go

@@ -15,17 +15,50 @@
 package pandoc
 
 import (
+	"strings"
+
 	"github.com/cli/safeexec"
 	"github.com/gohugoio/hugo/htesting"
+	"github.com/mitchellh/mapstructure"
 
 	"github.com/gohugoio/hugo/identity"
+	"github.com/gohugoio/hugo/markup/bibliography"
 	"github.com/gohugoio/hugo/markup/internal"
+	"github.com/gohugoio/hugo/markup/pandoc/pandoc_config"
 
 	"github.com/gohugoio/hugo/markup/converter"
 
+	"fmt"
+	"os"
 	"path"
 )
 
+type paramer interface {
+	Param(interface{}) (interface{}, error)
+}
+
+type searchPaths struct {
+	Paths []string
+}
+
+func (s *searchPaths) NormalizePath(in_path string) (string, error) {
+	if path.IsAbs(in_path) {
+		return in_path, nil
+	}
+
+	for _, p := range s.Paths {
+		fp := path.Join(p, in_path)
+		if _, err := os.Stat(fp); err == nil {
+			return fp, nil
+		}
+	}
+	return "", fmt.Errorf("Can't find %s", in_path)
+}
+
+func (s *searchPaths) AsResourcePath() string {
+	return strings.Join(s.Paths, ":")
+}
+
 // Provider is the package entry point.
 var Provider converter.ProviderProvider = provider{}
 
@@ -35,27 +68,27 @@ type provider struct {
 func (p provider) New(cfg converter.ProviderConfig) (converter.Provider, error) {
 	return converter.NewProvider("pandoc", func(ctx converter.DocumentContext) (converter.Converter, error) {
 		return &pandocConverter{
-			ctx: ctx,
-			cfg: cfg,
+			docCtx: ctx,
+			cfg:    cfg,
 		}, nil
 	}), nil
 }
 
 type pandocConverter struct {
-	ctx converter.DocumentContext
-	cfg converter.ProviderConfig
+	docCtx converter.DocumentContext
+	cfg    converter.ProviderConfig
 }
 
 func (c *pandocConverter) Convert(ctx converter.RenderContext) (converter.Result, error) {
-	return converter.Bytes(c.getPandocContent(ctx.Src, c.ctx)), nil
+	return converter.Bytes(c.getPandocContent(ctx.Src)), nil
 }
 
 func (c *pandocConverter) Supports(feature identity.Identity) bool {
 	return false
 }
 
 // getPandocContent calls pandoc as an external helper to convert pandoc markdown to HTML.
-func (c *pandocConverter) getPandocContent(src []byte, ctx converter.DocumentContext) []byte {
+func (c *pandocConverter) getPandocContent(src []byte) []byte {
 	logger := c.cfg.Logger
 	pandoc_path := getPandocExecPath()
 	if pandoc_path == "" {
@@ -64,21 +97,46 @@ func (c *pandocConverter) getPandocContent(src []byte, ctx converter.DocumentCon
 		return src
 	}
 
-	arguments := c.cfg.MarkupConfig.Pandoc.AsPandocArguments()
+	searchPathSet := searchPaths{
+		Paths: []string{path.Dir(c.docCtx.Filename), "static", "."},
+	}
+
+	var pandocConfig pandoc_config.Config = c.cfg.MarkupConfig.Pandoc
+	var bibConfig bibliography.Config = c.cfg.MarkupConfig.Bibliography
+
+	if pageParameters, ok := c.docCtx.Document.(paramer); ok {
+		if bibParam, err := pageParameters.Param("bibliography"); err == nil {
+			mapstructure.WeakDecode(bibParam, &bibConfig)
+		}
+
+		if pandocParam, err := pageParameters.Param("pandoc"); err == nil {
+			mapstructure.WeakDecode(pandocParam, &pandocConfig)
+		}
+	}
 
-	bibliography := c.cfg.MarkupConfig.Bibliography
+	arguments := pandocConfig.AsPandocArguments(&searchPathSet)
 
-	if bibliography.Source != "" {
-		arguments = append(arguments, "--bibliography", bibliography.Source)
+	if bibConfig.Source != "" {
+		sourcePath, err := searchPathSet.NormalizePath(bibConfig.Source)
+		if err != nil {
+			logger.Errorf("Can't find bibliography: %s", bibConfig.Source)
+		} else {
+			arguments = append(arguments, "--bibliography", sourcePath)
+		}
 	}
 
-	if bibliography.CitationStyle != "" {
-		arguments = append(arguments, "--csl", bibliography.CitationStyle)
+	if bibConfig.CitationStyle != "" {
+		citationPath, err := searchPathSet.NormalizePath(bibConfig.CitationStyle)
+		if err != nil {
+			logger.Errorf("Can't find citation style: %s", bibConfig.CitationStyle)
+		} else {
+			arguments = append(arguments, "--csl", citationPath)
+		}
 	}
 
-	arguments = append(arguments, "--resource-path", path.Dir(ctx.Filename))
+	arguments = append(arguments, "--resource-path", searchPathSet.AsResourcePath())
 
-	return internal.ExternallyRenderContent(c.cfg, ctx, src, pandoc_path, arguments)
+	return internal.ExternallyRenderContent(c.cfg, c.docCtx, src, pandoc_path, arguments)
 }
 
 func getPandocExecPath() string {

Diff for: markup/pandoc/pandoc_config/pandoc.go

@@ -35,9 +35,11 @@ type Config struct {
 	// See https://pandoc.org/MANUAL.html#math-rendering-in-html
 	UseKatex bool
 
-	// List of filters to use. These translate to '--filter=' arguments to the
-	// pandoc invocation.  The order of elements in `Filters` is preserved when
-	// constructing the `pandoc` commandline.
+	// List of filters to use. These translate to '--filter=' or '--lua-filter'
+	// arguments to the pandoc invocation.  The order of elements in `Filters`
+	// is preserved when constructing the `pandoc` commandline.
+	//
+	// Use the prefix 'lua:' or the suffix '.lua' to indicate Lua filters.
 	Filters []string
 
 	// List of Pandoc Markdown extensions to use. No need to include default
@@ -109,25 +111,37 @@ func (c *Config) getMathRenderingArg() string {
 	}
 }
 
-func (c *Config) getFilterArgs() []string {
+func (c *Config) getFilterArgs(pathLookup PathNormalizer) []string {
 	var args []string
 	for _, filter := range c.Filters {
-		args = append(args, fmt.Sprintf("--filter=%s", filter))
+		filterPath, err := pathLookup.NormalizePath(filter)
+		if err != nil {
+			continue
+		}
+		if strings.HasPrefix(filterPath, "lua:") || strings.HasSuffix(filterPath, ".lua") {
+			args = append(args, fmt.Sprintf("--lua-filter=%s", strings.TrimPrefix(filterPath, "lua:")))
+		} else {
+			args = append(args, fmt.Sprintf("--filter=%s", filterPath))
+		}
 	}
 	return args
 }
 
 // AsPandocArguments returns a list of strings that can be used as arguments to
 // a "pandoc" invocation. All the settings contained in Config are represented
 // in the returned list of arguments.
-func (c *Config) AsPandocArguments() []string {
+func (c *Config) AsPandocArguments(pathLookup PathNormalizer) []string {
 	args := []string{
 		c.getInputArg(),
 		c.getOutputArg(),
 		c.getMathRenderingArg()}
 
-	args = append(args, c.getFilterArgs()...)
+	args = append(args, c.getFilterArgs(pathLookup)...)
 	args = append(args, c.ExtraArgs...)
 
 	return args
 }
+
+type PathNormalizer interface {
+	NormalizePath(string) (string, error)
+}