12857640190

Committed 19 Jan 2025 10:16PM CUT coverage: 57.418% (-0.4%) from 57.843%

Build # 12857640190

Build Type

push

github

Committed by

web-flow

Commit Message

Check for name conflicts in re-exports (#72)

Run Details

18 of 33 new or added lines in 3 files covered. (54.55%)

4 existing lines in 1 file now uncovered.

836 of 1456 relevant lines covered (57.42%)

8.24 hits per line

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

0.0

/format/mdbook.go

package format

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

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

type MdBookFormatter struct{}

func (f *MdBookFormatter) Render(docs *document.Docs, config *document.Config) error {
        return document.Render(docs, config, f)
}

func (f *MdBookFormatter) ProcessMarkdown(element any, text string, proc *document.Processor) (string, error) {
        return text, nil
}

func (f *MdBookFormatter) WriteAuxiliary(p *document.Package, dir string, proc *document.Processor) error {
        if err := f.writeSummary(p, dir, proc); err != nil {
                return err
        }
        if err := f.writeToml(p, dir, proc); err != nil {
                return err
        }
        if err := f.writeCss(dir, proc); err != nil {
                return err
        }
        return nil
}

func (f *MdBookFormatter) ToFilePath(p string, kind string) (string, error) {
        if kind == "package" || kind == "module" {
                return path.Join(p, "_index.md"), nil
        }
        return p + ".md", nil
}

func (f *MdBookFormatter) ToLinkPath(p string, kind string) (string, error) {
        return f.ToFilePath(p, kind)
}

type summary struct {
        Summary   string
        Packages  string
        Modules   string
        Structs   string
        Traits    string
        Functions string
}

func (f *MdBookFormatter) writeSummary(p *document.Package, dir string, proc *document.Processor) error {
        summary, err := f.renderSummary(p, proc)
        if err != nil {
                return err
        }
        summaryPath := path.Join(dir, p.GetFileName(), "SUMMARY.md")
        if proc.Config.DryRun {
                return nil
        }
        if err := os.WriteFile(summaryPath, []byte(summary), 0666); err != nil {
                return err
        }
        return nil
}

func (f *MdBookFormatter) renderSummary(p *document.Package, proc *document.Processor) (string, error) {
        s := summary{}

        pkgFile, err := f.ToLinkPath("", "package")
        if err != nil {
                return "", err
        }
        s.Summary = fmt.Sprintf("[`%s`](%s)", p.GetName(), pkgFile)

        pkgs := strings.Builder{}
        for _, p := range p.Packages {
                if err := f.renderPackage(p, proc.Template, nil, &pkgs); err != nil {
                        return "", err
                }
        }
        s.Packages = pkgs.String()

        mods := strings.Builder{}
        for _, m := range p.Modules {
                if err := f.renderModule(m, nil, &mods); err != nil {
                        return "", err
                }
        }
        s.Modules = mods.String()

        elems := strings.Builder{}
        for _, elem := range p.Structs {
                if err := f.renderModuleMember(elem, "", 0, &elems); err != nil {
                        return "", err
                }
        }
        s.Structs = elems.String()
        elems = strings.Builder{}
        for _, elem := range p.Traits {
                if err := f.renderModuleMember(elem, "", 0, &elems); err != nil {
                        return "", err
                }
        }
        s.Traits = elems.String()
        elems = strings.Builder{}
        for _, elem := range p.Functions {
                if err := f.renderModuleMember(elem, "", 0, &elems); err != nil {
                        return "", err
                }
        }
        s.Functions = elems.String()

        b := strings.Builder{}
        if err := proc.Template.ExecuteTemplate(&b, "mdbook_summary.md", &s); err != nil {
                return "", err
        }

        return b.String(), nil
}

func (f *MdBookFormatter) renderPackage(pkg *document.Package, t *template.Template, linkPath []string, out *strings.Builder) error {
        newPath := append([]string{}, linkPath...)
        newPath = append(newPath, pkg.GetFileName())

        pkgFile, err := f.ToLinkPath(path.Join(newPath...), "package")
        if err != nil {
                return err
        }

        fmt.Fprintf(out, "%-*s- [`%s`](%s))\n", 2*len(linkPath), "", pkg.GetName(), pkgFile)
        for _, p := range pkg.Packages {
                if err := f.renderPackage(p, t, newPath, out); err != nil {
                        return err
                }
        }
        for _, m := range pkg.Modules {
                if err := f.renderModule(m, newPath, out); err != nil {
                        return err
                }
        }

        pathStr := path.Join(newPath...)
        childDepth := 2*(len(newPath)-1) + 2
        for _, elem := range pkg.Structs {
                if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {
                        return err
                }
        }
        for _, elem := range pkg.Traits {
                if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {
                        return err
                }
        }
        for _, elem := range pkg.Functions {
                if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {
                        return err
                }
        }

        return nil
}

func (f *MdBookFormatter) renderModule(mod *document.Module, linkPath []string, out *strings.Builder) error {
        newPath := append([]string{}, linkPath...)
        newPath = append(newPath, mod.GetFileName())

        pathStr := path.Join(newPath...)

        modFile, err := f.ToLinkPath(pathStr, "module")
        if err != nil {
                return err
        }
        fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", 2*(len(newPath)-1), "", mod.GetName(), modFile)

        childDepth := 2*(len(newPath)-1) + 2
        for _, elem := range mod.Structs {
                if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {
                        return err
                }
        }
        for _, elem := range mod.Traits {
                if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {
                        return err
                }
        }
        for _, elem := range mod.Functions {
                if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {
                        return err
                }
        }
        return nil
}

func (f *MdBookFormatter) renderModuleMember(mem document.Named, pathStr string, depth int, out io.Writer) error {
        memPath, err := f.ToLinkPath(path.Join(pathStr, mem.GetFileName(), ""), "")
        if err != nil {
                return err
        }
        fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", depth, "", mem.GetName(), memPath)
        return nil
}

func (f *MdBookFormatter) writeToml(p *document.Package, dir string, proc *document.Processor) error {
        toml, err := f.renderToml(p, proc.Template)
        if err != nil {
                return err
        }
        if proc.Config.DryRun {
                return nil
        }
        tomlPath := path.Join(dir, "book.toml")
        if err := os.WriteFile(tomlPath, []byte(toml), 0666); err != nil {
                return err
        }
        return nil
}

func (f *MdBookFormatter) renderToml(p *document.Package, t *template.Template) (string, error) {
        b := strings.Builder{}
        if err := t.ExecuteTemplate(&b, "book.toml", p); err != nil {
                return "", err
        }
        return b.String(), nil
}

func (f *MdBookFormatter) writeCss(dir string, proc *document.Processor) error {
        cssDir := path.Join(dir, "css")
        if !proc.Config.DryRun {
                if err := os.MkdirAll(cssDir, os.ModePerm); err != nil && !os.IsExist(err) {
                        return err
                }
        }
        css, err := fs.ReadFile(assets.CSS, "css/mdbook.css")
        if err != nil {
                return err
        }
        if !proc.Config.DryRun {
                if err := os.WriteFile(path.Join(cssDir, "custom.css"), css, 0666); err != nil {
                        return err
                }
        }
        return nil
}

1	package format
2
3	import (
4	"fmt"
5	"io"
6	"io/fs"
7	"os"
8	"path"
9	"strings"
10	"text/template"
11
12	"github.com/mlange-42/modo/assets"
13	"github.com/mlange-42/modo/document"
14	)
15
16	type MdBookFormatter struct{}
17
18	func (f MdBookFormatter) Render(docs document.Docs, config *document.Config) error {	×
19	return document.Render(docs, config, f)	×
20	}	×
21
22	func (f MdBookFormatter) ProcessMarkdown(element any, text string, proc document.Processor) (string, error) {	×
23	return text, nil	×
24	}	×
25
26	func (f MdBookFormatter) WriteAuxiliary(p document.Package, dir string, proc *document.Processor) error {	×
27	if err := f.writeSummary(p, dir, proc); err != nil {	×
28	return err	×
29	}	×
30	if err := f.writeToml(p, dir, proc); err != nil {	×
31	return err	×
32	}	×
33	if err := f.writeCss(dir, proc); err != nil {	×
34	return err	×
35	}	×
36	return nil	×
37	}
38
39	func (f *MdBookFormatter) ToFilePath(p string, kind string) (string, error) {	×
40	if kind == "package" \|\| kind == "module" {	×
41	return path.Join(p, "_index.md"), nil	×
42	}	×
43	return p + ".md", nil	×
44	}
45
46	func (f *MdBookFormatter) ToLinkPath(p string, kind string) (string, error) {	×
47	return f.ToFilePath(p, kind)	×
48	}	×
49
50	type summary struct {
51	Summary string
52	Packages string
53	Modules string
54	Structs string
55	Traits string
56	Functions string
57	}
58
59	func (f MdBookFormatter) writeSummary(p document.Package, dir string, proc *document.Processor) error {	×
60	summary, err := f.renderSummary(p, proc)	×
61	if err != nil {	×
62	return err	×
63	}	×
64	summaryPath := path.Join(dir, p.GetFileName(), "SUMMARY.md")	×
65	if proc.Config.DryRun {	×
66	return nil	×
67	}	×
68	if err := os.WriteFile(summaryPath, []byte(summary), 0666); err != nil {	×
69	return err	×
70	}	×
71	return nil	×
72	}
73
74	func (f MdBookFormatter) renderSummary(p document.Package, proc *document.Processor) (string, error) {	×
75	s := summary{}	×
76		×
77	pkgFile, err := f.ToLinkPath("", "package")	×
78	if err != nil {	×
79	return "", err	×
80	}	×
81	s.Summary = fmt.Sprintf("[`%s`](%s)", p.GetName(), pkgFile)	×
82		×
83	pkgs := strings.Builder{}	×
84	for _, p := range p.Packages {	×
85	if err := f.renderPackage(p, proc.Template, nil, &pkgs); err != nil {	×
86	return "", err	×
87	}	×
88	}
89	s.Packages = pkgs.String()	×
90		×
91	mods := strings.Builder{}	×
92	for _, m := range p.Modules {	×
93	if err := f.renderModule(m, nil, &mods); err != nil {	×
94	return "", err	×
95	}	×
96	}
97	s.Modules = mods.String()	×
98		×
99	elems := strings.Builder{}	×
100	for _, elem := range p.Structs {	×
101	if err := f.renderModuleMember(elem, "", 0, &elems); err != nil {	×
102	return "", err	×
103	}	×
104	}
105	s.Structs = elems.String()	×
106	elems = strings.Builder{}	×
107	for _, elem := range p.Traits {	×
108	if err := f.renderModuleMember(elem, "", 0, &elems); err != nil {	×
109	return "", err	×
110	}	×
111	}
112	s.Traits = elems.String()	×
113	elems = strings.Builder{}	×
114	for _, elem := range p.Functions {	×
115	if err := f.renderModuleMember(elem, "", 0, &elems); err != nil {	×
116	return "", err	×
117	}	×
118	}
119	s.Functions = elems.String()	×
120		×
121	b := strings.Builder{}	×
122	if err := proc.Template.ExecuteTemplate(&b, "mdbook_summary.md", &s); err != nil {	×
123	return "", err	×
124	}	×
125
126	return b.String(), nil	×
127	}
128
129	func (f MdBookFormatter) renderPackage(pkg document.Package, t template.Template, linkPath []string, out strings.Builder) error {	×
130	newPath := append([]string{}, linkPath...)	×
131	newPath = append(newPath, pkg.GetFileName())	×
132		×
133	pkgFile, err := f.ToLinkPath(path.Join(newPath...), "package")	×
134	if err != nil {	×
135	return err	×
136	}	×
137
138	fmt.Fprintf(out, "%-s- [`%s`](%s))\n", 2len(linkPath), "", pkg.GetName(), pkgFile)	×
139	for _, p := range pkg.Packages {	×
140	if err := f.renderPackage(p, t, newPath, out); err != nil {	×
141	return err	×
142	}	×
143	}
144	for _, m := range pkg.Modules {	×
145	if err := f.renderModule(m, newPath, out); err != nil {	×
146	return err	×
147	}	×
148	}
149
150	pathStr := path.Join(newPath...)	×
151	childDepth := 2*(len(newPath)-1) + 2	×
152	for _, elem := range pkg.Structs {	×
153	if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {	×
154	return err	×
155	}	×
156	}
157	for _, elem := range pkg.Traits {	×
158	if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {	×
159	return err	×
160	}	×
161	}
162	for _, elem := range pkg.Functions {	×
163	if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {	×
164	return err	×
165	}	×
166	}
167
168	return nil	×
169	}
170
171	func (f MdBookFormatter) renderModule(mod document.Module, linkPath []string, out *strings.Builder) error {	×
172	newPath := append([]string{}, linkPath...)	×
173	newPath = append(newPath, mod.GetFileName())	×
174		×
175	pathStr := path.Join(newPath...)	×
176		×
177	modFile, err := f.ToLinkPath(pathStr, "module")	×
178	if err != nil {	×
179	return err	×
180	}	×
181	fmt.Fprintf(out, "%-s- [`%s`](%s)\n", 2(len(newPath)-1), "", mod.GetName(), modFile)	×
182		×
183	childDepth := 2*(len(newPath)-1) + 2	×
184	for _, elem := range mod.Structs {	×
185	if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {	×
186	return err	×
187	}	×
188	}
189	for _, elem := range mod.Traits {	×
190	if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {	×
191	return err	×
192	}	×
193	}
194	for _, elem := range mod.Functions {	×
195	if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {	×
196	return err	×
197	}	×
198	}
199	return nil	×
200	}
201
202	func (f *MdBookFormatter) renderModuleMember(mem document.Named, pathStr string, depth int, out io.Writer) error {	×
203	memPath, err := f.ToLinkPath(path.Join(pathStr, mem.GetFileName(), ""), "")	×
204	if err != nil {	×
205	return err	×
206	}	×
207	fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", depth, "", mem.GetName(), memPath)	×
208	return nil	×
209	}
210
211	func (f MdBookFormatter) writeToml(p document.Package, dir string, proc *document.Processor) error {	×
212	toml, err := f.renderToml(p, proc.Template)	×
213	if err != nil {	×
214	return err	×
215	}	×
216	if proc.Config.DryRun {	×
217	return nil	×
218	}	×
219	tomlPath := path.Join(dir, "book.toml")	×
220	if err := os.WriteFile(tomlPath, []byte(toml), 0666); err != nil {	×
221	return err	×
222	}	×
223	return nil	×
224	}
225
226	func (f MdBookFormatter) renderToml(p document.Package, t *template.Template) (string, error) {	×
227	b := strings.Builder{}	×
228	if err := t.ExecuteTemplate(&b, "book.toml", p); err != nil {	×
229	return "", err	×
230	}	×
231	return b.String(), nil	×
232	}
233
234	func (f MdBookFormatter) writeCss(dir string, proc document.Processor) error {	×
235	cssDir := path.Join(dir, "css")	×
236	if !proc.Config.DryRun {	×
237	if err := os.MkdirAll(cssDir, os.ModePerm); err != nil && !os.IsExist(err) {	×
238	return err	×
239	}	×
240	}
241	css, err := fs.ReadFile(assets.CSS, "css/mdbook.css")	×
242	if err != nil {	×
243	return err	×
244	}	×
245	if !proc.Config.DryRun {	×
246	if err := os.WriteFile(path.Join(cssDir, "custom.css"), css, 0666); err != nil {	×
247	return err	×
248	}	×
249	}
250	return nil	×
251	}

mlange-42 / modo / 12857640190

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