12735598201

Committed 12 Jan 2025 05:21PM CUT coverage: 26.287% (-1.3%) from 27.616%

Build # 12735598201

Build Type

push

github

Committed by

web-flow

Commit Message

Use templates to generate paths (#22)

Run Details

3 of 46 new or added lines in 2 files covered. (6.52%)

97 of 369 relevant lines covered (26.29%)

1.37 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{}

        s.Summary = fmt.Sprintf("[`%s`](./_index.md)", p.GetName())

        pkgs := strings.Builder{}
        for _, p := range p.Packages {
                f.renderPackage(p, []string{}, &pkgs)
        }
        s.Packages = pkgs.String()

        mods := strings.Builder{}
        for _, m := range p.Modules {
                f.renderModule(m, []string{}, &mods)
        }
        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, linkPath []string, out *strings.Builder) {
        newPath := append([]string{}, linkPath...)
        newPath = append(newPath, pkg.GetFileName())
        fmt.Fprintf(out, "%-*s- [`%s`](./%s/_index.md))\n", 2*len(linkPath), "", pkg.GetName(), path.Join(newPath...))
        for _, p := range pkg.Packages {
                f.renderPackage(p, newPath, out)
        }
        for _, m := range pkg.Modules {
                f.renderModule(m, newPath, out)
        }
}

func (f *MdBookFormatter) renderModule(mod *document.Module, linkPath []string, out *strings.Builder) {
        newPath := append([]string{}, linkPath...)
        newPath = append(newPath, mod.GetFileName())
        pathStr := path.Join(newPath...)
        fmt.Fprintf(out, "%-*s- [`%s`](./%s/_index.md)\n", 2*len(linkPath), "", mod.GetName(), pathStr)

        for _, s := range mod.Structs {
                fmt.Fprintf(out, "%-*s- [`%s`](./%s/%s.md)\n", 2*len(linkPath)+2, "", s.GetName(), pathStr, s.GetFileName())
        }
        for _, t := range mod.Traits {
                fmt.Fprintf(out, "%-*s- [`%s`](./%s/%s.md)\n", 2*len(linkPath)+2, "", t.GetName(), pathStr, t.GetFileName())
        }
        for _, f := range mod.Functions {
                fmt.Fprintf(out, "%-*s- [`%s`](./%s/%s.md)\n", 2*len(linkPath)+2, "", f.GetName(), pathStr, f.GetFileName())
        }
}

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 {	×
NEW 32	summary, err := f.renderSummary(p, t)	×
NEW 33	if err != nil {	×
NEW 34	return err	×
NEW 35	}	×
36	summaryPath := path.Join(dir, p.GetFileName(), "SUMMARY.md")	×
NEW 37	if err := os.WriteFile(summaryPath, []byte(summary), 0666); err != nil {	×
NEW 38	return err	×
NEW 39	}	×
NEW 40	return nil	×
41	}
42
NEW 43	func (f MdBookFormatter) renderSummary(p document.Package, t *template.Template) (string, error) {	×
44	s := summary{}	×
45		×
46	s.Summary = fmt.Sprintf("[`%s`](./_index.md)", p.GetName())	×
47		×
48	pkgs := strings.Builder{}	×
49	for _, p := range p.Packages {	×
50	f.renderPackage(p, []string{}, &pkgs)	×
51	}	×
52	s.Packages = pkgs.String()	×
53		×
54	mods := strings.Builder{}	×
55	for _, m := range p.Modules {	×
56	f.renderModule(m, []string{}, &mods)	×
57	}	×
58	s.Modules = mods.String()	×
59		×
60	b := strings.Builder{}	×
61	if err := t.ExecuteTemplate(&b, "mdbook_summary.md", &s); err != nil {	×
NEW 62	return "", err	×
63	}	×
64
NEW 65	return b.String(), nil	×
66	}
67
68	func (f MdBookFormatter) renderPackage(pkg document.Package, linkPath []string, out *strings.Builder) {	×
69	newPath := append([]string{}, linkPath...)	×
70	newPath = append(newPath, pkg.GetFileName())	×
71	fmt.Fprintf(out, "%-s- [`%s`](./%s/_index.md))\n", 2len(linkPath), "", pkg.GetName(), path.Join(newPath...))	×
72	for _, p := range pkg.Packages {	×
73	f.renderPackage(p, newPath, out)	×
74	}	×
75	for _, m := range pkg.Modules {	×
76	f.renderModule(m, newPath, out)	×
77	}	×
78	}
79
80	func (f MdBookFormatter) renderModule(mod document.Module, linkPath []string, out *strings.Builder) {	×
81	newPath := append([]string{}, linkPath...)	×
82	newPath = append(newPath, mod.GetFileName())	×
83	pathStr := path.Join(newPath...)	×
84	fmt.Fprintf(out, "%-s- [`%s`](./%s/_index.md)\n", 2len(linkPath), "", mod.GetName(), pathStr)	×
85		×
86	for _, s := range mod.Structs {	×
87	fmt.Fprintf(out, "%-s- [`%s`](./%s/%s.md)\n", 2len(linkPath)+2, "", s.GetName(), pathStr, s.GetFileName())	×
88	}	×
89	for _, t := range mod.Traits {	×
90	fmt.Fprintf(out, "%-s- [`%s`](./%s/%s.md)\n", 2len(linkPath)+2, "", t.GetName(), pathStr, t.GetFileName())	×
91	}	×
92	for _, f := range mod.Functions {	×
93	fmt.Fprintf(out, "%-s- [`%s`](./%s/%s.md)\n", 2len(linkPath)+2, "", f.GetName(), pathStr, f.GetFileName())	×
94	}	×
95	}
96
97	func (f MdBookFormatter) writeToml(p document.Package, dir string, t *template.Template) error {	×
NEW 98	toml, err := f.renderToml(p, t)	×
NEW 99	if err != nil {	×
100	return err	×
101	}	×
NEW 102	tomlPath := path.Join(dir, "book.toml")	×
NEW 103	if err := os.WriteFile(tomlPath, []byte(toml), 0666); err != nil {	×
104	return err	×
105	}	×
106	return nil	×
107	}
108
NEW 109	func (f MdBookFormatter) renderToml(p document.Package, t *template.Template) (string, error) {	×
NEW 110	b := strings.Builder{}	×
NEW 111	if err := t.ExecuteTemplate(&b, "book.toml", p); err != nil {	×
NEW 112	return "", err	×
NEW 113	}	×
NEW 114	return b.String(), nil	×
115	}

mlange-42 / modo / 12735598201

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