12758132717

Committed 13 Jan 2025 11:36PM CUT coverage: 34.783%. Remained the same

Build # 12758132717

Build Type

push

github

Committed by

web-flow

Commit Message

Tweak README intro (#32)

Run Details

264 of 759 relevant lines covered (34.78%)

2.0 hits per line

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

21.67

/render.go

package modo

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

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

//go:embed templates/* templates/**/*
var templates embed.FS
var t *template.Template

var functions = template.FuncMap{
        "pathJoin": path.Join,
}

func init() {
        var err error
        t, err = loadTemplates()
        if err != nil {
                log.Fatal(err)
        }
}

func Render(data document.Kinded) (string, error) {
        b := strings.Builder{}
        err := t.ExecuteTemplate(&b, data.GetKind()+".md", data)
        if err != nil {
                return "", err
        }
        return b.String(), nil
}

func RenderDocs(docs *document.Docs, dir string, rFormat format.Format) error {
        err := document.ProcessLinks(docs, t)
        if err != nil {
                return err
        }
        return RenderPackage(docs.Decl, dir, rFormat, true)
}

func RenderPackage(p *document.Package, dir string, rFormat format.Format, root bool) error {
        pkgPath := path.Join(dir, p.GetFileName())
        if err := mkDirs(pkgPath); err != nil {
                return err
        }

        pkgFile := strings.Builder{}
        if err := t.ExecuteTemplate(&pkgFile, "package_path.md", pkgPath); err != nil {
                return err
        }

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

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

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

        if root {
                if err := format.GetFormatter(rFormat).WriteAuxiliary(p, dir, t); err != nil {
                        return err
                }
        }

        return nil
}

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

        modFile := strings.Builder{}
        if err := t.ExecuteTemplate(&modFile, "module_path.md", dir); err != nil {
                return err
        }

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

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

        return nil
}

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

                memberFile := strings.Builder{}
                if err := t.ExecuteTemplate(&memberFile, "member_path.md", memberPath); err != nil {
                        return err
                }

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

func loadTemplates() (*template.Template, error) {
        allTemplates, err := findTemplates()
        if err != nil {
                return nil, err
        }
        templ, err := template.New("all").Funcs(functions).ParseFS(templates, allTemplates...)
        if err != nil {
                return nil, err
        }
        return templ, nil
}

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

mlange-42 / modo / 12758132717

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