"
- }
-
- return code.Element.StartTag()
-}
-
-func (code *InlineCode) EndTag() string {
- if code == nil || code.Element == nil {
- return ""
- }
-
- return code.Element.EndTag()
+ return json.MarshalIndent(m, "", " ")
}
func (code *InlineCode) String() string {
diff --git a/inline_code_test.go b/inline_code_test.go
new file mode 100644
index 0000000..2504b6f
--- /dev/null
+++ b/inline_code_test.go
@@ -0,0 +1,16 @@
+package hype
+
+import "testing"
+
+func Test_InlineCode_MarshalJSON(t *testing.T) {
+ t.Parallel()
+
+ il := &InlineCode{
+ Element: NewEl("code", nil),
+ }
+
+ il.Nodes = append(il.Nodes, Text("var x = 1"))
+
+ testJSON(t, "inline_code", il)
+
+}
diff --git a/json_test.go b/json_test.go
deleted file mode 100644
index 57ae722..0000000
--- a/json_test.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package hype
-
-import (
- "context"
- "encoding/json"
- "os"
- "strings"
- "testing"
- "time"
-
- "github.com/stretchr/testify/require"
-)
-
-func Test_Document_JSON(t *testing.T) {
- t.Skip()
-
- t.Parallel()
- r := require.New(t)
-
- root := "testdata/doc/to_md"
-
- p := testParser(t, root)
-
- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
- defer cancel()
-
- doc, err := p.ParseExecuteFile(ctx, "module.md")
- // doc, err := p.ParseFile("module.md")
- r.NoError(err)
-
- b, err := json.MarshalIndent(doc, "", " ")
- r.NoError(err)
-
- act := string(b)
- act = strings.TrimSpace(act)
-
- // fmt.Println(act)
- f, err := os.Create("testdata/doc/to_md/module.json")
- r.NoError(err)
- defer f.Close()
-
- _, err = f.WriteString(act)
- r.NoError(err)
-
- exp := ``
-
- r.Equal(exp, act)
-
-}
diff --git a/li.go b/li.go
index 44b606a..5e654df 100644
--- a/li.go
+++ b/li.go
@@ -3,12 +3,12 @@ package hype
import (
"bytes"
"encoding/json"
- "fmt"
)
type LI struct {
- Type string
*Element
+
+ Type string
}
func (li *LI) MarshalJSON() ([]byte, error) {
@@ -21,13 +21,13 @@ func (li *LI) MarshalJSON() ([]byte, error) {
return nil, err
}
- m["type"] = fmt.Sprintf("%T", li)
+ m["type"] = toType(li)
if li.Type != "" {
m["list-type"] = li.Type
}
- return json.Marshal(m)
+ return json.MarshalIndent(m, "", " ")
}
func (li *LI) MD() string {
diff --git a/li_test.go b/li_test.go
new file mode 100644
index 0000000..a189653
--- /dev/null
+++ b/li_test.go
@@ -0,0 +1,17 @@
+package hype
+
+import "testing"
+
+func Test_LI_MarshalJSON(t *testing.T) {
+ t.Parallel()
+
+ li := &LI{
+ Element: NewEl("li", nil),
+ Type: "ul",
+ }
+
+ li.Nodes = append(li.Nodes, Text("This is a list item"))
+
+ testJSON(t, "li", li)
+
+}
diff --git a/link.go b/link.go
index d699f3c..8ddd620 100644
--- a/link.go
+++ b/link.go
@@ -23,7 +23,7 @@ func (l *Link) MarshalJSON() ([]byte, error) {
return nil, err
}
- m["type"] = fmt.Sprintf("%T", l)
+ m["type"] = toType(l)
h, err := l.Href()
if err != nil {
@@ -32,7 +32,7 @@ func (l *Link) MarshalJSON() ([]byte, error) {
m["url"] = h
- return json.Marshal(m)
+ return json.MarshalIndent(m, "", " ")
}
func (l *Link) Href() (string, error) {
diff --git a/link_test.go b/link_test.go
new file mode 100644
index 0000000..367328c
--- /dev/null
+++ b/link_test.go
@@ -0,0 +1,23 @@
+package hype
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func Test_Link_MarshalJSON(t *testing.T) {
+ t.Parallel()
+
+ r := require.New(t)
+
+ link := &Link{
+ Element: NewEl("a", nil),
+ }
+ link.Nodes = append(link.Nodes, Text("This is a link"))
+
+ err := link.Set("href", "https://example.com")
+ r.NoError(err)
+
+ testJSON(t, "link", link)
+}
diff --git a/md.go b/md.go
index 9ecf677..932aeb8 100644
--- a/md.go
+++ b/md.go
@@ -2,6 +2,7 @@ package hype
import (
"bytes"
+ "fmt"
"io"
"github.com/gopherguides/hype/mdx"
@@ -22,13 +23,13 @@ func Markdown() PreParseFn {
b, err := io.ReadAll(r)
if err != nil {
- return nil, err
+ return nil, fmt.Errorf("markdown: %w", err)
}
b = bytes.ReplaceAll(b, []byte("\\n"), []byte(" \n"))
b, err = md.Parse(b)
if err != nil {
- return nil, err
+ return nil, fmt.Errorf("markdown: %w", err)
}
b = bytes.ReplaceAll(b, []byte("’"), []byte("'"))
diff --git a/metadata.go b/metadata.go
index 69fd69e..324b068 100644
--- a/metadata.go
+++ b/metadata.go
@@ -29,10 +29,10 @@ func (md *Metadata) MarshalJSON() ([]byte, error) {
return nil, err
}
- m["type"] = fmt.Sprintf("%T", md)
+ m["type"] = toType(md)
m["data"] = md.Map.Map()
- return json.Marshal(m)
+ return json.MarshalIndent(m, "", " ")
}
func (md *Metadata) IsEmptyNode() bool {
diff --git a/metadata_test.go b/metadata_test.go
index 99a6888..e9eaa60 100644
--- a/metadata_test.go
+++ b/metadata_test.go
@@ -1,9 +1,11 @@
package hype
import (
+ "errors"
"os"
"testing"
+ "github.com/markbates/syncx"
"github.com/stretchr/testify/require"
)
@@ -49,4 +51,22 @@ func Test_NewMetadata_Multiple_Erro0r(t *testing.T) {
p := NewParser(cab)
_, err := p.ParseFile("module.md")
r.Error(err)
+
+ r.True(errors.Is(err, ParseError{}))
+}
+
+func Test_Metadata_MarshalJSON(t *testing.T) {
+ t.Parallel()
+ r := require.New(t)
+
+ md := &Metadata{
+ Element: NewEl("metadata", nil),
+ Map: syncx.Map[string, string]{},
+ }
+
+ err := md.Set("title", "Hello, World!")
+ r.NoError(err)
+
+ testJSON(t, "metadata", md)
+
}
diff --git a/now.go b/now.go
index eb61ab7..a7cf7d1 100644
--- a/now.go
+++ b/now.go
@@ -3,7 +3,6 @@ package hype
import (
"context"
"encoding/json"
- "fmt"
"time"
)
@@ -23,9 +22,9 @@ func (now *Now) MarshalJSON() ([]byte, error) {
return nil, err
}
- m["type"] = fmt.Sprintf("%T", now)
+ m["type"] = toType(now)
- return json.Marshal(m)
+ return json.MarshalIndent(m, "", " ")
}
func (now *Now) Execute(ctx context.Context, doc *Document) error {
diff --git a/now_test.go b/now_test.go
index 254f81d..febab7a 100644
--- a/now_test.go
+++ b/now_test.go
@@ -43,3 +43,14 @@ func Test_NowNodes(t *testing.T) {
r.Equal(exp, act)
}
+
+func Test_Now_MarshalJSON(t *testing.T) {
+ t.Parallel()
+
+ n := &Now{
+ Element: NewEl("now", nil),
+ }
+ n.Nodes = append(n.Nodes, Text("1/2/2006"))
+
+ testJSON(t, "now", n)
+}
diff --git a/ol.go b/ol.go
index bcc1a2f..c3756f6 100644
--- a/ol.go
+++ b/ol.go
@@ -2,7 +2,6 @@ package hype
import (
"encoding/json"
- "fmt"
)
type OL struct {
@@ -22,9 +21,9 @@ func (ol *OL) MarshalJSON() ([]byte, error) {
return nil, err
}
- m["type"] = fmt.Sprintf("%T", ol)
+ m["type"] = toType(ol)
- return json.Marshal(m)
+ return json.MarshalIndent(m, "", " ")
}
func (ol *OL) MD() string {
diff --git a/ol_test.go b/ol_test.go
new file mode 100644
index 0000000..78e1769
--- /dev/null
+++ b/ol_test.go
@@ -0,0 +1,15 @@
+package hype
+
+import "testing"
+
+func Test_OL_MarshalJSON(t *testing.T) {
+ t.Parallel()
+
+ ol := &OL{
+ Element: NewEl("ol", nil),
+ }
+
+ ol.Nodes = append(ol.Nodes, Text("This is an ordered list"))
+
+ testJSON(t, "ol", ol)
+}
diff --git a/page.go b/page.go
index dbad0e4..371c737 100644
--- a/page.go
+++ b/page.go
@@ -20,13 +20,13 @@ func (page *Page) MarshalJSON() ([]byte, error) {
return nil, err
}
- m["type"] = fmt.Sprintf("%T", page)
+ m["type"] = toType(page)
if len(page.Title) > 0 {
m["title"] = page.Title
}
- return json.Marshal(m)
+ return json.MarshalIndent(m, "", " ")
}
func (page *Page) Body() (*Body, error) {
diff --git a/page_test.go b/page_test.go
index 1029230..c873983 100644
--- a/page_test.go
+++ b/page_test.go
@@ -68,3 +68,15 @@ adfadf`
r.Len(pages, 5)
}
+
+func Test_Pages_MarshalJSON(t *testing.T) {
+ t.Parallel()
+
+ p := &Page{
+ Title: "Page 1",
+ Element: NewEl("page", nil),
+ }
+ p.Nodes = append(p.Nodes, Text("more text"))
+
+ testJSON(t, "page", p)
+}
diff --git a/paragraph.go b/paragraph.go
index 3da84ce..a222eb7 100644
--- a/paragraph.go
+++ b/paragraph.go
@@ -2,7 +2,6 @@ package hype
import (
"encoding/json"
- "fmt"
)
type Paragraph struct {
@@ -19,9 +18,9 @@ func (p *Paragraph) MarshalJSON() ([]byte, error) {
return nil, err
}
- m["type"] = fmt.Sprintf("%T", p)
+ m["type"] = toType(p)
- return json.Marshal(m)
+ return json.MarshalIndent(m, "", " ")
}
func (p *Paragraph) IsEmptyNode() bool {
diff --git a/paragraph_test.go b/paragraph_test.go
new file mode 100644
index 0000000..b1ccc1c
--- /dev/null
+++ b/paragraph_test.go
@@ -0,0 +1,15 @@
+package hype
+
+import "testing"
+
+func Test_Paragraph_MarshalJSON(t *testing.T) {
+ t.Parallel()
+
+ p := &Paragraph{
+ Element: NewEl("p", nil),
+ }
+
+ p.Nodes = append(p.Nodes, Text("This is a paragraph"))
+
+ testJSON(t, "p", p)
+}
diff --git a/parse_error.go b/parse_error.go
new file mode 100644
index 0000000..97468f6
--- /dev/null
+++ b/parse_error.go
@@ -0,0 +1,55 @@
+package hype
+
+import (
+ "encoding/json"
+ "errors"
+)
+
+type ParseError struct {
+ Err error
+ Filename string
+ Root string
+ Contents []byte
+}
+
+func (pe ParseError) MarshalJSON() ([]byte, error) {
+ mm := map[string]any{
+ "contents": string(pe.Contents),
+ "error": errForJSON(pe.Err),
+ "filename": pe.Filename,
+ "root": pe.Root,
+ "type": toType(pe),
+ }
+
+ return json.MarshalIndent(mm, "", " ")
+}
+
+func (pe ParseError) Error() string {
+ return toError(pe)
+}
+
+func (pe ParseError) Unwrap() error {
+ if _, ok := pe.Err.(unwrapper); ok {
+ return errors.Unwrap(pe.Err)
+ }
+
+ return pe.Err
+}
+
+func (pe ParseError) As(target any) bool {
+ ex, ok := target.(*ParseError)
+ if !ok {
+ return errors.As(pe.Err, target)
+ }
+
+ (*ex) = pe
+ return true
+}
+
+func (pe ParseError) Is(target error) bool {
+ if _, ok := target.(ParseError); ok {
+ return true
+ }
+
+ return errors.Is(pe.Err, target)
+}
diff --git a/parse_error_test.go b/parse_error_test.go
new file mode 100644
index 0000000..b31ac8f
--- /dev/null
+++ b/parse_error_test.go
@@ -0,0 +1,47 @@
+package hype
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func Test_ParseError(t *testing.T) {
+ t.Parallel()
+ r := require.New(t)
+
+ oce := ParseError{
+ Err: io.EOF,
+ }
+
+ wrapped := fmt.Errorf("error: %w", oce)
+
+ r.True(oce.As(&ParseError{}), oce)
+ r.True(oce.Is(oce), oce)
+ r.True(oce.Unwrap() == io.EOF, oce)
+
+ var ce ParseError
+ r.True(errors.As(wrapped, &ce), wrapped)
+
+ ce = ParseError{}
+ r.True(errors.Is(wrapped, ce), wrapped)
+
+ err := errors.Unwrap(oce)
+ r.Equal(io.EOF, err)
+}
+
+func Test_ParseError_MarshalJSON(t *testing.T) {
+ t.Parallel()
+
+ pe := ParseError{
+ Contents: []byte("contents"),
+ Err: io.EOF,
+ Filename: "test.md",
+ Root: "root",
+ }
+
+ testJSON(t, "parse_error", pe)
+}
diff --git a/parser.go b/parser.go
index bdd75a2..9750003 100644
--- a/parser.go
+++ b/parser.go
@@ -1,6 +1,7 @@
package hype
import (
+ "bytes"
"context"
"encoding/json"
"errors"
@@ -22,20 +23,20 @@ import (
type ParseElementFn func(p *Parser, el *Element) (Nodes, error)
type Parser struct {
- fs.FS `json:"-"`
-
- Root string `json:"root,omitempty"`
- DisablePages bool `json:"disable_pages,omitempty"`
- NodeParsers map[Atom]ParseElementFn `json:"-"`
- PreParsers PreParsers `json:"-"`
- Snippets Snippets `json:"snippets,omitempty"`
- Section int `json:"section,omitempty"`
- NowFn func() time.Time `json:"-"` // default: time.Now()
- DocIDGen func() (string, error) `json:"-"` // default: uuid.NewV4().String()
- Vars syncx.Map[string, any] `json:"vars,omitempty"`
-
- fileName string
- mu sync.RWMutex
+ fs.FS
+
+ DisablePages bool
+ DocIDGen func() (string, error) // default: uuid.NewV4().String()
+ Filename string // only set when Parser.ParseFile() is used
+ NodeParsers map[Atom]ParseElementFn
+ NowFn func() time.Time // default: time.Now()
+ PreParsers PreParsers
+ Root string
+ Section int
+ Vars syncx.Map[string, any]
+ Contents []byte // a copy of the contents being parsed - set just before parsing
+
+ mu sync.RWMutex
}
func (p *Parser) MarshalJSON() ([]byte, error) {
@@ -46,25 +47,23 @@ func (p *Parser) MarshalJSON() ([]byte, error) {
p.mu.RLock()
defer p.mu.RUnlock()
- // p.Vars.Map()
-
x := struct {
Type string `json:"type,omitempty"`
Root string `json:"root,omitempty"`
DisablePages bool `json:"disable_pages,omitempty"`
Section int `json:"section,omitempty"`
- Snippets Snippets `json:"snippets,omitempty"`
Vars map[string]any `json:"vars,omitempty"`
+ Contents string `json:"contents,omitempty"`
}{
- Type: fmt.Sprintf("%T", p),
+ Type: toType(p),
Root: p.Root,
DisablePages: p.DisablePages,
Section: p.Section,
- Snippets: p.Snippets,
Vars: p.Vars.Map(),
+ Contents: string(p.Contents),
}
- return json.Marshal(x)
+ return json.MarshalIndent(x, "", " ")
}
@@ -79,54 +78,70 @@ func (p *Parser) Now() time.Time {
// ParseFile parses the given file from Parser.FS.
// If successful a *Document is returned. The returned
// *Document is NOT yet executed.
-func (p *Parser) ParseFile(name string) (*Document, error) {
+func (p *Parser) ParseFile(name string) (doc *Document, err error) {
if p == nil {
return nil, ErrIsNil("parser")
}
+ defer func() {
+ err = p.ensureParseError(err)
+ }()
+
p.mu.Lock()
- p.fileName = name
+ p.Filename = name
p.mu.Unlock()
f, err := p.Open(name)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
defer f.Close()
- doc, err := p.Parse(f)
+ doc, err = p.Parse(f)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
return doc, nil
}
-func (p *Parser) Parse(r io.Reader) (*Document, error) {
+func (p *Parser) Parse(r io.Reader) (doc *Document, err error) {
if p == nil {
return nil, ErrIsNil("parser")
}
+ defer func() {
+ err = p.ensureParseError(err)
+ }()
+
+ b, err := io.ReadAll(r)
+ if err != nil {
+ return nil, err
+ }
+ p.Contents = b
+
+ r = bytes.NewReader(b)
+
// pre parse
- r, err := p.PreParsers.PreParse(p, r)
+ r, err = p.PreParsers.PreParse(p, r)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
// parse
hdoc, err := html.Parse(r)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
node, err := p.ParseHTMLNode(hdoc, nil)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
- doc, err := p.newDoc()
+ doc, err = p.newDoc()
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
doc.Nodes = Nodes{node}
@@ -137,7 +152,7 @@ func (p *Parser) Parse(r io.Reader) (*Document, error) {
// post parse
err = doc.Nodes.PostParse(p, doc, err)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
return doc, nil
@@ -150,29 +165,45 @@ func (p *Parser) ParseExecuteFile(ctx context.Context, name string) (*Document,
doc, err := p.ParseFile(name)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
err = doc.Execute(ctx)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
return doc, nil
}
-func (p *Parser) ParseFolder(name string) (Documents, error) {
+func (p *Parser) ParseFolder(name string) (doc Documents, err error) {
if p == nil {
return nil, ErrIsNil("parser")
}
+ defer func() {
+ if err == nil {
+ return
+ }
+
+ if _, ok := err.(ParseError); ok {
+ return
+ }
+
+ err = ParseError{
+ Err: err,
+ Filename: name,
+ Root: p.Root,
+ }
+ }()
+
var docs Documents
var wg errgroup.Group
var mu sync.Mutex
whole, err := binding.WholeFromPath(p.FS, name, "book", "chapter")
if err != nil && !errors.Is(err, binding.ErrPath("")) {
- return nil, p.wrapErr(err)
+ return nil, err
}
err = fs.WalkDir(p.FS, ".", func(path string, d fs.DirEntry, err error) error {
@@ -208,7 +239,7 @@ func (p *Parser) ParseFolder(name string) (Documents, error) {
doc, err := p.ParseFile(base)
if err != nil {
- return fmt.Errorf("error parsing: %q: %w", path, err)
+ return err
}
mu.Lock()
@@ -223,11 +254,13 @@ func (p *Parser) ParseFolder(name string) (Documents, error) {
if err != nil {
err = fmt.Errorf("error walking: %q: %w", name, err)
- return nil, p.wrapErr(err)
+ if err != nil && !errors.Is(err, binding.ErrPath("")) {
+ return nil, err
+ }
}
if err := wg.Wait(); err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
sort.Slice(docs, func(i, j int) bool {
@@ -244,12 +277,12 @@ func (p *Parser) ParseExecuteFolder(ctx context.Context, name string) (Documents
docs, err := p.ParseFolder(name)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
err = docs.Execute(ctx)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
return docs, nil
@@ -262,19 +295,19 @@ func (p *Parser) ParseExecuteFragment(ctx context.Context, r io.Reader) (Nodes,
nodes, err := p.ParseFragment(r)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
doc, err := p.newDoc()
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
doc.Nodes = nodes
err = doc.Execute(ctx)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
return nodes, nil
@@ -283,12 +316,12 @@ func (p *Parser) ParseExecuteFragment(ctx context.Context, r io.Reader) (Nodes,
func (p *Parser) ParseExecute(ctx context.Context, r io.Reader) (*Document, error) {
doc, err := p.Parse(r)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
err = doc.Execute(ctx)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
return doc, nil
@@ -301,7 +334,7 @@ func (p *Parser) ParseFragment(r io.Reader) (Nodes, error) {
doc, err := p.Parse(r)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
nodes := doc.Nodes
@@ -332,21 +365,27 @@ func (p *Parser) ParseHTMLNode(node *html.Node, parent Node) (Node, error) {
switch node.Type {
case html.CommentNode:
return Comment(node.Data), nil
- case html.DoctypeNode:
- // return p.NewDocType(node)
case html.DocumentNode, html.ElementNode:
n, err := p.element(node, parent)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
return n, nil
- case html.ErrorNode:
- return nil, p.wrapErr(fmt.Errorf(node.Data))
case html.TextNode:
return Text(node.Data), nil
+ case html.ErrorNode:
+ return nil, ParseError{
+ Err: fmt.Errorf("error node: %+v", node),
+ Filename: p.Filename,
+ Root: p.Root,
+ }
}
- return nil, p.wrapErr(fmt.Errorf("unknown node type %v", node.Data))
+ return nil, ParseError{
+ Err: fmt.Errorf("unknown node: %+v", node),
+ Filename: p.Filename,
+ Root: p.Root,
+ }
}
func (p *Parser) Sub(dir string) (*Parser, error) {
@@ -367,7 +406,7 @@ func (p *Parser) Sub(dir string) (*Parser, error) {
cab, err := fs.Sub(p.FS, dir)
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
p2.FS = cab
@@ -385,7 +424,7 @@ func (p *Parser) element(node *html.Node, parent Node) (Node, error) {
Attributes: ats,
HTMLNode: node,
Parent: parent,
- FileName: p.fileName,
+ Filename: p.Filename,
}
var nodes Nodes
@@ -444,94 +483,38 @@ func (p *Parser) newDoc() (*Document, error) {
id, err := p.DocIDGen()
if err != nil {
- return nil, p.wrapErr(err)
+ return nil, err
}
doc := &Document{
- ID: id,
FS: p.FS,
+ Filename: p.Filename,
+ ID: id,
Parser: p,
Root: p.Root,
SectionID: p.Section,
- Snippets: p.Snippets,
- Filename: p.fileName,
+ Snippets: Snippets{},
}
return doc, nil
}
-func (p *Parser) wrapErr(err error) error {
- if err == nil {
- return nil
- }
-
- if _, ok := err.(parserErr); ok {
- return err
- }
-
+func (p *Parser) ensureParseError(err error) error {
if p == nil {
- return err
- }
-
- p.mu.RLock()
- defer p.mu.RUnlock()
-
- return parserErr{
- fileName: p.fileName,
- root: p.Root,
- err: err,
- }
-}
-
-type parserErr struct {
- err error
- fileName string
- root string
-}
-
-func (pe parserErr) Error() string {
- if pe.err == nil {
- return ""
- }
-
- err := pe.err
-
- if len(pe.fileName) > 0 {
- err = fmt.Errorf("file: %q: %s", pe.fileName, err)
- }
-
- if len(pe.root) > 0 {
- err = fmt.Errorf("root: %q: %s", pe.root, err)
- }
-
- return err.Error()
-}
-
-func (pe parserErr) Unwrap() error {
- type Unwrapper interface {
- Unwrap() error
+ return ErrIsNil("parser")
}
- if _, ok := pe.err.(Unwrapper); ok {
- return errors.Unwrap(pe.err)
+ if err == nil {
+ return nil
}
- return pe.err
-}
-
-func (pe parserErr) As(target any) bool {
- ex, ok := target.(*parserErr)
- if !ok {
- return errors.As(pe.err, target)
+ if _, ok := err.(ParseError); ok {
+ return err
}
- (*ex) = pe
- return true
-}
-
-func (pe parserErr) Is(target error) bool {
- if _, ok := target.(parserErr); ok {
- return true
+ return ParseError{
+ Err: err,
+ Filename: p.Filename,
+ Root: p.Root,
+ Contents: p.Contents,
}
-
- return errors.Is(pe.err, target)
}
diff --git a/parser_test.go b/parser_test.go
index e736656..9084d2c 100644
--- a/parser_test.go
+++ b/parser_test.go
@@ -2,147 +2,146 @@ package hype
import (
"context"
+ "errors"
"fmt"
"os"
+ "strings"
"testing"
- "testing/fstest"
"github.com/stretchr/testify/require"
+ "golang.org/x/net/html"
)
-func Test_Parser(t *testing.T) {
+func Test_Parser_ParseFolder(t *testing.T) {
t.Parallel()
-
- // t.Skip()
r := require.New(t)
- cab := helloCab(t, "second")
-
- modmd := []byte(`# Page 1
-
-This is ` + "`inline`" + ` code.
-
-
+ docs, err := p.ParseExecuteFolder(context.Background(), root)
+ r.NoError(err)
-Page 1
+ tcs := []struct { + name string + node *html.Node + }{ + { + name: "error node", + node: &html.Node{ + Type: html.ErrorNode, + Data: "boom", + }, + }, + { + name: "unknown node", + node: &html.Node{ + Type: 42, + Data: "boom", + }, + }, + } -This is inline code.
Second Page
+ for _, tc := range tcs { + t.Run(tc.name, func(t *testing.T) { + r := require.New(t) -
+ p := testParser(t, "testdata/auto/parser/hello")
+ _, err := p.ParseHTMLNode(tc.node, nil)
+ r.Error(err)
-package main
+ var pe ParseError
+ r.True(errors.As(err, &pe), err)
-import "fmt"
+ pe = ParseError{}
+ r.True(errors.Is(err, pe), err)
+ })
+ }
-func main() {
- fmt.Println("Hello second!")
-}$ echo hello
+func Test_Parser_ParseFragment_Error(t *testing.T) {
+ t.Parallel()
+ r := require.New(t)
-hellomore words
-module demo
-go 1.18
+go 1.22
func main() {
// snippet: example
fmt.Println("Hello, World!")
diff --git a/testdata/auto/commands/greet/src/go.mod b/testdata/auto/commands/greet/src/go.mod
index 21cc482..2287625 100644
--- a/testdata/auto/commands/greet/src/go.mod
+++ b/testdata/auto/commands/greet/src/go.mod
@@ -1,3 +1,3 @@
module demo
-go 1.18
+go 1.22
diff --git a/testdata/auto/commands/results/truncate/src/go.mod b/testdata/auto/commands/results/truncate/src/go.mod
index 21cc482..2287625 100644
--- a/testdata/auto/commands/results/truncate/src/go.mod
+++ b/testdata/auto/commands/results/truncate/src/go.mod
@@ -1,3 +1,3 @@
module demo
-go 1.18
+go 1.22
diff --git a/testdata/auto/commands/side-by-side/values/src/string-keys/go.mod b/testdata/auto/commands/side-by-side/values/src/string-keys/go.mod
index 21cc482..2287625 100644
--- a/testdata/auto/commands/side-by-side/values/src/string-keys/go.mod
+++ b/testdata/auto/commands/side-by-side/values/src/string-keys/go.mod
@@ -1,3 +1,3 @@
module demo
-go 1.18
+go 1.22
diff --git a/testdata/auto/commands/timeout/go.mod b/testdata/auto/commands/timeout/go.mod
index 21cc482..2287625 100644
--- a/testdata/auto/commands/timeout/go.mod
+++ b/testdata/auto/commands/timeout/go.mod
@@ -1,3 +1,3 @@
module demo
-go 1.18
+go 1.22
diff --git a/testdata/auto/parser/hello/module.gold b/testdata/auto/parser/hello/module.gold
new file mode 100644
index 0000000..0cf4903
--- /dev/null
+++ b/testdata/auto/parser/hello/module.gold
@@ -0,0 +1,26 @@
+
+Page 1
+
+This is inline code.
+
+
+Second Page
+
+package main
+
+import "fmt"
+
+func main() {
+ fmt.Println("Hello second!")
+}
+
+
+
+
+$ echo hello
+
+hello
more words
+
+
\ No newline at end of file
diff --git a/testdata/auto/parser/hello/module.md b/testdata/auto/parser/hello/module.md
new file mode 100644
index 0000000..a18c4c5
--- /dev/null
+++ b/testdata/auto/parser/hello/module.md
@@ -0,0 +1,9 @@
+# Page 1
+
+This is `inline` code.
+
+
+Lone Ranger
+
+func main() {
+ fmt.Println("Hello, world!")
+}
+
+
\ No newline at end of file
diff --git a/testdata/auto/snippets/simple/module.md b/testdata/auto/snippets/simple/module.md
new file mode 100644
index 0000000..7faa460
--- /dev/null
+++ b/testdata/auto/snippets/simple/module.md
@@ -0,0 +1,3 @@
+# Lone Ranger
+
+
+
+
+
+
+
+