12810176069

Committed 16 Jan 2025 01:43PM CUT coverage: 36.569% (+1.8%) from 34.803%

Build # 12810176069

Build Type

push

github

Committed by

web-flow

Commit Message

Implement re-exports on package level (#42)

Run Details

235 of 505 new or added lines in 11 files covered. (46.53%)

41 existing lines in 4 files now uncovered.

437 of 1195 relevant lines covered (36.57%)

2.65 hits per line

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

20.29

/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, useExports bool, shortLinks bool) error {
        formatter := GetFormatter(rFormat)
        t, err := loadTemplates(formatter)
        if err != nil {
                return err
        }
        proc := document.NewProcessor(docs, formatter, t, useExports, shortLinks)
        err = proc.ProcessLinks()
        if err != nil {
                return err
        }

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

        if err := proc.Formatter.WriteAuxiliary(proc.ExportDocs.Decl, dir, &proc); 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 {
                if err := renderModule(mod, pkgPath, proc); err != nil {
                        return err
                }
        }

        if err := renderList(p.Structs, pkgPath, proc); err != nil {
                return err
        }
        if err := renderList(p.Traits, pkgPath, proc); err != nil {
                return err
        }
        if err := renderList(p.Functions, pkgPath, 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 {
        modPath := path.Join(dir, mod.GetFileName())
        if err := mkDirs(modPath); err != nil {
                return err
        }

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

        if err := renderList(mod.Structs, modPath, proc); err != nil {
                return err
        }
        if err := renderList(mod.Traits, modPath, proc); err != nil {
                return err
        }
        if err := renderList(mod.Functions, modPath, 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, useExports bool, shortLinks bool) error {	×
15	formatter := GetFormatter(rFormat)	×
16	t, err := loadTemplates(formatter)	×
17	if err != nil {	×
18	return err	×
19	}	×
NEW 20	proc := document.NewProcessor(docs, formatter, t, useExports, shortLinks)	×
NEW 21	err = proc.ProcessLinks()	×
22	if err != nil {	×
23	return err	×
24	}	×
25
NEW 26	err = renderPackage(proc.ExportDocs.Decl, dir, &proc)	×
27	if err != nil {	×
28	return err	×
29	}	×
30
NEW 31	if err := proc.Formatter.WriteAuxiliary(proc.ExportDocs.Decl, dir, &proc); 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 {	×
NEW 72	if err := renderModule(mod, pkgPath, proc); err != nil {	×
73	return err	×
74	}	×
75	}
76
NEW 77	if err := renderList(p.Structs, pkgPath, proc); err != nil {	×
NEW 78	return err	×
NEW 79	}	×
NEW 80	if err := renderList(p.Traits, pkgPath, proc); err != nil {	×
NEW 81	return err	×
NEW 82	}	×
NEW 83	if err := renderList(p.Functions, pkgPath, proc); err != nil {	×
NEW 84	return err	×
NEW 85	}	×
86
87	text, err := renderElement(p, proc)	×
88	if err != nil {	×
89	return err	×
90	}	×
91	if err := os.WriteFile(pkgFile, []byte(text), 0666); err != nil {	×
92	return err	×
93	}	×
94
95	return nil	×
96	}
97
98	func renderModule(mod document.Module, dir string, proc document.Processor) error {	×
NEW 99	modPath := path.Join(dir, mod.GetFileName())	×
NEW 100	if err := mkDirs(modPath); err != nil {	×
101	return err	×
102	}	×
103
NEW 104	modFile, err := proc.Formatter.ToFilePath(modPath, "module")	×
105	if err != nil {	×
106	return err	×
107	}	×
108
NEW 109	if err := renderList(mod.Structs, modPath, proc); err != nil {	×
110	return err	×
111	}	×
NEW 112	if err := renderList(mod.Traits, modPath, proc); err != nil {	×
113	return err	×
114	}	×
NEW 115	if err := renderList(mod.Functions, modPath, proc); err != nil {	×
116	return err	×
117	}	×
118
119	text, err := renderElement(mod, proc)	×
120	if err != nil {	×
121	return err	×
122	}	×
123	if err := os.WriteFile(modFile, []byte(text), 0666); err != nil {	×
124	return err	×
125	}	×
126
127	return nil	×
128	}
129
130	func renderList[T interface {
131	document.Named
132	document.Kinded
133	}](list []T, dir string, proc *document.Processor) error {	×
134	for _, elem := range list {	×
135	text, err := renderElement(elem, proc)	×
136	if err != nil {	×
137	return err	×
138	}	×
139	memberPath := path.Join(dir, elem.GetFileName())	×
140		×
141	memberFile, err := proc.Formatter.ToFilePath(memberPath, elem.GetKind())	×
142	if err != nil {	×
143	return err	×
144	}	×
145
146	if err := os.WriteFile(memberFile, []byte(text), 0666); err != nil {	×
147	return err	×
148	}	×
149	}
150	return nil	×
151	}
152
153	func loadTemplates(f document.Formatter) (*template.Template, error) {	2✔
154	allTemplates, err := findTemplates()	2✔
155	if err != nil {	2✔
156	return nil, err	×
157	}	×
158	templ, err := template.New("all").Funcs(template.FuncMap{	2✔
159	"toLink": f.ToLinkPath,	2✔
160	}).ParseFS(assets.Templates, allTemplates...)	2✔
161	if err != nil {	2✔
162	return nil, err	×
163	}	×
164	return templ, nil	2✔
165	}
166
167	func findTemplates() ([]string, error) {	2✔
168	allTemplates := []string{}	2✔
169	err := fs.WalkDir(assets.Templates, ".",	2✔
170	func(path string, info os.DirEntry, err error) error {	56✔
171	if err != nil {	54✔
172	return err	×
173	}	×
174	if !info.IsDir() {	100✔
175	allTemplates = append(allTemplates, path)	46✔
176	}	46✔
177	return nil	54✔
178	})
179	if err != nil {	2✔
180	return nil, err	×
181	}	×
182	return allTemplates, nil	2✔
183	}
184
185	func mkDirs(path string) error {	×
186	if err := os.MkdirAll(path, os.ModePerm); err != nil && !os.IsExist(err) {	×
187	return err	×
188	}	×
189	return nil	×
190	}

mlange-42 / modo / 12810176069

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