mirror/hugo
1
0
Fork 0
mirror of https://github.com/gohugoio/hugo.git synced 2025-08-25 22:00:58 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove mmark

Browse Source 
Closes #9350
This commit is contained in:
Bjørn Erik Pedersen
2022-01-04 13:26:23 +01:00
parent 2b6063c3e3
commit 1651beb2c1
11 changed files with 5 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
markup/markup.go
View File

@@ -27,7 +27,6 @@ import (
"github.com/gohugoio/hugo/markup/asciidocext"
"github.com/gohugoio/hugo/markup/blackfriday"
"github.com/gohugoio/hugo/markup/converter"
"github.com/gohugoio/hugo/markup/mmark"
"github.com/gohugoio/hugo/markup/pandoc"
"github.com/gohugoio/hugo/markup/rst"
)
@@ -73,9 +72,6 @@ func NewConverterProvider(cfg converter.ProviderConfig) (ConverterProvider, erro
if err := add(blackfriday.Provider); err != nil {
return nil, err
}
if err := add(mmark.Provider); err != nil {
return nil, err
}
if err := add(asciidocext.Provider, "ad", "adoc"); err != nil {
return nil, err
}

1
markup/markup_test.go
View File

@@ -39,7 +39,6 @@ func TestConverterRegistry(t *testing.T) {
c.Assert(r.Get("markdown").Name(), qt.Equals, "goldmark")
checkName("goldmark")
checkName("mmark")
checkName("asciidocext")
checkName("rst")
checkName("pandoc")

137
markup/mmark/convert.go
View File

@@ -1,137 +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 mmark converts Markdown to HTML using MMark v1.
package mmark
import (
"github.com/gohugoio/hugo/identity"
"github.com/gohugoio/hugo/markup/blackfriday/blackfriday_config"
"github.com/gohugoio/hugo/markup/converter"
"github.com/miekg/mmark"
)
// Provider is the package entry point.
var Provider converter.ProviderProvider = provider{}
type provider struct {
}
func (p provider) New(cfg converter.ProviderConfig) (converter.Provider, error) {
defaultBlackFriday := cfg.MarkupConfig.BlackFriday
defaultExtensions := getMmarkExtensions(defaultBlackFriday)
return converter.NewProvider("mmark", func(ctx converter.DocumentContext) (converter.Converter, error) {
b := defaultBlackFriday
extensions := defaultExtensions
if ctx.ConfigOverrides != nil {
var err error
b, err = blackfriday_config.UpdateConfig(b, ctx.ConfigOverrides)
if err != nil {
return nil, err
}
extensions = getMmarkExtensions(b)
}
return &mmarkConverter{
ctx: ctx,
b: b,
extensions: extensions,
cfg: cfg,
}, nil
}), nil
}
type mmarkConverter struct {
ctx converter.DocumentContext
extensions int
b blackfriday_config.Config
cfg converter.ProviderConfig
}
func (c *mmarkConverter) Convert(ctx converter.RenderContext) (converter.Result, error) {
r := getHTMLRenderer(c.ctx, c.b, c.cfg)
return mmark.Parse(ctx.Src, r, c.extensions), nil
}
func (c *mmarkConverter) Supports(feature identity.Identity) bool {
return false
}
func getHTMLRenderer(
ctx converter.DocumentContext,
cfg blackfriday_config.Config,
pcfg converter.ProviderConfig) mmark.Renderer {
var (
flags int
documentID string
)
documentID = ctx.DocumentID
renderParameters := mmark.HtmlRendererParameters{
FootnoteAnchorPrefix: cfg.FootnoteAnchorPrefix,
FootnoteReturnLinkContents: cfg.FootnoteReturnLinkContents,
}
if documentID != "" && !cfg.PlainIDAnchors {
renderParameters.FootnoteAnchorPrefix = documentID + ":" + renderParameters.FootnoteAnchorPrefix
}
htmlFlags := flags
htmlFlags |= mmark.HTML_FOOTNOTE_RETURN_LINKS
return &mmarkRenderer{
BlackfridayConfig: cfg,
Config: pcfg,
Renderer: mmark.HtmlRendererWithParameters(htmlFlags, "", "", renderParameters),
}
}
func getMmarkExtensions(cfg blackfriday_config.Config) 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
for _, extension := range cfg.Extensions {
if flag, ok := mmarkExtensionMap[extension]; ok {
flags |= flag
}
}
return flags
}
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,
}

72
markup/mmark/convert_test.go
View File

@@ -1,72 +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 mmark
import (
"testing"
"github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/common/loggers"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/markup/blackfriday/blackfriday_config"
"github.com/gohugoio/hugo/markup/converter"
"github.com/miekg/mmark"
)
func TestGetMmarkExtensions(t *testing.T) {
b := blackfriday_config.Default
// TODO: This is doing the same just with different marks...
type data struct {
testFlag int
}
b.Extensions = []string{"tables"}
b.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(b)
for _, e := range allExtensions {
if actualFlags&e.testFlag != e.testFlag {
t.Errorf("Flag %v was not found in the list of extensions.", e)
}
}
}
func TestConvert(t *testing.T) {
c := qt.New(t)
p, err := Provider.New(converter.ProviderConfig{Cfg: config.New(), Logger: loggers.NewErrorLogger()})
c.Assert(err, qt.IsNil)
conv, err := p.New(converter.DocumentContext{})
c.Assert(err, qt.IsNil)
b, err := conv.Convert(converter.RenderContext{Src: []byte("testContent")})
c.Assert(err, qt.IsNil)
c.Assert(string(b.Bytes()), qt.Equals, "<p>testContent</p>\n")
}

42
markup/mmark/renderer.go
View File

@@ -1,42 +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 mmark
import (
"bytes"
"strings"
"github.com/gohugoio/hugo/markup/blackfriday/blackfriday_config"
"github.com/gohugoio/hugo/markup/converter"
"github.com/miekg/mmark"
)
// hugoHTMLRenderer wraps a blackfriday.Renderer, typically a blackfriday.Html
// adding some custom behaviour.
type mmarkRenderer struct {
Config converter.ProviderConfig
BlackfridayConfig blackfriday_config.Config
mmark.Renderer
}
// BlockCode renders a given text as a block of code.
func (r *mmarkRenderer) BlockCode(out *bytes.Buffer, text []byte, lang string, caption []byte, subfigure bool, callouts bool) {
if r.Config.MarkupConfig.Highlight.CodeFences {
str := strings.Trim(string(text), "\n\r")
highlighted, _ := r.Config.Highlight(str, lang, "")
out.WriteString(highlighted)
} else {
r.Renderer.BlockCode(out, text, lang, caption, subfigure, callouts)
}
}