12729458095

Committed 12 Jan 2025 01:54AM CUT coverage: 12.644%. Remained the same

Build # 12729458095

Build Type

push

github

Committed by

web-flow

Commit Message

Renames package doc to document (#17)

Run Details

1 of 10 new or added lines in 4 files covered. (10.0%)

33 of 261 relevant lines covered (12.64%)

0.8 hits per line

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

23.08

/template.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

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 RenderPackage(p *document.Package, dir string, renderFormat format.Format, root bool) error {
        pkgPath := path.Join(dir, p.GetName())
        if err := mkDirs(pkgPath); err != nil {
                return err
        }
        p.SetPath(pkgPath)
        pkgFile := path.Join(pkgPath, "_index.md")

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

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

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

        if root {
                if err := format.GetFormatter(renderFormat).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
        }
        mod.SetPath(dir)
        modFile := path.Join(dir, "_index.md")

        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, []byte(text), 0666); err != nil {
                return err
        }

        return nil
}

func renderList[T interface {
        document.Named
        document.Kinded
        document.Pathed
}](list []T, dir string) error {
        for _, elem := range list {
                text, err := Render(elem)
                if err != nil {
                        return err
                }
                strPath := path.Join(dir, elem.GetName())
                elem.SetPath(strPath)
                if err := os.WriteFile(strPath+".md", []byte(text), 0666); err != nil {
                        return err
                }
        }
        return nil
}

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

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	func init() {	1✔
21	var err error	1✔
22	t, err = loadTemplates()	1✔
23	if err != nil {	1✔
24	log.Fatal(err)	×
25	}	×
26	}
27
28	func Render(data document.Kinded) (string, error) {	2✔
29	b := strings.Builder{}	2✔
30	err := t.ExecuteTemplate(&b, data.GetKind()+".md", data)	2✔
31	if err != nil {	2✔
32	return "", err	×
33	}	×
34	return b.String(), nil	2✔
35	}
36
NEW 37	func RenderPackage(p *document.Package, dir string, renderFormat format.Format, root bool) error {	×
38	pkgPath := path.Join(dir, p.GetName())	×
39	if err := mkDirs(pkgPath); err != nil {	×
40	return err	×
41	}	×
42	p.SetPath(pkgPath)	×
43	pkgFile := path.Join(pkgPath, "_index.md")	×
44		×
45	for _, pkg := range p.Packages {	×
46	if err := RenderPackage(pkg, pkgPath, renderFormat, false); err != nil {	×
47	return err	×
48	}	×
49	}
50
51	for _, mod := range p.Modules {	×
52	modPath := path.Join(pkgPath, mod.GetName())	×
53	if err := renderModule(mod, modPath); err != nil {	×
54	return err	×
55	}	×
56	}
57
58	text, err := Render(p)	×
59	if err != nil {	×
60	return err	×
61	}	×
62	if err := os.WriteFile(pkgFile, []byte(text), 0666); err != nil {	×
63	return err	×
64	}	×
65
66	if root {	×
67	if err := format.GetFormatter(renderFormat).WriteAuxiliary(p, dir, t); err != nil {	×
68	return err	×
69	}	×
70	}
71
72	return nil	×
73	}
74
NEW 75	func renderModule(mod *document.Module, dir string) error {	×
76	if err := mkDirs(dir); err != nil {	×
77	return err	×
78	}	×
79	mod.SetPath(dir)	×
80	modFile := path.Join(dir, "_index.md")	×
81		×
82	if err := renderList(mod.Structs, dir); err != nil {	×
83	return err	×
84	}	×
85	if err := renderList(mod.Traits, dir); err != nil {	×
86	return err	×
87	}	×
88	if err := renderList(mod.Functions, dir); err != nil {	×
89	return err	×
90	}	×
91
92	text, err := Render(mod)	×
93	if err != nil {	×
94	return err	×
95	}	×
96	if err := os.WriteFile(modFile, []byte(text), 0666); err != nil {	×
97	return err	×
98	}	×
99
100	return nil	×
101	}
102
103	func renderList[T interface {
104	document.Named
105	document.Kinded
106	document.Pathed
107	}](list []T, dir string) error {	×
108	for _, elem := range list {	×
109	text, err := Render(elem)	×
110	if err != nil {	×
111	return err	×
112	}	×
113	strPath := path.Join(dir, elem.GetName())	×
114	elem.SetPath(strPath)	×
115	if err := os.WriteFile(strPath+".md", []byte(text), 0666); err != nil {	×
116	return err	×
117	}	×
118	}
119	return nil	×
120	}
121
122	func loadTemplates() (*template.Template, error) {	1✔
123	allTemplates, err := findTemplates()	1✔
124	if err != nil {	1✔
125	return nil, err	×
126	}	×
127	return template.New("all").ParseFS(templates, allTemplates...)	1✔
128	}
129
130	func findTemplates() ([]string, error) {	1✔
131	allTemplates := []string{}	1✔
132	err := fs.WalkDir(templates, ".",	1✔
133	func(path string, info os.DirEntry, err error) error {	28✔
134	if err != nil {	27✔
135	return err	×
136	}	×
137	if !info.IsDir() {	50✔
138	allTemplates = append(allTemplates, path)	23✔
139	}	23✔
140	return nil	27✔
141	})
142	if err != nil {	1✔
143	return nil, err	×
144	}	×
145	return allTemplates, nil	1✔
146	}
147
148	func mkDirs(path string) error {	×
149	if err := os.MkdirAll(path, os.ModePerm); err != nil && !os.IsExist(err) {	×
150	return err	×
151	}	×
152	return nil	×
153	}

mlange-42 / modo / 12729458095

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