forgejo/modules/markup/markdown/markdown.go

201 lines
5.8 KiB
Go
Raw Normal View History

2014-04-10 20:20:58 +02:00
// Copyright 2014 The Gogs Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
2016-02-20 23:10:05 +01:00
package markdown
2014-04-10 20:20:58 +02:00
import (
"bytes"
"strings"
"code.gitea.io/gitea/modules/markup"
"code.gitea.io/gitea/modules/setting"
2017-07-06 22:38:38 +02:00
"github.com/russross/blackfriday"
2014-04-10 20:20:58 +02:00
)
2016-02-20 23:10:05 +01:00
// Renderer is a extended version of underlying render object.
type Renderer struct {
2014-10-04 23:15:22 +02:00
blackfriday.Renderer
URLPrefix string
IsWiki bool
2014-04-10 20:20:58 +02:00
}
2016-02-20 23:10:05 +01:00
// Link defines how formal links should be processed to produce corresponding HTML elements.
func (r *Renderer) Link(out *bytes.Buffer, link []byte, title []byte, content []byte) {
if len(link) > 0 && !markup.IsLink(link) {
2016-02-20 23:10:05 +01:00
if link[0] != '#' {
lnk := string(link)
if r.IsWiki {
lnk = markup.URLJoin("wiki", lnk)
}
mLink := markup.URLJoin(r.URLPrefix, lnk)
link = []byte(mLink)
2016-01-09 03:59:04 +01:00
}
}
r.Renderer.Link(out, link, title, content)
}
// List renders markdown bullet or digit lists to HTML
func (r *Renderer) List(out *bytes.Buffer, text func() bool, flags int) {
marker := out.Len()
if out.Len() > 0 {
out.WriteByte('\n')
2016-01-09 03:59:04 +01:00
}
if flags&blackfriday.LIST_TYPE_DEFINITION != 0 {
out.WriteString("<dl>")
} else if flags&blackfriday.LIST_TYPE_ORDERED != 0 {
out.WriteString("<ol class='ui list'>")
} else {
out.WriteString("<ul class='ui list'>")
}
if !text() {
out.Truncate(marker)
return
}
if flags&blackfriday.LIST_TYPE_DEFINITION != 0 {
out.WriteString("</dl>\n")
} else if flags&blackfriday.LIST_TYPE_ORDERED != 0 {
out.WriteString("</ol>\n")
} else {
out.WriteString("</ul>\n")
2014-04-10 20:20:58 +02:00
}
}
2016-02-20 23:10:05 +01:00
// ListItem defines how list items should be processed to produce corresponding HTML elements.
2016-11-25 02:58:05 +01:00
func (r *Renderer) ListItem(out *bytes.Buffer, text []byte, flags int) {
2016-02-20 23:10:05 +01:00
// Detect procedures to draw checkboxes.
prefix := ""
if bytes.HasPrefix(text, []byte("<p>")) {
prefix = "<p>"
}
2016-01-13 13:25:52 +01:00
switch {
case bytes.HasPrefix(text, []byte(prefix+"[ ] ")):
text = append([]byte(`<span class="ui fitted disabled checkbox"><input type="checkbox" disabled="disabled" /><label /></span>`), text[3+len(prefix):]...)
2017-04-24 06:18:36 +02:00
if prefix != "" {
text = bytes.Replace(text, []byte(prefix), []byte{}, 1)
}
case bytes.HasPrefix(text, []byte(prefix+"[x] ")):
text = append([]byte(`<span class="ui checked fitted disabled checkbox"><input type="checkbox" checked="" disabled="disabled" /><label /></span>`), text[3+len(prefix):]...)
2017-04-24 06:18:36 +02:00
if prefix != "" {
text = bytes.Replace(text, []byte(prefix), []byte{}, 1)
}
2016-01-13 13:25:52 +01:00
}
2016-11-25 02:58:05 +01:00
r.Renderer.ListItem(out, text, flags)
2016-01-13 13:25:52 +01:00
}
2016-02-20 23:10:05 +01:00
// Note: this section is for purpose of increase performance and
// reduce memory allocation at runtime since they are constant literals.
2015-11-20 11:37:51 +01:00
var (
svgSuffix = []byte(".svg")
svgSuffixWithMark = []byte(".svg?")
)
2016-02-20 23:10:05 +01:00
// Image defines how images should be processed to produce corresponding HTML elements.
func (r *Renderer) Image(out *bytes.Buffer, link []byte, title []byte, alt []byte) {
prefix := r.URLPrefix
if r.IsWiki {
prefix = markup.URLJoin(prefix, "wiki", "src")
}
prefix = strings.Replace(prefix, "/src/", "/raw/", 1)
2015-11-20 11:37:51 +01:00
if len(link) > 0 {
if markup.IsLink(link) {
2015-11-20 11:37:51 +01:00
// External link with .svg suffix usually means CI status.
2016-02-20 23:10:05 +01:00
// TODO: define a keyword to allow non-svg images render as external link.
2015-11-20 11:37:51 +01:00
if bytes.HasSuffix(link, svgSuffix) || bytes.Contains(link, svgSuffixWithMark) {
2016-01-09 03:59:04 +01:00
r.Renderer.Image(out, link, title, alt)
2015-11-20 11:37:51 +01:00
return
}
} else {
lnk := string(link)
lnk = markup.URLJoin(prefix, lnk)
lnk = strings.Replace(lnk, " ", "+", -1)
link = []byte(lnk)
}
2014-10-15 05:44:34 +02:00
}
out.WriteString(`<a href="`)
out.Write(link)
out.WriteString(`">`)
2016-01-09 03:59:04 +01:00
r.Renderer.Image(out, link, title, alt)
out.WriteString("</a>")
2014-10-15 05:44:34 +02:00
}
2016-02-20 23:10:05 +01:00
// RenderRaw renders Markdown to HTML without handling special links.
func RenderRaw(body []byte, urlPrefix string, wikiMarkdown bool) []byte {
2014-04-10 20:20:58 +02:00
htmlFlags := 0
2014-10-04 23:15:22 +02:00
htmlFlags |= blackfriday.HTML_SKIP_STYLE
htmlFlags |= blackfriday.HTML_OMIT_CONTENTS
2016-02-20 23:10:05 +01:00
renderer := &Renderer{
Renderer: blackfriday.HtmlRenderer(htmlFlags, "", ""),
URLPrefix: urlPrefix,
IsWiki: wikiMarkdown,
2014-04-10 20:20:58 +02:00
}
// set up the parser
extensions := 0
2014-10-04 23:15:22 +02:00
extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
extensions |= blackfriday.EXTENSION_TABLES
extensions |= blackfriday.EXTENSION_FENCED_CODE
extensions |= blackfriday.EXTENSION_STRIKETHROUGH
extensions |= blackfriday.EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK
if setting.Markdown.EnableHardLineBreak {
extensions |= blackfriday.EXTENSION_HARD_LINE_BREAK
}
2014-10-04 23:15:22 +02:00
body = blackfriday.Markdown(body, renderer, extensions)
2014-05-05 19:08:01 +02:00
return body
}
var (
// MarkupName describes markup's name
MarkupName = "markdown"
)
func init() {
markup.RegisterParser(Parser{})
}
// Parser implements markup.Parser
type Parser struct {
}
// Name implements markup.Parser
func (Parser) Name() string {
return MarkupName
}
// Extensions implements markup.Parser
func (Parser) Extensions() []string {
return setting.Markdown.FileExtensions
}
// Render implements markup.Parser
func (Parser) Render(rawBytes []byte, urlPrefix string, metas map[string]string, isWiki bool) []byte {
return RenderRaw(rawBytes, urlPrefix, isWiki)
}
// Render renders Markdown to HTML with all specific handling stuff.
func Render(rawBytes []byte, urlPrefix string, metas map[string]string) []byte {
return markup.Render("a.md", rawBytes, urlPrefix, metas)
}
// RenderString renders Markdown to HTML with special links and returns string type.
func RenderString(raw, urlPrefix string, metas map[string]string) string {
return markup.RenderString("a.md", raw, urlPrefix, metas)
}
// RenderWiki renders markdown wiki page to HTML and return HTML string
func RenderWiki(rawBytes []byte, urlPrefix string, metas map[string]string) string {
return markup.RenderWiki("a.md", rawBytes, urlPrefix, metas)
}
// IsMarkdownFile reports whether name looks like a Markdown file
// based on its extension.
func IsMarkdownFile(name string) bool {
return markup.IsMarkupFile(name, MarkupName)
}