12828318641

Committed 17 Jan 2025 11:37AM CUT coverage: 48.228% (+11.7%) from 36.563%

Build # 12828318641

Build Type

Pull #54

github

Committed by

web-flow

Commit Message

Merge 519b6c6c2 into 41ff6f833

Pull Request Pull Request #54: More unit tests

Run Details

12 of 28 new or added lines in 3 files covered. (42.86%)

108 existing lines in 3 files now uncovered.

626 of 1298 relevant lines covered (48.23%)

3.77 hits per line

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

46.84

/format/render.go

package format

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

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

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

func Render(docs *document.Docs, config *Config) error {
        return renderWithWriter(docs, config, func(file, text string) error {
                return os.WriteFile(file, []byte(text), 0666)
        })
}

func renderWithWriter(docs *document.Docs, config *Config, writer func(file, text string) error) error {
        formatter := GetFormatter(config.RenderFormat)
        t, err := loadTemplates(formatter, config.TemplateDirs...)
        if err != nil {
                return err
        }
        proc := document.NewProcessorWithWriter(docs, formatter, t, config.UseExports, config.ShortLinks, writer)
        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 {
        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
        }
        return proc.Formatter.ProcessMarkdown(data, b.String(), proc)
}

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

mlange-42 / modo / 12828318641

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