12759040435

Committed 14 Jan 2025 01:08AM CUT coverage: 34.065% (-0.7%) from 34.783%

Build # 12759040435

Build Type

Pull #33

github

Committed by

web-flow

Commit Message

Merge 13c24c5d4 into b2b3f2790

Pull Request Pull Request #33: Add CSS to mdBook for line wrapping in code

Run Details

2 of 18 new or added lines in 2 files covered. (11.11%)

1 existing line in 1 file now uncovered.

264 of 775 relevant lines covered (34.06%)

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

        "github.com/mlange-42/modo/assets"
        "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
        }
        if err := f.writeCss(dir); 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
}

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

mlange-42 / modo / 12759040435

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