12737935283

Committed 12 Jan 2025 11:14PM CUT coverage: 24.557%. Remained the same

Build # 12737935283

Build Type

Pull #26

github

Committed by

web-flow

Commit Message

Merge fdc77f32e into ee3165c19

Pull Request Pull Request #26: Add CI tests on stable and nightly

Run Details

97 of 395 relevant lines covered (24.56%)

1.28 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"
        "os"
        "path"
        "strings"
        "text/template"

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

type MdBookFormatter struct{}

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

type summary struct {
        Summary  string
        Packages string
        Modules  string
}

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

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

        pkgFile := strings.Builder{}
        if err := t.ExecuteTemplate(&pkgFile, "package_path.md", ""); err != nil {
                return "", err
        }
        s.Summary = fmt.Sprintf("[`%s`](%s)", p.GetName(), pkgFile.String())

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

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

        b := strings.Builder{}
        if err := t.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 := strings.Builder{}
        if err := t.ExecuteTemplate(&pkgFile, "package_path.md", path.Join(newPath...)); err != nil {
                return err
        }

        fmt.Fprintf(out, "%-*s- [`%s`](%s))\n", 2*len(linkPath), "", pkg.GetName(), pkgFile.String())
        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, t, newPath, out); err != nil {
                        return err
                }
        }
        return nil
}

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

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

        pkgFile := strings.Builder{}
        if err := t.ExecuteTemplate(&pkgFile, "module_path.md", pathStr); err != nil {
                return err
        }

        fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", 2*len(linkPath), "", mod.GetName(), pkgFile.String())

        for _, s := range mod.Structs {
                memPath, err := memberPath(t, pathStr, s.GetFileName())
                if err != nil {
                        return err
                }
                fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", 2*len(linkPath)+2, "", s.GetName(), memPath)
        }
        for _, tr := range mod.Traits {
                memPath, err := memberPath(t, pathStr, tr.GetFileName())
                if err != nil {
                        return err
                }
                fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", 2*len(linkPath)+2, "", tr.GetName(), memPath)
        }
        for _, f := range mod.Functions {
                memPath, err := memberPath(t, pathStr, f.GetFileName())
                if err != nil {
                        return err
                }
                fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", 2*len(linkPath)+2, "", f.GetName(), memPath)
        }
        return nil
}

func memberPath(t *template.Template, p string, fn string) (string, error) {
        pathStr := path.Join(p, fn)
        b := strings.Builder{}
        if err := t.ExecuteTemplate(&b, "member_path.md", pathStr); err != nil {
                return "", err
        }
        return b.String(), nil
}

func (f *MdBookFormatter) writeToml(p *document.Package, dir string, t *template.Template) error {
        toml, err := f.renderToml(p, t)
        if err != nil {
                return err
        }
        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
}

1	package format
2
3	import (
4	"fmt"
5	"os"
6	"path"
7	"strings"
8	"text/template"
9
10	"github.com/mlange-42/modo/document"
11	)
12
13	type MdBookFormatter struct{}
14
15	func (f MdBookFormatter) WriteAuxiliary(p document.Package, dir string, t *template.Template) error {	×
16	if err := f.writeSummary(p, dir, t); err != nil {	×
17	return err	×
18	}	×
19	if err := f.writeToml(p, dir, t); err != nil {	×
20	return err	×
21	}	×
22	return nil	×
23	}
24
25	type summary struct {
26	Summary string
27	Packages string
28	Modules string
29	}
30
31	func (f MdBookFormatter) writeSummary(p document.Package, dir string, t *template.Template) error {	×
32	summary, err := f.renderSummary(p, t)	×
33	if err != nil {	×
34	return err	×
35	}	×
36	summaryPath := path.Join(dir, p.GetFileName(), "SUMMARY.md")	×
37	if err := os.WriteFile(summaryPath, []byte(summary), 0666); err != nil {	×
38	return err	×
39	}	×
40	return nil	×
41	}
42
43	func (f MdBookFormatter) renderSummary(p document.Package, t *template.Template) (string, error) {	×
44	s := summary{}	×
45		×
46	pkgFile := strings.Builder{}	×
47	if err := t.ExecuteTemplate(&pkgFile, "package_path.md", ""); err != nil {	×
48	return "", err	×
49	}	×
50	s.Summary = fmt.Sprintf("[`%s`](%s)", p.GetName(), pkgFile.String())	×
51		×
52	pkgs := strings.Builder{}	×
53	for _, p := range p.Packages {	×
54	if err := f.renderPackage(p, t, []string{}, &pkgs); err != nil {	×
55	return "", err	×
56	}	×
57	}
58	s.Packages = pkgs.String()	×
59		×
60	mods := strings.Builder{}	×
61	for _, m := range p.Modules {	×
62	if err := f.renderModule(m, t, []string{}, &mods); err != nil {	×
63	return "", err	×
64	}	×
65	}
66	s.Modules = mods.String()	×
67		×
68	b := strings.Builder{}	×
69	if err := t.ExecuteTemplate(&b, "mdbook_summary.md", &s); err != nil {	×
70	return "", err	×
71	}	×
72
73	return b.String(), nil	×
74	}
75
76	func (f MdBookFormatter) renderPackage(pkg document.Package, t template.Template, linkPath []string, out strings.Builder) error {	×
77	newPath := append([]string{}, linkPath...)	×
78	newPath = append(newPath, pkg.GetFileName())	×
79		×
80	pkgFile := strings.Builder{}	×
81	if err := t.ExecuteTemplate(&pkgFile, "package_path.md", path.Join(newPath...)); err != nil {	×
82	return err	×
83	}	×
84
85	fmt.Fprintf(out, "%-s- [`%s`](%s))\n", 2len(linkPath), "", pkg.GetName(), pkgFile.String())	×
86	for _, p := range pkg.Packages {	×
87	if err := f.renderPackage(p, t, newPath, out); err != nil {	×
88	return err	×
89	}	×
90	}
91	for _, m := range pkg.Modules {	×
92	if err := f.renderModule(m, t, newPath, out); err != nil {	×
93	return err	×
94	}	×
95	}
96	return nil	×
97	}
98
99	func (f MdBookFormatter) renderModule(mod document.Module, t template.Template, linkPath []string, out strings.Builder) error {	×
100	newPath := append([]string{}, linkPath...)	×
101	newPath = append(newPath, mod.GetFileName())	×
102		×
103	pathStr := path.Join(newPath...)	×
104		×
105	pkgFile := strings.Builder{}	×
106	if err := t.ExecuteTemplate(&pkgFile, "module_path.md", pathStr); err != nil {	×
107	return err	×
108	}	×
109
110	fmt.Fprintf(out, "%-s- [`%s`](%s)\n", 2len(linkPath), "", mod.GetName(), pkgFile.String())	×
111		×
112	for _, s := range mod.Structs {	×
113	memPath, err := memberPath(t, pathStr, s.GetFileName())	×
114	if err != nil {	×
115	return err	×
116	}	×
117	fmt.Fprintf(out, "%-s- [`%s`](%s)\n", 2len(linkPath)+2, "", s.GetName(), memPath)	×
118	}
119	for _, tr := range mod.Traits {	×
120	memPath, err := memberPath(t, pathStr, tr.GetFileName())	×
121	if err != nil {	×
122	return err	×
123	}	×
124	fmt.Fprintf(out, "%-s- [`%s`](%s)\n", 2len(linkPath)+2, "", tr.GetName(), memPath)	×
125	}
126	for _, f := range mod.Functions {	×
127	memPath, err := memberPath(t, pathStr, f.GetFileName())	×
128	if err != nil {	×
129	return err	×
130	}	×
131	fmt.Fprintf(out, "%-s- [`%s`](%s)\n", 2len(linkPath)+2, "", f.GetName(), memPath)	×
132	}
133	return nil	×
134	}
135
136	func memberPath(t *template.Template, p string, fn string) (string, error) {	×
137	pathStr := path.Join(p, fn)	×
138	b := strings.Builder{}	×
139	if err := t.ExecuteTemplate(&b, "member_path.md", pathStr); err != nil {	×
140	return "", err	×
141	}	×
142	return b.String(), nil	×
143	}
144
145	func (f MdBookFormatter) writeToml(p document.Package, dir string, t *template.Template) error {	×
146	toml, err := f.renderToml(p, t)	×
147	if err != nil {	×
148	return err	×
149	}	×
150	tomlPath := path.Join(dir, "book.toml")	×
151	if err := os.WriteFile(tomlPath, []byte(toml), 0666); err != nil {	×
152	return err	×
153	}	×
154	return nil	×
155	}
156
157	func (f MdBookFormatter) renderToml(p document.Package, t *template.Template) (string, error) {	×
158	b := strings.Builder{}	×
159	if err := t.ExecuteTemplate(&b, "book.toml", p); err != nil {	×
160	return "", err	×
161	}	×
162	return b.String(), nil	×
163	}

mlange-42 / modo / 12737935283

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