From 5f6b6ec68936ebbbf590894c02a1a3ecad30735f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B8rn=20Erik=20Pedersen?=
 <bjorn.erik.pedersen@gmail.com>
Date: Fri, 16 Aug 2019 15:55:03 +0200
Subject: Prepare for Goldmark

This commmit prepares for the addition of Goldmark as the new Markdown renderer in Hugo.

This introduces a new `markup` package with some common interfaces and each implementation in its own package.

See #5963
---
 helpers/content.go               | 524 +++------------------------------------
 helpers/content_renderer.go      | 108 --------
 helpers/content_renderer_test.go | 141 -----------
 helpers/content_test.go          | 235 +-----------------
 helpers/pygments_test.go         |  10 +-
 helpers/testhelpers_test.go      |   4 +-
 6 files changed, 47 insertions(+), 975 deletions(-)
 delete mode 100644 helpers/content_renderer.go
 delete mode 100644 helpers/content_renderer_test.go

(limited to 'helpers')

diff --git a/helpers/content.go b/helpers/content.go
index fe96ce7d2..357bd48e7 100644
--- a/helpers/content.go
+++ b/helpers/content.go
@@ -19,22 +19,18 @@ package helpers
 
 import (
 	"bytes"
-	"fmt"
 	"html/template"
-	"os/exec"
-	"runtime"
 	"unicode"
 	"unicode/utf8"
 
-	"github.com/gohugoio/hugo/common/maps"
-	"github.com/gohugoio/hugo/hugolib/filesystems"
-	"github.com/niklasfasching/go-org/org"
+	"github.com/gohugoio/hugo/common/loggers"
+
+	"github.com/gohugoio/hugo/markup/converter"
+
+	"github.com/gohugoio/hugo/markup"
 
 	bp "github.com/gohugoio/hugo/bufferpool"
 	"github.com/gohugoio/hugo/config"
-	"github.com/miekg/mmark"
-	"github.com/mitchellh/mapstructure"
-	"github.com/russross/blackfriday"
 	"github.com/spf13/afero"
 	jww "github.com/spf13/jwalterweatherman"
 
@@ -52,9 +48,9 @@ var (
 
 // ContentSpec provides functionality to render markdown content.
 type ContentSpec struct {
-	BlackFriday                *BlackFriday
-	footnoteAnchorPrefix       string
-	footnoteReturnLinkContents string
+	Converters       markup.ConverterProvider
+	MardownConverter converter.Converter // Markdown converter with no document context
+
 	// SummaryLength is the length of the summary that Hugo extracts from a content.
 	summaryLength int
 
@@ -70,16 +66,13 @@ type ContentSpec struct {
 
 // NewContentSpec returns a ContentSpec initialized
 // with the appropriate fields from the given config.Provider.
-func NewContentSpec(cfg config.Provider) (*ContentSpec, error) {
-	bf := newBlackfriday(cfg.GetStringMap("blackfriday"))
+func NewContentSpec(cfg config.Provider, logger *loggers.Logger, contentFs afero.Fs) (*ContentSpec, error) {
+
 	spec := &ContentSpec{
-		BlackFriday:                bf,
-		footnoteAnchorPrefix:       cfg.GetString("footnoteAnchorPrefix"),
-		footnoteReturnLinkContents: cfg.GetString("footnoteReturnLinkContents"),
-		summaryLength:              cfg.GetInt("summaryLength"),
-		BuildFuture:                cfg.GetBool("buildFuture"),
-		BuildExpired:               cfg.GetBool("buildExpired"),
-		BuildDrafts:                cfg.GetBool("buildDrafts"),
+		summaryLength: cfg.GetInt("summaryLength"),
+		BuildFuture:   cfg.GetBool("buildFuture"),
+		BuildExpired:  cfg.GetBool("buildExpired"),
+		BuildDrafts:   cfg.GetBool("buildDrafts"),
 
 		Cfg: cfg,
 	}
@@ -109,99 +102,29 @@ func NewContentSpec(cfg config.Provider) (*ContentSpec, error) {
 		spec.Highlight = h.chromaHighlight
 	}
 
-	return spec, nil
-}
-
-// BlackFriday holds configuration values for BlackFriday rendering.
-type BlackFriday struct {
-	Smartypants           bool
-	SmartypantsQuotesNBSP bool
-	AngledQuotes          bool
-	Fractions             bool
-	HrefTargetBlank       bool
-	NofollowLinks         bool
-	NoreferrerLinks       bool
-	SmartDashes           bool
-	LatexDashes           bool
-	TaskLists             bool
-	PlainIDAnchors        bool
-	Extensions            []string
-	ExtensionsMask        []string
-	SkipHTML              bool
-}
-
-// NewBlackfriday creates a new Blackfriday filled with site config or some sane defaults.
-func newBlackfriday(config map[string]interface{}) *BlackFriday {
-	defaultParam := map[string]interface{}{
-		"smartypants":           true,
-		"angledQuotes":          false,
-		"smartypantsQuotesNBSP": false,
-		"fractions":             true,
-		"hrefTargetBlank":       false,
-		"nofollowLinks":         false,
-		"noreferrerLinks":       false,
-		"smartDashes":           true,
-		"latexDashes":           true,
-		"plainIDAnchors":        true,
-		"taskLists":             true,
-		"skipHTML":              false,
-	}
-
-	maps.ToLower(defaultParam)
-
-	siteConfig := make(map[string]interface{})
-
-	for k, v := range defaultParam {
-		siteConfig[k] = v
-	}
-
-	for k, v := range config {
-		siteConfig[k] = v
+	converterProvider, err := markup.NewConverterProvider(converter.ProviderConfig{
+		Cfg:       cfg,
+		ContentFs: contentFs,
+		Logger:    logger,
+		Highlight: spec.Highlight,
+	})
+	if err != nil {
+		return nil, err
 	}
 
-	combinedConfig := &BlackFriday{}
-	if err := mapstructure.Decode(siteConfig, combinedConfig); err != nil {
-		jww.FATAL.Printf("Failed to get site rendering config\n%s", err.Error())
+	spec.Converters = converterProvider
+	p := converterProvider.Get("markdown")
+	conv, err := p.New(converter.DocumentContext{})
+	if err != nil {
+		return nil, err
 	}
+	spec.MardownConverter = conv
 
-	return combinedConfig
-}
-
-var blackfridayExtensionMap = map[string]int{
-	"noIntraEmphasis":        blackfriday.EXTENSION_NO_INTRA_EMPHASIS,
-	"tables":                 blackfriday.EXTENSION_TABLES,
-	"fencedCode":             blackfriday.EXTENSION_FENCED_CODE,
-	"autolink":               blackfriday.EXTENSION_AUTOLINK,
-	"strikethrough":          blackfriday.EXTENSION_STRIKETHROUGH,
-	"laxHtmlBlocks":          blackfriday.EXTENSION_LAX_HTML_BLOCKS,
-	"spaceHeaders":           blackfriday.EXTENSION_SPACE_HEADERS,
-	"hardLineBreak":          blackfriday.EXTENSION_HARD_LINE_BREAK,
-	"tabSizeEight":           blackfriday.EXTENSION_TAB_SIZE_EIGHT,
-	"footnotes":              blackfriday.EXTENSION_FOOTNOTES,
-	"noEmptyLineBeforeBlock": blackfriday.EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK,
-	"headerIds":              blackfriday.EXTENSION_HEADER_IDS,
-	"titleblock":             blackfriday.EXTENSION_TITLEBLOCK,
-	"autoHeaderIds":          blackfriday.EXTENSION_AUTO_HEADER_IDS,
-	"backslashLineBreak":     blackfriday.EXTENSION_BACKSLASH_LINE_BREAK,
-	"definitionLists":        blackfriday.EXTENSION_DEFINITION_LISTS,
-	"joinLines":              blackfriday.EXTENSION_JOIN_LINES,
+	return spec, nil
 }
 
 var stripHTMLReplacer = strings.NewReplacer("\n", " ", "</p>", "\n", "<br>", "\n", "<br />", "\n")
 
-var mmarkExtensionMap = map[string]int{
-	"tables":                 mmark.EXTENSION_TABLES,
-	"fencedCode":             mmark.EXTENSION_FENCED_CODE,
-	"autolink":               mmark.EXTENSION_AUTOLINK,
-	"laxHtmlBlocks":          mmark.EXTENSION_LAX_HTML_BLOCKS,
-	"spaceHeaders":           mmark.EXTENSION_SPACE_HEADERS,
-	"hardLineBreak":          mmark.EXTENSION_HARD_LINE_BREAK,
-	"footnotes":              mmark.EXTENSION_FOOTNOTES,
-	"noEmptyLineBeforeBlock": mmark.EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK,
-	"headerIds":              mmark.EXTENSION_HEADER_IDS,
-	"autoHeaderIds":          mmark.EXTENSION_AUTO_HEADER_IDS,
-}
-
 // StripHTML accepts a string, strips out all HTML tags and returns it.
 func StripHTML(s string) string {
 
@@ -250,181 +173,6 @@ func BytesToHTML(b []byte) template.HTML {
 	return template.HTML(string(b))
 }
 
-// getHTMLRenderer creates a new Blackfriday HTML Renderer with the given configuration.
-func (c *ContentSpec) getHTMLRenderer(defaultFlags int, ctx *RenderingContext) blackfriday.Renderer {
-	renderParameters := blackfriday.HtmlRendererParameters{
-		FootnoteAnchorPrefix:       c.footnoteAnchorPrefix,
-		FootnoteReturnLinkContents: c.footnoteReturnLinkContents,
-	}
-
-	b := len(ctx.DocumentID) != 0
-
-	if ctx.Config == nil {
-		panic(fmt.Sprintf("RenderingContext of %q doesn't have a config", ctx.DocumentID))
-	}
-
-	if b && !ctx.Config.PlainIDAnchors {
-		renderParameters.FootnoteAnchorPrefix = ctx.DocumentID + ":" + renderParameters.FootnoteAnchorPrefix
-		renderParameters.HeaderIDSuffix = ":" + ctx.DocumentID
-	}
-
-	htmlFlags := defaultFlags
-	htmlFlags |= blackfriday.HTML_USE_XHTML
-	htmlFlags |= blackfriday.HTML_FOOTNOTE_RETURN_LINKS
-
-	if ctx.Config.Smartypants {
-		htmlFlags |= blackfriday.HTML_USE_SMARTYPANTS
-	}
-
-	if ctx.Config.SmartypantsQuotesNBSP {
-		htmlFlags |= blackfriday.HTML_SMARTYPANTS_QUOTES_NBSP
-	}
-
-	if ctx.Config.AngledQuotes {
-		htmlFlags |= blackfriday.HTML_SMARTYPANTS_ANGLED_QUOTES
-	}
-
-	if ctx.Config.Fractions {
-		htmlFlags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
-	}
-
-	if ctx.Config.HrefTargetBlank {
-		htmlFlags |= blackfriday.HTML_HREF_TARGET_BLANK
-	}
-
-	if ctx.Config.NofollowLinks {
-		htmlFlags |= blackfriday.HTML_NOFOLLOW_LINKS
-	}
-
-	if ctx.Config.NoreferrerLinks {
-		htmlFlags |= blackfriday.HTML_NOREFERRER_LINKS
-	}
-
-	if ctx.Config.SmartDashes {
-		htmlFlags |= blackfriday.HTML_SMARTYPANTS_DASHES
-	}
-
-	if ctx.Config.LatexDashes {
-		htmlFlags |= blackfriday.HTML_SMARTYPANTS_LATEX_DASHES
-	}
-
-	if ctx.Config.SkipHTML {
-		htmlFlags |= blackfriday.HTML_SKIP_HTML
-	}
-
-	return &HugoHTMLRenderer{
-		cs:               c,
-		RenderingContext: ctx,
-		Renderer:         blackfriday.HtmlRendererWithParameters(htmlFlags, "", "", renderParameters),
-	}
-}
-
-func getMarkdownExtensions(ctx *RenderingContext) int {
-	// Default Blackfriday common extensions
-	commonExtensions := 0 |
-		blackfriday.EXTENSION_NO_INTRA_EMPHASIS |
-		blackfriday.EXTENSION_TABLES |
-		blackfriday.EXTENSION_FENCED_CODE |
-		blackfriday.EXTENSION_AUTOLINK |
-		blackfriday.EXTENSION_STRIKETHROUGH |
-		blackfriday.EXTENSION_SPACE_HEADERS |
-		blackfriday.EXTENSION_HEADER_IDS |
-		blackfriday.EXTENSION_BACKSLASH_LINE_BREAK |
-		blackfriday.EXTENSION_DEFINITION_LISTS
-
-	// Extra Blackfriday extensions that Hugo enables by default
-	flags := commonExtensions |
-		blackfriday.EXTENSION_AUTO_HEADER_IDS |
-		blackfriday.EXTENSION_FOOTNOTES
-
-	if ctx.Config == nil {
-		panic(fmt.Sprintf("RenderingContext of %q doesn't have a config", ctx.DocumentID))
-	}
-
-	for _, extension := range ctx.Config.Extensions {
-		if flag, ok := blackfridayExtensionMap[extension]; ok {
-			flags |= flag
-		}
-	}
-	for _, extension := range ctx.Config.ExtensionsMask {
-		if flag, ok := blackfridayExtensionMap[extension]; ok {
-			flags &= ^flag
-		}
-	}
-	return flags
-}
-
-func (c *ContentSpec) markdownRender(ctx *RenderingContext) []byte {
-	if ctx.RenderTOC {
-		return blackfriday.Markdown(ctx.Content,
-			c.getHTMLRenderer(blackfriday.HTML_TOC, ctx),
-			getMarkdownExtensions(ctx))
-	}
-	return blackfriday.Markdown(ctx.Content, c.getHTMLRenderer(0, ctx),
-		getMarkdownExtensions(ctx))
-}
-
-// getMmarkHTMLRenderer creates a new mmark HTML Renderer with the given configuration.
-func (c *ContentSpec) getMmarkHTMLRenderer(defaultFlags int, ctx *RenderingContext) mmark.Renderer {
-	renderParameters := mmark.HtmlRendererParameters{
-		FootnoteAnchorPrefix:       c.footnoteAnchorPrefix,
-		FootnoteReturnLinkContents: c.footnoteReturnLinkContents,
-	}
-
-	b := len(ctx.DocumentID) != 0
-
-	if ctx.Config == nil {
-		panic(fmt.Sprintf("RenderingContext of %q doesn't have a config", ctx.DocumentID))
-	}
-
-	if b && !ctx.Config.PlainIDAnchors {
-		renderParameters.FootnoteAnchorPrefix = ctx.DocumentID + ":" + renderParameters.FootnoteAnchorPrefix
-		// renderParameters.HeaderIDSuffix = ":" + ctx.DocumentId
-	}
-
-	htmlFlags := defaultFlags
-	htmlFlags |= mmark.HTML_FOOTNOTE_RETURN_LINKS
-
-	return &HugoMmarkHTMLRenderer{
-		cs:       c,
-		Renderer: mmark.HtmlRendererWithParameters(htmlFlags, "", "", renderParameters),
-		Cfg:      c.Cfg,
-	}
-}
-
-func getMmarkExtensions(ctx *RenderingContext) int {
-	flags := 0
-	flags |= mmark.EXTENSION_TABLES
-	flags |= mmark.EXTENSION_FENCED_CODE
-	flags |= mmark.EXTENSION_AUTOLINK
-	flags |= mmark.EXTENSION_SPACE_HEADERS
-	flags |= mmark.EXTENSION_CITATION
-	flags |= mmark.EXTENSION_TITLEBLOCK_TOML
-	flags |= mmark.EXTENSION_HEADER_IDS
-	flags |= mmark.EXTENSION_AUTO_HEADER_IDS
-	flags |= mmark.EXTENSION_UNIQUE_HEADER_IDS
-	flags |= mmark.EXTENSION_FOOTNOTES
-	flags |= mmark.EXTENSION_SHORT_REF
-	flags |= mmark.EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK
-	flags |= mmark.EXTENSION_INCLUDE
-
-	if ctx.Config == nil {
-		panic(fmt.Sprintf("RenderingContext of %q doesn't have a config", ctx.DocumentID))
-	}
-
-	for _, extension := range ctx.Config.Extensions {
-		if flag, ok := mmarkExtensionMap[extension]; ok {
-			flags |= flag
-		}
-	}
-	return flags
-}
-
-func (c *ContentSpec) mmarkRender(ctx *RenderingContext) []byte {
-	return mmark.Parse(ctx.Content, c.getMmarkHTMLRenderer(0, ctx),
-		getMmarkExtensions(ctx)).Bytes()
-}
-
 // ExtractTOC extracts Table of Contents from content.
 func ExtractTOC(content []byte) (newcontent []byte, toc []byte) {
 	if !bytes.Contains(content, []byte("<nav>")) {
@@ -464,38 +212,12 @@ func ExtractTOC(content []byte) (newcontent []byte, toc []byte) {
 	return
 }
 
-// RenderingContext holds contextual information, like content and configuration,
-// for a given content rendering.
-// By creating you must set the Config, otherwise it will panic.
-type RenderingContext struct {
-	BaseFs       *filesystems.BaseFs
-	Content      []byte
-	PageFmt      string
-	DocumentID   string
-	DocumentName string
-	Config       *BlackFriday
-	RenderTOC    bool
-	Cfg          config.Provider
-}
-
-// RenderBytes renders a []byte.
-func (c *ContentSpec) RenderBytes(ctx *RenderingContext) []byte {
-	switch ctx.PageFmt {
-	default:
-		return c.markdownRender(ctx)
-	case "markdown":
-		return c.markdownRender(ctx)
-	case "asciidoc":
-		return getAsciidocContent(ctx)
-	case "mmark":
-		return c.mmarkRender(ctx)
-	case "rst":
-		return getRstContent(ctx)
-	case "org":
-		return orgRender(ctx, c)
-	case "pandoc":
-		return getPandocContent(ctx)
+func (c *ContentSpec) RenderMarkdown(src []byte) ([]byte, error) {
+	b, err := c.MardownConverter.Convert(converter.RenderContext{Src: src})
+	if err != nil {
+		return nil, err
 	}
+	return b.Bytes(), nil
 }
 
 // TotalWords counts instance of one or more consecutive white space
@@ -622,181 +344,3 @@ func (c *ContentSpec) truncateWordsToWholeSentenceOld(content string) (string, b
 
 	return strings.Join(words[:c.summaryLength], " "), true
 }
-
-func getAsciidocExecPath() string {
-	path, err := exec.LookPath("asciidoc")
-	if err != nil {
-		return ""
-	}
-	return path
-}
-
-func getAsciidoctorExecPath() string {
-	path, err := exec.LookPath("asciidoctor")
-	if err != nil {
-		return ""
-	}
-	return path
-}
-
-// HasAsciidoc returns whether Asciidoc or Asciidoctor is installed on this computer.
-func HasAsciidoc() bool {
-	return (getAsciidoctorExecPath() != "" ||
-		getAsciidocExecPath() != "")
-}
-
-// getAsciidocContent calls asciidoctor or asciidoc as an external helper
-// to convert AsciiDoc content to HTML.
-func getAsciidocContent(ctx *RenderingContext) []byte {
-	var isAsciidoctor bool
-	path := getAsciidoctorExecPath()
-	if path == "" {
-		path = getAsciidocExecPath()
-		if path == "" {
-			jww.ERROR.Println("asciidoctor / asciidoc not found in $PATH: Please install.\n",
-				"                 Leaving AsciiDoc content unrendered.")
-			return ctx.Content
-		}
-	} else {
-		isAsciidoctor = true
-	}
-
-	jww.INFO.Println("Rendering", ctx.DocumentName, "with", path, "...")
-	args := []string{"--no-header-footer", "--safe"}
-	if isAsciidoctor {
-		// asciidoctor-specific arg to show stack traces on errors
-		args = append(args, "--trace")
-	}
-	args = append(args, "-")
-	return externallyRenderContent(ctx, path, args)
-}
-
-// HasRst returns whether rst2html is installed on this computer.
-func HasRst() bool {
-	return getRstExecPath() != ""
-}
-
-func getRstExecPath() string {
-	path, err := exec.LookPath("rst2html")
-	if err != nil {
-		path, err = exec.LookPath("rst2html.py")
-		if err != nil {
-			return ""
-		}
-	}
-	return path
-}
-
-func getPythonExecPath() string {
-	path, err := exec.LookPath("python")
-	if err != nil {
-		path, err = exec.LookPath("python.exe")
-		if err != nil {
-			return ""
-		}
-	}
-	return path
-}
-
-// getRstContent calls the Python script rst2html as an external helper
-// to convert reStructuredText content to HTML.
-func getRstContent(ctx *RenderingContext) []byte {
-	path := getRstExecPath()
-
-	if path == "" {
-		jww.ERROR.Println("rst2html / rst2html.py not found in $PATH: Please install.\n",
-			"                 Leaving reStructuredText content unrendered.")
-		return ctx.Content
-
-	}
-	jww.INFO.Println("Rendering", ctx.DocumentName, "with", path, "...")
-	var result []byte
-	// certain *nix based OSs wrap executables in scripted launchers
-	// invoking binaries on these OSs via python interpreter causes SyntaxError
-	// invoke directly so that shebangs work as expected
-	// handle Windows manually because it doesn't do shebangs
-	if runtime.GOOS == "windows" {
-		python := getPythonExecPath()
-		args := []string{path, "--leave-comments", "--initial-header-level=2"}
-		result = externallyRenderContent(ctx, python, args)
-	} else {
-		args := []string{"--leave-comments", "--initial-header-level=2"}
-		result = externallyRenderContent(ctx, path, args)
-	}
-	// TODO(bep) check if rst2html has a body only option.
-	bodyStart := bytes.Index(result, []byte("<body>\n"))
-	if bodyStart < 0 {
-		bodyStart = -7 //compensate for length
-	}
-
-	bodyEnd := bytes.Index(result, []byte("\n</body>"))
-	if bodyEnd < 0 || bodyEnd >= len(result) {
-		bodyEnd = len(result) - 1
-		if bodyEnd < 0 {
-			bodyEnd = 0
-		}
-	}
-
-	return result[bodyStart+7 : bodyEnd]
-}
-
-// getPandocContent calls pandoc as an external helper to convert pandoc markdown to HTML.
-func getPandocContent(ctx *RenderingContext) []byte {
-	path, err := exec.LookPath("pandoc")
-	if err != nil {
-		jww.ERROR.Println("pandoc not found in $PATH: Please install.\n",
-			"                 Leaving pandoc content unrendered.")
-		return ctx.Content
-	}
-	args := []string{"--mathjax"}
-	return externallyRenderContent(ctx, path, args)
-}
-
-func orgRender(ctx *RenderingContext, c *ContentSpec) []byte {
-	config := org.New()
-	config.Log = jww.WARN
-	config.ReadFile = func(filename string) ([]byte, error) {
-		return afero.ReadFile(ctx.BaseFs.Content.Fs, filename)
-	}
-	writer := org.NewHTMLWriter()
-	writer.HighlightCodeBlock = func(source, lang string) string {
-		highlightedSource, err := c.Highlight(source, lang, "")
-		if err != nil {
-			jww.ERROR.Printf("Could not highlight source as lang %s. Using raw source.", lang)
-			return source
-		}
-		return highlightedSource
-	}
-
-	html, err := config.Parse(bytes.NewReader(ctx.Content), ctx.DocumentName).Write(writer)
-	if err != nil {
-		jww.ERROR.Printf("Could not render org: %s. Using unrendered content.", err)
-		return ctx.Content
-	}
-	return []byte(html)
-}
-
-func externallyRenderContent(ctx *RenderingContext, path string, args []string) []byte {
-	content := ctx.Content
-	cleanContent := bytes.Replace(content, SummaryDivider, []byte(""), 1)
-
-	cmd := exec.Command(path, args...)
-	cmd.Stdin = bytes.NewReader(cleanContent)
-	var out, cmderr bytes.Buffer
-	cmd.Stdout = &out
-	cmd.Stderr = &cmderr
-	err := cmd.Run()
-	// Most external helpers exit w/ non-zero exit code only if severe, i.e.
-	// halting errors occurred. -> log stderr output regardless of state of err
-	for _, item := range strings.Split(cmderr.String(), "\n") {
-		item := strings.TrimSpace(item)
-		if item != "" {
-			jww.ERROR.Printf("%s: %s", ctx.DocumentName, item)
-		}
-	}
-	if err != nil {
-		jww.ERROR.Printf("%s rendering %s: %v", path, ctx.DocumentName, err)
-	}
-
-	return normalizeExternalHelperLineFeeds(out.Bytes())
-}
diff --git a/helpers/content_renderer.go b/helpers/content_renderer.go
deleted file mode 100644
index dc22cb6f4..000000000
--- a/helpers/content_renderer.go
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright 2016 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package helpers
-
-import (
-	"bytes"
-	"strings"
-
-	"github.com/gohugoio/hugo/config"
-	"github.com/miekg/mmark"
-	"github.com/russross/blackfriday"
-)
-
-// HugoHTMLRenderer wraps a blackfriday.Renderer, typically a blackfriday.Html
-// Enabling Hugo to customise the rendering experience
-type HugoHTMLRenderer struct {
-	cs *ContentSpec
-	*RenderingContext
-	blackfriday.Renderer
-}
-
-// BlockCode renders a given text as a block of code.
-// Pygments is used if it is setup to handle code fences.
-func (r *HugoHTMLRenderer) BlockCode(out *bytes.Buffer, text []byte, lang string) {
-	if r.Cfg.GetBool("pygmentsCodeFences") && (lang != "" || r.Cfg.GetBool("pygmentsCodeFencesGuessSyntax")) {
-		opts := r.Cfg.GetString("pygmentsOptions")
-		str := strings.Trim(string(text), "\n\r")
-		highlighted, _ := r.cs.Highlight(str, lang, opts)
-		out.WriteString(highlighted)
-	} else {
-		r.Renderer.BlockCode(out, text, lang)
-	}
-}
-
-// ListItem adds task list support to the Blackfriday renderer.
-func (r *HugoHTMLRenderer) ListItem(out *bytes.Buffer, text []byte, flags int) {
-	if !r.Config.TaskLists {
-		r.Renderer.ListItem(out, text, flags)
-		return
-	}
-
-	switch {
-	case bytes.HasPrefix(text, []byte("[ ] ")):
-		text = append([]byte(`<label><input type="checkbox" disabled class="task-list-item">`), text[3:]...)
-		text = append(text, []byte(`</label>`)...)
-
-	case bytes.HasPrefix(text, []byte("[x] ")) || bytes.HasPrefix(text, []byte("[X] ")):
-		text = append([]byte(`<label><input type="checkbox" checked disabled class="task-list-item">`), text[3:]...)
-		text = append(text, []byte(`</label>`)...)
-	}
-
-	r.Renderer.ListItem(out, text, flags)
-}
-
-// List adds task list support to the Blackfriday renderer.
-func (r *HugoHTMLRenderer) List(out *bytes.Buffer, text func() bool, flags int) {
-	if !r.Config.TaskLists {
-		r.Renderer.List(out, text, flags)
-		return
-	}
-	marker := out.Len()
-	r.Renderer.List(out, text, flags)
-	if out.Len() > marker {
-		list := out.Bytes()[marker:]
-		if bytes.Contains(list, []byte("task-list-item")) {
-			// Find the index of the first >, it might be 3 or 4 depending on whether
-			// there is a new line at the start, but this is safer than just hardcoding it.
-			closingBracketIndex := bytes.Index(list, []byte(">"))
-			// Rewrite the buffer from the marker
-			out.Truncate(marker)
-			// Safely assuming closingBracketIndex won't be -1 since there is a list
-			// May be either dl, ul or ol
-			list := append(list[:closingBracketIndex], append([]byte(` class="task-list"`), list[closingBracketIndex:]...)...)
-			out.Write(list)
-		}
-	}
-}
-
-// HugoMmarkHTMLRenderer wraps a mmark.Renderer, typically a mmark.html,
-// enabling Hugo to customise the rendering experience.
-type HugoMmarkHTMLRenderer struct {
-	cs *ContentSpec
-	mmark.Renderer
-	Cfg config.Provider
-}
-
-// BlockCode renders a given text as a block of code.
-// Pygments is used if it is setup to handle code fences.
-func (r *HugoMmarkHTMLRenderer) BlockCode(out *bytes.Buffer, text []byte, lang string, caption []byte, subfigure bool, callouts bool) {
-	if r.Cfg.GetBool("pygmentsCodeFences") && (lang != "" || r.Cfg.GetBool("pygmentsCodeFencesGuessSyntax")) {
-		str := strings.Trim(string(text), "\n\r")
-		highlighted, _ := r.cs.Highlight(str, lang, "")
-		out.WriteString(highlighted)
-	} else {
-		r.Renderer.BlockCode(out, text, lang, caption, subfigure, callouts)
-	}
-}
diff --git a/helpers/content_renderer_test.go b/helpers/content_renderer_test.go
deleted file mode 100644
index 40acd89e1..000000000
--- a/helpers/content_renderer_test.go
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2019 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package helpers
-
-import (
-	"bytes"
-	"regexp"
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-	"github.com/spf13/viper"
-)
-
-// Renders a codeblock using Blackfriday
-func (c *ContentSpec) render(input string) string {
-	ctx := &RenderingContext{Cfg: c.Cfg, Config: c.BlackFriday}
-	render := c.getHTMLRenderer(0, ctx)
-
-	buf := &bytes.Buffer{}
-	render.BlockCode(buf, []byte(input), "html")
-	return buf.String()
-}
-
-// Renders a codeblock using Mmark
-func (c *ContentSpec) renderWithMmark(input string) string {
-	ctx := &RenderingContext{Cfg: c.Cfg, Config: c.BlackFriday}
-	render := c.getMmarkHTMLRenderer(0, ctx)
-
-	buf := &bytes.Buffer{}
-	render.BlockCode(buf, []byte(input), "html", []byte(""), false, false)
-	return buf.String()
-}
-
-func TestCodeFence(t *testing.T) {
-	c := qt.New(t)
-
-	type test struct {
-		enabled         bool
-		input, expected string
-	}
-
-	// Pygments 2.0 and 2.1 have slightly different outputs so only do partial matching
-	data := []test{
-		{true, "<html></html>", `(?s)^<div class="highlight">\n?<pre.*><code class="language-html" data-lang="html">.*?</code></pre>\n?</div>\n?$`},
-		{false, "<html></html>", `(?s)^<pre.*><code class="language-html">.*?</code></pre>\n$`},
-	}
-
-	for _, useClassic := range []bool{false, true} {
-		for i, d := range data {
-			v := viper.New()
-			v.Set("pygmentsStyle", "monokai")
-			v.Set("pygmentsUseClasses", true)
-			v.Set("pygmentsCodeFences", d.enabled)
-			v.Set("pygmentsUseClassic", useClassic)
-
-			cs, err := NewContentSpec(v)
-			c.Assert(err, qt.IsNil)
-
-			result := cs.render(d.input)
-
-			expectedRe, err := regexp.Compile(d.expected)
-
-			if err != nil {
-				t.Fatal("Invalid regexp", err)
-			}
-			matched := expectedRe.MatchString(result)
-
-			if !matched {
-				t.Errorf("Test %d failed. BlackFriday enabled:%t, Expected:\n%q got:\n%q", i, d.enabled, d.expected, result)
-			}
-
-			result = cs.renderWithMmark(d.input)
-			matched = expectedRe.MatchString(result)
-			if !matched {
-				t.Errorf("Test %d failed. Mmark enabled:%t, Expected:\n%q got:\n%q", i, d.enabled, d.expected, result)
-			}
-		}
-	}
-}
-
-func TestBlackfridayTaskList(t *testing.T) {
-	c := newTestContentSpec()
-
-	for i, this := range []struct {
-		markdown        string
-		taskListEnabled bool
-		expect          string
-	}{
-		{`
-TODO:
-
-- [x] On1
-- [X] On2
-- [ ] Off
-
-END
-`, true, `<p>TODO:</p>
-
-<ul class="task-list">
-<li><label><input type="checkbox" checked disabled class="task-list-item"> On1</label></li>
-<li><label><input type="checkbox" checked disabled class="task-list-item"> On2</label></li>
-<li><label><input type="checkbox" disabled class="task-list-item"> Off</label></li>
-</ul>
-
-<p>END</p>
-`},
-		{`- [x] On1`, false, `<ul>
-<li>[x] On1</li>
-</ul>
-`},
-		{`* [ ] Off
-
-END`, true, `<ul class="task-list">
-<li><label><input type="checkbox" disabled class="task-list-item"> Off</label></li>
-</ul>
-
-<p>END</p>
-`},
-	} {
-		blackFridayConfig := c.BlackFriday
-		blackFridayConfig.TaskLists = this.taskListEnabled
-		ctx := &RenderingContext{Content: []byte(this.markdown), PageFmt: "markdown", Config: blackFridayConfig}
-
-		result := string(c.RenderBytes(ctx))
-
-		if result != this.expect {
-			t.Errorf("[%d] got \n%v but expected \n%v", i, result, this.expect)
-		}
-	}
-}
diff --git a/helpers/content_test.go b/helpers/content_test.go
index 7500c2ac1..7f82abc9d 100644
--- a/helpers/content_test.go
+++ b/helpers/content_test.go
@@ -19,11 +19,13 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/spf13/afero"
+
+	"github.com/gohugoio/hugo/common/loggers"
+
 	"github.com/spf13/viper"
 
 	qt "github.com/frankban/quicktest"
-	"github.com/miekg/mmark"
-	"github.com/russross/blackfriday"
 )
 
 const tstHTMLContent = "<!DOCTYPE html><html><head><script src=\"http://two/foobar.js\"></script></head><body><nav><ul><li hugo-nav=\"section_0\"></li><li hugo-nav=\"section_1\"></li></ul></nav><article>content <a href=\"http://two/foobar\">foobar</a>. Follow up</article><p>This is some text.<br>And some more.</p></body></html>"
@@ -108,7 +110,7 @@ func TestNewContentSpec(t *testing.T) {
 	cfg.Set("buildExpired", true)
 	cfg.Set("buildDrafts", true)
 
-	spec, err := NewContentSpec(cfg)
+	spec, err := NewContentSpec(cfg, loggers.NewErrorLogger(), afero.NewMemMapFs())
 
 	c.Assert(err, qt.IsNil)
 	c.Assert(spec.summaryLength, qt.Equals, 32)
@@ -202,233 +204,6 @@ func TestTruncateWordsByRune(t *testing.T) {
 	}
 }
 
-func TestGetHTMLRendererFlags(t *testing.T) {
-	c := newTestContentSpec()
-	ctx := &RenderingContext{Cfg: c.Cfg, Config: c.BlackFriday}
-	renderer := c.getHTMLRenderer(blackfriday.HTML_USE_XHTML, ctx)
-	flags := renderer.GetFlags()
-	if flags&blackfriday.HTML_USE_XHTML != blackfriday.HTML_USE_XHTML {
-		t.Errorf("Test flag: %d was not found amongs set flags:%d; Result: %d", blackfriday.HTML_USE_XHTML, flags, flags&blackfriday.HTML_USE_XHTML)
-	}
-}
-
-func TestGetHTMLRendererAllFlags(t *testing.T) {
-	c := newTestContentSpec()
-
-	type data struct {
-		testFlag int
-	}
-
-	allFlags := []data{
-		{blackfriday.HTML_USE_XHTML},
-		{blackfriday.HTML_FOOTNOTE_RETURN_LINKS},
-		{blackfriday.HTML_USE_SMARTYPANTS},
-		{blackfriday.HTML_SMARTYPANTS_QUOTES_NBSP},
-		{blackfriday.HTML_SMARTYPANTS_ANGLED_QUOTES},
-		{blackfriday.HTML_SMARTYPANTS_FRACTIONS},
-		{blackfriday.HTML_HREF_TARGET_BLANK},
-		{blackfriday.HTML_NOFOLLOW_LINKS},
-		{blackfriday.HTML_NOREFERRER_LINKS},
-		{blackfriday.HTML_SMARTYPANTS_DASHES},
-		{blackfriday.HTML_SMARTYPANTS_LATEX_DASHES},
-	}
-	defaultFlags := blackfriday.HTML_USE_XHTML
-	ctx := &RenderingContext{Cfg: c.Cfg, Config: c.BlackFriday}
-	ctx.Config.AngledQuotes = true
-	ctx.Config.Fractions = true
-	ctx.Config.HrefTargetBlank = true
-	ctx.Config.NofollowLinks = true
-	ctx.Config.NoreferrerLinks = true
-	ctx.Config.LatexDashes = true
-	ctx.Config.PlainIDAnchors = true
-	ctx.Config.SmartDashes = true
-	ctx.Config.Smartypants = true
-	ctx.Config.SmartypantsQuotesNBSP = true
-	renderer := c.getHTMLRenderer(defaultFlags, ctx)
-	actualFlags := renderer.GetFlags()
-	var expectedFlags int
-	//OR-ing flags together...
-	for _, d := range allFlags {
-		expectedFlags |= d.testFlag
-	}
-	if expectedFlags != actualFlags {
-		t.Errorf("Expected flags (%d) did not equal actual (%d) flags.", expectedFlags, actualFlags)
-	}
-}
-
-func TestGetHTMLRendererAnchors(t *testing.T) {
-	c := newTestContentSpec()
-	ctx := &RenderingContext{Cfg: c.Cfg, Config: c.BlackFriday}
-	ctx.DocumentID = "testid"
-	ctx.Config.PlainIDAnchors = false
-
-	actualRenderer := c.getHTMLRenderer(0, ctx)
-	headerBuffer := &bytes.Buffer{}
-	footnoteBuffer := &bytes.Buffer{}
-	expectedFootnoteHref := []byte("href=\"#fn:testid:href\"")
-	expectedHeaderID := []byte("<h1 id=\"id:testid\"></h1>\n")
-
-	actualRenderer.Header(headerBuffer, func() bool { return true }, 1, "id")
-	actualRenderer.FootnoteRef(footnoteBuffer, []byte("href"), 1)
-
-	if !bytes.Contains(footnoteBuffer.Bytes(), expectedFootnoteHref) {
-		t.Errorf("Footnote anchor prefix not applied. Actual:%s Expected:%s", footnoteBuffer.String(), expectedFootnoteHref)
-	}
-
-	if !bytes.Equal(headerBuffer.Bytes(), expectedHeaderID) {
-		t.Errorf("Header Id Postfix not applied. Actual:%s Expected:%s", headerBuffer.String(), expectedHeaderID)
-	}
-}
-
-func TestGetMmarkHTMLRenderer(t *testing.T) {
-	c := newTestContentSpec()
-	ctx := &RenderingContext{Cfg: c.Cfg, Config: c.BlackFriday}
-	ctx.DocumentID = "testid"
-	ctx.Config.PlainIDAnchors = false
-	actualRenderer := c.getMmarkHTMLRenderer(0, ctx)
-
-	headerBuffer := &bytes.Buffer{}
-	footnoteBuffer := &bytes.Buffer{}
-	expectedFootnoteHref := []byte("href=\"#fn:testid:href\"")
-	expectedHeaderID := []byte("<h1 id=\"id\"></h1>")
-
-	actualRenderer.FootnoteRef(footnoteBuffer, []byte("href"), 1)
-	actualRenderer.Header(headerBuffer, func() bool { return true }, 1, "id")
-
-	if !bytes.Contains(footnoteBuffer.Bytes(), expectedFootnoteHref) {
-		t.Errorf("Footnote anchor prefix not applied. Actual:%s Expected:%s", footnoteBuffer.String(), expectedFootnoteHref)
-	}
-
-	if bytes.Equal(headerBuffer.Bytes(), expectedHeaderID) {
-		t.Errorf("Header Id Postfix applied. Actual:%s Expected:%s", headerBuffer.String(), expectedHeaderID)
-	}
-}
-
-func TestGetMarkdownExtensionsMasksAreRemovedFromExtensions(t *testing.T) {
-	c := newTestContentSpec()
-	ctx := &RenderingContext{Cfg: c.Cfg, Config: c.BlackFriday}
-	ctx.Config.Extensions = []string{"headerId"}
-	ctx.Config.ExtensionsMask = []string{"noIntraEmphasis"}
-
-	actualFlags := getMarkdownExtensions(ctx)
-	if actualFlags&blackfriday.EXTENSION_NO_INTRA_EMPHASIS == blackfriday.EXTENSION_NO_INTRA_EMPHASIS {
-		t.Errorf("Masked out flag {%v} found amongst returned extensions.", blackfriday.EXTENSION_NO_INTRA_EMPHASIS)
-	}
-}
-
-func TestGetMarkdownExtensionsByDefaultAllExtensionsAreEnabled(t *testing.T) {
-	type data struct {
-		testFlag int
-	}
-	c := newTestContentSpec()
-	ctx := &RenderingContext{Cfg: c.Cfg, Config: c.BlackFriday}
-	ctx.Config.Extensions = []string{""}
-	ctx.Config.ExtensionsMask = []string{""}
-	allExtensions := []data{
-		{blackfriday.EXTENSION_NO_INTRA_EMPHASIS},
-		{blackfriday.EXTENSION_TABLES},
-		{blackfriday.EXTENSION_FENCED_CODE},
-		{blackfriday.EXTENSION_AUTOLINK},
-		{blackfriday.EXTENSION_STRIKETHROUGH},
-		// {blackfriday.EXTENSION_LAX_HTML_BLOCKS},
-		{blackfriday.EXTENSION_SPACE_HEADERS},
-		// {blackfriday.EXTENSION_HARD_LINE_BREAK},
-		// {blackfriday.EXTENSION_TAB_SIZE_EIGHT},
-		{blackfriday.EXTENSION_FOOTNOTES},
-		// {blackfriday.EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK},
-		{blackfriday.EXTENSION_HEADER_IDS},
-		// {blackfriday.EXTENSION_TITLEBLOCK},
-		{blackfriday.EXTENSION_AUTO_HEADER_IDS},
-		{blackfriday.EXTENSION_BACKSLASH_LINE_BREAK},
-		{blackfriday.EXTENSION_DEFINITION_LISTS},
-	}
-
-	actualFlags := getMarkdownExtensions(ctx)
-	for _, e := range allExtensions {
-		if actualFlags&e.testFlag != e.testFlag {
-			t.Errorf("Flag %v was not found in the list of extensions.", e)
-		}
-	}
-}
-
-func TestGetMarkdownExtensionsAddingFlagsThroughRenderingContext(t *testing.T) {
-	c := newTestContentSpec()
-	ctx := &RenderingContext{Cfg: c.Cfg, Config: c.BlackFriday}
-	ctx.Config.Extensions = []string{"definitionLists"}
-	ctx.Config.ExtensionsMask = []string{""}
-
-	actualFlags := getMarkdownExtensions(ctx)
-	if actualFlags&blackfriday.EXTENSION_DEFINITION_LISTS != blackfriday.EXTENSION_DEFINITION_LISTS {
-		t.Errorf("Masked out flag {%v} found amongst returned extensions.", blackfriday.EXTENSION_DEFINITION_LISTS)
-	}
-}
-
-func TestGetMarkdownRenderer(t *testing.T) {
-	c := newTestContentSpec()
-	ctx := &RenderingContext{Cfg: c.Cfg, Config: c.BlackFriday}
-	ctx.Content = []byte("testContent")
-	actualRenderedMarkdown := c.markdownRender(ctx)
-	expectedRenderedMarkdown := []byte("<p>testContent</p>\n")
-	if !bytes.Equal(actualRenderedMarkdown, expectedRenderedMarkdown) {
-		t.Errorf("Actual rendered Markdown (%s) did not match expected markdown (%s)", actualRenderedMarkdown, expectedRenderedMarkdown)
-	}
-}
-
-func TestGetMarkdownRendererWithTOC(t *testing.T) {
-	c := newTestContentSpec()
-	ctx := &RenderingContext{RenderTOC: true, Cfg: c.Cfg, Config: c.BlackFriday}
-	ctx.Content = []byte("testContent")
-	actualRenderedMarkdown := c.markdownRender(ctx)
-	expectedRenderedMarkdown := []byte("<nav>\n</nav>\n\n<p>testContent</p>\n")
-	if !bytes.Equal(actualRenderedMarkdown, expectedRenderedMarkdown) {
-		t.Errorf("Actual rendered Markdown (%s) did not match expected markdown (%s)", actualRenderedMarkdown, expectedRenderedMarkdown)
-	}
-}
-
-func TestGetMmarkExtensions(t *testing.T) {
-	//TODO: This is doing the same just with different marks...
-	type data struct {
-		testFlag int
-	}
-	c := newTestContentSpec()
-	ctx := &RenderingContext{Cfg: c.Cfg, Config: c.BlackFriday}
-	ctx.Config.Extensions = []string{"tables"}
-	ctx.Config.ExtensionsMask = []string{""}
-	allExtensions := []data{
-		{mmark.EXTENSION_TABLES},
-		{mmark.EXTENSION_FENCED_CODE},
-		{mmark.EXTENSION_AUTOLINK},
-		{mmark.EXTENSION_SPACE_HEADERS},
-		{mmark.EXTENSION_CITATION},
-		{mmark.EXTENSION_TITLEBLOCK_TOML},
-		{mmark.EXTENSION_HEADER_IDS},
-		{mmark.EXTENSION_AUTO_HEADER_IDS},
-		{mmark.EXTENSION_UNIQUE_HEADER_IDS},
-		{mmark.EXTENSION_FOOTNOTES},
-		{mmark.EXTENSION_SHORT_REF},
-		{mmark.EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK},
-		{mmark.EXTENSION_INCLUDE},
-	}
-
-	actualFlags := getMmarkExtensions(ctx)
-	for _, e := range allExtensions {
-		if actualFlags&e.testFlag != e.testFlag {
-			t.Errorf("Flag %v was not found in the list of extensions.", e)
-		}
-	}
-}
-
-func TestMmarkRender(t *testing.T) {
-	c := newTestContentSpec()
-	ctx := &RenderingContext{Cfg: c.Cfg, Config: c.BlackFriday}
-	ctx.Content = []byte("testContent")
-	actualRenderedMarkdown := c.mmarkRender(ctx)
-	expectedRenderedMarkdown := []byte("<p>testContent</p>\n")
-	if !bytes.Equal(actualRenderedMarkdown, expectedRenderedMarkdown) {
-		t.Errorf("Actual rendered Markdown (%s) did not match expected markdown (%s)", actualRenderedMarkdown, expectedRenderedMarkdown)
-	}
-}
-
 func TestExtractTOCNormalContent(t *testing.T) {
 	content := []byte("<nav>\n<ul>\nTOC<li><a href=\"#")
 
diff --git a/helpers/pygments_test.go b/helpers/pygments_test.go
index acd591966..05d86e104 100644
--- a/helpers/pygments_test.go
+++ b/helpers/pygments_test.go
@@ -45,7 +45,7 @@ func TestParsePygmentsArgs(t *testing.T) {
 		v := viper.New()
 		v.Set("pygmentsStyle", this.pygmentsStyle)
 		v.Set("pygmentsUseClasses", this.pygmentsUseClasses)
-		spec, err := NewContentSpec(v)
+		spec, err := NewContentSpec(v, nil, nil)
 		c.Assert(err, qt.IsNil)
 
 		result1, err := spec.createPygmentsOptionsString(this.in)
@@ -94,7 +94,7 @@ func TestParseDefaultPygmentsArgs(t *testing.T) {
 			v.Set("pygmentsUseClasses", b)
 		}
 
-		spec, err := NewContentSpec(v)
+		spec, err := NewContentSpec(v, nil, nil)
 		c.Assert(err, qt.IsNil)
 
 		result, err := spec.createPygmentsOptionsString(this.in)
@@ -138,7 +138,7 @@ func TestChromaHTMLHighlight(t *testing.T) {
 
 	v := viper.New()
 	v.Set("pygmentsUseClasses", true)
-	spec, err := NewContentSpec(v)
+	spec, err := NewContentSpec(v, nil, nil)
 	c.Assert(err, qt.IsNil)
 
 	result, err := spec.Highlight(`echo "Hello"`, "bash", "")
@@ -206,7 +206,7 @@ func TestChromaHTMLFormatterFromOptions(t *testing.T) {
 			v.Set("pygmentsUseClasses", b)
 		}
 
-		spec, err := NewContentSpec(v)
+		spec, err := NewContentSpec(v, nil, nil)
 		c.Assert(err, qt.IsNil)
 
 		opts, err := spec.parsePygmentsOpts(this.in)
@@ -288,7 +288,7 @@ func GetTitleFunc(style string) func(s string) string {
 }
 `
 
-	spec, err := NewContentSpec(v)
+	spec, err := NewContentSpec(v, nil, nil)
 	c.Assert(err, qt.IsNil)
 
 	for i := 0; i < b.N; i++ {
diff --git a/helpers/testhelpers_test.go b/helpers/testhelpers_test.go
index 2d12289c6..bf249059d 100644
--- a/helpers/testhelpers_test.go
+++ b/helpers/testhelpers_test.go
@@ -1,6 +1,8 @@
 package helpers
 
 import (
+	"github.com/gohugoio/hugo/common/loggers"
+	"github.com/spf13/afero"
 	"github.com/spf13/viper"
 
 	"github.com/gohugoio/hugo/hugofs"
@@ -56,7 +58,7 @@ func newTestCfg() *viper.Viper {
 
 func newTestContentSpec() *ContentSpec {
 	v := viper.New()
-	spec, err := NewContentSpec(v)
+	spec, err := NewContentSpec(v, loggers.NewErrorLogger(), afero.NewMemMapFs())
 	if err != nil {
 		panic(err)
 	}
-- 
cgit v1.2.3