No OneTemporary
Actions

Size

27 KB

Subscribers

None

View Options

	diff --git a/config/config.go b/config/config.go
	index 40738e1..4c6ff62 100644
	--- a/config/config.go
	+++ b/config/config.go
	@@ -1,305 +1,344 @@
	/*
	* Copyright © 2018-2021 Musing Studio LLC.
	*
	* This file is part of WriteFreely.
	*
	* WriteFreely is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License, included
	* in the LICENSE file in this source code package.
	*/

	// Package config holds and assists in the configuration of a writefreely instance.
	package config

	import (
	"net/url"
	"strings"

	"github.com/go-ini/ini"
	"github.com/writeas/web-core/log"
	+ "github.com/yuin/goldmark"
	+ "github.com/yuin/goldmark/extension"
	"golang.org/x/net/idna"
	)

	const (
	// FileName is the default configuration file name
	FileName = "config.ini"

	UserNormal UserType = "user"
	UserAdmin = "admin"
	)

	type (
	UserType string

	// ServerCfg holds values that affect how the HTTP server runs
	ServerCfg struct {
	HiddenHost string `ini:"hidden_host"`
	Port int `ini:"port"`
	Bind string `ini:"bind"`

	TLSCertPath string `ini:"tls_cert_path"`
	TLSKeyPath string `ini:"tls_key_path"`
	Autocert bool `ini:"autocert"`

	TemplatesParentDir string `ini:"templates_parent_dir"`
	StaticParentDir string `ini:"static_parent_dir"`
	PagesParentDir string `ini:"pages_parent_dir"`
	KeysParentDir string `ini:"keys_parent_dir"`

	HashSeed string `ini:"hash_seed"`

	GopherPort int `ini:"gopher_port"`

	Dev bool `ini:"-"`
	}

	// DatabaseCfg holds values that determine how the application connects to a datastore
	DatabaseCfg struct {
	Type string `ini:"type"`
	FileName string `ini:"filename"`
	User string `ini:"username"`
	Password string `ini:"password"`
	Database string `ini:"database"`
	Host string `ini:"host"`
	Port int `ini:"port"`
	TLS bool `ini:"tls"`
	}

	WriteAsOauthCfg struct {
	ClientID string `ini:"client_id"`
	ClientSecret string `ini:"client_secret"`
	AuthLocation string `ini:"auth_location"`
	TokenLocation string `ini:"token_location"`
	InspectLocation string `ini:"inspect_location"`
	CallbackProxy string `ini:"callback_proxy"`
	CallbackProxyAPI string `ini:"callback_proxy_api"`
	}

	GitlabOauthCfg struct {
	ClientID string `ini:"client_id"`
	ClientSecret string `ini:"client_secret"`
	Host string `ini:"host"`
	DisplayName string `ini:"display_name"`
	CallbackProxy string `ini:"callback_proxy"`
	CallbackProxyAPI string `ini:"callback_proxy_api"`
	}

	GiteaOauthCfg struct {
	ClientID string `ini:"client_id"`
	ClientSecret string `ini:"client_secret"`
	Host string `ini:"host"`
	DisplayName string `ini:"display_name"`
	CallbackProxy string `ini:"callback_proxy"`
	CallbackProxyAPI string `ini:"callback_proxy_api"`
	}

	SlackOauthCfg struct {
	ClientID string `ini:"client_id"`
	ClientSecret string `ini:"client_secret"`
	TeamID string `ini:"team_id"`
	CallbackProxy string `ini:"callback_proxy"`
	CallbackProxyAPI string `ini:"callback_proxy_api"`
	}

	GenericOauthCfg struct {
	ClientID string `ini:"client_id"`
	ClientSecret string `ini:"client_secret"`
	Host string `ini:"host"`
	DisplayName string `ini:"display_name"`
	CallbackProxy string `ini:"callback_proxy"`
	CallbackProxyAPI string `ini:"callback_proxy_api"`
	TokenEndpoint string `ini:"token_endpoint"`
	InspectEndpoint string `ini:"inspect_endpoint"`
	AuthEndpoint string `ini:"auth_endpoint"`
	Scope string `ini:"scope"`
	AllowDisconnect bool `ini:"allow_disconnect"`
	MapUserID string `ini:"map_user_id"`
	MapUsername string `ini:"map_username"`
	MapDisplayName string `ini:"map_display_name"`
	MapEmail string `ini:"map_email"`
	}

	// AppCfg holds values that affect how the application functions
	AppCfg struct {
	SiteName string `ini:"site_name"`
	SiteDesc string `ini:"site_description"`
	Host string `ini:"host"`

	// Site appearance
	Theme string `ini:"theme"`
	Editor string `ini:"editor"`
	JSDisabled bool `ini:"disable_js"`
	WebFonts bool `ini:"webfonts"`
	Landing string `ini:"landing"`
	SimpleNav bool `ini:"simple_nav"`
	WFModesty bool `ini:"wf_modesty"`

	// Site functionality
	Chorus bool `ini:"chorus"`
	Forest bool `ini:"forest"` // The admin cares about the forest, not the trees. Hide unnecessary technical info.
	DisableDrafts bool `ini:"disable_drafts"`

	// Users
	SingleUser bool `ini:"single_user"`
	OpenRegistration bool `ini:"open_registration"`
	OpenDeletion bool `ini:"open_deletion"`
	MinUsernameLen int `ini:"min_username_len"`
	MaxBlogs int `ini:"max_blogs"`

	// Options for public instances
	// Federation
	Federation bool `ini:"federation"`
	PublicStats bool `ini:"public_stats"`
	Monetization bool `ini:"monetization"`
	NotesOnly bool `ini:"notes_only"`

	// Access
	Private bool `ini:"private"`

	// Additional functions
	LocalTimeline bool `ini:"local_timeline"`
	UserInvites string `ini:"user_invites"`

	// Defaults
	DefaultVisibility string `ini:"default_visibility"`

	// Check for Updates
	UpdateChecks bool `ini:"update_checks"`

	// Disable password authentication if use only Oauth
	DisablePasswordAuth bool `ini:"disable_password_auth"`

	// Which Markdown renderer to use
	Renderer string `ini:"markdown_renderer"`
	+
	+ // Options for the Goldmark renderer
	+ RendererOptions string `ini:"markdown_options"`
	+ // Conversion of options ready for the renderer
	+ rendererExtensions []goldmark.Extender
	}

	// Config holds the complete configuration for running a writefreely instance
	Config struct {
	Server ServerCfg `ini:"server"`
	Database DatabaseCfg `ini:"database"`
	App AppCfg `ini:"app"`
	SlackOauth SlackOauthCfg `ini:"oauth.slack"`
	WriteAsOauth WriteAsOauthCfg `ini:"oauth.writeas"`
	GitlabOauth GitlabOauthCfg `ini:"oauth.gitlab"`
	GiteaOauth GiteaOauthCfg `ini:"oauth.gitea"`
	GenericOauth GenericOauthCfg `ini:"oauth.generic"`
	}
	)

	// New creates a new Config with sane defaults
	func New() *Config {
	c := &Config{
	Server: ServerCfg{
	Port: 8080,
	Bind: "localhost", /* IPV6 support when not using localhost? */
	},
	App: AppCfg{
	Host: "http://localhost:8080",
	Theme: "write",
	WebFonts: true,
	SingleUser: true,
	MinUsernameLen: 3,
	MaxBlogs: 1,
	Federation: true,
	PublicStats: true,
	},
	}
	c.UseMySQL(true)
	return c
	}

	// UseMySQL resets the Config's Database to use default values for a MySQL setup.
	func (cfg *Config) UseMySQL(fresh bool) {
	cfg.Database.Type = "mysql"
	if fresh {
	cfg.Database.Host = "localhost"
	cfg.Database.Port = 3306
	}
	}

	// UseSQLite resets the Config's Database to use default values for a SQLite setup.
	func (cfg *Config) UseSQLite(fresh bool) {
	cfg.Database.Type = "sqlite3"
	if fresh {
	cfg.Database.FileName = "writefreely.db"
	}
	}

	// IsSecureStandalone returns whether or not the application is running as a
	// standalone server with TLS enabled.
	func (cfg *Config) IsSecureStandalone() bool {
	return cfg.Server.Port == 443 && cfg.Server.TLSCertPath != "" && cfg.Server.TLSKeyPath != ""
	}

	func (ac *AppCfg) LandingPath() string {
	if !strings.HasPrefix(ac.Landing, "/") {
	return "/" + ac.Landing
	}
	return ac.Landing
	}

	func (ac AppCfg) SignupPath() string {
	if !ac.OpenRegistration {
	return ""
	}
	if ac.Chorus \|\| ac.Private \|\| (ac.Landing != "" && ac.Landing != "/") {
	return "/signup"
	}
	return "/"
	}

	func (ac AppCfg) MarkdownRenderer() string {
	if strings.EqualFold(ac.Renderer, "goldmark") {
	return "goldmark"
	}
	return "saturday"
	}

	+func (ac AppCfg) RendererExtensions() []goldmark.Extender {
	+ if ac.rendererExtensions != nil {
	+ return ac.rendererExtensions
	+ }
	+ var extlist []goldmark.Extender
	+ optlist := strings.FieldsFunc(ac.RendererOptions, func(r rune) bool {
	+ return r == ' ' \|\| r == '\t' \|\| r == ','
	+ })
	+ for _, opt := range optlist {
	+ switch opt {
	+ case "table":
	+ extlist = append(extlist, extension.Table)
	+ case "strikethrough":
	+ extlist = append(extlist, extension.Strikethrough)
	+ case "linkify":
	+ extlist = append(extlist, extension.Linkify)
	+ case "tasklist":
	+ extlist = append(extlist, extension.TaskList)
	+ case "gfm":
	+ extlist = append(extlist, extension.GFM)
	+ case "definitionlist":
	+ extlist = append(extlist, extension.DefinitionList)
	+ case "typographer":
	+ extlist = append(extlist, extension.Typographer)
	+ case "cjk":
	+ extlist = append(extlist, extension.CJK)
	+ }
	+ }
	+ ac.rendererExtensions = extlist
	+ return extlist
	+}
	+
	// Load reads the given configuration file, then parses and returns it as a Config.
	func Load(fname string) (*Config, error) {
	if fname == "" {
	fname = FileName
	}
	cfg, err := ini.Load(fname)
	if err != nil {
	return nil, err
	}

	// Parse INI file
	uc := &Config{}
	err = cfg.MapTo(uc)
	if err != nil {
	return nil, err
	}

	// Do any transformations
	u, err := url.Parse(uc.App.Host)
	if err != nil {
	return nil, err
	}
	d, err := idna.ToASCII(u.Hostname())
	if err != nil {
	log.Error("idna.ToASCII for %s: %s", u.Hostname(), err)
	return nil, err
	}
	uc.App.Host = u.Scheme + "://" + d
	if u.Port() != "" {
	uc.App.Host += ":" + u.Port()
	}

	return uc, nil
	}

	// Save writes the given Config to the given file.
	func Save(uc *Config, fname string) error {
	cfg := ini.Empty()
	err := ini.ReflectFrom(cfg, uc)
	if err != nil {
	return err
	}

	if fname == "" {
	fname = FileName
	}
	return cfg.SaveTo(fname)
	}
	diff --git a/postrender.go b/postrender.go
	index 57b8579..2d155a3 100644
	--- a/postrender.go
	+++ b/postrender.go
	@@ -1,472 +1,461 @@
	/*
	* Copyright © 2018-2021 Musing Studio LLC.
	*
	* This file is part of WriteFreely.
	*
	* WriteFreely is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License, included
	* in the LICENSE file in this source code package.
	*/

	package writefreely

	import (
	"bytes"
	"encoding/json"
	"fmt"
	"html"
	"html/template"
	"net/http"
	"net/url"
	"regexp"
	"strings"
	"unicode"
	"unicode/utf8"

	hashtag "github.com/abhinav/goldmark-hashtag"
	"github.com/microcosm-cc/bluemonday"
	stripmd "github.com/writeas/go-strip-markdown/v2"
	"github.com/writeas/impart"
	blackfriday "github.com/writeas/saturday"
	"github.com/writeas/web-core/log"
	"github.com/writeas/web-core/stringmanip"
	"github.com/yuin/goldmark"
	- "github.com/yuin/goldmark/extension"
	"github.com/yuin/goldmark/parser"

	"github.com/writefreely/writefreely/config"
	"github.com/writefreely/writefreely/parse"
	)

	var (
	blockReg = regexp.MustCompile("<(ul\|ol\|blockquote)>\n")
	endBlockReg = regexp.MustCompile("</([a-z]+)>\n</(ul\|ol\|blockquote)>")
	youtubeReg = regexp.MustCompile("(https?://www.youtube.com/embed/[a-zA-Z0-9\\-_]+)(\\?[^\t\n\f\r \"']+)?")
	titleElementReg = regexp.MustCompile("</?h[1-6]>")
	hashtagReg = regexp.MustCompile(`{{\[\[\\|\\|([^\|]+)\\|\\|\]\]}}`)
	markeddownReg = regexp.MustCompile("<p>(.+)</p>")
	mentionReg = regexp.MustCompile(`@([A-Za-z0-9._%+-]+)(@[A-Za-z0-9.-]+\.[A-Za-z]+)\b`)
	)

	func (p Post) handlePremiumContent(c Collection, isOwner, postPage bool, cfg *config.Config) {
	if c.Monetization != "" {
	// User has Web Monetization enabled, so split content if it exists
	spl := strings.Index(p.Content, shortCodePaid)
	p.IsPaid = spl > -1
	if postPage {
	// We're viewing the individual post
	if isOwner {
	p.Content = strings.Replace(p.Content, shortCodePaid, "\n\n"+`<p class="split">Your subscriber content begins here.</p>`+"\n\n", 1)
	} else {
	if spl > -1 {
	p.Content = p.Content[:spl+len(shortCodePaid)]
	p.Content = strings.Replace(p.Content, shortCodePaid, "\n\n"+`<p class="split">Continue reading with a <strong>Coil</strong> membership.</p>`+"\n\n", 1)
	}
	}
	} else {
	// We've viewing the post on the collection landing
	if spl > -1 {
	baseURL := c.CanonicalURL()
	if isOwner {
	baseURL = "/" + c.Alias + "/"
	}

	p.Content = p.Content[:spl+len(shortCodePaid)]
	p.HTMLExcerpt = template.HTML(applyMarkdown([]byte(p.Content[:spl]), baseURL, cfg))
	}
	}
	}
	}

	func (p Post) formatContent(cfg config.Config, c *Collection, isOwner bool, isPostPage bool) {
	baseURL := c.CanonicalURL()
	// TODO: redundant
	if !isSingleUser {
	baseURL = "/" + c.Alias + "/"
	}

	p.handlePremiumContent(c, isOwner, isPostPage, cfg)
	p.Content = strings.Replace(p.Content, "<!--paid-->", "<!--paid-->", 1)

	p.HTMLTitle = template.HTML(applyBasicMarkdown([]byte(p.Title.String), cfg))
	p.HTMLContent = template.HTML(applyMarkdown([]byte(p.Content), baseURL, cfg))
	if exc := strings.Index(string(p.Content), "<!--more-->"); exc > -1 {
	p.HTMLExcerpt = template.HTML(applyMarkdown([]byte(p.Content[:exc]), baseURL, cfg))
	}
	}

	func (p PublicPost) formatContent(cfg config.Config, isOwner bool, isPostPage bool) {
	p.Post.formatContent(cfg, &p.Collection.Collection, isOwner, isPostPage)
	}

	func (p Post) augmentContent(c Collection) {
	if p.PinnedPosition.Valid {
	// Don't augment posts that are pinned
	return
	}
	if strings.Index(p.Content, "<!--nosig-->") > -1 {
	// Don't augment posts with the special "nosig" shortcode
	return
	}
	// Add post signatures
	if c.Signature != "" {
	p.Content += "\n\n" + c.Signature
	}
	}

	func (p *PublicPost) augmentContent() {
	p.Post.augmentContent(&p.Collection.Collection)
	}

	func (p *PublicPost) augmentReadingDestination() {
	if p.IsPaid {
	p.HTMLContent += template.HTML("\n\n" + `<p><a class="read-more" href="` + p.Collection.CanonicalURL() + p.Slug.String + `">` + localStr("Read more...", p.Language.String) + `</a> ($)</p>`)
	}
	}

	func applyMarkdown(data []byte, baseURL string, cfg *config.Config) string {
	if cfg.App.MarkdownRenderer() == "goldmark" {
	return applyCommonmarkSpecial(data, false, baseURL, cfg)
	}
	return applySaturdaySpecial(data, false, baseURL, cfg)
	}

	func disableYoutubeAutoplay(outHTML string) string {
	for _, match := range youtubeReg.FindAllString(outHTML, -1) {
	u, err := url.Parse(match)
	if err != nil {
	continue
	}
	u.RawQuery = html.UnescapeString(u.RawQuery)
	q := u.Query()
	// Set Youtube autoplay url parameter, if any, to 0
	if len(q["autoplay"]) == 1 {
	q.Set("autoplay", "0")
	}
	u.RawQuery = q.Encode()
	cleanURL := u.String()
	outHTML = strings.Replace(outHTML, match, cleanURL, 1)
	}
	return outHTML
	}

	type hashtagResolver struct {
	Prefix string
	}

	var _ hashtag.Resolver = hashtagResolver{}

	func (h hashtagResolver) ResolveHashtag(node *hashtag.Node) (destination []byte, err error) {
	var buf bytes.Buffer
	buf.WriteString(h.Prefix)
	buf.Write(node.Tag)
	return buf.Bytes(), nil
	}

	func applyMarkdownSpecial(data []byte, skipNoFollow bool, baseURL string, cfg *config.Config) string {
	if cfg.App.MarkdownRenderer() == "goldmark" {
	return applyCommonmarkSpecial(data, skipNoFollow, baseURL, cfg)
	} else {
	return applySaturdaySpecial(data, skipNoFollow, baseURL, cfg)
	}
	}

	func applyCommonmarkSpecial(data []byte, skipNoFollow bool, baseURL string, cfg *config.Config) string {
	- extensions := []goldmark.Extender{
	- extension.GFM,
	- extension.DefinitionList,
	- extension.Typographer,
	- // but no footnotes, see https://github.com/writefreely/writefreely/issues/338
	- }
	+ extensions := cfg.App.RendererExtensions()
	if baseURL != "" {
	tagPrefix := baseURL + "tag:"
	if cfg.App.Chorus {
	tagPrefix = "/read/t"
	}
	extensions = append(extensions, &hashtag.Extender{
	Resolver: hashtagResolver{Prefix: tagPrefix},
	})
	}
	md := goldmark.New(
	- goldmark.WithExtensions(
	- &hashtag.Extender{
	- Resolver: hashtagResolver{},
	- },
	- ),
	+ goldmark.WithExtensions(extensions...),
	goldmark.WithParserOptions(
	parser.WithAutoHeadingID(),
	),
	)
	var buf bytes.Buffer
	if err := md.Convert(data, &buf); err != nil {
	log.Info("error rendering CommonMark: %v", err)
	}
	htm := buf.Bytes()
	if baseURL != "" {
	handlePrefix := cfg.App.Host + "/@/"
	htm = []byte(mentionReg.ReplaceAll(htm, []byte("<a href=\""+handlePrefix+"$1$2\" class=\"u-url mention\">@<span>$1$2</span></a>")))
	}
	// Strip out bad HTML
	policy := getSanitizationPolicy()
	policy.RequireNoFollowOnLinks(!skipNoFollow)
	outHTML := string(policy.SanitizeBytes(htm))
	// Strip newlines on certain block elements that render with them
	outHTML = blockReg.ReplaceAllString(outHTML, "<$1>")
	outHTML = endBlockReg.ReplaceAllString(outHTML, "</$1></$2>")
	outHTML = disableYoutubeAutoplay(outHTML)
	return outHTML
	}

	func applySaturdaySpecial(data []byte, skipNoFollow bool, baseURL string, cfg *config.Config) string {
	mdExtensions := 0 \|
	blackfriday.EXTENSION_TABLES \|
	blackfriday.EXTENSION_FENCED_CODE \|
	blackfriday.EXTENSION_AUTOLINK \|
	blackfriday.EXTENSION_STRIKETHROUGH \|
	blackfriday.EXTENSION_SPACE_HEADERS \|
	blackfriday.EXTENSION_AUTO_HEADER_IDS
	htmlFlags := 0 \|
	blackfriday.HTML_USE_SMARTYPANTS \|
	blackfriday.HTML_SMARTYPANTS_DASHES

	if baseURL != "" {
	htmlFlags \|= blackfriday.HTML_HASHTAGS
	}

	// Generate Markdown
	md := blackfriday.Markdown([]byte(data), blackfriday.HtmlRenderer(htmlFlags, "", ""), mdExtensions)
	if baseURL != "" {
	// Replace special text generated by Markdown parser
	tagPrefix := baseURL + "tag:"
	if cfg.App.Chorus {
	tagPrefix = "/read/t/"
	}
	md = []byte(hashtagReg.ReplaceAll(md, []byte("<a href=\""+tagPrefix+"$1\" class=\"hashtag\"><span>#</span><span class=\"p-category\">$1</span></a>")))
	handlePrefix := cfg.App.Host + "/@/"
	md = []byte(mentionReg.ReplaceAll(md, []byte("<a href=\""+handlePrefix+"$1$2\" class=\"u-url mention\">@<span>$1$2</span></a>")))
	}
	// Strip out bad HTML
	policy := getSanitizationPolicy()
	policy.RequireNoFollowOnLinks(!skipNoFollow)
	outHTML := string(policy.SanitizeBytes(md))
	// Strip newlines on certain block elements that render with them
	outHTML = blockReg.ReplaceAllString(outHTML, "<$1>")
	outHTML = endBlockReg.ReplaceAllString(outHTML, "</$1></$2>")
	outHTML = disableYoutubeAutoplay(outHTML)
	return outHTML
	}

	func applyBasicMarkdown(data []byte, cfg *config.Config) string {
	if cfg.App.MarkdownRenderer() == "goldmark" {
	- return applyBasicCommonmark(data)
	+ return applyBasicCommonmark(data, cfg)
	} else {
	return applyBasicSaturday(data)
	}
	}

	-func applyBasicCommonmark(data []byte) string {
	+func applyBasicCommonmark(data []byte, cfg *config.Config) string {
	md := goldmark.New(
	goldmark.WithExtensions(
	- extension.Strikethrough,
	- extension.Linkify,
	- extension.Typographer,
	+ cfg.App.RendererExtensions()...,
	),
	)
	var inbuf bytes.Buffer
	inbuf.WriteString("# ")
	inbuf.Write(data)
	var outbuf bytes.Buffer
	if err := md.Convert(inbuf.Bytes(), &outbuf); err != nil {
	log.Info("error rendering basic CommonMark: %v", err)
	}
	htm := outbuf.Bytes()
	htm = bytes.TrimSpace(htm)

	htm = htm[len("<h1>") : len(htm)-len("</h1>")]
	// Strip out bad HTML
	policy := bluemonday.UGCPolicy()
	policy.AllowAttrs("class", "id").Globally()
	outHTML := string(policy.SanitizeBytes(htm))
	outHTML = markeddownReg.ReplaceAllString(outHTML, "$1")
	outHTML = strings.TrimRightFunc(outHTML, unicode.IsSpace)
	return outHTML
	}

	func applyBasicSaturday(data []byte) string {
	if len(bytes.TrimSpace(data)) == 0 {
	return ""
	}

	mdExtensions := 0 \|
	blackfriday.EXTENSION_STRIKETHROUGH \|
	blackfriday.EXTENSION_SPACE_HEADERS \|
	blackfriday.EXTENSION_HEADER_IDS
	htmlFlags := 0 \|
	blackfriday.HTML_SKIP_HTML \|
	blackfriday.HTML_USE_SMARTYPANTS \|
	blackfriday.HTML_SMARTYPANTS_DASHES

	// Generate Markdown
	// This passes the supplied title into blackfriday.Markdown() as an H1 header, so we only render HTML that
	// belongs in an H1.
	md := blackfriday.Markdown(append([]byte("# "), data...), blackfriday.HtmlRenderer(htmlFlags, "", ""), mdExtensions)
	// Remove H1 markup
	md = bytes.TrimSpace(md) // blackfriday.Markdown adds a newline at the end of the <h1>
	if len(md) == 0 {
	return ""
	}
	md = md[len("<h1>") : len(md)-len("</h1>")]
	// Strip out bad HTML
	policy := bluemonday.UGCPolicy()
	policy.AllowAttrs("class", "id").Globally()
	outHTML := string(policy.SanitizeBytes(md))
	outHTML = markeddownReg.ReplaceAllString(outHTML, "$1")
	outHTML = strings.TrimRightFunc(outHTML, unicode.IsSpace)

	return outHTML
	}

	func postTitle(content, friendlyId string) string {
	const maxTitleLen = 80

	content = stripHTMLWithoutEscaping(content)

	content = strings.TrimLeftFunc(stripmd.Strip(content), unicode.IsSpace)
	eol := strings.IndexRune(content, '\n')
	blankLine := strings.Index(content, "\n\n")
	if blankLine != -1 && blankLine <= eol && blankLine <= assumedTitleLen {
	return strings.TrimSpace(content[:blankLine])
	} else if utf8.RuneCountInString(content) <= maxTitleLen {
	return content
	}
	return friendlyId
	}

	// TODO: fix duplicated code from postTitle. postTitle is a widely used func we
	// don't have time to investigate right now.
	func friendlyPostTitle(content, friendlyId string) string {
	const maxTitleLen = 80

	content = stripHTMLWithoutEscaping(content)

	content = strings.TrimLeftFunc(stripmd.Strip(content), unicode.IsSpace)
	eol := strings.IndexRune(content, '\n')
	blankLine := strings.Index(content, "\n\n")
	if blankLine != -1 && blankLine <= eol && blankLine <= assumedTitleLen {
	return strings.TrimSpace(content[:blankLine])
	} else if eol == -1 && utf8.RuneCountInString(content) <= maxTitleLen {
	return content
	}
	title, truncd := parse.TruncToWord(parse.PostLede(content, true), maxTitleLen)
	if truncd {
	title += "..."
	}
	return title
	}

	// Strip HTML tags with bluemonday's StrictPolicy, then unescape the HTML
	// entities added in by sanitizing the content.
	func stripHTMLWithoutEscaping(content string) string {
	return html.UnescapeString(bluemonday.StrictPolicy().Sanitize(content))
	}

	func getSanitizationPolicy() *bluemonday.Policy {
	policy := bluemonday.UGCPolicy()
	policy.AllowAttrs("src", "style").OnElements("iframe", "video", "audio")
	policy.AllowAttrs("src", "type").OnElements("source")
	policy.AllowAttrs("frameborder", "width", "height").Matching(bluemonday.Integer).OnElements("iframe")
	policy.AllowAttrs("allowfullscreen").OnElements("iframe")
	policy.AllowAttrs("controls", "loop", "muted", "autoplay").OnElements("video")
	policy.AllowAttrs("controls", "loop", "muted", "autoplay", "preload").OnElements("audio")
	policy.AllowAttrs("target").OnElements("a")
	policy.AllowAttrs("title").OnElements("abbr")
	policy.AllowAttrs("style", "class", "id").Globally()
	policy.AllowElements("header", "footer")
	policy.AllowURLSchemes("http", "https", "mailto", "xmpp")
	return policy
	}

	func sanitizePost(content string) string {
	return strings.Replace(content, "<", "<", -1)
	}

	// postDescription generates a description based on the given post content,
	// title, and post ID. This doesn't consider a V2 post field, `title` when
	// choosing what to generate. In case a post has a title, this function will
	// fail, and logic should instead be implemented to skip this when there's no
	// title, like so:
	-// var desc string
	-// if title == "" {
	-// desc = postDescription(content, title, friendlyId)
	-// } else {
	-// desc = shortPostDescription(content)
	-// }
	+//
	+// var desc string
	+// if title == "" {
	+// desc = postDescription(content, title, friendlyId)
	+// } else {
	+// desc = shortPostDescription(content)
	+// }
	func postDescription(content, title, friendlyId string) string {
	maxLen := 140

	if content == "" {
	content = "WriteFreely is a painless, simple, federated blogging platform."
	} else {
	fmtStr := "%s"
	truncation := 0
	if utf8.RuneCountInString(content) > maxLen {
	// Post is longer than the max description, so let's show a better description
	fmtStr = "%s..."
	truncation = 3
	}

	if title == friendlyId {
	// No specific title was found; simply truncate the post, starting at the beginning
	content = fmt.Sprintf(fmtStr, strings.Replace(stringmanip.Substring(content, 0, maxLen-truncation), "\n", " ", -1))
	} else {
	// There was a title, so return a real description
	blankLine := strings.Index(content, "\n\n")
	if blankLine < 0 {
	blankLine = 0
	}
	truncd := stringmanip.Substring(content, blankLine, blankLine+maxLen-truncation)
	contentNoNL := strings.Replace(truncd, "\n", " ", -1)
	content = strings.TrimSpace(fmt.Sprintf(fmtStr, contentNoNL))
	}
	}

	return content
	}

	func shortPostDescription(content string) string {
	maxLen := 140
	fmtStr := "%s"
	truncation := 0
	if utf8.RuneCountInString(content) > maxLen {
	// Post is longer than the max description, so let's show a better description
	fmtStr = "%s..."
	truncation = 3
	}
	return strings.TrimSpace(fmt.Sprintf(fmtStr, strings.Replace(stringmanip.Substring(content, 0, maxLen-truncation), "\n", " ", -1)))
	}

	func handleRenderMarkdown(app App, w http.ResponseWriter, r http.Request) error {
	if !IsJSON(r) {
	return impart.HTTPError{Status: http.StatusUnsupportedMediaType, Message: "Markdown API only supports JSON requests"}
	}

	in := struct {
	CollectionURL string `json:"collection_url"`
	RawBody string `json:"raw_body"`
	}{}

	decoder := json.NewDecoder(r.Body)
	err := decoder.Decode(&in)
	if err != nil {
	log.Error("Couldn't parse markdown JSON request: %v", err)
	return ErrBadJSON
	}

	out := struct {
	Body string `json:"body"`
	}{
	Body: applyMarkdown([]byte(in.RawBody), in.CollectionURL, app.cfg),
	}

	return impart.WriteSuccess(w, out, http.StatusOK)
	}
	diff --git a/postrender_test.go b/postrender_test.go
	index ec6bbdd..3ac2a77 100644
	--- a/postrender_test.go
	+++ b/postrender_test.go
	@@ -1,43 +1,54 @@
	/*
	* Copyright © 2021 Musing Studio LLC.
	*
	* This file is part of WriteFreely.
	*
	* WriteFreely is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License, included
	* in the LICENSE file in this source code package.
	*/

	package writefreely

	-import "testing"
	+import (
	+ "testing"
	+
	+ "github.com/writefreely/writefreely/config"
	+)

	func TestApplyBasicMarkdown(t *testing.T) {
	tests := []struct {
	name string
	in string
	result string
	}{
	{"empty", "", ""},
	{"empty spaces", " ", ""},
	{"empty tabs", "\t", ""},
	{"empty newline", "\n", ""},
	{"nums", "123", "123"},
	{"dot", ".", "."},
	{"dash", "-", "-"},
	{"plain", "Hello, World!", "Hello, World!"},
	{"multibyte", "こんにちは", `こんにちは`},
	{"bold", "안녕하세요", `<strong>안녕하세요</strong>`},
	{"link", "[WriteFreely](https://writefreely.org)", `<a href="https://writefreely.org" rel="nofollow">WriteFreely</a>`},
	{"date", "12. April", `12. April`},
	{"table", "\| Hi \| There \|", `\| Hi \| There \|`},
	}
	- for _, test := range tests {
	- t.Run(test.name, func(t *testing.T) {
	- res := applyBasicMarkdown([]byte(test.in))
	- if res != test.result {
	- t.Errorf("%s: wanted %s, got %s", test.name, test.result, res)
	- }
	- })
	+ for _, renderer := range []string{"saturday", "goldmark"} {
	+ cfg := &config.Config{
	+ App: config.AppCfg{
	+ Renderer: renderer,
	+ },
	+ }
	+ for _, test := range tests {
	+ t.Run(test.name, func(t *testing.T) {
	+ res := applyBasicMarkdown([]byte(test.in), cfg)
	+ if res != test.result {
	+ t.Errorf("%s: wanted %s, got %s", test.name, test.result, res)
	+ }
	+ })
	+ }
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 23, 7:45 AM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3104452

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions