12979057873

Committed 26 Jan 2025 10:49PM CUT coverage: 65.591%. Remained the same

Build # 12979057873

Build Type

push

github

Committed by

web-flow

Commit Message

Add user guide section on bash scripts (#125)

Run Details

1098 of 1674 relevant lines covered (65.59%)

31.16 hits per line

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

50.5

/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, subdir string) 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, subdir)
        }

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

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

func ExtractTests(docs *Docs, config *Config, form Formatter, subdir string) error {
        caseSensitiveSystem = !config.CaseInsensitive
        t, err := LoadTemplates(form, config.TemplateDirs...)
        if err != nil {
                return err
        }
        var proc *Processor
        if config.DryRun {
                proc = NewProcessorWithWriter(docs, form, t, config, func(file, text string) error {
                        return nil
                })
        } else {
                proc = NewProcessor(docs, form, t, config)
        }
        return proc.ExtractTests(subdir)
}

func ExtractTestsMarkdown(config *Config, form Formatter, baseDir string, build bool) error {
        caseSensitiveSystem = !config.CaseInsensitive

        t, err := LoadTemplates(form, config.TemplateDirs...)
        if err != nil {
                return err
        }
        var proc *Processor
        if config.DryRun {
                proc = NewProcessorWithWriter(nil, form, t, config, func(file, text string) error {
                        return nil
                })
        } else {
                proc = NewProcessor(nil, form, t, config)
        }
        return proc.extractDocTestsMarkdown(baseDir, build)
}

func renderWith(config *Config, proc *Processor, subdir string) error {
        caseSensitiveSystem = !config.CaseInsensitive
        if err := proc.PrepareDocs(subdir); err != nil {
                return err
        }
        outPath := path.Join(config.OutputDir, subdir)
        if err := renderPackage(proc.ExportDocs.Decl, []string{outPath}, proc); err != nil {
                return err
        }
        if err := proc.Formatter.WriteAuxiliary(proc.ExportDocs.Decl, outPath, 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 := template.New("all")
        templ = templ.Funcs(template.FuncMap{
                "toLink": f.ToLinkPath,
        })
        templ, err = templ.ParseFS(assets.Templates, allTemplates...)
        if err != nil {
                return nil, err
        }

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

mlange-42 / modo / 12979057873

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