mark

by a8m

a8m / mark

A markdown processor written in Go. built for fun.

200 Stars 15 Forks Last release: Not found MIT License 364 Commits 2 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:

Archived. use https://github.com/russross/blackfriday instead

Mark Test coverage Build status Go doc license

A markdown processor written in Go. built for fun.

Mark is a markdown processor that supports all the features of GFM, smartypants and smart-fractions rendering.
It was built with a nice-ish concurrency model that fully inspired from Rob Pike - Lexical Scanning talk and marked project.
Please note that any contribution is welcomed and appreciated, so feel free to take some task here.

Table of contents:

Get Started

Installation

$ go get github.com/a8m/mark

Examples

Add to your project: ```go import ( "fmt" "github.com/a8m/mark" )

func main() { html := mark.Render("I am using markdown.") fmt.Println(html) //

I am using markdown.

} ```

or using as a command line tool:

1. install:

sh
$ go get github.com/a8m/mark/cmd/mark

2. usage:

sh
$ echo 'hello __world__...' | mark -smartypants
or:
sh
$ mark -i hello.text -o hello.html

Documentation

Render

Staic rendering function.

go
html := mark.Render("I am using __markdown__.")
fmt.Println(html)
// 

I am using markdown.

Mark
New

New
get string as an input, and
mark.Options
as configuration and return a new
Mark
.
go
m := mark.New("hello world...", &mark.Options{
    Smartypants: true,
})
fmt.Println(m.Render())
// 

hello world…

// Note: you can instantiate it like so: mark.New("...", nil) to get the default options.
Mark.AddRenderFn

AddRenderFn
let you pass
NodeType
, and
RenderFn
function and override the default
Node
rendering.
To get all Nodes type and their fields/methods, see the full documentation: go-doc

Example 1:

go
m := mark.New("hello", nil)
m.AddRenderFn(mark.NodeParagraph, func(node mark.Node) (s string) {
    p, _ := node.(*mark.ParagraphNode)
    s += "

" for _, n := range p.Nodes { s += n.Render() } s += "

" return }) fmt.Println(m.Render()) //

hello

Example 2:

go
m := mark.New("# Hello world", &mark.Options{
    Smartypants: true,
    Fractions:   true,
})
m.AddRenderFn(mark.NodeHeading, func(node mark.Node) string {
    h, _ := node.(*mark.HeadingNode)
    return fmt.Sprintf("", h.Level, h.Text)
})
fmt.Println(m.Render())
// 
Mark.Render

Parse and render input.

go
m := mark.New("hello", nil)
fmt.Println(m.Render())
// 

hello

Smartypants and Smartfractions

Mark also support smartypants and smartfractions rendering

go
func main() {
    opts := mark.DefaultOptions()
    opts.Smartypants = true
    opts.Fractions = true
    m := mark.New("'hello', 1/2 beer please...", opts)
    fmt.Println(m.Render())
    // ‘hello’, ½ beer please…
}

Todo

  • Commonmark support v0.2
  • Expand documentation
  • Configuration options
    • gfm, table
    • heading(auto hashing)

License

MIT

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.