12759040435

Committed 14 Jan 2025 01:08AM CUT coverage: 34.065% (-0.7%) from 34.783%

Build # 12759040435

Build Type

Pull #33

github

Committed by

web-flow

Commit Message

Merge 13c24c5d4 into b2b3f2790

Pull Request Pull Request #33: Add CSS to mdBook for line wrapping in code

Run Details

2 of 18 new or added lines in 2 files covered. (11.11%)

1 existing line in 1 file now uncovered.

264 of 775 relevant lines covered (34.06%)

1.96 hits per line

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

21.67

/render.go

package modo

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

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

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

mlange-42 / modo / 12759040435

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