12820268563

Committed 17 Jan 2025 12:39AM CUT coverage: 36.563%. Remained the same

Build # 12820268563

Build Type

Pull #51

github

Committed by

web-flow

Commit Message

Merge c0aa9b89b into fe50b7496

Pull Request Pull Request #51: Add Mojo and Modo emojis

Run Details

468 of 1280 relevant lines covered (36.56%)

2.63 hits per line

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

16.23

/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"
)

func Render(docs *document.Docs, dir string, templateDirs []string, rFormat Format, useExports bool, shortLinks bool) error {
        formatter := GetFormatter(rFormat)
        t, err := loadTemplates(formatter, templateDirs...)
        if err != nil {
                return err
        }
        proc := document.NewProcessor(docs, formatter, t, useExports, shortLinks)
        if err := proc.PrepareDocs(); err != nil {
                return err
        }
        if err := renderPackage(proc.ExportDocs.Decl, []string{dir}, &proc); 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
        }
        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 os.WriteFile(outFile, []byte(text), 0666)
}

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

mlange-42 / modo / 12820268563

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