chore: rename renderer package

api/v1/rss.go

@@ -15,7 +15,7 @@ import (
 	"github.com/usememos/memos/internal/util"
 	"github.com/usememos/memos/plugin/gomark/parser"
 	"github.com/usememos/memos/plugin/gomark/parser/tokenizer"
-	"github.com/usememos/memos/plugin/gomark/render"
+	"github.com/usememos/memos/plugin/gomark/renderer"
 	"github.com/usememos/memos/store"
 )
 
@@ -198,7 +198,7 @@ func getRSSItemDescription(content string) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	result := render.NewHTMLRender().Render(nodes)
+	result := renderer.NewHTMLRenderer().Render(nodes)
 	return result, nil
 }
 

plugin/gomark/render/renderer.go

-package render
-
-import (
-	htmlrender "github.com/usememos/memos/plugin/gomark/render/html"
-	stringrender "github.com/usememos/memos/plugin/gomark/render/string"
-)
-
-func NewHTMLRender() *htmlrender.HTMLRender {
-	return htmlrender.NewHTMLRender()
-}
-
-func NewStringRender() *stringrender.StringRender {
-	return stringrender.NewStringRender()
-}

plugin/gomark/render/html/html.go → plugin/gomark/renderer/html/html.go

@@ -7,8 +7,8 @@ import (
 	"github.com/usememos/memos/plugin/gomark/ast"
 )
 
-// HTMLRender is a simple renderer that converts AST to HTML.
-type HTMLRender struct {
+// HTMLRenderer is a simple renderer that converts AST to HTML.
+type HTMLRenderer struct {
 	output  *bytes.Buffer
 	context *RendererContext
 }
@@ -16,16 +16,16 @@ type HTMLRender struct {
 type RendererContext struct {
 }
 
-// NewHTMLRender creates a new HTMLRender.
-func NewHTMLRender() *HTMLRender {
-	return &HTMLRender{
+// NewHTMLRenderer creates a new HTMLRender.
+func NewHTMLRenderer() *HTMLRenderer {
+	return &HTMLRenderer{
 		output:  new(bytes.Buffer),
 		context: &RendererContext{},
 	}
 }
 
 // RenderNode renders a single AST node to HTML.
-func (r *HTMLRender) RenderNode(node ast.Node) {
+func (r *HTMLRenderer) RenderNode(node ast.Node) {
 	switch n := node.(type) {
 	case *ast.LineBreak:
 		r.renderLineBreak(n)
@@ -69,46 +69,46 @@ func (r *HTMLRender) RenderNode(node ast.Node) {
 }
 
 // RenderNodes renders a slice of AST nodes to HTML.
-func (r *HTMLRender) RenderNodes(nodes []ast.Node) {
+func (r *HTMLRenderer) RenderNodes(nodes []ast.Node) {
 	for _, node := range nodes {
 		r.RenderNode(node)
 	}
 }
 
 // Render renders the AST to HTML.
-func (r *HTMLRender) Render(astRoot []ast.Node) string {
+func (r *HTMLRenderer) Render(astRoot []ast.Node) string {
 	r.RenderNodes(astRoot)
 	return r.output.String()
 }
 
-func (r *HTMLRender) renderLineBreak(_ *ast.LineBreak) {
+func (r *HTMLRenderer) renderLineBreak(_ *ast.LineBreak) {
 	r.output.WriteString("<br>")
 }
 
-func (r *HTMLRender) renderParagraph(node *ast.Paragraph) {
+func (r *HTMLRenderer) renderParagraph(node *ast.Paragraph) {
 	r.output.WriteString("<p>")
 	r.RenderNodes(node.Children)
 	r.output.WriteString("</p>")
 }
 
-func (r *HTMLRender) renderCodeBlock(node *ast.CodeBlock) {
+func (r *HTMLRenderer) renderCodeBlock(node *ast.CodeBlock) {
 	r.output.WriteString("<pre><code>")
 	r.output.WriteString(node.Content)
 	r.output.WriteString("</code></pre>")
 }
 
-func (r *HTMLRender) renderHeading(node *ast.Heading) {
+func (r *HTMLRenderer) renderHeading(node *ast.Heading) {
 	element := fmt.Sprintf("h%d", node.Level)
 	r.output.WriteString(fmt.Sprintf("<%s>", element))
 	r.RenderNodes(node.Children)
 	r.output.WriteString(fmt.Sprintf("</%s>", element))
 }
 
-func (r *HTMLRender) renderHorizontalRule(_ *ast.HorizontalRule) {
+func (r *HTMLRenderer) renderHorizontalRule(_ *ast.HorizontalRule) {
 	r.output.WriteString("<hr>")
 }
 
-func (r *HTMLRender) renderBlockquote(node *ast.Blockquote) {
+func (r *HTMLRenderer) renderBlockquote(node *ast.Blockquote) {
 	prevSibling, nextSibling := node.PrevSibling(), node.NextSibling()
 	if prevSibling == nil || prevSibling.Type() != ast.BlockquoteNode {
 		r.output.WriteString("<blockquote>")
@@ -119,7 +119,7 @@ func (r *HTMLRender) renderBlockquote(node *ast.Blockquote) {
 	}
 }
 
-func (r *HTMLRender) renderUnorderedList(node *ast.UnorderedList) {
+func (r *HTMLRenderer) renderUnorderedList(node *ast.UnorderedList) {
 	prevSibling, nextSibling := node.PrevSibling(), node.NextSibling()
 	if prevSibling == nil || prevSibling.Type() != ast.UnorderedListNode {
 		r.output.WriteString("<ul>")
@@ -132,7 +132,7 @@ func (r *HTMLRender) renderUnorderedList(node *ast.UnorderedList) {
 	}
 }
 
-func (r *HTMLRender) renderOrderedList(node *ast.OrderedList) {
+func (r *HTMLRenderer) renderOrderedList(node *ast.OrderedList) {
 	prevSibling, nextSibling := node.PrevSibling(), node.NextSibling()
 	if prevSibling == nil || prevSibling.Type() != ast.OrderedListNode {
 		r.output.WriteString("<ol>")
@@ -145,35 +145,35 @@ func (r *HTMLRender) renderOrderedList(node *ast.OrderedList) {
 	}
 }
 
-func (r *HTMLRender) renderText(node *ast.Text) {
+func (r *HTMLRenderer) renderText(node *ast.Text) {
 	r.output.WriteString(node.Content)
 }
 
-func (r *HTMLRender) renderBold(node *ast.Bold) {
+func (r *HTMLRenderer) renderBold(node *ast.Bold) {
 	r.output.WriteString("<strong>")
 	r.RenderNodes(node.Children)
 	r.output.WriteString("</strong>")
 }
 
-func (r *HTMLRender) renderItalic(node *ast.Italic) {
+func (r *HTMLRenderer) renderItalic(node *ast.Italic) {
 	r.output.WriteString("<em>")
 	r.output.WriteString(node.Content)
 	r.output.WriteString("</em>")
 }
 
-func (r *HTMLRender) renderBoldItalic(node *ast.BoldItalic) {
+func (r *HTMLRenderer) renderBoldItalic(node *ast.BoldItalic) {
 	r.output.WriteString("<strong><em>")
 	r.output.WriteString(node.Content)
 	r.output.WriteString("</em></strong>")
 }
 
-func (r *HTMLRender) renderCode(node *ast.Code) {
+func (r *HTMLRenderer) renderCode(node *ast.Code) {
 	r.output.WriteString("<code>")
 	r.output.WriteString(node.Content)
 	r.output.WriteString("</code>")
 }
 
-func (r *HTMLRender) renderImage(node *ast.Image) {
+func (r *HTMLRenderer) renderImage(node *ast.Image) {
 	r.output.WriteString(`<img src="`)
 	r.output.WriteString(node.URL)
 	r.output.WriteString(`" alt="`)
@@ -181,7 +181,7 @@ func (r *HTMLRender) renderImage(node *ast.Image) {
 	r.output.WriteString(`" />`)
 }
 
-func (r *HTMLRender) renderLink(node *ast.Link) {
+func (r *HTMLRenderer) renderLink(node *ast.Link) {
 	r.output.WriteString(`<a href="`)
 	r.output.WriteString(node.URL)
 	r.output.WriteString(`">`)
@@ -189,20 +189,20 @@ func (r *HTMLRender) renderLink(node *ast.Link) {
 	r.output.WriteString("</a>")
 }
 
-func (r *HTMLRender) renderTag(node *ast.Tag) {
+func (r *HTMLRenderer) renderTag(node *ast.Tag) {
 	r.output.WriteString(`<span>`)
 	r.output.WriteString(`#`)
 	r.output.WriteString(node.Content)
 	r.output.WriteString(`</span>`)
 }
 
-func (r *HTMLRender) renderStrikethrough(node *ast.Strikethrough) {
+func (r *HTMLRenderer) renderStrikethrough(node *ast.Strikethrough) {
 	r.output.WriteString(`<del>`)
 	r.output.WriteString(node.Content)
 	r.output.WriteString(`</del>`)
 }
 
-func (r *HTMLRender) renderEscapingCharacter(node *ast.EscapingCharacter) {
+func (r *HTMLRenderer) renderEscapingCharacter(node *ast.EscapingCharacter) {
 	r.output.WriteString("\\")
 	r.output.WriteString(node.Symbol)
 }

plugin/gomark/render/html/html_test.go → plugin/gomark/renderer/html/html_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/usememos/memos/plugin/gomark/parser/tokenizer"
 )
 
-func TestHTMLRender(t *testing.T) {
+func TestHTMLRenderer(t *testing.T) {
 	tests := []struct {
 		text     string
 		expected string
@@ -60,7 +60,7 @@ func TestHTMLRender(t *testing.T) {
 		tokens := tokenizer.Tokenize(test.text)
 		nodes, err := parser.Parse(tokens)
 		require.NoError(t, err)
-		actual := NewHTMLRender().Render(nodes)
+		actual := NewHTMLRenderer().Render(nodes)
 		require.Equal(t, test.expected, actual)
 	}
 }

plugin/gomark/renderer/renderer.go

+package renderer
+
+import (
+	htmlrenderer "github.com/usememos/memos/plugin/gomark/renderer/html"
+	stringrenderer "github.com/usememos/memos/plugin/gomark/renderer/string"
+)
+
+func NewHTMLRenderer() *htmlrenderer.HTMLRenderer {
+	return htmlrenderer.NewHTMLRenderer()
+}
+
+func NewStringRenderer() *stringrenderer.StringRenderer {
+	return stringrenderer.NewStringRenderer()
+}

plugin/gomark/render/string/string.go → plugin/gomark/renderer/string/string.go

@@ -7,8 +7,8 @@ import (
 	"github.com/usememos/memos/plugin/gomark/ast"
 )
 
-// StringRender renders AST to raw string.
-type StringRender struct {
+// StringRenderer renders AST to raw string.
+type StringRenderer struct {
 	output  *bytes.Buffer
 	context *RendererContext
 }
@@ -16,16 +16,16 @@ type StringRender struct {
 type RendererContext struct {
 }
 
-// NewStringRender creates a new StringRender.
-func NewStringRender() *StringRender {
-	return &StringRender{
+// NewStringRenderer creates a new StringRender.
+func NewStringRenderer() *StringRenderer {
+	return &StringRenderer{
 		output:  new(bytes.Buffer),
 		context: &RendererContext{},
 	}
 }
 
 // RenderNode renders a single AST node to raw string.
-func (r *StringRender) RenderNode(node ast.Node) {
+func (r *StringRenderer) RenderNode(node ast.Node) {
 	switch n := node.(type) {
 	case *ast.LineBreak:
 		r.renderLineBreak(n)
@@ -69,98 +69,98 @@ func (r *StringRender) RenderNode(node ast.Node) {
 }
 
 // RenderNodes renders a slice of AST nodes to raw string.
-func (r *StringRender) RenderNodes(nodes []ast.Node) {
+func (r *StringRenderer) RenderNodes(nodes []ast.Node) {
 	for _, node := range nodes {
 		r.RenderNode(node)
 	}
 }
 
 // Render renders the AST to raw string.
-func (r *StringRender) Render(astRoot []ast.Node) string {
+func (r *StringRenderer) Render(astRoot []ast.Node) string {
 	r.RenderNodes(astRoot)
 	return r.output.String()
 }
 
-func (r *StringRender) renderLineBreak(_ *ast.LineBreak) {
+func (r *StringRenderer) renderLineBreak(_ *ast.LineBreak) {
 	r.output.WriteString("\n")
 }
 
-func (r *StringRender) renderParagraph(node *ast.Paragraph) {
+func (r *StringRenderer) renderParagraph(node *ast.Paragraph) {
 	r.RenderNodes(node.Children)
 	r.output.WriteString("\n")
 }
 
-func (r *StringRender) renderCodeBlock(node *ast.CodeBlock) {
+func (r *StringRenderer) renderCodeBlock(node *ast.CodeBlock) {
 	r.output.WriteString(node.Content)
 }
 
-func (r *StringRender) renderHeading(node *ast.Heading) {
+func (r *StringRenderer) renderHeading(node *ast.Heading) {
 	r.RenderNodes(node.Children)
 	r.output.WriteString("\n")
 }
 
-func (r *StringRender) renderHorizontalRule(_ *ast.HorizontalRule) {
+func (r *StringRenderer) renderHorizontalRule(_ *ast.HorizontalRule) {
 	r.output.WriteString("\n---\n")
 }
 
-func (r *StringRender) renderBlockquote(node *ast.Blockquote) {
+func (r *StringRenderer) renderBlockquote(node *ast.Blockquote) {
 	r.output.WriteString("\n")
 	r.RenderNodes(node.Children)
 	r.output.WriteString("\n")
 }
 
-func (r *StringRender) renderUnorderedList(node *ast.UnorderedList) {
+func (r *StringRenderer) renderUnorderedList(node *ast.UnorderedList) {
 	r.output.WriteString(node.Symbol)
 	r.RenderNodes(node.Children)
 	r.output.WriteString("\n")
 }
 
-func (r *StringRender) renderOrderedList(node *ast.OrderedList) {
+func (r *StringRenderer) renderOrderedList(node *ast.OrderedList) {
 	r.output.WriteString(fmt.Sprintf("%s. ", node.Number))
 	r.RenderNodes(node.Children)
 	r.output.WriteString("\n")
 }
 
-func (r *StringRender) renderText(node *ast.Text) {
+func (r *StringRenderer) renderText(node *ast.Text) {
 	r.output.WriteString(node.Content)
 }
 
-func (r *StringRender) renderBold(node *ast.Bold) {
+func (r *StringRenderer) renderBold(node *ast.Bold) {
 	r.RenderNodes(node.Children)
 }
 
-func (r *StringRender) renderItalic(node *ast.Italic) {
+func (r *StringRenderer) renderItalic(node *ast.Italic) {
 	r.output.WriteString(node.Content)
 }
 
-func (r *StringRender) renderBoldItalic(node *ast.BoldItalic) {
+func (r *StringRenderer) renderBoldItalic(node *ast.BoldItalic) {
 	r.output.WriteString(node.Content)
 }
 
-func (r *StringRender) renderCode(node *ast.Code) {
+func (r *StringRenderer) renderCode(node *ast.Code) {
 	r.output.WriteString("`")
 	r.output.WriteString(node.Content)
 	r.output.WriteString("`")
 }
 
-func (r *StringRender) renderImage(node *ast.Image) {
+func (r *StringRenderer) renderImage(node *ast.Image) {
 	r.output.WriteString(node.AltText)
 }
 
-func (r *StringRender) renderLink(node *ast.Link) {
+func (r *StringRenderer) renderLink(node *ast.Link) {
 	r.output.WriteString(node.Text)
 }
 
-func (r *StringRender) renderTag(node *ast.Tag) {
+func (r *StringRenderer) renderTag(node *ast.Tag) {
 	r.output.WriteString(`#`)
 	r.output.WriteString(node.Content)
 }
 
-func (r *StringRender) renderStrikethrough(node *ast.Strikethrough) {
+func (r *StringRenderer) renderStrikethrough(node *ast.Strikethrough) {
 	r.output.WriteString(node.Content)
 }
 
-func (r *StringRender) renderEscapingCharacter(node *ast.EscapingCharacter) {
+func (r *StringRenderer) renderEscapingCharacter(node *ast.EscapingCharacter) {
 	r.output.WriteString("\\")
 	r.output.WriteString(node.Symbol)
 }

plugin/gomark/render/string/string_test.go → plugin/gomark/renderer/string/string_test.go

@@ -40,7 +40,7 @@ func TestStringRender(t *testing.T) {
 		tokens := tokenizer.Tokenize(test.text)
 		nodes, err := parser.Parse(tokens)
 		require.NoError(t, err)
-		actual := NewStringRender().Render(nodes)
+		actual := NewStringRenderer().Render(nodes)
 		require.Equal(t, test.expected, actual)
 	}
 }

server/frontend/frontend.go

@@ -14,7 +14,7 @@ import (
 	"github.com/usememos/memos/internal/util"
 	"github.com/usememos/memos/plugin/gomark/parser"
 	"github.com/usememos/memos/plugin/gomark/parser/tokenizer"
-	"github.com/usememos/memos/plugin/gomark/render"
+	"github.com/usememos/memos/plugin/gomark/renderer"
 	"github.com/usememos/memos/server/profile"
 	"github.com/usememos/memos/store"
 )
@@ -162,7 +162,7 @@ func generateMemoMetadata(memo *store.Memo, creator *store.User) string {
 	} else {
 		tokens := tokenizer.Tokenize(memo.Content)
 		nodes, _ := parser.Parse(tokens)
-		description = render.NewStringRender().Render(nodes)
+		description = renderer.NewStringRenderer().Render(nodes)
 		if len(description) == 0 {
 			description = memo.Content
 		}