12777767016

Committed 14 Jan 2025 10:46PM CUT coverage: 34.058% (+0.2%) from 33.894%

Build # 12777767016

Build Type

Pull #39

github

Committed by

web-flow

Commit Message

Merge 12e54bf0f into efc472466

Pull Request Pull Request #39: Move the binary package to module root

Run Details

0 of 60 new or added lines in 3 files covered. (0.0%)

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

/format/render.go

package format

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

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

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

mlange-42 / modo / 12777767016

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