12775901286

Committed 14 Jan 2025 08:31PM CUT coverage: 34.058% (+0.2%) from 33.838%

Build # 12775901286

Build Type

Pull #36

github

Committed by

web-flow

Commit Message

Merge a0c741f43 into 2dc9d3121

Pull Request Pull Request #36: Add Hugo export format

Run Details

16 of 53 new or added lines in 7 files covered. (30.19%)

1 existing line in 1 file now uncovered.

282 of 828 relevant lines covered (34.06%)

2.1 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

21.71

/render.go

package modo

import (
        "io/fs"
        "os"
        "path"
        "strings"
        "text/template"

        "github.com/mlange-42/modo/assets"
        "github.com/mlange-42/modo/document"
        "github.com/mlange-42/modo/format"
)

func Render(docs *document.Docs, dir string, rFormat format.Format) error {
        formatter := format.GetFormatter(rFormat)
        t, err := loadTemplates(formatter)
        if err != nil {
                return err
        }
        proc := document.NewProcessor(formatter, t)
        err = proc.ProcessLinks(docs)
        if err != nil {
                return err
        }

        err = renderPackage(docs.Decl, dir, &proc)
        if err != nil {
                return err
        }

        if err := proc.Formatter.WriteAuxiliary(docs.Decl, dir, t); err != nil {
                return err
        }

        return nil
}

func renderElement(data interface {
        document.Named
        document.Kinded
}, proc *document.Processor) (string, error) {
        b := strings.Builder{}
        err := proc.Template.ExecuteTemplate(&b, data.GetKind()+".md", data)
        if err != nil {
                return "", err
        }
        var summary string
        if d, ok := data.(document.Summarized); ok {
                summary = d.GetSummary()
        }
        return proc.Formatter.ProcessMarkdown(data.GetName(), summary, b.String())
}

func renderPackage(p *document.Package, dir string, proc *document.Processor) error {
        pkgPath := path.Join(dir, p.GetFileName())
        if err := mkDirs(pkgPath); err != nil {
                return err
        }

        pkgFile, err := proc.Formatter.ToFilePath(pkgPath, "package")
        if err != nil {
                return err
        }

        for _, pkg := range p.Packages {
                if err := renderPackage(pkg, pkgPath, proc); err != nil {
                        return err
                }
        }

        for _, mod := range p.Modules {
                modPath := path.Join(pkgPath, mod.GetFileName())
                if err := renderModule(mod, modPath, proc); err != nil {
                        return err
                }
        }

        text, err := renderElement(p, proc)
        if err != nil {
                return err
        }
        if err := os.WriteFile(pkgFile, []byte(text), 0666); err != nil {
                return err
        }

        return nil
}

func renderModule(mod *document.Module, dir string, proc *document.Processor) error {
        if err := mkDirs(dir); err != nil {
                return err
        }

        modFile, err := proc.Formatter.ToFilePath(dir, "module")
        if err != nil {
                return err
        }

        if err := renderList(mod.Structs, dir, proc); err != nil {
                return err
        }
        if err := renderList(mod.Traits, dir, proc); err != nil {
                return err
        }
        if err := renderList(mod.Functions, dir, proc); err != nil {
                return err
        }

        text, err := renderElement(mod, proc)
        if err != nil {
                return err
        }
        if err := os.WriteFile(modFile, []byte(text), 0666); err != nil {
                return err
        }

        return nil
}

func renderList[T interface {
        document.Named
        document.Kinded
}](list []T, dir string, proc *document.Processor) error {
        for _, elem := range list {
                text, err := renderElement(elem, proc)
                if err != nil {
                        return err
                }
                memberPath := path.Join(dir, elem.GetFileName())

                memberFile, err := proc.Formatter.ToFilePath(memberPath, "")
                if err != nil {
                        return err
                }

                if err := os.WriteFile(memberFile, []byte(text), 0666); err != nil {
                        return err
                }
        }
        return nil
}

func loadTemplates(f document.Formatter) (*template.Template, error) {
        allTemplates, err := findTemplates()
        if err != nil {
                return nil, err
        }
        templ, err := template.New("all").Funcs(template.FuncMap{
                "toLink": f.ToLinkPath,
        }).ParseFS(assets.Templates, allTemplates...)
        if err != nil {
                return nil, err
        }
        return templ, nil
}

func findTemplates() ([]string, error) {
        allTemplates := []string{}
        err := fs.WalkDir(assets.Templates, ".",
                func(path string, info os.DirEntry, err error) error {
                        if err != nil {
                                return err
                        }
                        if !info.IsDir() {
                                allTemplates = append(allTemplates, path)
                        }
                        return nil
                })
        if err != nil {
                return nil, err
        }
        return allTemplates, nil
}

func mkDirs(path string) error {
        if err := os.MkdirAll(path, os.ModePerm); err != nil && !os.IsExist(err) {
                return err
        }
        return nil
}

1	package modo
2
3	import (
4	"io/fs"
5	"os"
6	"path"
7	"strings"
8	"text/template"
9
10	"github.com/mlange-42/modo/assets"
11	"github.com/mlange-42/modo/document"
12	"github.com/mlange-42/modo/format"
13	)
14
NEW 15	func Render(docs *document.Docs, dir string, rFormat format.Format) error {	×
NEW 16	formatter := format.GetFormatter(rFormat)	×
NEW 17	t, err := loadTemplates(formatter)	×
18	if err != nil {	×
NEW 19	return err	×
20	}	×
NEW 21	proc := document.NewProcessor(formatter, t)	×
NEW 22	err = proc.ProcessLinks(docs)	×
23	if err != nil {	×
24	return err	×
25	}	×
26
27	err = renderPackage(docs.Decl, dir, &proc)	×
28	if err != nil {	×
29	return err	×
30	}	×
31
32	if err := proc.Formatter.WriteAuxiliary(docs.Decl, dir, t); err != nil {	×
33	return err	×
34	}	×
35
36	return nil	×
37	}
38
39	func renderElement(data interface {
40	document.Named
41	document.Kinded
42	}, proc *document.Processor) (string, error) {	2✔
43	b := strings.Builder{}	2✔
44	err := proc.Template.ExecuteTemplate(&b, data.GetKind()+".md", data)	2✔
45	if err != nil {	2✔
46	return "", err	×
47	}	×
48	var summary string	2✔
49	if d, ok := data.(document.Summarized); ok {	4✔
50	summary = d.GetSummary()	2✔
51	}	2✔
52	return proc.Formatter.ProcessMarkdown(data.GetName(), summary, b.String())	2✔
53	}
54
55	func renderPackage(p document.Package, dir string, proc document.Processor) error {	×
56	pkgPath := path.Join(dir, p.GetFileName())	×
57	if err := mkDirs(pkgPath); err != nil {	×
58	return err	×
59	}	×
60
61	pkgFile, err := proc.Formatter.ToFilePath(pkgPath, "package")	×
62	if err != nil {	×
63	return err	×
64	}	×
65
66	for _, pkg := range p.Packages {	×
67	if err := renderPackage(pkg, pkgPath, proc); err != nil {	×
68	return err	×
69	}	×
70	}
71
72	for _, mod := range p.Modules {	×
73	modPath := path.Join(pkgPath, mod.GetFileName())	×
74	if err := renderModule(mod, modPath, proc); err != nil {	×
75	return err	×
76	}	×
77	}
78
NEW 79	text, err := renderElement(p, proc)	×
80	if err != nil {	×
81	return err	×
82	}	×
83	if err := os.WriteFile(pkgFile, []byte(text), 0666); err != nil {	×
84	return err	×
85	}	×
86
87	return nil	×
88	}
89
90	func renderModule(mod document.Module, dir string, proc document.Processor) error {	×
91	if err := mkDirs(dir); err != nil {	×
92	return err	×
93	}	×
94
95	modFile, err := proc.Formatter.ToFilePath(dir, "module")	×
96	if err != nil {	×
97	return err	×
98	}	×
99
100	if err := renderList(mod.Structs, dir, proc); err != nil {	×
101	return err	×
102	}	×
103	if err := renderList(mod.Traits, dir, proc); err != nil {	×
104	return err	×
105	}	×
106	if err := renderList(mod.Functions, dir, proc); err != nil {	×
107	return err	×
108	}	×
109
NEW 110	text, err := renderElement(mod, proc)	×
111	if err != nil {	×
112	return err	×
113	}	×
114	if err := os.WriteFile(modFile, []byte(text), 0666); err != nil {	×
115	return err	×
116	}	×
117
118	return nil	×
119	}
120
121	func renderList[T interface {
122	document.Named
123	document.Kinded
124	}](list []T, dir string, proc *document.Processor) error {	×
125	for _, elem := range list {	×
NEW 126	text, err := renderElement(elem, proc)	×
127	if err != nil {	×
128	return err	×
129	}	×
130	memberPath := path.Join(dir, elem.GetFileName())	×
131		×
132	memberFile, err := proc.Formatter.ToFilePath(memberPath, "")	×
133	if err != nil {	×
134	return err	×
135	}	×
136
137	if err := os.WriteFile(memberFile, []byte(text), 0666); err != nil {	×
138	return err	×
139	}	×
140	}
141	return nil	×
142	}
143
144	func loadTemplates(f document.Formatter) (*template.Template, error) {	2✔
145	allTemplates, err := findTemplates()	2✔
146	if err != nil {	2✔
147	return nil, err	×
148	}	×
149	templ, err := template.New("all").Funcs(template.FuncMap{	2✔
150	"toLink": f.ToLinkPath,	2✔
151	}).ParseFS(assets.Templates, allTemplates...)	2✔
152	if err != nil {	2✔
153	return nil, err	×
154	}	×
155	return templ, nil	2✔
156	}
157
158	func findTemplates() ([]string, error) {	2✔
159	allTemplates := []string{}	2✔
160	err := fs.WalkDir(assets.Templates, ".",	2✔
161	func(path string, info os.DirEntry, err error) error {	56✔
162	if err != nil {	54✔
163	return err	×
164	}	×
165	if !info.IsDir() {	100✔
166	allTemplates = append(allTemplates, path)	46✔
167	}	46✔
168	return nil	54✔
169	})
170	if err != nil {	2✔
171	return nil, err	×
172	}	×
173	return allTemplates, nil	2✔
174	}
175
176	func mkDirs(path string) error {	×
177	if err := os.MkdirAll(path, os.ModePerm); err != nil && !os.IsExist(err) {	×
178	return err	×
179	}	×
180	return nil	×
181	}

mlange-42 / modo / 12775901286

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous