12829041089

Committed 17 Jan 2025 12:26PM CUT coverage: 56.552% (+20.0%) from 36.563%

Build # 12829041089

Build Type

push

github

Committed by

web-flow

Commit Message

More unit tests (#54)

* move args to config
* add a rendering test
* add a test for docs processing
* move rendering code to package document
* add tests for all member kinds

Run Details

32 of 49 new or added lines in 4 files covered. (65.31%)

13 existing lines in 2 files now uncovered.

725 of 1282 relevant lines covered (56.55%)

6.69 hits per line

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

45.16

/document/render.go

package document

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

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

type Config struct {
        OutputDir    string
        TemplateDirs []string
        RenderFormat Formatter
        UseExports   bool
        ShortLinks   bool
}

func Render(docs *Docs, config *Config) error {
        t, err := loadTemplates(config.RenderFormat, config.TemplateDirs...)
        if err != nil {
                return err
        }
        proc := NewProcessor(docs, config.RenderFormat, t, config.UseExports, config.ShortLinks)
        return renderWith(config.OutputDir, proc)
}

func renderWith(outDir string, proc *Processor) error {
        if err := proc.PrepareDocs(); err != nil {
                return err
        }
        if err := renderPackage(proc.ExportDocs.Decl, []string{outDir}, proc); err != nil {
                return err
        }
        if err := proc.Formatter.WriteAuxiliary(proc.ExportDocs.Decl, outDir, 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 := 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 := 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)
}

func mkDirs(path string) error {
        if err := os.MkdirAll(path, os.ModePerm); err != nil && !os.IsExist(err) {
                return err
        }
        return nil
}

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

mlange-42 / modo / 12829041089

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