From 1d524762bc56950a85aa748aa873901621741dc7 Mon Sep 17 00:00:00 2001
From: Anhgelus Morhtuuzh <william@herges.fr>
Date: Tue, 30 Sep 2025 20:06:54 +0200
Subject: refactor(markdown): create top layer type paragraph

---
 mardown/ast.go           | 26 +++++++++++++------
 mardown/ast_literal.go   |  9 -------
 mardown/ast_paragraph.go | 65 ++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 83 insertions(+), 17 deletions(-)
 delete mode 100644 mardown/ast_literal.go
 create mode 100644 mardown/ast_paragraph.go

diff --git a/mardown/ast.go b/mardown/ast.go
index fb78113..602d21e 100644
--- a/mardown/ast.go
+++ b/mardown/ast.go
@@ -22,30 +22,40 @@ func (t *tree) Eval() (template.HTML, error) {
 
 func ast(lxs lexers) (*tree, error) {
 	tr := new(tree)
+	newLine := false
 	for lxs.Next() {
-		b, err := getBlock(lxs)
+		b, err := getBlock(lxs, newLine)
 		if err != nil {
 			return nil, err
 		}
 		tr.blocks = append(tr.blocks, b)
+		newLine = lxs.Current().Type == lexerBreak
 	}
 	return tr, nil
 }
 
-func getBlock(lxs lexers) (block, error) {
+func getBlock(lxs lexers, newLine bool) (block, error) {
 	var b block
 	var err error
 	switch lxs.Current().Type {
 	case lexerHeader:
 		b, err = header(lxs)
 	case lexerExternal:
-	case lexerModifier:
-	case lexerCode:
-	case lexerEscape:
+		if newLine && lxs.Current().Value == "!" {
+			//TODO: handle
+		} else {
+			b, err = paragraph(lxs)
+		}
 	case lexerQuote:
-	case lexerBreak:
-	case lexerLiteral:
-		b = astLiteral(lxs.Current().Value)
+	case lexerCode:
+		if newLine && len(lxs.Current().Value) == 3 {
+			//TODO: handle
+		} else {
+			b, err = paragraph(lxs)
+		}
+	case lexerLiteral, lexerEscape, lexerModifier:
+		b, err = paragraph(lxs)
+	case lexerBreak: // do nothing
 	default:
 		err = errors.Join(ErrUnkownLexType, fmt.Errorf("type received: %s", lxs.Current().Type))
 	}
diff --git a/mardown/ast_literal.go b/mardown/ast_literal.go
deleted file mode 100644
index 23b9004..0000000
--- a/mardown/ast_literal.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package mardown
-
-import "html/template"
-
-type astLiteral string
-
-func (a astLiteral) Eval() (template.HTML, error) {
-	return template.HTML(template.HTMLEscapeString(string(a))), nil
-}
diff --git a/mardown/ast_paragraph.go b/mardown/ast_paragraph.go
new file mode 100644
index 0000000..3ebc519
--- /dev/null
+++ b/mardown/ast_paragraph.go
@@ -0,0 +1,65 @@
+package mardown
+
+import (
+	"errors"
+	"html/template"
+)
+
+var (
+	ErrInvalidParagraph         = errors.New("invalid paragraph")
+	ErrInvalidCodeBlockPosition = errors.Join(ErrInvalidParagraph, errors.New("invalid code block position"))
+)
+
+type astParagraph struct {
+	content []block
+}
+
+func (a *astParagraph) Eval() (template.HTML, error) {
+	var content template.HTML
+	for _, c := range a.content {
+		ct, err := c.Eval()
+		if err != nil {
+			return "", err
+		}
+		content += ct
+	}
+	return content, nil
+}
+
+func paragraph(lxs lexers) (block, error) {
+	tree := new(astParagraph)
+	n := 0
+	lxs.current-- // because we do not use it before the next
+	for lxs.Next() && n < 2 {
+		switch lxs.Current().Type {
+		case lexerBreak:
+			n++
+		case lexerLiteral:
+			tree.content = append(tree.content, astLiteral(lxs.Current().Value))
+		case lexerModifier:
+			//TODO: handle
+		case lexerQuote:
+			//TODO: handle
+		case lexerEscape:
+			//TODO: handle
+		case lexerExternal:
+			//TODO: handle
+		case lexerCode:
+			if len(lxs.Current().Value) == 3 {
+				if n == 0 {
+					return nil, ErrInvalidCodeBlockPosition
+				}
+				lxs.current-- // because we do not use it before the next
+				return tree, nil
+			}
+			//TODO: handle
+		}
+	}
+	return tree, nil
+}
+
+type astLiteral string
+
+func (a astLiteral) Eval() (template.HTML, error) {
+	return template.HTML(template.HTMLEscapeString(string(a))), nil
+}
-- 
cgit v1.2.3