13074745779

Committed 31 Jan 2025 02:29PM CUT coverage: 67.728%. Remained the same

Build # 13074745779

Build Type

Pull #171

github

Committed by

web-flow

Commit Message

Merge 27bb17a6a into 82e1dee76

Pull Request Pull Request #171: Show full sources of example package

Run Details

1213 of 1791 relevant lines covered (67.73%)

28.13 hits per line

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

12.16

/format/mdbook.go

package format

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

        "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) 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
        }
        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
}

1	package format
2
3	import (
4	"fmt"
5	"io"
6	"os"
7	"path"
8	"strings"
9	"text/template"
10
11	"github.com/mlange-42/modo/document"
12	)
13
14	type MdBook struct{}
15
16	func (f *MdBook) Accepts(files []string) error {	2✔
17	if len(files) > 1 {	3✔
18	return fmt.Errorf("mdBook formatter can process only a single JSON file, but %d is given", len(files))	1✔
19	}	1✔
20	if len(files) == 0 \|\| files[0] == "" {	1✔
21	return nil	×
22	}	×
23	if s, err := os.Stat(files[0]); err == nil {	2✔
24	if s.IsDir() {	2✔
25	return fmt.Errorf("mdBook formatter can process only a single JSON file, but directory '%s' is given", files[0])	1✔
26	}	1✔
27	} else {	×
28	return err	×
29	}	×
30	return nil	×
31	}
32
33	func (f MdBook) ProcessMarkdown(element any, text string, proc document.Processor) (string, error) {	×
34	return text, nil	×
35	}	×
36
37	func (f MdBook) WriteAuxiliary(p document.Package, dir string, proc *document.Processor) error {	×
38	if err := f.writeSummary(p, dir, proc); err != nil {	×
39	return err	×
40	}	×
41	return nil	×
42	}
43
44	func (f *MdBook) ToFilePath(p string, kind string) string {	6✔
45	if kind == "package" \|\| kind == "module" {	10✔
46	return path.Join(p, "_index.md")	4✔
47	}	4✔
48	if len(p) == 0 {	2✔
49	return p	×
50	}	×
51	return p + ".md"	2✔
52	}
53
54	func (f *MdBook) ToLinkPath(p string, kind string) string {	3✔
55	return f.ToFilePath(p, kind)	3✔
56	}	3✔
57
58	type summary struct {
59	Summary string
60	Packages string
61	Modules string
62	Structs string
63	Traits string
64	Functions string
65	}
66
67	func (f MdBook) writeSummary(p document.Package, dir string, proc *document.Processor) error {	×
68	summary, err := f.renderSummary(p, proc)	×
69	if err != nil {	×
70	return err	×
71	}	×
72	summaryPath := path.Join(dir, p.GetFileName(), "SUMMARY.md")	×
73	if proc.Config.DryRun {	×
74	return nil	×
75	}	×
76	if err := os.WriteFile(summaryPath, []byte(summary), 0644); err != nil {	×
77	return err	×
78	}	×
79	return nil	×
80	}
81
82	func (f MdBook) renderSummary(p document.Package, proc *document.Processor) (string, error) {	×
83	s := summary{}	×
84		×
85	pkgFile := f.ToLinkPath("", "package")	×
86	s.Summary = fmt.Sprintf("[`%s`](%s)", p.GetName(), pkgFile)	×
87		×
88	pkgs := strings.Builder{}	×
89	for _, p := range p.Packages {	×
90	if err := f.renderPackage(p, proc.Template, nil, &pkgs); err != nil {	×
91	return "", err	×
92	}	×
93	}
94	s.Packages = pkgs.String()	×
95		×
96	mods := strings.Builder{}	×
97	for _, m := range p.Modules {	×
98	if err := f.renderModule(m, nil, &mods); err != nil {	×
99	return "", err	×
100	}	×
101	}
102	s.Modules = mods.String()	×
103		×
104	elems := strings.Builder{}	×
105	for _, elem := range p.Structs {	×
106	if err := f.renderModuleMember(elem, "", 0, &elems); err != nil {	×
107	return "", err	×
108	}	×
109	}
110	s.Structs = elems.String()	×
111	elems = strings.Builder{}	×
112	for _, elem := range p.Traits {	×
113	if err := f.renderModuleMember(elem, "", 0, &elems); err != nil {	×
114	return "", err	×
115	}	×
116	}
117	s.Traits = elems.String()	×
118	elems = strings.Builder{}	×
119	for _, elem := range p.Functions {	×
120	if err := f.renderModuleMember(elem, "", 0, &elems); err != nil {	×
121	return "", err	×
122	}	×
123	}
124	s.Functions = elems.String()	×
125		×
126	b := strings.Builder{}	×
127	if err := proc.Template.ExecuteTemplate(&b, "mdbook_summary.md", &s); err != nil {	×
128	return "", err	×
129	}	×
130
131	return b.String(), nil	×
132	}
133
134	func (f MdBook) renderPackage(pkg document.Package, t template.Template, linkPath []string, out strings.Builder) error {	×
135	newPath := append([]string{}, linkPath...)	×
136	newPath = append(newPath, pkg.GetFileName())	×
137		×
138	pkgFile := f.ToLinkPath(path.Join(newPath...), "package")	×
139	fmt.Fprintf(out, "%-s- [`%s`](%s))\n", 2len(linkPath), "", pkg.GetName(), pkgFile)	×
140	for _, p := range pkg.Packages {	×
141	if err := f.renderPackage(p, t, newPath, out); err != nil {	×
142	return err	×
143	}	×
144	}
145	for _, m := range pkg.Modules {	×
146	if err := f.renderModule(m, newPath, out); err != nil {	×
147	return err	×
148	}	×
149	}
150
151	pathStr := path.Join(newPath...)	×
152	childDepth := 2*(len(newPath)-1) + 2	×
153	for _, elem := range pkg.Structs {	×
154	if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {	×
155	return err	×
156	}	×
157	}
158	for _, elem := range pkg.Traits {	×
159	if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {	×
160	return err	×
161	}	×
162	}
163	for _, elem := range pkg.Functions {	×
164	if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {	×
165	return err	×
166	}	×
167	}
168
169	return nil	×
170	}
171
172	func (f MdBook) renderModule(mod document.Module, linkPath []string, out *strings.Builder) error {	×
173	newPath := append([]string{}, linkPath...)	×
174	newPath = append(newPath, mod.GetFileName())	×
175		×
176	pathStr := path.Join(newPath...)	×
177		×
178	modFile := f.ToLinkPath(pathStr, "module")	×
179	fmt.Fprintf(out, "%-s- [`%s`](%s)\n", 2(len(newPath)-1), "", mod.GetName(), modFile)	×
180		×
181	childDepth := 2*(len(newPath)-1) + 2	×
182	for _, elem := range mod.Structs {	×
183	if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {	×
184	return err	×
185	}	×
186	}
187	for _, elem := range mod.Traits {	×
188	if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {	×
189	return err	×
190	}	×
191	}
192	for _, elem := range mod.Functions {	×
193	if err := f.renderModuleMember(elem, pathStr, childDepth, out); err != nil {	×
194	return err	×
195	}	×
196	}
197	return nil	×
198	}
199
200	func (f *MdBook) renderModuleMember(mem document.Named, pathStr string, depth int, out io.Writer) error {	×
201	memPath := f.ToLinkPath(path.Join(pathStr, mem.GetFileName(), ""), "")	×
202	fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", depth, "", mem.GetName(), memPath)	×
203	return nil	×
204	}	×

mlange-42 / modo / 13074745779

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