chore: initial gomark plugin (#1678)

chore: initial gomark folder

plugin/gomark/README.md

+# gomark
+
+A markdown parser for memos. WIP

plugin/gomark/ast/ast.go

+package ast
+
+type Node struct {
+	Type     string
+	Text     string
+	Children []*Node
+}
+
+type Document struct {
+	Nodes []*Node
+}
+
+func NewDocument() *Document {
+	return &Document{}
+}
+
+func (d *Document) AddNode(node *Node) {
+	d.Nodes = append(d.Nodes, node)
+}

plugin/gomark/ast/node.go

+package ast
+
+func NewNode(tp, text string) *Node {
+	return &Node{
+		Type: tp,
+		Text: text,
+	}
+}
+
+func (n *Node) AddChild(child *Node) {
+	n.Children = append(n.Children, child)
+}

plugin/gomark/gomark.go

+package gomark

plugin/gomark/parser/heading.go

+package parser
+
+import (
+	"strings"
+
+	"github.com/usememos/memos/plugin/gomark/ast"
+)
+
+type HeadingTokenizer struct {
+}
+
+func NewHeadingTokenizer() *HeadingTokenizer {
+	return &HeadingTokenizer{}
+}
+
+func (*HeadingTokenizer) Trigger() []byte {
+	return []byte{'#'}
+}
+
+func (*HeadingTokenizer) Parse(parent *ast.Node, block string) *ast.Node {
+	line := block
+	level := 0
+	for _, c := range line {
+		if c == '#' {
+			level++
+		} else if c == ' ' {
+			break
+		} else {
+			return nil
+		}
+	}
+	if level == 0 || level > 6 {
+		return nil
+	}
+	text := strings.TrimSpace(line[level+1:])
+	node := ast.NewNode("h1", text)
+	if parent != nil {
+		parent.AddChild(node)
+	}
+	return node
+}

plugin/gomark/parser/heading_test.go

+package parser

plugin/gomark/parser/parser.go

+package parser

plugin/gomark/parser/tokenizer/token.go

+package tokenizer
+
+type TokenType = string
+
+const (
+	Underline TokenType = "_"
+	Star      TokenType = "*"
+	Newline   TokenType = "\n"
+	Hash      TokenType = "#"
+	Space     TokenType = " "
+)
+
+const (
+	Text TokenType = ""
+)
+
+type Token struct {
+	Type  TokenType
+	Value string
+}
+
+func NewToken(tp, text string) *Token {
+	return &Token{
+		Type:  tp,
+		Value: text,
+	}
+}

plugin/gomark/parser/tokenizer/tokenizer.go

+package tokenizer
+
+func tokenize(text string) []*Token {
+	tokens := []*Token{}
+	for _, c := range text {
+		switch c {
+		case '_':
+			tokens = append(tokens, NewToken(Underline, "_"))
+		case '*':
+			tokens = append(tokens, NewToken(Star, "*"))
+		case '\n':
+			tokens = append(tokens, NewToken(Newline, "\n"))
+		case ' ':
+			tokens = append(tokens, NewToken(Space, " "))
+		default:
+			var lastToken *Token
+			if len(tokens) > 0 {
+				lastToken = tokens[len(tokens)-1]
+			}
+			if lastToken == nil || lastToken.Type != Text {
+				tokens = append(tokens, NewToken(Text, string(c)))
+			} else {
+				lastToken.Value += string(c)
+			}
+		}
+	}
+	return tokens
+}

plugin/gomark/parser/tokenizer/tokenizer_test.go

+package tokenizer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestTokenize(t *testing.T) {
+	tests := []struct {
+		text   string
+		tokens []*Token
+	}{
+		{
+			text: "*Hello world!",
+			tokens: []*Token{
+				{
+					Type:  Star,
+					Value: "*",
+				},
+				{
+					Type:  Text,
+					Value: "Hello",
+				},
+				{
+					Type:  Space,
+					Value: " ",
+				},
+				{
+					Type:  Text,
+					Value: "world!",
+				},
+			},
+		},
+	}
+	for _, test := range tests {
+		result := tokenize(test.text)
+		require.Equal(t, test.tokens, result)
+	}
+}

plugin/gomark/renderer/renderer.go

+package renderer