12978042620

Committed 26 Jan 2025 08:23PM CUT coverage: 65.241% (+3.1%) from 62.103%

Build # 12978042620

Build Type

Pull #123

github

Committed by

web-flow

Commit Message

Merge 32c19e408 into 39fbafe7b

Pull Request Pull Request #123: Unit tests for formatter

Run Details

19 of 26 new or added lines in 5 files covered. (73.08%)

1 existing line in 1 file now uncovered.

1098 of 1683 relevant lines covered (65.24%)

30.99 hits per line

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

9.42

/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 MdBook struct{}

func (f *MdBook) Accepts(files []string) error {
        if len(files) > 1 {
                return fmt.Errorf("mdBook formatter can process only a single JSON file, but %d is given", len(files))
        }
        if len(files) == 0 || files[0] == "" {
                return nil
        }
        if s, err := os.Stat(files[0]); err == nil {
                if s.IsDir() {
                        return fmt.Errorf("mdBook formatter can process only a single JSON file, but directory '%s' is given", files[0])
                }
        } else {
                return err
        }
        return nil
}

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

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

func (f *MdBook) 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 *MdBook) ToFilePath(p string, kind string) string {
        if kind == "package" || kind == "module" {
                return path.Join(p, "_index.md")
        }
        if len(p) == 0 {
                return p
        }
        return p + ".md"
}

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

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

func (f *MdBook) 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), 0644); err != nil {
                return err
        }
        return nil
}

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

        pkgFile := f.ToLinkPath("", "package")
        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 *MdBook) renderPackage(pkg *document.Package, t *template.Template, linkPath []string, out *strings.Builder) error {
        newPath := append([]string{}, linkPath...)
        newPath = append(newPath, pkg.GetFileName())

        pkgFile := f.ToLinkPath(path.Join(newPath...), "package")
        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 *MdBook) renderModule(mod *document.Module, linkPath []string, out *strings.Builder) error {
        newPath := append([]string{}, linkPath...)
        newPath = append(newPath, mod.GetFileName())

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

        modFile := f.ToLinkPath(pathStr, "module")
        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 *MdBook) renderModuleMember(mem document.Named, pathStr string, depth int, out io.Writer) error {
        memPath := f.ToLinkPath(path.Join(pathStr, mem.GetFileName(), ""), "")
        fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", depth, "", mem.GetName(), memPath)
        return nil
}

func (f *MdBook) 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), 0644); err != nil {
                return err
        }
        return nil
}

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

mlange-42 / modo / 12978042620

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