12856315602

Committed 19 Jan 2025 06:58PM CUT coverage: 59.246% (+0.3%) from 58.921%

Build # 12856315602

Build Type

push

github

Committed by

web-flow

Commit Message

Allow cross-refs to aliases in modules and structs (#69)

Run Details

14 of 16 new or added lines in 3 files covered. (87.5%)

833 of 1406 relevant lines covered (59.25%)

7.94 hits per line

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

45.51

/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
        UseExports    bool
        ShortLinks    bool
        CaseSensitive bool
        Strict        bool
}

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

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

mlange-42 / modo / 12856315602

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