func markdownRender(ctx *RenderingContext) []byte {
if ctx.RenderTOC {
return blackfriday.Markdown(ctx.Content,
getHTMLRenderer(blackfriday.HTML_TOC, ctx),
getMarkdownExtensions(ctx))
}
return blackfriday.Markdown(ctx.Content, getHTMLRenderer(0, ctx),
getMarkdownExtensions(ctx))
}
func main() {
flag.Parse()
args := flag.Args()
renderer := &Console{}
extensions := 0 |
blackfriday.EXTENSION_NO_INTRA_EMPHASIS |
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
if len(args) > 0 {
for i := 0; i < len(args); i++ {
input, err := ioutil.ReadFile(args[i])
if err != nil {
os.Stderr.WriteString(fmt.Sprintf("mdcat: %s: unable to read from file\n", args[i]))
os.Exit(1)
}
output := blackfriday.Markdown(input, renderer, extensions)
os.Stdout.Write(output)
}
} else {
reader := bufio.NewReader(os.Stdin)
var input []byte
buffer := make([]byte, 2<<20)
for {
count, err := reader.Read(buffer)
if count == 0 {
break
}
if err != nil {
os.Stderr.WriteString("mdcat: unable to read from pipe\n")
os.Exit(1)
}
input = append(input, buffer...)
}
output := blackfriday.Markdown(input, renderer, extensions)
os.Stdout.Write(output)
}
}
func (post *PostModel) RenderPost(postId string) *Post {
result := post.Get(postId)
renderer := blackfriday.HtmlRenderer(post.html_flags, "", "")
if result.Type == 1 {
result.Content = string(blackfriday.Markdown([]byte(result.Content), renderer, post.extensions))
}
// Also render all blog comments as markdown
for i, v := range result.Comments {
result.Comments[i].Content = string(blackfriday.Markdown([]byte(v.Content), renderer, post.extensions))
}
return result
}
func markdownFile(path string) (string, error) {
if input, err := ioutil.ReadFile(path); err == nil {
htmlFlags := 0
htmlFlags |= blackfriday.HTML_USE_XHTML
htmlFlags |= blackfriday.HTML_USE_SMARTYPANTS
htmlFlags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
htmlFlags |= blackfriday.HTML_SMARTYPANTS_LATEX_DASHES
renderer := blackfriday.HtmlRenderer(htmlFlags, "", "")
// set up the parser
extensions := 0
extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
extensions |= blackfriday.EXTENSION_TABLES
extensions |= blackfriday.EXTENSION_FENCED_CODE
extensions |= blackfriday.EXTENSION_AUTOLINK
extensions |= blackfriday.EXTENSION_STRIKETHROUGH
extensions |= blackfriday.EXTENSION_SPACE_HEADERS
extensions |= blackfriday.EXTENSION_FOOTNOTES
data := blackfriday.Markdown(input, renderer, extensions)
return string(data), nil
} else {
return "", err
}
}
// RenderRaw renders Markdown to HTML without handling special links.
func RenderRaw(body []byte, urlPrefix string) []byte {
htmlFlags := 0
htmlFlags |= blackfriday.HTML_SKIP_STYLE
htmlFlags |= blackfriday.HTML_OMIT_CONTENTS
renderer := &Renderer{
Renderer: blackfriday.HtmlRenderer(htmlFlags, "", ""),
urlPrefix: urlPrefix,
}
// set up the parser
extensions := 0
extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
extensions |= blackfriday.EXTENSION_TABLES
extensions |= blackfriday.EXTENSION_FENCED_CODE
extensions |= blackfriday.EXTENSION_AUTOLINK
extensions |= blackfriday.EXTENSION_STRIKETHROUGH
extensions |= blackfriday.EXTENSION_SPACE_HEADERS
extensions |= blackfriday.EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK
if setting.Markdown.EnableHardLineBreak {
extensions |= blackfriday.EXTENSION_HARD_LINE_BREAK
}
body = blackfriday.Markdown(body, renderer, extensions)
return body
}
// Markdown renders GitHub Flavored Markdown text.
func Markdown(text []byte) []byte {
htmlFlags := 0
renderer := &renderer{Html: blackfriday.HtmlRenderer(htmlFlags, "", "").(*blackfriday.Html)}
// Parser extensions for GitHub Flavored Markdown.
extensions := 0
extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
extensions |= blackfriday.EXTENSION_TABLES
extensions |= blackfriday.EXTENSION_FENCED_CODE
extensions |= blackfriday.EXTENSION_AUTOLINK
extensions |= blackfriday.EXTENSION_STRIKETHROUGH
extensions |= blackfriday.EXTENSION_SPACE_HEADERS
//extensions |= blackfriday.EXTENSION_HARD_LINE_BREAK
unsanitized := blackfriday.Markdown(text, renderer, extensions)
// GitHub Flavored Markdown-like sanitization policy.
p := bluemonday.UGCPolicy()
p.AllowAttrs("class").Matching(bluemonday.SpaceSeparatedTokens).OnElements("div", "span")
p.AllowAttrs("class", "name").Matching(bluemonday.SpaceSeparatedTokens).OnElements("a")
p.AllowAttrs("rel").Matching(regexp.MustCompile(`^nofollow$`)).OnElements("a")
p.AllowAttrs("aria-hidden").Matching(regexp.MustCompile(`^true$`)).OnElements("a")
p.AllowDataURIImages()
return p.SanitizeBytes(unsanitized)
}
// RenderPost runs the input source through the blackfriday library.
func RenderPost(post *Post, input []byte, page PageParams) ([]byte, error) {
tpl, err := page.getTemplate("post")
if err != nil {
return nil, err
}
content := blackfriday.Markdown(
input,
blackfriday.HtmlRenderer(page.Blog.GetMarkdownHTMLOptions(), "", ""),
page.Blog.GetMarkdownExtensions())
page.Title = post.Title
params := PostPageParams{
Post: post,
Content: string(content),
PageParams: page,
}
buf := new(bytes.Buffer)
if err := tpl.Execute(buf, params); err != nil {
return nil, err
}
return wrapPage(buf.Bytes(), params.PageParams)
}
func RenderMarkdown(input []byte) []byte {
// set up the HTML renderer
htmlFlags := 0
htmlFlags |= blackfriday.HTML_USE_XHTML
htmlFlags |= blackfriday.HTML_USE_SMARTYPANTS
htmlFlags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
htmlFlags |= blackfriday.HTML_SMARTYPANTS_LATEX_DASHES
htmlFlags |= blackfriday.HTML_FOOTNOTE_RETURN_LINKS
renderer := &renderer{
Html: blackfriday.HtmlRendererWithParameters(htmlFlags, "", "", blackfriday.HtmlRendererParameters{
FootnoteReturnLinkContents: "↩",
}).(*blackfriday.Html),
}
// set up the parser
extensions := 0
extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
extensions |= blackfriday.EXTENSION_TABLES
extensions |= blackfriday.EXTENSION_FENCED_CODE
extensions |= blackfriday.EXTENSION_AUTOLINK
extensions |= blackfriday.EXTENSION_STRIKETHROUGH
extensions |= blackfriday.EXTENSION_SPACE_HEADERS
extensions |= blackfriday.EXTENSION_HEADER_IDS
extensions |= blackfriday.EXTENSION_FOOTNOTES
return blackfriday.Markdown(input, renderer, extensions)
}
// MarkdownToTextNoMetadata is the same as MarkdownToText only skipping the
// detection and parsing of any leading metadata. If opts is nil the defaults
// will be used.
func MarkdownToTextNoMetadata(markdown []byte, opts *Options) []byte {
opts = resolveOpts(opts)
rend := &renderer{
width: opts.Width,
color: opts.Color,
tableAlignOptions: opts.TableAlignOptions,
headerPrefix: opts.HeaderPrefix,
headerSuffix: opts.HeaderSuffix,
}
markdown = bytes.Replace(markdown, []byte("\n///\n"), []byte(""), -1)
txt := blackfriday.Markdown(markdown, rend,
blackfriday.EXTENSION_NO_INTRA_EMPHASIS|
blackfriday.EXTENSION_TABLES|
blackfriday.EXTENSION_FENCED_CODE|
blackfriday.EXTENSION_AUTOLINK|
blackfriday.EXTENSION_STRIKETHROUGH|
blackfriday.EXTENSION_DEFINITION_LISTS)
for rend.level > 0 {
txt = append(txt, markIndentStop)
rend.level--
}
if len(txt) > 0 {
txt = bytes.Replace(txt, []byte(" \n"), []byte(" "), -1)
txt = bytes.Replace(txt, []byte("\n"), []byte(" "), -1)
txt = reflow(txt, opts.Indent1, opts.Indent2, rend.width)
txt = bytes.Replace(txt, []byte{markNBSP}, []byte(" "), -1)
txt = bytes.Replace(txt, []byte{markLineBreak}, []byte("\n"), -1)
}
return txt
}
//渲染评论HTML代码
func (cl CommentNode) renderItemBegin(b *bytes.Buffer, sortType string) {
if cl.Status == 2 {
cl.Content = "[已删除]"
}
b.WriteString(fmt.Sprintf(`<div id="cm-%d" class="cm" data-id="%v">
<div class="vt">
<a class="icon-thumbs-up up" href="javascript:"></a>
<a class="icon-thumbs-down down" href="javascript:"></a>
</div>
<div class="ct">
<div class="uif">
<a class="ep" href="javascript:">[–]</a>
<a href="/user/%v">%v</a>
<i class="v" title="↑%v ↓%v">%v分</i> <i class="t">%v</i>
</div>
<div class="tx">%s</div>
<div class="ed">
<a href="/link/permacoment/%v/%v/?cm_order=%s" class="cbtn">查看</a>
<a href="javascript:" class="cbtn rp">回复</a>
</div>`, cl.Id, cl.Id,
cl.UserId, cl.UserName,
cl.VoteUp, cl.VoteDown,
cl.VoteUp-cl.VoteDown,
cl.SinceTime(), blackfriday.Markdown([]byte(cl.Content), renderer, extensions), //strings.Replace(cl.Content, "\n", "<br/>", -1),
cl.LinkId, cl.Id, sortType))
}
// Renders markdown in submitted messages.
func Render(raw []byte) []byte {
htmlFlags := 0
htmlFlags |= blackfriday.HTML_USE_XHTML
htmlFlags |= blackfriday.HTML_USE_SMARTYPANTS
htmlFlags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
htmlFlags |= blackfriday.HTML_SMARTYPANTS_LATEX_DASHES
renderer := blackfriday.HtmlRenderer(htmlFlags, "", "")
// set up the parser
extensions := 0
extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
extensions |= blackfriday.EXTENSION_TABLES
extensions |= blackfriday.EXTENSION_FENCED_CODE
extensions |= blackfriday.EXTENSION_STRIKETHROUGH
extensions |= blackfriday.EXTENSION_SPACE_HEADERS
escaped := new(bytes.Buffer)
template.HTMLEscape(escaped, raw)
rendered := blackfriday.Markdown(escaped.Bytes(), renderer, extensions)
enabled := true
fmt.Println("Raw message:")
fmt.Println(string(raw))
if enabled {
fmt.Println("Rendered message:")
fmt.Println(string(rendered))
return rendered
}
return raw
}
func RenderMarkdown(rawBytes []byte, urlPrefix string) []byte {
// slow!
//body := RenderSpecialLink(rawBytes, urlPrefix)
body := rawBytes
htmlFlags := 0
// htmlFlags |= gfm.HTML_USE_XHTML
// htmlFlags |= gfm.HTML_USE_SMARTYPANTS
// htmlFlags |= gfm.HTML_SMARTYPANTS_FRACTIONS
// htmlFlags |= gfm.HTML_SMARTYPANTS_LATEX_DASHES
// htmlFlags |= gfm.HTML_SKIP_HTML
htmlFlags |= gfm.HTML_SKIP_STYLE
//htmlFlags |= gfm.HTML_SKIP_SCRIPT
htmlFlags |= gfm.HTML_GITHUB_BLOCKCODE
htmlFlags |= gfm.HTML_OMIT_CONTENTS
// htmlFlags |= gfm.HTML_COMPLETE_PAGE
renderer := &CustomRender{
Renderer: gfm.HtmlRenderer(htmlFlags, "", ""),
urlPrefix: urlPrefix,
}
// set up the parser
extensions := 0
extensions |= gfm.EXTENSION_NO_INTRA_EMPHASIS
extensions |= gfm.EXTENSION_TABLES
extensions |= gfm.EXTENSION_FENCED_CODE
extensions |= gfm.EXTENSION_AUTOLINK
extensions |= gfm.EXTENSION_STRIKETHROUGH
extensions |= gfm.EXTENSION_HARD_LINE_BREAK
extensions |= gfm.EXTENSION_SPACE_HEADERS
extensions |= gfm.EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK
body = gfm.Markdown(body, renderer, extensions)
return body
}
func markdown(raw []byte) []byte {
htmlFlags := 0
htmlFlags |= blackfriday.HTML_USE_XHTML
htmlFlags |= blackfriday.HTML_USE_SMARTYPANTS
htmlFlags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
htmlFlags |= blackfriday.HTML_SMARTYPANTS_LATEX_DASHES
htmlFlags |= blackfriday.HTML_OMIT_CONTENTS
htmlFlags |= blackfriday.HTML_COMPLETE_PAGE
renderer := &CustomRender{
Renderer: blackfriday.HtmlRenderer(htmlFlags, "", ""),
}
// set up the parser
extensions := 0
extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
extensions |= blackfriday.EXTENSION_TABLES
extensions |= blackfriday.EXTENSION_FENCED_CODE
extensions |= blackfriday.EXTENSION_AUTOLINK
extensions |= blackfriday.EXTENSION_STRIKETHROUGH
extensions |= blackfriday.EXTENSION_HARD_LINE_BREAK
extensions |= blackfriday.EXTENSION_SPACE_HEADERS
extensions |= blackfriday.EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK
body := blackfriday.Markdown(raw, renderer, extensions)
return body
}
func RenderRawMarkdown(body []byte, urlPrefix string) []byte {
htmlFlags := 0
// htmlFlags |= blackfriday.HTML_USE_XHTML
// htmlFlags |= blackfriday.HTML_USE_SMARTYPANTS
// htmlFlags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
// htmlFlags |= blackfriday.HTML_SMARTYPANTS_LATEX_DASHES
// htmlFlags |= blackfriday.HTML_SKIP_HTML
htmlFlags |= blackfriday.HTML_SKIP_STYLE
// htmlFlags |= blackfriday.HTML_SKIP_SCRIPT
// htmlFlags |= blackfriday.HTML_GITHUB_BLOCKCODE
htmlFlags |= blackfriday.HTML_OMIT_CONTENTS
// htmlFlags |= blackfriday.HTML_COMPLETE_PAGE
renderer := &CustomRender{
Renderer: blackfriday.HtmlRenderer(htmlFlags, "", ""),
urlPrefix: urlPrefix,
}
// set up the parser
extensions := 0
extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
extensions |= blackfriday.EXTENSION_TABLES
extensions |= blackfriday.EXTENSION_FENCED_CODE
extensions |= blackfriday.EXTENSION_AUTOLINK
extensions |= blackfriday.EXTENSION_STRIKETHROUGH
extensions |= blackfriday.EXTENSION_SPACE_HEADERS
extensions |= blackfriday.EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK
if setting.Markdown.EnableHardLineBreak {
extensions |= blackfriday.EXTENSION_HARD_LINE_BREAK
}
body = blackfriday.Markdown(body, renderer, extensions)
return body
}
// Markdown formats input using a plain-text renderer, and
// then returns up to the first `wordcount` words as a summary.
func Markdown(input []byte, wordcount int) []byte {
words := bytes.Fields(blackfriday.Markdown(input, renderer{}, 0))
if wordcount > len(words) {
wordcount = len(words)
}
return bytes.Join(words[0:wordcount], []byte{' '})
}
func renderMarkdown(appDir string, path string, markdownContent string, jsonContent map[string]interface{}) {
renderer, extensions := configureBlackFriday(path)
content := blackfriday.Markdown([]byte(markdownContent), renderer, extensions)
re2 := regexp.MustCompile("/content/")
src := []byte(path)
replacement := []byte("/views/")
htmlPath := re2.ReplaceAll(src, replacement)
template, _ := loadHTML(appDir, string(htmlPath))
result, err := ParseAndInsert(appDir, string(content), jsonContent, template)
if err != nil {
log.Fatal(err)
}
re := regexp.MustCompile("/content/(.+)")
if matches := re.FindStringSubmatch(path); matches != nil && len(matches) == 2 {
oldPath := matches[1]
//tmpPath is the expected location before some manipulation around the filename, e.g. convert
// blah.fuel to blah.html
tmpPath := fmt.Sprintf("%s/public/%s", appDir, oldPath)
//convert from .fuel to .html
newDir, newPath := convertFromFuelToHTML(tmpPath)
//make the new dir in public
os.MkdirAll(newDir, 0777)
//output is a []byte -- write it to a file
ioutil.WriteFile(newPath, []byte(result), 0644)
}
}
func RenderMarkdown(mdStr string) string {
htmlFlags := 0
htmlFlags |= blackfriday.HTML_USE_XHTML
// htmlFlags |= blackfriday.HTML_USE_SMARTYPANTS
// htmlFlags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
// htmlFlags |= blackfriday.HTML_SMARTYPANTS_LATEX_DASHES
htmlFlags |= blackfriday.HTML_SKIP_HTML
htmlFlags |= blackfriday.HTML_SKIP_STYLE
htmlFlags |= blackfriday.HTML_SKIP_SCRIPT
htmlFlags |= blackfriday.HTML_GITHUB_BLOCKCODE
htmlFlags |= blackfriday.HTML_OMIT_CONTENTS
htmlFlags |= blackfriday.HTML_COMPLETE_PAGE
renderer := blackfriday.HtmlRenderer(htmlFlags, "", "")
// set up the parser
extensions := 0
extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
extensions |= blackfriday.EXTENSION_TABLES
extensions |= blackfriday.EXTENSION_FENCED_CODE
extensions |= blackfriday.EXTENSION_AUTOLINK
extensions |= blackfriday.EXTENSION_STRIKETHROUGH
extensions |= blackfriday.EXTENSION_HARD_LINE_BREAK
extensions |= blackfriday.EXTENSION_SPACE_HEADERS
extensions |= blackfriday.EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK
body := blackfriday.Markdown([]byte(mdStr), renderer, extensions)
return string(body)
}
func RenderMarkdownSafe(input []byte) []byte {
// set up the HTML renderer
flags := 0
flags |= blackfriday.HTML_USE_XHTML
flags |= blackfriday.HTML_USE_SMARTYPANTS
flags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
flags |= blackfriday.HTML_SMARTYPANTS_LATEX_DASHES
flags |= blackfriday.HTML_SKIP_HTML
flags |= blackfriday.HTML_SKIP_SCRIPT
flags |= blackfriday.HTML_SKIP_STYLE
// flags |= blackfriday.HTML_TOC
// flags |= blackfriday.HTML_GITHUB_BLOCKCODE
renderer := blackfriday.HtmlRenderer(flags, "", "")
// set up the parser
ext := 0
ext |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
ext |= blackfriday.EXTENSION_TABLES
ext |= blackfriday.EXTENSION_FENCED_CODE
ext |= blackfriday.EXTENSION_AUTOLINK
ext |= blackfriday.EXTENSION_STRIKETHROUGH
ext |= blackfriday.EXTENSION_SPACE_HEADERS
ext |= blackfriday.EXTENSION_HARD_LINE_BREAK
ext |= blackfriday.EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK
return blackfriday.Markdown(input, renderer, ext)
}
func (p *Post) html() (T.HTML, error) {
body, err := p.withImages()
if err != nil {
return "", err
}
extensions := md.EXTENSION_SPACE_HEADERS | md.EXTENSION_TABLES | md.EXTENSION_NO_INTRA_EMPHASIS | md.EXTENSION_STRIKETHROUGH | md.EXTENSION_FOOTNOTES
renderer := md.HtmlRenderer(0, "", "")
return T.HTML(md.Markdown([]byte(body), renderer, extensions)), nil
}
/*
Process a subset of markdown elements and prints them with flying colours!
*/
func Markdown(input []byte) []byte {
tr := NewTerminalRenderer()
ret := blackfriday.Markdown(input, tr, blackfriday.EXTENSION_STRIKETHROUGH)
//get rid of \n at the end of the text
for len(ret) > 0 && ret[len(ret)-1] == '\n' {
ret = ret[:len(ret)-1]
}
return ret
}
func ToHtml(content string) template.HTML {
htmlFlags := 0
htmlFlags |= blackfriday.HTML_USE_SMARTYPANTS
htmlFlags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
renderer := blackfriday.HtmlRenderer(htmlFlags, "", "")
html := blackfriday.Markdown([]byte(content), renderer, enabled_md_extensions)
return template.HTML(bluemonday.UGCPolicy().SanitizeBytes(html))
}
// Process processes the contents of a page in b. It parses the metadata
// (if any) and uses the template (if found).
func (md Markdown) Process(c *Config, requestPath string, b []byte, ctx middleware.Context) ([]byte, error) {
var metadata = newMetadata()
var markdown []byte
var err error
// find parser compatible with page contents
parser := findParser(b)
if parser == nil {
// if not found, assume whole file is markdown (no front matter)
markdown = b
} else {
// if found, assume metadata present and parse.
markdown, err = parser.Parse(b)
if err != nil {
return nil, err
}
metadata = parser.Metadata()
}
// if template is not specified, check if Default template is set
if metadata.Template == "" {
if _, ok := c.Templates[DefaultTemplate]; ok {
metadata.Template = DefaultTemplate
}
}
// if template is set, load it
var tmpl []byte
if metadata.Template != "" {
if t, ok := c.Templates[metadata.Template]; ok {
tmpl, err = ioutil.ReadFile(t)
}
if err != nil {
return nil, err
}
}
// process markdown
extns := blackfriday.EXTENSION_TABLES | blackfriday.EXTENSION_FENCED_CODE | blackfriday.EXTENSION_STRIKETHROUGH | blackfriday.EXTENSION_DEFINITION_LISTS
markdown = blackfriday.Markdown(markdown, c.Renderer, extns)
// set it as body for template
metadata.Variables["body"] = string(markdown)
title := metadata.Title
if title == "" {
title = filepath.Base(requestPath)
var extension = filepath.Ext(requestPath)
title = title[0 : len(title)-len(extension)]
}
metadata.Variables["title"] = title
return md.processTemplate(c, requestPath, tmpl, metadata, ctx)
}
// Markdown returns the HTML contents of the markdown contained in filename
// (relative to the site root).
func (c Context) Markdown(filename string) (string, error) {
body, err := c.Include(filename)
if err != nil {
return "", err
}
renderer := blackfriday.HtmlRenderer(0, "", "")
extns := blackfriday.EXTENSION_TABLES | blackfriday.EXTENSION_FENCED_CODE | blackfriday.EXTENSION_STRIKETHROUGH | blackfriday.EXTENSION_DEFINITION_LISTS
markdown := blackfriday.Markdown([]byte(body), renderer, extns)
return string(markdown), nil
}
func main() {
// read the input
var input []byte
var err os.Error
switch len(os.Args) {
case 1:
if input, err = ioutil.ReadAll(os.Stdin); err != nil {
fmt.Fprintln(os.Stderr, "Error reading from Stdin:", err)
os.Exit(-1)
}
case 2, 3:
if input, err = ioutil.ReadFile(os.Args[1]); err != nil {
fmt.Fprintln(os.Stderr, "Error reading from", os.Args[1], ":", err)
os.Exit(-1)
}
default:
fmt.Fprintln(os.Stderr, "Usage:", os.Args[0], "[inputfile [outputfile]]")
os.Exit(-1)
}
// set up options
var extensions uint32
extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
extensions |= blackfriday.EXTENSION_TABLES
extensions |= blackfriday.EXTENSION_FENCED_CODE
extensions |= blackfriday.EXTENSION_AUTOLINK
extensions |= blackfriday.EXTENSION_STRIKETHROUGH
extensions |= blackfriday.EXTENSION_SPACE_HEADERS
html_flags := 0
html_flags |= blackfriday.HTML_USE_XHTML
// note: uncomment the following line to enable smartypants
// it is commented out by default so that markdown
// compatibility tests pass
//html_flags |= blackfriday.HTML_USE_SMARTYPANTS
html_flags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
html_flags |= blackfriday.HTML_SMARTYPANTS_LATEX_DASHES
// render the data
output := blackfriday.Markdown(input, blackfriday.HtmlRenderer(html_flags), extensions)
// output the result
if len(os.Args) == 3 {
if err = ioutil.WriteFile(os.Args[2], output, 0644); err != nil {
fmt.Fprintln(os.Stderr, "Error writing to", os.Args[2], ":", err)
os.Exit(-1)
}
} else {
if _, err = os.Stdout.Write(output); err != nil {
fmt.Fprintln(os.Stderr, "Error writing to Stdout:", err)
os.Exit(-1)
}
}
}
func getHtmlPageData(title string, md string) *PageData {
mdData := MarkdownData{}
pageData := PageData{Title: "Walking Noticeboard"}
mdData.Title = title
mdData.MdContent = md
htmlRenderer := blackfriday.HtmlRenderer(htmlFlags, "", "")
mdData.HtmlContent = template.HTML(blackfriday.Markdown([]byte(md), htmlRenderer, htmlExt))
pageData.MarkDown = mdData
return &pageData
}
func markdownFormatter(formatter *Formatter, stream io.Reader, args ...string) (string, error) {
buf := &bytes.Buffer{}
io.Copy(buf, stream)
md := blackfriday.Markdown(buf.Bytes(), mkdHtmlRenderer,
blackfriday.EXTENSION_NO_INTRA_EMPHASIS|
blackfriday.EXTENSION_TABLES|
blackfriday.EXTENSION_AUTOLINK|
blackfriday.EXTENSION_FENCED_CODE|
blackfriday.EXTENSION_HEADER_IDS|
blackfriday.EXTENSION_LAX_HTML_BLOCKS)
return sanitationPolicy.Sanitize(string(md)), nil
}
func getLongDescriptionForGopkg(gopkg string) (string, error) {
if !strings.HasPrefix(gopkg, "github.com/") {
return "", nil
}
resp, err := http.Get("https://api.github.com/repos/" + gopkg[len("github.com/"):] + "/readme")
if err != nil {
return "", err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("unexpected HTTP status: got %d, want %d", resp.StatusCode, http.StatusOK)
}
var rr readmeReply
if err := json.NewDecoder(resp.Body).Decode(&rr); err != nil {
return "", err
}
if rr.Encoding != "base64" {
return "", fmt.Errorf("unexpected encoding: got %q, want %q", rr.Encoding, "base64")
}
content, err := base64.StdEncoding.DecodeString(rr.Content)
if err != nil {
return "", err
}
// Supported filename suffixes are from
// https://github.com/github/markup/blob/master/README.md
// NOTE(stapelberg): Ideally, we’d use https://github.com/github/markup
// itself to render to HTML, then convert HTML to plaintext. That sounds
// fairly involved, but it’d be the most correct solution to the problem at
// hand. Our current code just knows markdown, which is good enough since
// most (Go?) projects in fact use markdown for their README files.
if !strings.HasSuffix(rr.Name, "md") &&
!strings.HasSuffix(rr.Name, "markdown") &&
!strings.HasSuffix(rr.Name, "mdown") &&
!strings.HasSuffix(rr.Name, "mkdn") {
return strings.TrimSpace(string(content)), nil
}
output := blackfriday.Markdown(content, &TextRenderer{}, 0)
// Shell out to fmt(1) to line-wrap the output.
cmd := exec.Command("fmt")
cmd.Stdin = bytes.NewBuffer(output)
out, err := cmd.Output()
if err != nil {
return "", err
}
return strings.TrimSpace(string(out)), nil
}
func (g *Generator) markdown(name string, argsv ...string) string {
// find template with correct name
t := g.Master.Lookup(name)
if t == nil {
abort("cannot find template '%s' (used as markdown function argument)", name)
}
// create new scope and execute the template
args := g.ParseArgs(argsv)
g.PushScope(args)
defer g.PopScope()
buf := bytes.NewBuffer(nil)
err := t.Execute(buf, nil)
if err != nil {
abort("ff%s", err)
}
// set up the HTML renderer
htmlFlags := 0
htmlFlags |= blackfriday.HTML_USE_XHTML
htmlFlags |= blackfriday.HTML_USE_SMARTYPANTS
htmlFlags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
htmlFlags |= blackfriday.HTML_SMARTYPANTS_LATEX_DASHES
htmlFlags |= blackfriday.HTML_SKIP_SCRIPT
htmlFlags |= blackfriday.HTML_GITHUB_BLOCKCODE
// set up the parser
extensions := 0
extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
extensions |= blackfriday.EXTENSION_TABLES
extensions |= blackfriday.EXTENSION_FENCED_CODE
extensions |= blackfriday.EXTENSION_AUTOLINK
extensions |= blackfriday.EXTENSION_STRIKETHROUGH
extensions |= blackfriday.EXTENSION_SPACE_HEADERS
extensions |= blackfriday.EXTENSION_FOOTNOTES
if str2bool(args["toc"]) {
htmlFlags |= blackfriday.HTML_TOC
}
// convert markdown to html
basename := path.Base(name)
extension := path.Ext(basename)
mdname := basename[0 : len(basename)-len(extension)]
renderer := blackfriday.HtmlRenderer(htmlFlags, mdname, "")
html := blackfriday.Markdown(buf.Bytes(), renderer, extensions)
return string(html)
}
func renderMarkdown(title string, input []byte) []byte {
var renderer md.Renderer
htmlFlags := 0
extensions := 0
css := "../stylesheets/styles.css"
htmlFlags |= md.HTML_USE_XHTML
htmlFlags |= md.HTML_USE_SMARTYPANTS
htmlFlags |= md.HTML_SMARTYPANTS_FRACTIONS
htmlFlags |= md.HTML_COMPLETE_PAGE
renderer = md.HtmlRenderer(htmlFlags, title, css)
return md.Markdown(input, renderer, extensions)
}
func Render(doc []byte) []byte {
renderer := RoffRenderer(0)
extensions := 0
extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
extensions |= blackfriday.EXTENSION_TABLES
extensions |= blackfriday.EXTENSION_FENCED_CODE
extensions |= blackfriday.EXTENSION_AUTOLINK
extensions |= blackfriday.EXTENSION_SPACE_HEADERS
extensions |= blackfriday.EXTENSION_FOOTNOTES
extensions |= blackfriday.EXTENSION_TITLEBLOCK
return blackfriday.Markdown(doc, renderer, extensions)
}