caddy/middleware/markdown/process.go

package markdown

import (
	"bytes"
	"io/ioutil"
	"path/filepath"
	"text/template"

	"github.com/mholt/caddy/middleware"
	"github.com/russross/blackfriday"
)

const (
	// DefaultTemplate is the default template.
	DefaultTemplate = "defaultTemplate"
)

// Data represents a markdown document.
type Data struct {
	middleware.Context
	Doc      map[string]string
	DocFlags map[string]bool
	Styles   []string
	Scripts  []string
}

// Include "overrides" the embedded middleware.Context's Include()
// method so that included files have access to d's fields.
func (d Data) Include(filename string) (string, error) {
	return middleware.ContextInclude(filename, d, d.Root)
}

// Process processes the contents of a page in b. It parses the metadata
// (if any) and uses the template (if found).
func (md Markdown) Process(c *Config, requestPath string, b []byte, ctx middleware.Context) ([]byte, error) {
	var metadata = newMetadata()
	var markdown []byte
	var err error

	// find parser compatible with page contents
	parser := findParser(b)

	if parser == nil {
		// if not found, assume whole file is markdown (no front matter)
		markdown = b
	} else {
		// if found, assume metadata present and parse.
		markdown, err = parser.Parse(b)
		if err != nil {
			return nil, err
		}
		metadata = parser.Metadata()
	}

	// if template is not specified, check if Default template is set
	if metadata.Template == "" {
		if _, ok := c.Templates[DefaultTemplate]; ok {
			metadata.Template = DefaultTemplate
		}
	}

	// if template is set, load it
	var tmpl []byte
	if metadata.Template != "" {
		if t, ok := c.Templates[metadata.Template]; ok {
			tmpl, err = ioutil.ReadFile(t)
		}
		if err != nil {
			return nil, err
		}
	}

	// process markdown
	extns := 0
	extns |= blackfriday.EXTENSION_TABLES
	extns |= blackfriday.EXTENSION_FENCED_CODE
	extns |= blackfriday.EXTENSION_STRIKETHROUGH
	extns |= blackfriday.EXTENSION_DEFINITION_LISTS
	markdown = blackfriday.Markdown(markdown, c.Renderer, extns)

	// set it as body for template
	metadata.Variables["body"] = string(markdown)
	title := metadata.Title
	if title == "" {
		title = filepath.Base(requestPath)
		var extension = filepath.Ext(requestPath)
		title = title[0 : len(title)-len(extension)]
	}
	metadata.Variables["title"] = title

	return md.processTemplate(c, requestPath, tmpl, metadata, ctx)
}

// processTemplate processes a template given a requestPath,
// template (tmpl) and metadata
func (md Markdown) processTemplate(c *Config, requestPath string, tmpl []byte, metadata Metadata, ctx middleware.Context) ([]byte, error) {
	var t *template.Template
	var err error

	// if template is not specified,
	// use the default template
	if tmpl == nil {
		t = template.Must(template.New("").Parse(htmlTemplate))
	} else {
		t, err = template.New("").Parse(string(tmpl))
		if err != nil {
			return nil, err
		}
	}

	// process the template
	mdData := Data{
		Context:  ctx,
		Doc:      metadata.Variables,
		DocFlags: metadata.Flags,
		Styles:   c.Styles,
		Scripts:  c.Scripts,
	}

	b := new(bytes.Buffer)
	err = t.Execute(b, mdData)
	if err != nil {
		return nil, err
	}

	return b.Bytes(), nil
}

const (
	htmlTemplate = `<!DOCTYPE html>
<html>
	<head>
		<title>{{.Doc.title}}</title>
		<meta charset="utf-8">
		{{range .Styles}}<link rel="stylesheet" href="{{.}}">
		{{end -}}
		{{range .Scripts}}<script src="{{.}}"></script>
		{{end -}}
	</head>
	<body>
		{{.Doc.body}}
	</body>
</html>`
)
markdown: added template codes. awaiting integration and tests 2015-05-05 21:37:29 -05:00			`package markdown`

			`import (`
			`"bytes"`
			`"io/ioutil"`
markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00			`"path/filepath"`
markdown: added template codes. awaiting integration and tests 2015-05-05 21:37:29 -05:00			`"text/template"`
markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00
Add context to markdown template Created a struct containing middleware.Context, Title, Markdown and the variables from the user to use to render the template. The title now can be accessed via {{.Title}}. The variables can now be accessed via {{.Var.myVariableName}}. 2015-07-21 00:58:34 -05:00			`"github.com/mholt/caddy/middleware"`
markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00			`"github.com/russross/blackfriday"`
markdown: added template codes. awaiting integration and tests 2015-05-05 21:37:29 -05:00			`)`

markdown: template integration done. awaiting documentation and test 2015-05-07 07:45:27 -05:00			`const (`
pass golint pass all tests respond to maintainer comments reinstate assignment of t correct typo correct typo pass linter some more 2015-11-02 14:28:50 -05:00			`// DefaultTemplate is the default template.`
			`DefaultTemplate = "defaultTemplate"`
markdown: template integration done. awaiting documentation and test 2015-05-07 07:45:27 -05:00			`)`

pass golint pass all tests respond to maintainer comments reinstate assignment of t correct typo correct typo pass linter some more 2015-11-02 14:28:50 -05:00			`// Data represents a markdown document.`
Address various lint and gocyclo warnings. Fixes #253 2015-10-09 17:35:34 -05:00			`type Data struct {`
Add context to markdown template Created a struct containing middleware.Context, Title, Markdown and the variables from the user to use to render the template. The title now can be accessed via {{.Title}}. The variables can now be accessed via {{.Var.myVariableName}}. 2015-07-21 00:58:34 -05:00			`middleware.Context`
Implement .DocFlags directive and tests. It holds all the boolean-typed front matter values. 2016-02-22 05:53:47 -05:00			`Doc map[string]string`
			`DocFlags map[string]bool`
Revamp markdown processing. Nuke pre-generation. This may come back in the form of a more general caching layer at some later stage. Nuke index generation. This should likely be rethought and re-implemented. 2016-04-10 19:20:09 -05:00			`Styles []string`
			`Scripts []string`
Add context to markdown template Created a struct containing middleware.Context, Title, Markdown and the variables from the user to use to render the template. The title now can be accessed via {{.Title}}. The variables can now be accessed via {{.Var.myVariableName}}. 2015-07-21 00:58:34 -05:00			`}`

Included files in Markdown templates have access to document vars (fixes #660) Refactor how middleware.Context includes files 2016-03-07 17:32:07 -05:00			`// Include "overrides" the embedded middleware.Context's Include()`
			`// method so that included files have access to d's fields.`
			`func (d Data) Include(filename string) (string, error) {`
			`return middleware.ContextInclude(filename, d, d.Root)`
			`}`

markdown: sitegen keyword and run generation at startup Also fixed bug for markdown files that don't contain front matter 2015-05-09 22:12:28 -05:00			`// Process processes the contents of a page in b. It parses the metadata`
			`// (if any) and uses the template (if found).`
Use markdown.Config as pointer everywhere * As value mutex was copied and therefore synchronization worked wrong * It's pretty big structure with reference types, so copying create unnecessary pressure on GC Signed-off-by: Alexander Morozov <lk4d4@docker.com> 2015-09-10 17:12:46 -05:00			`func (md Markdown) Process(c *Config, requestPath string, b []byte, ctx middleware.Context) ([]byte, error) {`
Implement .DocFlags directive and tests. It holds all the boolean-typed front matter values. 2016-02-22 05:53:47 -05:00			`var metadata = newMetadata()`
markdown: remove identifier from Json metadata 2015-05-09 05:49:54 -05:00			`var markdown []byte`
			`var err error`

			`// find parser compatible with page contents`
			`parser := findParser(b)`

markdown: sitegen keyword and run generation at startup Also fixed bug for markdown files that don't contain front matter 2015-05-09 22:12:28 -05:00			`if parser == nil {`
			`// if not found, assume whole file is markdown (no front matter)`
			`markdown = b`
			`} else {`
			`// if found, assume metadata present and parse.`
markdown: remove identifier from Json metadata 2015-05-09 05:49:54 -05:00			`markdown, err = parser.Parse(b)`
			`if err != nil {`
			`return nil, err`
			`}`
			`metadata = parser.Metadata()`
markdown: added template codes. awaiting integration and tests 2015-05-05 21:37:29 -05:00			`}`
markdown: remove identifier from Json metadata 2015-05-09 05:49:54 -05:00
markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00			`// if template is not specified, check if Default template is set`
			`if metadata.Template == "" {`
			`if _, ok := c.Templates[DefaultTemplate]; ok {`
			`metadata.Template = DefaultTemplate`
			`}`
			`}`

			`// if template is set, load it`
markdown: added template codes. awaiting integration and tests 2015-05-05 21:37:29 -05:00			`var tmpl []byte`
			`if metadata.Template != "" {`
			`if t, ok := c.Templates[metadata.Template]; ok {`
markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00			`tmpl, err = ioutil.ReadFile(t)`
markdown: added template codes. awaiting integration and tests 2015-05-05 21:37:29 -05:00			`}`
			`if err != nil {`
			`return nil, err`
			`}`
			`}`

			`// process markdown`
Revamp markdown processing. Nuke pre-generation. This may come back in the form of a more general caching layer at some later stage. Nuke index generation. This should likely be rethought and re-implemented. 2016-04-10 19:20:09 -05:00			`extns := 0`
			`extns \|= blackfriday.EXTENSION_TABLES`
			`extns \|= blackfriday.EXTENSION_FENCED_CODE`
			`extns \|= blackfriday.EXTENSION_STRIKETHROUGH`
			`extns \|= blackfriday.EXTENSION_DEFINITION_LISTS`
markdown: Enable tables, fenced code, and strikethrough (closes #294) 2015-10-29 10:59:14 -05:00			`markdown = blackfriday.Markdown(markdown, c.Renderer, extns)`
markdown: documentation done. awaiting test 2015-05-08 10:20:07 -05:00
markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00			`// set it as body for template`
Changed .Var to .Doc in Markdown templates Put the title into the .Doc variables as well. Changed the test template file to use new names. 2015-07-24 15:14:05 -05:00			`metadata.Variables["body"] = string(markdown)`
Remove debug line, add file name as default title 2015-07-25 15:39:13 -05:00			`title := metadata.Title`
			`if title == "" {`
			`title = filepath.Base(requestPath)`
			`var extension = filepath.Ext(requestPath)`
			`title = title[0 : len(title)-len(extension)]`
			`}`
			`metadata.Variables["title"] = title`
markdown: added template codes. awaiting integration and tests 2015-05-05 21:37:29 -05:00
Add context to markdown template Created a struct containing middleware.Context, Title, Markdown and the variables from the user to use to render the template. The title now can be accessed via {{.Title}}. The variables can now be accessed via {{.Var.myVariableName}}. 2015-07-21 00:58:34 -05:00			`return md.processTemplate(c, requestPath, tmpl, metadata, ctx)`
markdown: added template codes. awaiting integration and tests 2015-05-05 21:37:29 -05:00			`}`

markdown: documentation done. awaiting test 2015-05-08 10:20:07 -05:00			`// processTemplate processes a template given a requestPath,`
			`// template (tmpl) and metadata`
Use markdown.Config as pointer everywhere * As value mutex was copied and therefore synchronization worked wrong * It's pretty big structure with reference types, so copying create unnecessary pressure on GC Signed-off-by: Alexander Morozov <lk4d4@docker.com> 2015-09-10 17:12:46 -05:00			`func (md Markdown) processTemplate(c *Config, requestPath string, tmpl []byte, metadata Metadata, ctx middleware.Context) ([]byte, error) {`
Revamp markdown processing. Nuke pre-generation. This may come back in the form of a more general caching layer at some later stage. Nuke index generation. This should likely be rethought and re-implemented. 2016-04-10 19:20:09 -05:00			`var t *template.Template`
			`var err error`

markdown: documentation done. awaiting test 2015-05-08 10:20:07 -05:00			`// if template is not specified,`
			`// use the default template`
			`if tmpl == nil {`
Revamp markdown processing. Nuke pre-generation. This may come back in the form of a more general caching layer at some later stage. Nuke index generation. This should likely be rethought and re-implemented. 2016-04-10 19:20:09 -05:00			`t = template.Must(template.New("").Parse(htmlTemplate))`
			`} else {`
			`t, err = template.New("").Parse(string(tmpl))`
			`if err != nil {`
			`return nil, err`
			`}`
markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00			`}`

markdown: documentation done. awaiting test 2015-05-08 10:20:07 -05:00			`// process the template`
Address various lint and gocyclo warnings. Fixes #253 2015-10-09 17:35:34 -05:00			`mdData := Data{`
Implement .DocFlags directive and tests. It holds all the boolean-typed front matter values. 2016-02-22 05:53:47 -05:00			`Context: ctx,`
			`Doc: metadata.Variables,`
			`DocFlags: metadata.Flags,`
Revamp markdown processing. Nuke pre-generation. This may come back in the form of a more general caching layer at some later stage. Nuke index generation. This should likely be rethought and re-implemented. 2016-04-10 19:20:09 -05:00			`Styles: c.Styles,`
			`Scripts: c.Scripts,`
Add context to markdown template Created a struct containing middleware.Context, Title, Markdown and the variables from the user to use to render the template. The title now can be accessed via {{.Title}}. The variables can now be accessed via {{.Var.myVariableName}}. 2015-07-21 00:58:34 -05:00			`}`

Revamp markdown processing. Nuke pre-generation. This may come back in the form of a more general caching layer at some later stage. Nuke index generation. This should likely be rethought and re-implemented. 2016-04-10 19:20:09 -05:00			`b := new(bytes.Buffer)`
Metadata variables flattened. Fix race condition on parsers. Added page links generator. 2015-07-27 23:21:09 -05:00			`err = t.Execute(b, mdData)`
			`if err != nil {`
markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00			`return nil, err`
markdown: added template codes. awaiting integration and tests 2015-05-05 21:37:29 -05:00			`}`
markdown: template integration done. awaiting documentation and test 2015-05-07 07:45:27 -05:00
markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00			`return b.Bytes(), nil`
markdown: documentation done. awaiting test 2015-05-08 10:20:07 -05:00			`}`

markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00			`const (`
			htmlTemplate = `<!DOCTYPE html>
			`<html>`
			`<head>`
Revamp markdown processing. Nuke pre-generation. This may come back in the form of a more general caching layer at some later stage. Nuke index generation. This should likely be rethought and re-implemented. 2016-04-10 19:20:09 -05:00			`<title>{{.Doc.title}}</title>`
markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00			`<meta charset="utf-8">`
Revamp markdown processing. Nuke pre-generation. This may come back in the form of a more general caching layer at some later stage. Nuke index generation. This should likely be rethought and re-implemented. 2016-04-10 19:20:09 -05:00			`{{range .Styles}}<link rel="stylesheet" href="{{.}}">`
			`{{end -}}`
			`{{range .Scripts}}<script src="{{.}}"></script>`
			`{{end -}}`
markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00			`</head>`
			`<body>`
Changed .Var to .Doc in Markdown templates Put the title into the .Doc variables as well. Changed the test template file to use new names. 2015-07-24 15:14:05 -05:00			`{{.Doc.body}}`
markdown: working version of template integration. Awaiting static site generation and tests. 2015-05-06 18:19:02 -05:00			`</body>`
			</html>`
			`)`