From 3a9276307c48620c272d0819fcaeef5475e97676 Mon Sep 17 00:00:00 2001 From: Unknwon Date: Fri, 31 Mar 2017 17:46:57 -0400 Subject: [PATCH] modules/markup: move common functions to markup.go --- modules/markup/markdown.go | 345 ++----------------------------- modules/markup/markdown_test.go | 252 +++------------------- modules/markup/markup.go | 335 ++++++++++++++++++++++++++++++ modules/markup/markup_test.go | 284 +++++++++++++++++++++++++ modules/markup/sanitizer.go | 4 - modules/markup/sanitizer_test.go | 2 +- routers/api/v1/misc/markdown.go | 4 +- 7 files changed, 666 insertions(+), 560 deletions(-) create mode 100644 modules/markup/markup.go create mode 100644 modules/markup/markup_test.go diff --git a/modules/markup/markdown.go b/modules/markup/markdown.go index e59ae9a60..c325f19f4 100644 --- a/modules/markup/markdown.go +++ b/modules/markup/markdown.go @@ -7,34 +7,18 @@ package markup import ( "bytes" "fmt" - "io" "path" "path/filepath" "regexp" "strings" - "github.com/Unknwon/com" "github.com/russross/blackfriday" - "golang.org/x/net/html" "github.com/gogits/gogs/modules/base" "github.com/gogits/gogs/modules/setting" ) -const ( - ISSUE_NAME_STYLE_NUMERIC = "numeric" - ISSUE_NAME_STYLE_ALPHANUMERIC = "alphanumeric" -) - -var validLinksPattern = regexp.MustCompile(`^[a-z][\w-]+://|^mailto:`) - -// isLink reports whether link fits valid format. -func isLink(link []byte) bool { - return validLinksPattern.Match(link) -} - -// IsMarkdownFile reports whether name looks like a Markdown file -// based on its extension. +// IsMarkdownFile reports whether name looks like a Markdown file based on its extension. func IsMarkdownFile(name string) bool { extension := strings.ToLower(filepath.Ext(name)) for _, ext := range setting.Markdown.FileExtensions { @@ -45,61 +29,21 @@ func IsMarkdownFile(name string) bool { return false } -// IsReadmeFile reports whether name looks like a README file -// based on its extension. -func IsReadmeFile(name string) bool { - name = strings.ToLower(name) - if len(name) < 6 { - return false - } else if len(name) == 6 { - return name == "readme" - } - return name[:7] == "readme." -} - -var ( - // MentionPattern matches string that mentions someone, e.g. @Unknwon - MentionPattern = regexp.MustCompile(`(\s|^|\W)@[0-9a-zA-Z-_\.]+`) - - // CommitPattern matches link to certain commit with or without trailing hash, - // e.g. https://try.gogs.io/gogs/gogs/commit/d8a994ef243349f321568f9e36d5c3f444b99cae#diff-2 - CommitPattern = regexp.MustCompile(`(\s|^)https?.*commit/[0-9a-zA-Z]+(#+[0-9a-zA-Z-]*)?`) - - // IssueFullPattern matches link to an issue with or without trailing hash, - // e.g. https://try.gogs.io/gogs/gogs/issues/4#issue-685 - IssueFullPattern = regexp.MustCompile(`(\s|^)https?.*issues/[0-9]+(#+[0-9a-zA-Z-]*)?`) - // IssueNumericPattern matches string that references to a numeric issue, e.g. #1287 - IssueNumericPattern = regexp.MustCompile(`( |^|\()#[0-9]+\b`) - // IssueAlphanumericPattern matches string that references to an alphanumeric issue, e.g. ABC-1234 - IssueAlphanumericPattern = regexp.MustCompile(`( |^|\()[A-Z]{1,10}-[1-9][0-9]*\b`) - // CrossReferenceIssueNumericPattern matches string that references a numeric issue in a difference repository - // e.g. gogits/gogs#12345 - CrossReferenceIssueNumericPattern = regexp.MustCompile(`( |^)[0-9a-zA-Z-_\.]+/[0-9a-zA-Z-_\.]+#[0-9]+\b`) - - // Sha1CurrentPattern matches string that represents a commit SHA, e.g. d8a994ef243349f321568f9e36d5c3f444b99cae - // FIXME: this pattern matches pure numbers as well, right now we do a hack to check in RenderSha1CurrentPattern - // by converting string to a number. - Sha1CurrentPattern = regexp.MustCompile(`\b[0-9a-f]{40}\b`) -) - -// FindAllMentions matches mention patterns in given content -// and returns a list of found user names without @ prefix. -func FindAllMentions(content string) []string { - mentions := MentionPattern.FindAllString(content, -1) - for i := range mentions { - mentions[i] = mentions[i][strings.Index(mentions[i], "@")+1:] // Strip @ character - } - return mentions -} - -// Renderer is a extended version of underlying render object. -type Renderer struct { +// MarkdownRenderer is a extended version of underlying Markdown render object. +type MarkdownRenderer struct { blackfriday.Renderer urlPrefix string } +var validLinksPattern = regexp.MustCompile(`^[a-z][\w-]+://|^mailto:`) + +// isLink reports whether link fits valid format. +func isLink(link []byte) bool { + return validLinksPattern.Match(link) +} + // 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) { +func (r *MarkdownRenderer) Link(out *bytes.Buffer, link []byte, title []byte, content []byte) { if len(link) > 0 && !isLink(link) { if link[0] != '#' { link = []byte(path.Join(r.urlPrefix, string(link))) @@ -111,7 +55,7 @@ func (r *Renderer) Link(out *bytes.Buffer, link []byte, title []byte, content [] // AutoLink defines how auto-detected links should be processed to produce corresponding HTML elements. // Reference for kind: https://github.com/russross/blackfriday/blob/master/markdown.go#L69-L76 -func (r *Renderer) AutoLink(out *bytes.Buffer, link []byte, kind int) { +func (r *MarkdownRenderer) AutoLink(out *bytes.Buffer, link []byte, kind int) { if kind != blackfriday.LINK_TYPE_NORMAL { r.Renderer.AutoLink(out, link, kind) return @@ -161,7 +105,7 @@ func (r *Renderer) AutoLink(out *bytes.Buffer, link []byte, kind int) { } // ListItem defines how list items should be processed to produce corresponding HTML elements. -func (options *Renderer) ListItem(out *bytes.Buffer, text []byte, flags int) { +func (options *MarkdownRenderer) ListItem(out *bytes.Buffer, text []byte, flags int) { // Detect procedures to draw checkboxes. switch { case bytes.HasPrefix(text, []byte("[ ] ")): @@ -172,108 +116,8 @@ func (options *Renderer) ListItem(out *bytes.Buffer, text []byte, flags int) { options.Renderer.ListItem(out, text, flags) } -// Note: this section is for purpose of increase performance and -// reduce memory allocation at runtime since they are constant literals. -var ( - pound = []byte("#") - space = " " - spaceEncoded = "%20" -) - -// cutoutVerbosePrefix cutouts URL prefix including sub-path to -// return a clean unified string of request URL path. -func cutoutVerbosePrefix(prefix string) string { - if len(prefix) == 0 || prefix[0] != '/' { - return prefix - } - count := 0 - for i := 0; i < len(prefix); i++ { - if prefix[i] == '/' { - count++ - } - if count >= 3+setting.AppSubUrlDepth { - return prefix[:i] - } - } - return prefix -} - -// RenderIssueIndexPattern renders issue indexes to corresponding links. -func RenderIssueIndexPattern(rawBytes []byte, urlPrefix string, metas map[string]string) []byte { - urlPrefix = cutoutVerbosePrefix(urlPrefix) - - pattern := IssueNumericPattern - if metas["style"] == ISSUE_NAME_STYLE_ALPHANUMERIC { - pattern = IssueAlphanumericPattern - } - - ms := pattern.FindAll(rawBytes, -1) - for _, m := range ms { - if m[0] == ' ' || m[0] == '(' { - m = m[1:] // ignore leading space or opening parentheses - } - var link string - if metas == nil { - link = fmt.Sprintf(`%s`, urlPrefix, m[1:], m) - } else { - // Support for external issue tracker - if metas["style"] == ISSUE_NAME_STYLE_ALPHANUMERIC { - metas["index"] = string(m) - } else { - metas["index"] = string(m[1:]) - } - link = fmt.Sprintf(`%s`, com.Expand(metas["format"], metas), m) - } - rawBytes = bytes.Replace(rawBytes, m, []byte(link), 1) - } - return rawBytes -} - -// RenderCrossReferenceIssueIndexPattern renders issue indexes from other repositories to corresponding links. -func RenderCrossReferenceIssueIndexPattern(rawBytes []byte, urlPrefix string, metas map[string]string) []byte { - ms := CrossReferenceIssueNumericPattern.FindAll(rawBytes, -1) - for _, m := range ms { - if m[0] == ' ' || m[0] == '(' { - m = m[1:] // ignore leading space or opening parentheses - } - - delimIdx := bytes.Index(m, pound) - repo := string(m[:delimIdx]) - index := string(m[delimIdx+1:]) - - link := fmt.Sprintf(`%s`, setting.AppUrl, repo, index, m) - rawBytes = bytes.Replace(rawBytes, m, []byte(link), 1) - } - return rawBytes -} - -// RenderSha1CurrentPattern renders SHA1 strings to corresponding links that assumes in the same repository. -func RenderSha1CurrentPattern(rawBytes []byte, urlPrefix string) []byte { - return []byte(Sha1CurrentPattern.ReplaceAllStringFunc(string(rawBytes[:]), func(m string) string { - if com.StrTo(m).MustInt() > 0 { - return m - } - return fmt.Sprintf(`%s`, urlPrefix, m, base.ShortSha(string(m))) - })) -} - -// RenderSpecialLink renders mentions, indexes and SHA1 strings to corresponding links. -func RenderSpecialLink(rawBytes []byte, urlPrefix string, metas map[string]string) []byte { - ms := MentionPattern.FindAll(rawBytes, -1) - for _, m := range ms { - m = m[bytes.Index(m, []byte("@")):] - rawBytes = bytes.Replace(rawBytes, m, - []byte(fmt.Sprintf(`%s`, setting.AppSubUrl, m[1:], m)), -1) - } - - rawBytes = RenderIssueIndexPattern(rawBytes, urlPrefix, metas) - rawBytes = RenderCrossReferenceIssueIndexPattern(rawBytes, urlPrefix, metas) - rawBytes = RenderSha1CurrentPattern(rawBytes, urlPrefix) - return rawBytes -} - -// RenderRaw renders Markdown to HTML without handling special links. -func RenderRaw(body []byte, urlPrefix string) []byte { +// RawMarkdown renders Markdown to HTML without handling special links. +func RawMarkdown(body []byte, urlPrefix string) []byte { htmlFlags := 0 htmlFlags |= blackfriday.HTML_SKIP_STYLE htmlFlags |= blackfriday.HTML_OMIT_CONTENTS @@ -294,7 +138,7 @@ func RenderRaw(body []byte, urlPrefix string) []byte { } } - renderer := &Renderer{ + renderer := &MarkdownRenderer{ Renderer: blackfriday.HtmlRenderer(htmlFlags, "", ""), urlPrefix: urlPrefix, } @@ -317,162 +161,7 @@ func RenderRaw(body []byte, urlPrefix string) []byte { return body } -var ( - leftAngleBracket = []byte("") -) - -var noEndTags = []string{"input", "br", "hr", "img"} - -// wrapImgWithLink warps link to standalone tags. -func wrapImgWithLink(urlPrefix string, buf *bytes.Buffer, token html.Token) { - var src, alt string - // Extract "src" and "alt" attributes - for i := range token.Attr { - switch token.Attr[i].Key { - case "src": - src = token.Attr[i].Val - case "alt": - alt = token.Attr[i].Val - } - } - - // Skip in case the "src" is empty - if len(src) == 0 { - buf.WriteString(token.String()) - return - } - - // Prepend repository base URL for internal links - needPrepend := !isLink([]byte(src)) - if needPrepend { - urlPrefix = strings.Replace(urlPrefix, "/src/", "/raw/", 1) - if src[0] != '/' { - urlPrefix += "/" - } - } - - buf.WriteString(``) - - if needPrepend { - src = strings.Replace(urlPrefix+string(src), " ", "%20", -1) - buf.WriteString(` 0 { - buf.WriteString(` alt="`) - buf.WriteString(alt) - buf.WriteString(`"`) - } - - buf.WriteString(`>`) - - } else { - buf.WriteString(token.String()) - } - - buf.WriteString(``) -} - -// PostProcess treats different types of HTML differently, -// and only renders special links for plain text blocks. -func PostProcess(rawHTML []byte, urlPrefix string, metas map[string]string) []byte { - startTags := make([]string, 0, 5) - buf := bytes.NewBuffer(nil) - tokenizer := html.NewTokenizer(bytes.NewReader(rawHTML)) - -OUTER_LOOP: - for html.ErrorToken != tokenizer.Next() { - token := tokenizer.Token() - switch token.Type { - case html.TextToken: - buf.Write(RenderSpecialLink([]byte(token.String()), urlPrefix, metas)) - - case html.StartTagToken: - tagName := token.Data - - if tagName == "img" { - wrapImgWithLink(urlPrefix, buf, token) - continue OUTER_LOOP - } - - buf.WriteString(token.String()) - // If this is an excluded tag, we skip processing all output until a close tag is encountered. - if strings.EqualFold("a", tagName) || strings.EqualFold("code", tagName) || strings.EqualFold("pre", tagName) { - stackNum := 1 - for html.ErrorToken != tokenizer.Next() { - token = tokenizer.Token() - - // Copy the token to the output verbatim - buf.WriteString(token.String()) - - // Stack number doesn't increate for tags without end tags. - if token.Type == html.StartTagToken && !com.IsSliceContainsStr(noEndTags, token.Data) { - stackNum++ - } - - // If this is the close tag to the outer-most, we are done - if token.Type == html.EndTagToken { - stackNum-- - if stackNum <= 0 && strings.EqualFold(tagName, token.Data) { - break - } - } - } - continue OUTER_LOOP - } - - if !com.IsSliceContainsStr(noEndTags, tagName) { - startTags = append(startTags, tagName) - } - - case html.EndTagToken: - if len(startTags) == 0 { - buf.WriteString(token.String()) - break - } - - buf.Write(leftAngleBracket) - buf.WriteString(startTags[len(startTags)-1]) - buf.Write(rightAngleBracket) - startTags = startTags[:len(startTags)-1] - default: - buf.WriteString(token.String()) - } - } - - if io.EOF == tokenizer.Err() { - return buf.Bytes() - } - - // If we are not at the end of the input, then some other parsing error has occurred, - // so return the input verbatim. - return rawHTML -} - // Markdown takes a string or []byte and renders to HTML in Markdown syntax with special links. func Markdown(input interface{}, urlPrefix string, metas map[string]string) []byte { - var rawBytes []byte - switch v := input.(type) { - case []byte: - rawBytes = v - case string: - rawBytes = []byte(v) - default: - panic(fmt.Sprintf("unexpected input content type: %T", input)) - } - - urlPrefix = strings.Replace(urlPrefix, space, spaceEncoded, -1) - result := RenderRaw(rawBytes, urlPrefix) - result = PostProcess(result, urlPrefix, metas) - result = SanitizeBytes(result) - return result + return Render(MARKDOWN, input, urlPrefix, metas) } diff --git a/modules/markup/markdown_test.go b/modules/markup/markdown_test.go index cbf753121..8f048df8a 100644 --- a/modules/markup/markdown_test.go +++ b/modules/markup/markdown_test.go @@ -1,7 +1,12 @@ +// Copyright 2016 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. + package markup_test import ( "bytes" + "strings" "testing" "github.com/russross/blackfriday" @@ -11,238 +16,35 @@ import ( "github.com/gogits/gogs/modules/setting" ) -func TestMarkdown(t *testing.T) { - Convey("Rendering an issue mention", t, func() { - var ( - urlPrefix = "/prefix" - metas map[string]string = nil - ) - setting.AppSubUrlDepth = 0 +func Test_IsMarkdownFile(t *testing.T) { + setting.Markdown.FileExtensions = strings.Split(".md,.markdown,.mdown,.mkd", ",") + Convey("Detect Markdown file extension", t, func() { + testCases := []struct { + ext string + match bool + }{ + {".md", true}, + {".markdown", true}, + {".mdown", true}, + {".mkd", true}, + {".org", false}, + {".rst", false}, + {".asciidoc", false}, + } - Convey("To the internal issue tracker", func() { - Convey("It should not render anything when there are no mentions", func() { - testCases := []string{ - "", - "this is a test", - "test 123 123 1234", - "#", - "# # #", - "# 123", - "#abcd", - "##1234", - "test#1234", - "#1234test", - " test #1234test", - } - - for i := 0; i < len(testCases); i++ { - So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i]) - } - }) - Convey("It should render freestanding mentions", func() { - testCases := []string{ - "#1234 test", "#1234 test", - "test #1234 issue", "test #1234 issue", - "test issue #1234", "test issue #1234", - "#5 test", "#5 test", - "test #5 issue", "test #5 issue", - "test issue #5", "test issue #5", - } - - for i := 0; i < len(testCases); i += 2 { - So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) - } - }) - Convey("It should not render issue mention without leading space", func() { - input := []byte("test#54321 issue") - expected := "test#54321 issue" - So(string(RenderIssueIndexPattern(input, urlPrefix, metas)), ShouldEqual, expected) - }) - Convey("It should not render issue mention without trailing space", func() { - input := []byte("test #54321issue") - expected := "test #54321issue" - So(string(RenderIssueIndexPattern(input, urlPrefix, metas)), ShouldEqual, expected) - }) - Convey("It should render issue mention in parentheses", func() { - testCases := []string{ - "(#54321 issue)", "(#54321 issue)", - "test (#54321) issue", "test (#54321) issue", - "test (#54321 extra) issue", "test (#54321 extra) issue", - "test (#54321 issue)", "test (#54321 issue)", - "test (#54321)", "test (#54321)", - } - - for i := 0; i < len(testCases); i += 2 { - So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) - } - }) - Convey("It should render multiple issue mentions in the same line", func() { - testCases := []string{ - "#54321 #1243", "#54321 #1243", - "test #54321 #1243", "test #54321 #1243", - "(#54321 #1243)", "(#54321 #1243)", - "(#54321)(#1243)", "(#54321)(#1243)", - "text #54321 test #1243 issue", "text #54321 test #1243 issue", - "#1 (#4321) test", "#1 (#4321) test", - } - - for i := 0; i < len(testCases); i += 2 { - So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) - } - }) - }) - Convey("To an external issue tracker with numeric style", func() { - metas = make(map[string]string) - metas["format"] = "https://someurl.com/{user}/{repo}/{index}" - metas["user"] = "someuser" - metas["repo"] = "somerepo" - metas["style"] = ISSUE_NAME_STYLE_NUMERIC - - Convey("should not render anything when there are no mentions", func() { - testCases := []string{ - "this is a test", - "test 123 123 1234", - "#", - "# # #", - "# 123", - "#abcd", - } - - for i := 0; i < len(testCases); i++ { - So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i]) - } - }) - Convey("It should render freestanding issue mentions", func() { - testCases := []string{ - "#1234 test", "#1234 test", - "test #1234 issue", "test #1234 issue", - "test issue #1234", "test issue #1234", - "#5 test", "#5 test", - "test #5 issue", "test #5 issue", - "test issue #5", "test issue #5", - } - for i := 0; i < len(testCases); i += 2 { - So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) - } - }) - Convey("It should not render issue mention without leading space", func() { - input := []byte("test#54321 issue") - expected := "test#54321 issue" - So(string(RenderIssueIndexPattern(input, urlPrefix, metas)), ShouldEqual, expected) - }) - Convey("It should not render issue mention without trailing space", func() { - input := []byte("test #54321issue") - expected := "test #54321issue" - So(string(RenderIssueIndexPattern(input, urlPrefix, metas)), ShouldEqual, expected) - }) - Convey("It should render issue mention in parentheses", func() { - testCases := []string{ - "(#54321 issue)", "(#54321 issue)", - "test (#54321) issue", "test (#54321) issue", - "test (#54321 extra) issue", "test (#54321 extra) issue", - "test (#54321 issue)", "test (#54321 issue)", - "test (#54321)", "test (#54321)", - } - - for i := 0; i < len(testCases); i += 2 { - So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) - } - }) - Convey("It should render multiple issue mentions in the same line", func() { - testCases := []string{ - "#54321 #1243", "#54321 #1243", - "test #54321 #1243", "test #54321 #1243", - "(#54321 #1243)", "(#54321 #1243)", - "(#54321)(#1243)", "(#54321)(#1243)", - "text #54321 test #1243 issue", "text #54321 test #1243 issue", - "#1 (#4321) test", "#1 (#4321) test", - } - - for i := 0; i < len(testCases); i += 2 { - So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) - } - }) - }) - Convey("To an external issue tracker with alphanumeric style", func() { - metas = make(map[string]string) - metas["format"] = "https://someurl.com/{user}/{repo}/?b={index}" - metas["user"] = "someuser" - metas["repo"] = "somerepo" - metas["style"] = ISSUE_NAME_STYLE_ALPHANUMERIC - Convey("It should not render anything when there are no mentions", func() { - testCases := []string{ - "", - "this is a test", - "test 123 123 1234", - "#", - "##1234", - "# 123", - "#abcd", - "test #123", - "abc-1234", // issue prefix must be capital - "ABc-1234", // issue prefix must be _all_ capital - "ABCDEFGHIJK-1234", // the limit is 10 characters in the prefix - "ABC1234", // dash is required - "test ABC- test", // number is required - "test -1234 test", // prefix is required - "testABC-123 test", // leading space is required - "test ABC-123test", // trailing space is required - "ABC-0123", // no leading zero - } - - for i := 0; i < len(testCases); i += 2 { - So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i]) - } - }) - Convey("It should render freestanding issue mention", func() { - testCases := []string{ - "OTT-1234 test", "OTT-1234 test", - "test T-12 issue", "test T-12 issue", - "test issue ABCDEFGHIJ-1234567890", "test issue ABCDEFGHIJ-1234567890", - "A-1 test", "A-1 test", - "test ZED-1 issue", "test ZED-1 issue", - "test issue DEED-7154", "test issue DEED-7154", - } - for i := 0; i < len(testCases); i += 2 { - So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) - } - }) - Convey("It should render issue mention in parentheses", func() { - testCases := []string{ - "(ABG-124 issue)", "(ABG-124 issue)", - "test (ABG-124) issue", "test (ABG-124) issue", - "test (ABG-124 extra) issue", "test (ABG-124 extra) issue", - "test (ABG-124 issue)", "test (ABG-124 issue)", - "test (ABG-124)", "test (ABG-124)", - } - - for i := 0; i < len(testCases); i += 2 { - So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) - } - }) - Convey("It should render multiple issue mentions in the same line", func() { - testCases := []string{ - "ABG-124 OTT-4321", "ABG-124 OTT-4321", - "test ABG-124 OTT-4321", "test ABG-124 OTT-4321", - "(ABG-124 OTT-4321)", "(ABG-124 OTT-4321)", - "(ABG-124)(OTT-4321)", "(ABG-124)(OTT-4321)", - "text ABG-124 test OTT-4321 issue", "text ABG-124 test OTT-4321 issue", - "A-1 (RRE-345) test", "A-1 (RRE-345) test", - } - - for i := 0; i < len(testCases); i += 2 { - So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) - } - }) - }) + for _, tc := range testCases { + So(IsMarkdownFile(tc.ext), ShouldEqual, tc.match) + } }) +} +func Test_Markdown(t *testing.T) { Convey("Rendering an issue URL", t, func() { setting.AppUrl = "http://localhost:3000/" htmlFlags := 0 htmlFlags |= blackfriday.HTML_SKIP_STYLE htmlFlags |= blackfriday.HTML_OMIT_CONTENTS - renderer := &Renderer{ + renderer := &MarkdownRenderer{ Renderer: blackfriday.HtmlRenderer(htmlFlags, "", ""), } buffer := new(bytes.Buffer) @@ -284,7 +86,7 @@ func TestMarkdown(t *testing.T) { htmlFlags := 0 htmlFlags |= blackfriday.HTML_SKIP_STYLE htmlFlags |= blackfriday.HTML_OMIT_CONTENTS - renderer := &Renderer{ + renderer := &MarkdownRenderer{ Renderer: blackfriday.HtmlRenderer(htmlFlags, "", ""), } buffer := new(bytes.Buffer) diff --git a/modules/markup/markup.go b/modules/markup/markup.go new file mode 100644 index 000000000..a1c862a9f --- /dev/null +++ b/modules/markup/markup.go @@ -0,0 +1,335 @@ +// Copyright 2017 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. + +package markup + +import ( + "bytes" + "fmt" + "io" + "regexp" + "strings" + + "github.com/Unknwon/com" + "golang.org/x/net/html" + + "github.com/gogits/gogs/modules/base" + "github.com/gogits/gogs/modules/setting" +) + +// IsReadmeFile reports whether name looks like a README file based on its extension. +func IsReadmeFile(name string) bool { + return strings.HasPrefix(strings.ToLower(name), "readme") +} + +const ( + ISSUE_NAME_STYLE_NUMERIC = "numeric" + ISSUE_NAME_STYLE_ALPHANUMERIC = "alphanumeric" +) + +var ( + // MentionPattern matches string that mentions someone, e.g. @Unknwon + MentionPattern = regexp.MustCompile(`(\s|^|\W)@[0-9a-zA-Z-_\.]+`) + + // CommitPattern matches link to certain commit with or without trailing hash, + // e.g. https://try.gogs.io/gogs/gogs/commit/d8a994ef243349f321568f9e36d5c3f444b99cae#diff-2 + CommitPattern = regexp.MustCompile(`(\s|^)https?.*commit/[0-9a-zA-Z]+(#+[0-9a-zA-Z-]*)?`) + + // IssueFullPattern matches link to an issue with or without trailing hash, + // e.g. https://try.gogs.io/gogs/gogs/issues/4#issue-685 + IssueFullPattern = regexp.MustCompile(`(\s|^)https?.*issues/[0-9]+(#+[0-9a-zA-Z-]*)?`) + // IssueNumericPattern matches string that references to a numeric issue, e.g. #1287 + IssueNumericPattern = regexp.MustCompile(`( |^|\()#[0-9]+\b`) + // IssueAlphanumericPattern matches string that references to an alphanumeric issue, e.g. ABC-1234 + IssueAlphanumericPattern = regexp.MustCompile(`( |^|\()[A-Z]{1,10}-[1-9][0-9]*\b`) + // CrossReferenceIssueNumericPattern matches string that references a numeric issue in a difference repository + // e.g. gogits/gogs#12345 + CrossReferenceIssueNumericPattern = regexp.MustCompile(`( |^)[0-9a-zA-Z-_\.]+/[0-9a-zA-Z-_\.]+#[0-9]+\b`) + + // Sha1CurrentPattern matches string that represents a commit SHA, e.g. d8a994ef243349f321568f9e36d5c3f444b99cae + // FIXME: this pattern matches pure numbers as well, right now we do a hack to check in RenderSha1CurrentPattern + // by converting string to a number. + Sha1CurrentPattern = regexp.MustCompile(`\b[0-9a-f]{40}\b`) +) + +// FindAllMentions matches mention patterns in given content +// and returns a list of found user names without @ prefix. +func FindAllMentions(content string) []string { + mentions := MentionPattern.FindAllString(content, -1) + for i := range mentions { + mentions[i] = mentions[i][strings.Index(mentions[i], "@")+1:] // Strip @ character + } + return mentions +} + +// cutoutVerbosePrefix cutouts URL prefix including sub-path to +// return a clean unified string of request URL path. +func cutoutVerbosePrefix(prefix string) string { + if len(prefix) == 0 || prefix[0] != '/' { + return prefix + } + count := 0 + for i := 0; i < len(prefix); i++ { + if prefix[i] == '/' { + count++ + } + if count >= 3+setting.AppSubUrlDepth { + return prefix[:i] + } + } + return prefix +} + +// RenderIssueIndexPattern renders issue indexes to corresponding links. +func RenderIssueIndexPattern(rawBytes []byte, urlPrefix string, metas map[string]string) []byte { + urlPrefix = cutoutVerbosePrefix(urlPrefix) + + pattern := IssueNumericPattern + if metas["style"] == ISSUE_NAME_STYLE_ALPHANUMERIC { + pattern = IssueAlphanumericPattern + } + + ms := pattern.FindAll(rawBytes, -1) + for _, m := range ms { + if m[0] == ' ' || m[0] == '(' { + m = m[1:] // ignore leading space or opening parentheses + } + var link string + if metas == nil { + link = fmt.Sprintf(`%s`, urlPrefix, m[1:], m) + } else { + // Support for external issue tracker + if metas["style"] == ISSUE_NAME_STYLE_ALPHANUMERIC { + metas["index"] = string(m) + } else { + metas["index"] = string(m[1:]) + } + link = fmt.Sprintf(`%s`, com.Expand(metas["format"], metas), m) + } + rawBytes = bytes.Replace(rawBytes, m, []byte(link), 1) + } + return rawBytes +} + +// Note: this section is for purpose of increase performance and +// reduce memory allocation at runtime since they are constant literals. +var pound = []byte("#") + +// RenderCrossReferenceIssueIndexPattern renders issue indexes from other repositories to corresponding links. +func RenderCrossReferenceIssueIndexPattern(rawBytes []byte, urlPrefix string, metas map[string]string) []byte { + ms := CrossReferenceIssueNumericPattern.FindAll(rawBytes, -1) + for _, m := range ms { + if m[0] == ' ' || m[0] == '(' { + m = m[1:] // ignore leading space or opening parentheses + } + + delimIdx := bytes.Index(m, pound) + repo := string(m[:delimIdx]) + index := string(m[delimIdx+1:]) + + link := fmt.Sprintf(`%s`, setting.AppUrl, repo, index, m) + rawBytes = bytes.Replace(rawBytes, m, []byte(link), 1) + } + return rawBytes +} + +// RenderSha1CurrentPattern renders SHA1 strings to corresponding links that assumes in the same repository. +func RenderSha1CurrentPattern(rawBytes []byte, urlPrefix string) []byte { + return []byte(Sha1CurrentPattern.ReplaceAllStringFunc(string(rawBytes[:]), func(m string) string { + if com.StrTo(m).MustInt() > 0 { + return m + } + return fmt.Sprintf(`%s`, urlPrefix, m, base.ShortSha(string(m))) + })) +} + +// RenderSpecialLink renders mentions, indexes and SHA1 strings to corresponding links. +func RenderSpecialLink(rawBytes []byte, urlPrefix string, metas map[string]string) []byte { + ms := MentionPattern.FindAll(rawBytes, -1) + for _, m := range ms { + m = m[bytes.Index(m, []byte("@")):] + rawBytes = bytes.Replace(rawBytes, m, + []byte(fmt.Sprintf(`%s`, setting.AppSubUrl, m[1:], m)), -1) + } + + rawBytes = RenderIssueIndexPattern(rawBytes, urlPrefix, metas) + rawBytes = RenderCrossReferenceIssueIndexPattern(rawBytes, urlPrefix, metas) + rawBytes = RenderSha1CurrentPattern(rawBytes, urlPrefix) + return rawBytes +} + +var ( + leftAngleBracket = []byte("") +) + +var noEndTags = []string{"input", "br", "hr", "img"} + +// wrapImgWithLink warps link to standalone tags. +func wrapImgWithLink(urlPrefix string, buf *bytes.Buffer, token html.Token) { + // Extract "src" and "alt" attributes + var src, alt string + for i := range token.Attr { + switch token.Attr[i].Key { + case "src": + src = token.Attr[i].Val + case "alt": + alt = token.Attr[i].Val + } + } + + // Skip in case the "src" is empty + if len(src) == 0 { + buf.WriteString(token.String()) + return + } + + // Prepend repository base URL for internal links + needPrepend := !isLink([]byte(src)) + if needPrepend { + urlPrefix = strings.Replace(urlPrefix, "/src/", "/raw/", 1) + if src[0] != '/' { + urlPrefix += "/" + } + } + + buf.WriteString(``) + + if needPrepend { + src = strings.Replace(urlPrefix+string(src), " ", "%20", -1) + buf.WriteString(` 0 { + buf.WriteString(` alt="`) + buf.WriteString(alt) + buf.WriteString(`"`) + } + + buf.WriteString(`>`) + + } else { + buf.WriteString(token.String()) + } + + buf.WriteString(``) +} + +// postProcessHTML treats different types of HTML differently, +// and only renders special links for plain text blocks. +func postProcessHTML(rawHTML []byte, urlPrefix string, metas map[string]string) []byte { + startTags := make([]string, 0, 5) + buf := bytes.NewBuffer(nil) + tokenizer := html.NewTokenizer(bytes.NewReader(rawHTML)) + +OUTER_LOOP: + for html.ErrorToken != tokenizer.Next() { + token := tokenizer.Token() + switch token.Type { + case html.TextToken: + buf.Write(RenderSpecialLink([]byte(token.String()), urlPrefix, metas)) + + case html.StartTagToken: + tagName := token.Data + + if tagName == "img" { + wrapImgWithLink(urlPrefix, buf, token) + continue OUTER_LOOP + } + + buf.WriteString(token.String()) + // If this is an excluded tag, we skip processing all output until a close tag is encountered. + if strings.EqualFold("a", tagName) || strings.EqualFold("code", tagName) || strings.EqualFold("pre", tagName) { + stackNum := 1 + for html.ErrorToken != tokenizer.Next() { + token = tokenizer.Token() + + // Copy the token to the output verbatim + buf.WriteString(token.String()) + + // Stack number doesn't increate for tags without end tags. + if token.Type == html.StartTagToken && !com.IsSliceContainsStr(noEndTags, token.Data) { + stackNum++ + } + + // If this is the close tag to the outer-most, we are done + if token.Type == html.EndTagToken { + stackNum-- + if stackNum <= 0 && strings.EqualFold(tagName, token.Data) { + break + } + } + } + continue OUTER_LOOP + } + + if !com.IsSliceContainsStr(noEndTags, tagName) { + startTags = append(startTags, tagName) + } + + case html.EndTagToken: + if len(startTags) == 0 { + buf.WriteString(token.String()) + break + } + + buf.Write(leftAngleBracket) + buf.WriteString(startTags[len(startTags)-1]) + buf.Write(rightAngleBracket) + startTags = startTags[:len(startTags)-1] + default: + buf.WriteString(token.String()) + } + } + + if io.EOF == tokenizer.Err() { + return buf.Bytes() + } + + // If we are not at the end of the input, then some other parsing error has occurred, + // so return the input verbatim. + return rawHTML +} + +type Type string + +const ( + UNRECOGNIZED Type = "unrecognized" + MARKDOWN Type = "markdown" + ORG_MODE Type = "orgmode" +) + +// Render takes a string or []byte and renders to HTML in given type of syntax with special links. +func Render(typ Type, input interface{}, urlPrefix string, metas map[string]string) []byte { + var rawBytes []byte + switch v := input.(type) { + case []byte: + rawBytes = v + case string: + rawBytes = []byte(v) + default: + panic(fmt.Sprintf("unrecognized input content type: %T", input)) + } + + urlPrefix = strings.Replace(urlPrefix, " ", "%20", -1) + var rawHTML []byte + switch typ { + case MARKDOWN: + rawHTML = RawMarkdown(rawBytes, urlPrefix) + case ORG_MODE: + default: + return rawBytes // Do nothing if syntax type is not recognized + } + + rawHTML = postProcessHTML(rawHTML, urlPrefix, metas) + return SanitizeBytes(rawHTML) +} diff --git a/modules/markup/markup_test.go b/modules/markup/markup_test.go new file mode 100644 index 000000000..8352911b2 --- /dev/null +++ b/modules/markup/markup_test.go @@ -0,0 +1,284 @@ +// Copyright 2017 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. + +package markup_test + +import ( + "strings" + "testing" + + . "github.com/smartystreets/goconvey/convey" + + . "github.com/gogits/gogs/modules/markup" + "github.com/gogits/gogs/modules/setting" +) + +func Test_IsReadmeFile(t *testing.T) { + Convey("Detect README file extension", t, func() { + testCases := []struct { + ext string + match bool + }{ + {"readme", true}, + {"README", true}, + {"readme.md", true}, + {"readme.markdown", true}, + {"readme.mdown", true}, + {"readme.mkd", true}, + {"readme.org", true}, + {"readme.rst", true}, + {"readme.asciidoc", true}, + {"readme_ZH", true}, + } + + for _, tc := range testCases { + So(IsReadmeFile(tc.ext), ShouldEqual, tc.match) + } + }) +} + +func Test_FindAllMentions(t *testing.T) { + Convey("Find all mention patterns", t, func() { + testCases := []struct { + content string + matches string + }{ + {"@Unknwon, what do you think?", "Unknwon"}, + {"@Unknwon what do you think?", "Unknwon"}, + {"Hi @Unknwon, sounds good to me", "Unknwon"}, + {"cc/ @Unknwon @User", "Unknwon,User"}, + } + + for _, tc := range testCases { + So(strings.Join(FindAllMentions(tc.content), ","), ShouldEqual, tc.matches) + } + }) +} + +func Test_RenderIssueIndexPattern(t *testing.T) { + Convey("Rendering an issue reference", t, func() { + var ( + urlPrefix = "/prefix" + metas map[string]string = nil + ) + setting.AppSubUrlDepth = 0 + + Convey("To the internal issue tracker", func() { + Convey("It should not render anything when there are no mentions", func() { + testCases := []string{ + "", + "this is a test", + "test 123 123 1234", + "#", + "# # #", + "# 123", + "#abcd", + "##1234", + "test#1234", + "#1234test", + " test #1234test", + } + + for i := 0; i < len(testCases); i++ { + So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i]) + } + }) + Convey("It should render freestanding mentions", func() { + testCases := []string{ + "#1234 test", "#1234 test", + "test #1234 issue", "test #1234 issue", + "test issue #1234", "test issue #1234", + "#5 test", "#5 test", + "test #5 issue", "test #5 issue", + "test issue #5", "test issue #5", + } + + for i := 0; i < len(testCases); i += 2 { + So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) + } + }) + Convey("It should not render issue mention without leading space", func() { + input := []byte("test#54321 issue") + expected := "test#54321 issue" + So(string(RenderIssueIndexPattern(input, urlPrefix, metas)), ShouldEqual, expected) + }) + Convey("It should not render issue mention without trailing space", func() { + input := []byte("test #54321issue") + expected := "test #54321issue" + So(string(RenderIssueIndexPattern(input, urlPrefix, metas)), ShouldEqual, expected) + }) + Convey("It should render issue mention in parentheses", func() { + testCases := []string{ + "(#54321 issue)", "(#54321 issue)", + "test (#54321) issue", "test (#54321) issue", + "test (#54321 extra) issue", "test (#54321 extra) issue", + "test (#54321 issue)", "test (#54321 issue)", + "test (#54321)", "test (#54321)", + } + + for i := 0; i < len(testCases); i += 2 { + So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) + } + }) + Convey("It should render multiple issue mentions in the same line", func() { + testCases := []string{ + "#54321 #1243", "#54321 #1243", + "test #54321 #1243", "test #54321 #1243", + "(#54321 #1243)", "(#54321 #1243)", + "(#54321)(#1243)", "(#54321)(#1243)", + "text #54321 test #1243 issue", "text #54321 test #1243 issue", + "#1 (#4321) test", "#1 (#4321) test", + } + + for i := 0; i < len(testCases); i += 2 { + So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) + } + }) + }) + Convey("To an external issue tracker with numeric style", func() { + metas = make(map[string]string) + metas["format"] = "https://someurl.com/{user}/{repo}/{index}" + metas["user"] = "someuser" + metas["repo"] = "somerepo" + metas["style"] = ISSUE_NAME_STYLE_NUMERIC + + Convey("should not render anything when there are no mentions", func() { + testCases := []string{ + "this is a test", + "test 123 123 1234", + "#", + "# # #", + "# 123", + "#abcd", + } + + for i := 0; i < len(testCases); i++ { + So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i]) + } + }) + Convey("It should render freestanding issue mentions", func() { + testCases := []string{ + "#1234 test", "#1234 test", + "test #1234 issue", "test #1234 issue", + "test issue #1234", "test issue #1234", + "#5 test", "#5 test", + "test #5 issue", "test #5 issue", + "test issue #5", "test issue #5", + } + for i := 0; i < len(testCases); i += 2 { + So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) + } + }) + Convey("It should not render issue mention without leading space", func() { + input := []byte("test#54321 issue") + expected := "test#54321 issue" + So(string(RenderIssueIndexPattern(input, urlPrefix, metas)), ShouldEqual, expected) + }) + Convey("It should not render issue mention without trailing space", func() { + input := []byte("test #54321issue") + expected := "test #54321issue" + So(string(RenderIssueIndexPattern(input, urlPrefix, metas)), ShouldEqual, expected) + }) + Convey("It should render issue mention in parentheses", func() { + testCases := []string{ + "(#54321 issue)", "(#54321 issue)", + "test (#54321) issue", "test (#54321) issue", + "test (#54321 extra) issue", "test (#54321 extra) issue", + "test (#54321 issue)", "test (#54321 issue)", + "test (#54321)", "test (#54321)", + } + + for i := 0; i < len(testCases); i += 2 { + So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) + } + }) + Convey("It should render multiple issue mentions in the same line", func() { + testCases := []string{ + "#54321 #1243", "#54321 #1243", + "test #54321 #1243", "test #54321 #1243", + "(#54321 #1243)", "(#54321 #1243)", + "(#54321)(#1243)", "(#54321)(#1243)", + "text #54321 test #1243 issue", "text #54321 test #1243 issue", + "#1 (#4321) test", "#1 (#4321) test", + } + + for i := 0; i < len(testCases); i += 2 { + So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) + } + }) + }) + Convey("To an external issue tracker with alphanumeric style", func() { + metas = make(map[string]string) + metas["format"] = "https://someurl.com/{user}/{repo}/?b={index}" + metas["user"] = "someuser" + metas["repo"] = "somerepo" + metas["style"] = ISSUE_NAME_STYLE_ALPHANUMERIC + Convey("It should not render anything when there are no mentions", func() { + testCases := []string{ + "", + "this is a test", + "test 123 123 1234", + "#", + "##1234", + "# 123", + "#abcd", + "test #123", + "abc-1234", // issue prefix must be capital + "ABc-1234", // issue prefix must be _all_ capital + "ABCDEFGHIJK-1234", // the limit is 10 characters in the prefix + "ABC1234", // dash is required + "test ABC- test", // number is required + "test -1234 test", // prefix is required + "testABC-123 test", // leading space is required + "test ABC-123test", // trailing space is required + "ABC-0123", // no leading zero + } + + for i := 0; i < len(testCases); i += 2 { + So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i]) + } + }) + Convey("It should render freestanding issue mention", func() { + testCases := []string{ + "OTT-1234 test", "OTT-1234 test", + "test T-12 issue", "test T-12 issue", + "test issue ABCDEFGHIJ-1234567890", "test issue ABCDEFGHIJ-1234567890", + "A-1 test", "A-1 test", + "test ZED-1 issue", "test ZED-1 issue", + "test issue DEED-7154", "test issue DEED-7154", + } + for i := 0; i < len(testCases); i += 2 { + So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) + } + }) + Convey("It should render issue mention in parentheses", func() { + testCases := []string{ + "(ABG-124 issue)", "(ABG-124 issue)", + "test (ABG-124) issue", "test (ABG-124) issue", + "test (ABG-124 extra) issue", "test (ABG-124 extra) issue", + "test (ABG-124 issue)", "test (ABG-124 issue)", + "test (ABG-124)", "test (ABG-124)", + } + + for i := 0; i < len(testCases); i += 2 { + So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) + } + }) + Convey("It should render multiple issue mentions in the same line", func() { + testCases := []string{ + "ABG-124 OTT-4321", "ABG-124 OTT-4321", + "test ABG-124 OTT-4321", "test ABG-124 OTT-4321", + "(ABG-124 OTT-4321)", "(ABG-124 OTT-4321)", + "(ABG-124)(OTT-4321)", "(ABG-124)(OTT-4321)", + "text ABG-124 test OTT-4321 issue", "text ABG-124 test OTT-4321 issue", + "A-1 (RRE-345) test", "A-1 (RRE-345) test", + } + + for i := 0; i < len(testCases); i += 2 { + So(string(RenderIssueIndexPattern([]byte(testCases[i]), urlPrefix, metas)), ShouldEqual, testCases[i+1]) + } + }) + }) + }) +} diff --git a/modules/markup/sanitizer.go b/modules/markup/sanitizer.go index f685657bf..8a88f761e 100644 --- a/modules/markup/sanitizer.go +++ b/modules/markup/sanitizer.go @@ -9,7 +9,6 @@ import ( "sync" "github.com/microcosm-cc/bluemonday" - log "gopkg.in/clog.v1" "github.com/gogits/gogs/modules/setting" ) @@ -27,7 +26,6 @@ var sanitizer = &Sanitizer{} // Multiple calls to this function will only create one instance of Sanitizer during // entire application lifecycle. func NewSanitizer() { - log.Trace("Markup: sanitizer initialization requested") sanitizer.init.Do(func() { sanitizer.policy = bluemonday.UGCPolicy() // We only want to allow HighlightJS specific classes for code blocks @@ -39,8 +37,6 @@ func NewSanitizer() { // Custom URL-Schemes sanitizer.policy.AllowURLSchemes(setting.Markdown.CustomURLSchemes...) - - log.Trace("Markup: sanitizer initialized") }) } diff --git a/modules/markup/sanitizer_test.go b/modules/markup/sanitizer_test.go index a8f41fbf8..2bd7d537d 100644 --- a/modules/markup/sanitizer_test.go +++ b/modules/markup/sanitizer_test.go @@ -13,7 +13,7 @@ import ( ) func Test_Sanitizer(t *testing.T) { - BuildSanitizer() + NewSanitizer() Convey("Sanitize HTML string and bytes", t, func() { testCases := []string{ // Regular diff --git a/routers/api/v1/misc/markdown.go b/routers/api/v1/misc/markdown.go index 4c6251b93..4ef0ddf1a 100644 --- a/routers/api/v1/misc/markdown.go +++ b/routers/api/v1/misc/markdown.go @@ -27,7 +27,7 @@ func Markdown(ctx *context.APIContext, form api.MarkdownOption) { case "gfm": ctx.Write(markup.Markdown([]byte(form.Text), form.Context, nil)) default: - ctx.Write(markup.RenderRaw([]byte(form.Text), "")) + ctx.Write(markup.RawMarkdown([]byte(form.Text), "")) } } @@ -38,5 +38,5 @@ func MarkdownRaw(ctx *context.APIContext) { ctx.Error(422, "", err) return } - ctx.Write(markup.RenderRaw(body, "")) + ctx.Write(markup.RawMarkdown(body, "")) }