12857640190

Committed 19 Jan 2025 10:16PM CUT coverage: 57.418% (-0.4%) from 57.843%

Build # 12857640190

Build Type

push

github

Committed by

web-flow

Commit Message

Check for name conflicts in re-exports (#72)

Run Details

18 of 33 new or added lines in 3 files covered. (54.55%)

4 existing lines in 1 file now uncovered.

836 of 1456 relevant lines covered (57.42%)

8.24 hits per line

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

40.72

/document/render.go

package document

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

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

func Render(docs *Docs, config *Config, form Formatter) error {
        t, err := loadTemplates(form, config.TemplateDirs...)
        if err != nil {
                return err
        }
        if !config.DryRun {
                proc := NewProcessor(docs, form, t, config)
                return renderWith(config, proc)
        }

        files := []string{}
        proc := NewProcessorWithWriter(docs, form, t, config, func(file, text string) error {
                files = append(files, file)
                return nil
        })
        err = renderWith(config, proc)
        if err != nil {
                return err
        }

        fmt.Println("Dry-run. Would write these files:")
        for _, f := range files {
                fmt.Println(f)
        }
        return nil
}

func renderWith(config *Config, proc *Processor) error {
        caseSensitiveSystem = !config.CaseInsensitive
        if err := proc.PrepareDocs(); err != nil {
                return err
        }
        if err := renderPackage(proc.ExportDocs.Decl, []string{config.OutputDir}, proc); err != nil {
                return err
        }
        if err := proc.Formatter.WriteAuxiliary(proc.ExportDocs.Decl, config.OutputDir, proc); err != nil {
                return err
        }
        return nil
}

func renderElement(data interface {
        Named
        Kinded
}, proc *Processor) (string, error) {
        b := strings.Builder{}
        err := proc.Template.ExecuteTemplate(&b, data.GetKind()+".md", data)
        if err != nil {
                return "", err
        }
        return proc.Formatter.ProcessMarkdown(data, b.String(), proc)
}

func renderPackage(p *Package, dir []string, proc *Processor) error {
        newDir := appendNew(dir, p.GetFileName())
        pkgPath := path.Join(newDir...)
        if err := proc.mkDirs(pkgPath); err != nil {
                return err
        }

        for _, pkg := range p.Packages {
                if err := renderPackage(pkg, newDir, proc); err != nil {
                        return err
                }
        }

        for _, mod := range p.Modules {
                if err := renderModule(mod, newDir, proc); err != nil {
                        return err
                }
        }

        if err := renderList(p.Structs, newDir, proc); err != nil {
                return err
        }
        if err := renderList(p.Traits, newDir, proc); err != nil {
                return err
        }
        if err := renderList(p.Functions, newDir, proc); err != nil {
                return err
        }

        text, err := renderElement(p, proc)
        if err != nil {
                return err
        }
        if err := linkAndWrite(text, newDir, len(newDir), "package", proc); err != nil {
                return err
        }

        return nil
}

func renderModule(mod *Module, dir []string, proc *Processor) error {
        newDir := appendNew(dir, mod.GetFileName())
        if err := proc.mkDirs(path.Join(newDir...)); err != nil {
                return err
        }

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

        text, err := renderElement(mod, proc)
        if err != nil {
                return err
        }
        if err := linkAndWrite(text, newDir, len(newDir), "module", proc); err != nil {
                return err
        }

        return nil
}

func renderList[T interface {
        Named
        Kinded
}](list []T, dir []string, proc *Processor) error {
        for _, elem := range list {
                newDir := appendNew(dir, elem.GetFileName())
                text, err := renderElement(elem, proc)
                if err != nil {
                        return err
                }
                if err := linkAndWrite(text, newDir, len(dir), elem.GetKind(), proc); err != nil {
                        return err
                }
        }
        return nil
}

func loadTemplates(f Formatter, additional ...string) (*template.Template, error) {
        allTemplates, err := findTemplatesFS()
        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
        }
        for _, dir := range additional {
                moreTemplates, err := findTemplates(dir)
                if err != nil {
                        return nil, err
                }
                templ, err = templ.ParseFiles(moreTemplates...)
                if err != nil {
                        return nil, err
                }
        }
        return templ, nil
}

func findTemplatesFS() ([]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 findTemplates(dir string) ([]string, error) {
        allTemplates := []string{}
        err := filepath.WalkDir(dir,
                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 linkAndWrite(text string, dir []string, modElems int, kind string, proc *Processor) error {
        text, err := proc.ReplacePlaceholders(text, dir[1:], modElems-1)
        if err != nil {
                return err
        }
        outFile, err := proc.Formatter.ToFilePath(path.Join(dir...), kind)
        if err != nil {
                return err
        }
        return proc.WriteFile(outFile, text)
}

1	package document
2
3	import (
4	"fmt"
5	"io/fs"
6	"os"
7	"path"
8	"path/filepath"
9	"strings"
10	"text/template"
11
12	"github.com/mlange-42/modo/assets"
13	)
14
15	func Render(docs Docs, config Config, form Formatter) error {	×
16	t, err := loadTemplates(form, config.TemplateDirs...)	×
17	if err != nil {	×
18	return err	×
19	}	×
20	if !config.DryRun {	×
21	proc := NewProcessor(docs, form, t, config)	×
22	return renderWith(config, proc)	×
23	}	×
24
25	files := []string{}	×
26	proc := NewProcessorWithWriter(docs, form, t, config, func(file, text string) error {	×
27	files = append(files, file)	×
28	return nil	×
29	})	×
30	err = renderWith(config, proc)	×
31	if err != nil {	×
32	return err	×
33	}	×
34
35	fmt.Println("Dry-run. Would write these files:")	×
36	for _, f := range files {	×
37	fmt.Println(f)	×
38	}	×
39	return nil	×
40	}
41
42	func renderWith(config Config, proc Processor) error {	4✔
43	caseSensitiveSystem = !config.CaseInsensitive	4✔
44	if err := proc.PrepareDocs(); err != nil {	4✔
45	return err	×
46	}	×
47	if err := renderPackage(proc.ExportDocs.Decl, []string{config.OutputDir}, proc); err != nil {	4✔
48	return err	×
49	}	×
50	if err := proc.Formatter.WriteAuxiliary(proc.ExportDocs.Decl, config.OutputDir, proc); err != nil {	4✔
51	return err	×
52	}	×
53	return nil	4✔
54	}
55
56	func renderElement(data interface {
57	Named
58	Kinded
59	}, proc *Processor) (string, error) {	17✔
60	b := strings.Builder{}	17✔
61	err := proc.Template.ExecuteTemplate(&b, data.GetKind()+".md", data)	17✔
62	if err != nil {	17✔
63	return "", err	×
64	}	×
65	return proc.Formatter.ProcessMarkdown(data, b.String(), proc)	17✔
66	}
67
68	func renderPackage(p Package, dir []string, proc Processor) error {	4✔
69	newDir := appendNew(dir, p.GetFileName())	4✔
70	pkgPath := path.Join(newDir...)	4✔
71	if err := proc.mkDirs(pkgPath); err != nil {	4✔
72	return err	×
73	}	×
74
75	for _, pkg := range p.Packages {	4✔
76	if err := renderPackage(pkg, newDir, proc); err != nil {	×
77	return err	×
78	}	×
79	}
80
81	for _, mod := range p.Modules {	8✔
82	if err := renderModule(mod, newDir, proc); err != nil {	4✔
83	return err	×
84	}	×
85	}
86
87	if err := renderList(p.Structs, newDir, proc); err != nil {	4✔
88	return err	×
89	}	×
90	if err := renderList(p.Traits, newDir, proc); err != nil {	4✔
91	return err	×
92	}	×
93	if err := renderList(p.Functions, newDir, proc); err != nil {	4✔
94	return err	×
95	}	×
96
97	text, err := renderElement(p, proc)	4✔
98	if err != nil {	4✔
99	return err	×
100	}	×
101	if err := linkAndWrite(text, newDir, len(newDir), "package", proc); err != nil {	4✔
102	return err	×
103	}	×
104
105	return nil	4✔
106	}
107
108	func renderModule(mod Module, dir []string, proc Processor) error {	4✔
109	newDir := appendNew(dir, mod.GetFileName())	4✔
110	if err := proc.mkDirs(path.Join(newDir...)); err != nil {	4✔
111	return err	×
112	}	×
113
114	if err := renderList(mod.Structs, newDir, proc); err != nil {	4✔
115	return err	×
116	}	×
117	if err := renderList(mod.Traits, newDir, proc); err != nil {	4✔
118	return err	×
119	}	×
120	if err := renderList(mod.Functions, newDir, proc); err != nil {	4✔
121	return err	×
122	}	×
123
124	text, err := renderElement(mod, proc)	4✔
125	if err != nil {	4✔
126	return err	×
127	}	×
128	if err := linkAndWrite(text, newDir, len(newDir), "module", proc); err != nil {	4✔
129	return err	×
130	}	×
131
132	return nil	4✔
133	}
134
135	func renderList[T interface {
136	Named
137	Kinded
138	}](list []T, dir []string, proc *Processor) error {	24✔
139	for _, elem := range list {	31✔
140	newDir := appendNew(dir, elem.GetFileName())	7✔
141	text, err := renderElement(elem, proc)	7✔
142	if err != nil {	7✔
143	return err	×
144	}	×
145	if err := linkAndWrite(text, newDir, len(dir), elem.GetKind(), proc); err != nil {	7✔
146	return err	×
147	}	×
148	}
149	return nil	24✔
150	}
151
152	func loadTemplates(f Formatter, additional ...string) (*template.Template, error) {	6✔
153	allTemplates, err := findTemplatesFS()	6✔
154	if err != nil {	6✔
155	return nil, err	×
156	}	×
157	templ, err := template.New("all").Funcs(template.FuncMap{	6✔
158	"toLink": f.ToLinkPath,	6✔
159	}).ParseFS(assets.Templates, allTemplates...)	6✔
160	if err != nil {	6✔
161	return nil, err	×
162	}	×
163	for _, dir := range additional {	6✔
164	moreTemplates, err := findTemplates(dir)	×
165	if err != nil {	×
166	return nil, err	×
167	}	×
168	templ, err = templ.ParseFiles(moreTemplates...)	×
169	if err != nil {	×
170	return nil, err	×
171	}	×
172	}
173	return templ, nil	6✔
174	}
175
176	func findTemplatesFS() ([]string, error) {	6✔
177	allTemplates := []string{}	6✔
178	err := fs.WalkDir(assets.Templates, ".",	6✔
179	func(path string, info os.DirEntry, err error) error {	180✔
180	if err != nil {	174✔
181	return err	×
182	}	×
183	if !info.IsDir() {	318✔
184	allTemplates = append(allTemplates, path)	144✔
185	}	144✔
186	return nil	174✔
187	})
188	if err != nil {	6✔
189	return nil, err	×
190	}	×
191	return allTemplates, nil	6✔
192	}
193
194	func findTemplates(dir string) ([]string, error) {	×
195	allTemplates := []string{}	×
196	err := filepath.WalkDir(dir,	×
197	func(path string, info os.DirEntry, err error) error {	×
198	if err != nil {	×
199	return err	×
200	}	×
201	if !info.IsDir() {	×
202	allTemplates = append(allTemplates, path)	×
203	}	×
204	return nil	×
205	})
206	if err != nil {	×
207	return nil, err	×
208	}	×
209	return allTemplates, nil	×
210	}
211
212	func linkAndWrite(text string, dir []string, modElems int, kind string, proc *Processor) error {	15✔
213	text, err := proc.ReplacePlaceholders(text, dir[1:], modElems-1)	15✔
214	if err != nil {	15✔
215	return err	×
216	}	×
217	outFile, err := proc.Formatter.ToFilePath(path.Join(dir...), kind)	15✔
218	if err != nil {	15✔
219	return err	×
220	}	×
221	return proc.WriteFile(outFile, text)	15✔
222	}

mlange-42 / modo / 12857640190

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