Golang blackfriday.MarkdownBasic函数代码示例

func (a *Article) LoadRelated(s *mgo.Session) {
	fmt.Println("Meta start")
	if a.Meta == nil {
		a.Meta = make(map[string]interface{})
	}
	a.Meta["author"] = a.GetAuthor(s).String()
	a.Meta["markdown"] = template.HTML(string(blackfriday.MarkdownBasic([]byte(a.Body))))
	if len(a.Body) > trimLength {
		a.Meta["teaser"] = template.HTML(string(blackfriday.MarkdownBasic([]byte(a.Body[0:trimLength]))))
	} else {
		a.Meta["teaser"] = template.HTML(string(blackfriday.MarkdownBasic([]byte(a.Body[0:len(a.Body)]))))
	}
	fmt.Println("Meta:", a.Meta)

}

func TestDocument(t *testing.T) {
	const markdownIn = `This is Markdown.

- Item
- Item
- Item

And here are some ordered items.

1. Item 1
1. Item 2
1. Item 3

Cool.
`

	renderedHtml := blackfriday.MarkdownBasic([]byte(markdownIn))

	t.Log(string(renderedHtml))

	parsedHtml, err := html.Parse(bytes.NewReader(renderedHtml))
	if err != nil {
		panic(err)
	}

	markdownOut := html_to_markdown.Document(parsedHtml)

	if markdownIn != markdownOut {
		goon.DumpExpr(markdownIn, markdownOut)
		t.Fail()
	}
}

func BlogSaveHandler(w http.ResponseWriter, r *http.Request, title string) {
	body := r.FormValue("body")

	const layout = "2006-01-02 15:04:05"
	t := time.Now()
	information := t.Format(layout)
	dBody := template.HTML(blackfriday.MarkdownBasic([]byte(html.EscapeString(body))))
	p := &Page{Title: title, DisplayBody: dBody, Information: information}
	versions := make(map[string]*Page)
	filename := "./blogs/" + p.Title
	file, err := os.Open(filename)
	if err == nil {
		defer file.Close()
		decoder := json.NewDecoder(file)
		decoder.Decode(&versions)

	}
	versions[t.Format(layout)] = p
	out, err := json.Marshal(versions)
	if err != nil {

	}

	ioutil.WriteFile(filename, out, 0600)
	http.Redirect(w, r, "/blog/"+title, http.StatusFound)
}

func SaveHandler(w http.ResponseWriter, r *http.Request, title string) {
	body := r.FormValue("body")

	dBody := template.HTML(blackfriday.MarkdownBasic([]byte(html.EscapeString(body))))
	const layout = "2006-01-02 15:04:05"
	t := time.Now()
	cookie, err := r.Cookie("User")
	if err != nil {
		// just do something
	}
	author := cookie.Value
	information := "Aktualisiert:" + t.Format(layout) + " by " + string(author)
	p := &Page{Title: title, Body: body, DisplayBody: dBody, Information: information}
	versions := make(map[string]*Page)
	filename := "./articles/" + p.Title
	file, err := os.Open(filename)
	if err == nil {
		defer file.Close()
		decoder := json.NewDecoder(file)
		decoder.Decode(&versions)

	}
	versions[t.Format(layout)] = p
	out, err := json.Marshal(versions)
	if err != nil {
		fmt.Println("nicht jsoned")
	}

	ioutil.WriteFile(filename, out, 0600)
	http.Redirect(w, r, "/view/"+title, http.StatusFound)
}

func main() {
	setup()
	input := readInput(goopt.Args)
	if input == nil {
		fmt.Println("No input found")
		os.Exit(1)
	}
	outfile := getOutfile()
	markdown := blackfriday.MarkdownBasic(input)
	if *templatePath != "" {
		tpl, err := loadTemplate(*templatePath)
		if err != nil {
			fmt.Println("Template loading error: %v", err)
			os.Exit(2)
		}
		data := TemplateData{Contents: string(markdown)}
		err = tpl.Execute(outfile, data)
		if err != nil {
			fmt.Println("Template execution error: %v", err)
			os.Exit(3)
		}
		return
	}
	_, err := outfile.WriteString(string(markdown))
	if err != nil {
		fmt.Println("Write error: %v", err)
	}

	os.Exit(0)
}

func (t *Template) load(g *Group, name string, info interface{}) error {
	t.g = g
	tmpl := template.New(name)
	tmpl.Funcs(g.Funcs)
	var fm map[string]interface{}
	bytes, err := fmatter.ReadFile(filepath.Join(g.Dir, name), &fm)
	if err != nil {
		return err
	}
	t.funcMap = template.FuncMap{
		"page": func() interface{} {
			return fm
		},
	}
	tmpl.Funcs(t.funcMap)
	ext := filepath.Ext(name)
	if ext == ".md" {
		bytes = blackfriday.MarkdownBasic(bytes)
	}
	_, err = tmpl.Parse(string(bytes))
	if err != nil {
		return err
	}
	t.tmpl = tmpl
	if l, ok := fm["layout"]; ok {
		t.layout = l.(string)
	} else {
		t.layout = "default"
	}
	//writeInfo(info, fm)
	return nil
}

func PreViewArticleHandler(w http.ResponseWriter, r *http.Request) {
	ctx := GetContext()
	args := ctx.Args
	articleMetaData := &ArticleMetaData{}
	articleMetaData.Author, _ = args["author"].(string)
	articleMetaData.Title = strings.TrimSpace(r.FormValue("title"))
	tags := strings.TrimSpace(r.FormValue("tags"))
	if len(tags) > 0 {
		tags = strings.Replace(tags, "，", ",", -1)
		tags = strings.Replace(tags, " ", ",", -1)
		tag := strings.Split(tags, ",")
		articleMetaData.Tags = tag
	}
	articleMetaData.Summary = r.FormValue("summary")
	articleMetaData.Content = []byte(r.FormValue("content"))
	now := time.Now()
	articleMetaData.PostTime = now
	articleMetaData.UpdateTime = now
	articleMetaData.Flag = 1
	//article.Flag, _ = strconv.ParseInt(r.FormValue("flag"), 10, 64)
	articleMetaData.Count = 0

	article := &Article{MetaData: *articleMetaData,
		Text: template.HTML([]byte(blackfriday.MarkdownBasic(articleMetaData.Content)))}
	data := make(map[string]interface{})
	data["article"] = article

	args["title"] = articleMetaData.Title
	data["config"] = args
	viewTPL.ExecuteTemplate(w, "main", data)
}

func main() {

	rawKBZ, kbz := ScrapKBZ(kbz)
	rawCB, cb := ScrapCB(cb)

	r := gin.Default()

	r.GET("/:bank", func(c *gin.Context) {
		bankName := c.Params.ByName("bank")

		if bankName == "kbz" {
			bank := Process(rawKBZ, kbz)
			c.JSON(200, bank)
		} else if bankName == "cb" {
			bank := Process(rawCB, cb)
			c.JSON(200, bank)
		}
	})

	r.GET("/", func(c *gin.Context) {
		body, err := ioutil.ReadFile("README.md")
		PanicIf(err)
		c.String(200,
			string(blackfriday.MarkdownBasic([]byte(body))))
	})

	r.Run(":" + os.Getenv("PORT"))
}

func (t *Thing) EmailParticipants() error {
	if len(t.Participants) == 0 {
		return nil
	}

	showurl := fmt.Sprint(URL_ROOT, "/show/", t.Id)
	editurl := fmt.Sprint(URL_ROOT, "/edit/", t.Id)

	e := email.NewEmail()
	e.From = t.Owner.Email
	e.To = []string{}
	for _, p := range t.Participants {
		if !p.Done {
			e.To = append(e.To, p.Email)
		}
	}
	e.Subject = "A friendly reminder..."
	e.Text = []byte(fmt.Sprintf(texttempl, t.Owner.Email, showurl, t.ThingName, t.ThingLink, editurl))
	e.HTML = []byte(blackfriday.MarkdownBasic(e.Text))
	fmt.Printf("%v\n", e.To)
	println(string(e.Text))

	return e.Send("MAILHOST:25", nil)
	//	return nil

}

// Apply markdown to each section's documentation.
func markdownComments(sections []*section) {
	for _, section := range sections {
		// IMHO BlackFriday should use a string interface, since it
		// operates on text (not arbitrary binary) data...
		section.Doc = string(blackfriday.MarkdownBasic([]byte(section.Doc)))
	}
}

// Fill in Summary and Body values from the Text byte slice.
func (this *Article) InflateSummary() {
	line := bytes.Index(this.Text, []byte("\r\n"))
	if line == -1 {
		line = len(this.Text)
	}
	this.Summary = string(blackfriday.MarkdownBasic(this.Text[:line]))
}

func createPost(file *os.File) (*Post, error) {
	post := &Post{}
	var err error = nil
	reader := bufio.NewReader(file)

	parse := func(prefix string) string {
		regex := regexp.MustCompile(prefix + ":")
		line, _ := reader.ReadString('\n')
		if match := regex.FindStringIndex(line); match != nil {
			return strings.TrimSpace(line[match[1] : len(line)-1])
		}
		err = fmt.Errorf("Expected %s string, got : \"%s\"", prefix, line)
		return ""
	}

	post.Title = parse("Title")
	date := parse("Date")
	post.Date, err = time.Parse("January 2, 2006", date)
	post.Filename = path.Base(file.Name())

	buffer := bytes.NewBuffer(nil)
	io.Copy(buffer, reader)
	post.Content = string(blackfriday.MarkdownBasic(buffer.Bytes()))

	return post, err
}

func (this *TopicController) FileAdd() {
	this.Ctx.Request.ParseMultipartForm(32 << 20)
	file, _, err := this.Ctx.Request.FormFile("file")
	if err != nil {
		beego.Error("[上传文件错误]" + err.Error())
	}
	defer file.Close()
	datas, err := ioutil.ReadAll(file)
	fmt.Println("fmt", datas)
	if err != nil {
		beego.Error("[读取文件错误]" + err.Error())
	}

	beego.Info(string(datas) + "[datas]")

	a := string(datas)
	result := string(blackfriday.MarkdownBasic(datas))
	result = strings.Replace(result, "<code>", "<code class=\"go\">", -1)
	// this.Ctx.WriteString(string(datas)) 为什么这里不输出

	beego.Info(a)

	this.Data["json"] = result
	this.ServeJson()
}

func saveAllDir(db *mgo.Database, path string) {

	list, _ := ioutil.ReadDir(path)
	for _, f := range list {
		if f.IsDir() && strings.HasPrefix(f.Name(), "2014") {
			fmt.Println(f.Name())
			saveAllDir(db, filepath.Join(path, f.Name()))
		} else if strings.HasSuffix(f.Name(), ".md") && (strings.HasPrefix(f.Name(), "2015") || strings.HasPrefix(f.Name(), "2014")) {
			file, err := os.Open(filepath.Join(path, f.Name()))
			if err != nil {
				fmt.Println(err)
				return
			}
			defer file.Close()

			contents, err := ioutil.ReadAll(file)
			if err != nil {
				fmt.Println(err)
				return
			}

			unsafe := blackfriday.MarkdownBasic(contents)
			html := bluemonday.UGCPolicy().SanitizeBytes(unsafe)
			// fmt.Println(string(html))
			doc, err := goquery.NewDocumentFromReader(bytes.NewReader(html))
			langs := make(map[string]Repos)
			doc.Find("h4").Each(func(i int, hs *goquery.Selection) {
				var repos Repos

				hs.NextUntil("h4").Find("li").Each(func(i int, s *goquery.Selection) {
					repo := &Repo{}
					repo.URL, _ = s.Find("a").Attr("href")
					repo.Name = strings.Replace(strings.Replace(s.Find("a").Text(), " ", "", -1), "\n", "", -1)
					// repo.Description =
					parts := strings.Split(s.Text(), ":")
					repo.Description = strings.TrimSpace(strings.Replace(strings.Join(parts[1:], ""), "\n", "", -1))

					img, ok := s.Find("img").Attr("src")
					if ok {
						repo.BuiltBy = Contributors{Contributor{
							Avatar: img,
							// Username: "$$unknown$$",
						}}
					}
					repos = append(repos, repo)
				})
				fmt.Println("len:", len(repos))
				langs[strings.Title(hs.Text())] = repos
			})
			_, filename := filepath.Split(file.Name())
			ymd := strings.Split(strings.TrimSuffix(filename, ".md"), "-")
			s := &Snapshot{
				Date:      fmt.Sprintf("%s-%s-%s", ymd[2], ymd[1], ymd[0]),
				Languages: langs,
			}
			s.Save(db)
		}
	}
}

func main() {
	m := martini.Classic()
	m.Post("/generate", func(r *http.Request) []byte {
		body := r.FormValue("body")
		return blackfriday.MarkdownBasic([]byte(body))
	})
	m.Run()
}