goldmark-mmd

meta.go (6568B)

---

 // package meta is a extension for the goldmark(http://github.com/yuin/goldmark).
 //
 // This extension parses YAML metadata blocks and store metadata to a
 // parser.Context.
 package meta
 
 import (
 	"bytes"
 	"fmt"
 
 	"github.com/yuin/goldmark"
 	gast "github.com/yuin/goldmark/ast"
 	"github.com/yuin/goldmark/parser"
 	"github.com/yuin/goldmark/text"
 	"github.com/yuin/goldmark/util"
 	"notabug.org/gearsix/dati"
 )
 
 type metadata map[string]interface{}
 
 type data struct {
 	Map   metadata
 	Error error
 	Node  gast.Node
 }
 
 var contextKey = parser.NewContextKey()
 
 // Get returns a metadata.
 func Get(pc parser.Context) metadata {
 	v := pc.Get(contextKey)
 	if v == nil {
 		return nil
 	}
 	d := v.(*data)
 	return d.Map
 }
 
 // TryGet tries to get a metadata.
 // If there are parsing errors, then nil and error are returned
 func TryGet(pc parser.Context) (metadata, error) {
 	dtmp := pc.Get(contextKey)
 	if dtmp == nil {
 		return nil, nil
 	}
 	d := dtmp.(*data)
 	if d.Error != nil {
 		return nil, d.Error
 	}
 	return d.Map, nil
 }
 
 const openToken = "<!--"
 const closeToken = "-->"
 const formatYaml = ':'
 const formatToml = '#'
 const formatJsonOpen = '{'
 const formatJsonClose = '}'
 
 type metaParser struct {
 	format byte
 }
 
 var defaultParser = &metaParser{}
 
 // NewParser returns a BlockParser that can parse metadata blocks.
 func NewParser() parser.BlockParser {
 	return defaultParser
 }
 
 func isOpen(line []byte) bool {
 	line = util.TrimRightSpace(util.TrimLeftSpace(line))
 	for i := 0; i < len(line); i++ {
 		if len(line[i:]) >= len(openToken)+1 && line[i] == openToken[0] {
 			signal := line[i+len(openToken)]
 			switch signal {
 			case formatYaml:
 				fallthrough
 			case formatToml:
 				fallthrough
 			case formatJsonOpen:
 				return true
 			default:
 				break
 			}
 		}
 	}
 	return false
 }
 
 // isClose will check `line` for the closing token.
 // If found, the integer returned will be the *nth* byte of `line` that the close token starts at.
 // If not found, then -1 is returned.
 func isClose(line []byte, signal byte) int {
 	//line = util.TrimRightSpace(util.TrimLeftSpace(line))
 	for i := 0; i < len(line); i++ {
 		if line[i] == signal && len(line[i:]) >= len(closeToken)+1 {
 			i++
 			if string(line[i:i+len(closeToken)]) == closeToken {
 				if signal == formatJsonClose {
 					return i
 				} else {
 					return i - 1
 				}
 			}
 		}
 	}
 	return -1
 }
 
 func (b *metaParser) Trigger() []byte {
 	return []byte{openToken[0]}
 }
 
 func (b *metaParser) Open(parent gast.Node, reader text.Reader, pc parser.Context) (gast.Node, parser.State) {
 	if linenum, _ := reader.Position(); linenum != 0 {
 		return nil, parser.NoChildren
 	}
 	line, _ := reader.PeekLine()
 
 	if isOpen(line) {
 		reader.Advance(len(openToken))
 		if b.format = reader.Peek(); b.format == formatJsonOpen {
 			b.format = formatJsonClose
 		} else {
 			reader.Advance(1)
 		}
 
 		node := gast.NewTextBlock()
 		if b.Continue(node, reader, pc) != parser.Close {
 			return node, parser.NoChildren
 		}
 		parent.AppendChild(parent, node)
 		b.Close(node, reader, pc)
 	}
 	return nil, parser.NoChildren
 }
 
 func (b *metaParser) Continue(node gast.Node, reader text.Reader, pc parser.Context) parser.State {
 	line, segment := reader.PeekLine()
 	if n := isClose(line, b.format); n != -1 && !util.IsBlank(line) {
 		segment.Stop -= len(line[n:])
 		node.Lines().Append(segment)
 		reader.Advance(n + len(closeToken) + 1)
 		return parser.Close
 	}
 	node.Lines().Append(segment)
 	return parser.Continue | parser.NoChildren
 }
 
 func (b *metaParser) loadMetadata(buf []byte) (meta metadata, err error) {
 	var format dati.DataFormat
 	switch b.format {
 	case formatYaml:
 		format = dati.YAML
 	case formatToml:
 		format = dati.TOML
 	case formatJsonClose:
 		format = dati.JSON
 	default:
 		return meta, dati.ErrUnsupportedData(string(b.format))
 	}
 	err = dati.LoadData(format, bytes.NewReader(buf), &meta)
 	return meta, err
 }
 
 func (b *metaParser) Close(node gast.Node, reader text.Reader, pc parser.Context) {
 	lines := node.Lines()
 	var buf bytes.Buffer
 	for i := 0; i < lines.Len(); i++ {
 		segment := lines.At(i)
 		buf.Write(segment.Value(reader.Source()))
 	}
 	d := &data{Node: node}
 	d.Map, d.Error = b.loadMetadata(buf.Bytes())
 
 	pc.Set(contextKey, d)
 
 	if d.Error == nil {
 		node.Parent().RemoveChild(node.Parent(), node)
 	}
 }
 
 func (b *metaParser) CanInterruptParagraph() bool {
 	return true
 }
 
 func (b *metaParser) CanAcceptIndentedLine() bool {
 	return true
 }
 
 type astTransformer struct {
 	transformerConfig
 }
 
 type transformerConfig struct {
 	// Stores metadata in ast.Document.Meta().
 	StoresInDocument bool
 }
 
 type transformerOption interface {
 	Option
 
 	// SetMetaOption sets options for the metadata parser.
 	SetMetaOption(*transformerConfig)
 }
 
 var _ transformerOption = &withStoresInDocument{}
 
 type withStoresInDocument struct {
 	value bool
 }
 
 // WithStoresInDocument is a functional option that parser will store meta in ast.Document.Meta().
 func WithStoresInDocument() Option {
 	return &withStoresInDocument{
 		value: true,
 	}
 }
 
 func newTransformer(opts ...transformerOption) parser.ASTTransformer {
 	p := &astTransformer{
 		transformerConfig: transformerConfig{
 			StoresInDocument: false,
 		},
 	}
 	for _, o := range opts {
 		o.SetMetaOption(&p.transformerConfig)
 	}
 	return p
 }
 
 func (a *astTransformer) Transform(node *gast.Document, reader text.Reader, pc parser.Context) {
 	dtmp := pc.Get(contextKey)
 	if dtmp == nil {
 		return
 	}
 	d := dtmp.(*data)
 	if d.Error != nil {
 		msg := gast.NewString([]byte(fmt.Sprintf("<!-- meta error, %s -->", d.Error)))
 		msg.SetCode(true)
 		d.Node.AppendChild(d.Node, msg)
 		return
 	}
 
 	if a.StoresInDocument {
 		for k, v := range d.Map {
 			node.AddMeta(k, v)
 		}
 	}
 }
 
 // Option interface sets options for this extension.
 type Option interface {
 	metaOption()
 }
 
 func (o *withStoresInDocument) metaOption() {}
 
 func (o *withStoresInDocument) SetMetaOption(c *transformerConfig) {
 	c.StoresInDocument = o.value
 }
 
 type meta struct {
 	options []Option
 }
 
 // Meta is a extension for the goldmark.
 var Meta = &meta{}
 
 // New returns a new Meta extension.
 func New(opts ...Option) goldmark.Extender {
 	e := &meta{
 		options: opts,
 	}
 	return e
 }
 
 // Extend implements goldmark.Extender.
 func (e *meta) Extend(m goldmark.Markdown) {
 	topts := []transformerOption{}
 	for _, opt := range e.options {
 		if topt, ok := opt.(transformerOption); ok {
 			topts = append(topts, topt)
 		}
 	}
 	m.Parser().AddOptions(
 		parser.WithBlockParsers(
 			util.Prioritized(NewParser(), 0),
 		),
 	)
 	m.Parser().AddOptions(
 		parser.WithASTTransformers(
 			util.Prioritized(newTransformer(topts...), 0),
 		),
 	)
 }