1 files changed, 85 insertions, 0 deletions
diff --git a/vendor/github.com/gomarkdown/markdown/markdown.go b/vendor/github.com/gomarkdown/markdown/markdown.go
new file mode 100644
index 00000000..fd5c1cfb
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/markdown.go
@@ -0,0 +1,85 @@
+package markdown
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/gomarkdown/markdown/ast"
+	"github.com/gomarkdown/markdown/html"
+	"github.com/gomarkdown/markdown/parser"
+)
+
+// Renderer is an interface for implementing custom renderers.
+type Renderer interface {
+	// RenderNode renders markdown node to w.
+	// It's called once for a leaf node.
+	// It's called twice for non-leaf nodes:
+	// * first with entering=true
+	// * then with entering=false
+	//
+	// Return value is a way to tell the calling walker to adjust its walk
+	// pattern: e.g. it can terminate the traversal by returning Terminate. Or it
+	// can ask the walker to skip a subtree of this node by returning SkipChildren.
+	// The typical behavior is to return GoToNext, which asks for the usual
+	// traversal to the next node.
+	RenderNode(w io.Writer, node ast.Node, entering bool) ast.WalkStatus
+
+	// RenderHeader is a method that allows the renderer to produce some
+	// content preceding the main body of the output document. The header is
+	// understood in the broad sense here. For example, the default HTML
+	// renderer will write not only the HTML document preamble, but also the
+	// table of contents if it was requested.
+	//
+	// The method will be passed an entire document tree, in case a particular
+	// implementation needs to inspect it to produce output.
+	//
+	// The output should be written to the supplied writer w. If your
+	// implementation has no header to write, supply an empty implementation.
+	RenderHeader(w io.Writer, ast ast.Node)
+
+	// RenderFooter is a symmetric counterpart of RenderHeader.
+	RenderFooter(w io.Writer, ast ast.Node)
+}
+
+// Parse parsers a markdown document using provided parser. If parser is nil,
+// we use parser configured with parser.CommonExtensions.
+//
+// It returns AST (abstract syntax tree) that can be converted to another
+// format using Render function.
+func Parse(markdown []byte, p *parser.Parser) ast.Node {
+	if p == nil {
+		p = parser.New()
+	}
+	return p.Parse(markdown)
+}
+
+// Render uses renderer to convert parsed markdown document into a different format.
+//
+// To convert to HTML, pass html.Renderer
+func Render(doc ast.Node, renderer Renderer) []byte {
+	var buf bytes.Buffer
+	renderer.RenderHeader(&buf, doc)
+	ast.WalkFunc(doc, func(node ast.Node, entering bool) ast.WalkStatus {
+		return renderer.RenderNode(&buf, node, entering)
+	})
+	renderer.RenderFooter(&buf, doc)
+	return buf.Bytes()
+}
+
+// ToHTML converts markdownDoc to HTML.
+//
+// You can optionally pass a parser and renderer. This allows to customize
+// a parser, use a customized html render or use completely custom renderer.
+//
+// If you pass nil for both, we use parser configured with parser.CommonExtensions
+// and html.Renderer configured with html.CommonFlags.
+func ToHTML(markdown []byte, p *parser.Parser, renderer Renderer) []byte {
+	doc := Parse(markdown, p)
+	if renderer == nil {
+		opts := html.RendererOptions{
+			Flags: html.CommonFlags,
+		}
+		renderer = html.NewRenderer(opts)
+	}
+	return Render(doc, renderer)
+}