• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

mlange-42 / modo / 12777767016

14 Jan 2025 10:46PM CUT coverage: 34.058% (+0.2%) from 33.894%
12777767016

Pull #39

github

web-flow
Merge 12e54bf0f into efc472466
Pull Request #39: Move the binary package to module root

0 of 60 new or added lines in 3 files covered. (0.0%)

282 of 828 relevant lines covered (34.06%)

2.1 hits per line

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

0.0
/format/mdbook.go
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) ProcessMarkdown(name, summary, text string) (string, error) {
×
18
        return text, nil
×
19
}
×
20

21
func (f *MdBookFormatter) WriteAuxiliary(p *document.Package, dir string, t *template.Template) error {
×
22
        if err := f.writeSummary(p, dir, t); err != nil {
×
23
                return err
×
24
        }
×
25
        if err := f.writeToml(p, dir, t); err != nil {
×
26
                return err
×
27
        }
×
28
        if err := f.writeCss(dir); err != nil {
×
29
                return err
×
30
        }
×
31
        return nil
×
32
}
33

34
func (f *MdBookFormatter) ToFilePath(p string, kind string) (string, error) {
×
35
        if kind == "package" || kind == "module" {
×
36
                return path.Join(p, "_index.md"), nil
×
37
        }
×
38
        return p + ".md", nil
×
39
}
40

41
func (f *MdBookFormatter) ToLinkPath(p string, kind string) (string, error) {
×
42
        return f.ToFilePath(p, kind)
×
43
}
×
44

45
type summary struct {
46
        Summary  string
47
        Packages string
48
        Modules  string
49
}
50

51
func (f *MdBookFormatter) writeSummary(p *document.Package, dir string, t *template.Template) error {
×
52
        summary, err := f.renderSummary(p, t)
×
53
        if err != nil {
×
54
                return err
×
55
        }
×
56
        summaryPath := path.Join(dir, p.GetFileName(), "SUMMARY.md")
×
57
        if err := os.WriteFile(summaryPath, []byte(summary), 0666); err != nil {
×
58
                return err
×
59
        }
×
60
        return nil
×
61
}
62

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

×
66
        pkgFile, err := f.ToLinkPath("", "package")
×
67
        if err != nil {
×
68
                return "", err
×
69
        }
×
70
        s.Summary = fmt.Sprintf("[`%s`](%s)", p.GetName(), pkgFile)
×
71

×
72
        pkgs := strings.Builder{}
×
73
        for _, p := range p.Packages {
×
74
                if err := f.renderPackage(p, t, []string{}, &pkgs); err != nil {
×
75
                        return "", err
×
76
                }
×
77
        }
78
        s.Packages = pkgs.String()
×
79

×
80
        mods := strings.Builder{}
×
81
        for _, m := range p.Modules {
×
82
                if err := f.renderModule(m, []string{}, &mods); err != nil {
×
83
                        return "", err
×
84
                }
×
85
        }
86
        s.Modules = mods.String()
×
87

×
88
        b := strings.Builder{}
×
89
        if err := t.ExecuteTemplate(&b, "mdbook_summary.md", &s); err != nil {
×
90
                return "", err
×
91
        }
×
92

93
        return b.String(), nil
×
94
}
95

96
func (f *MdBookFormatter) renderPackage(pkg *document.Package, t *template.Template, linkPath []string, out *strings.Builder) error {
×
97
        newPath := append([]string{}, linkPath...)
×
98
        newPath = append(newPath, pkg.GetFileName())
×
99

×
100
        pkgFile, err := f.ToLinkPath(path.Join(newPath...), "package")
×
101
        if err != nil {
×
102
                return err
×
103
        }
×
104

105
        fmt.Fprintf(out, "%-*s- [`%s`](%s))\n", 2*len(linkPath), "", pkg.GetName(), pkgFile)
×
106
        for _, p := range pkg.Packages {
×
107
                if err := f.renderPackage(p, t, newPath, out); err != nil {
×
108
                        return err
×
109
                }
×
110
        }
111
        for _, m := range pkg.Modules {
×
112
                if err := f.renderModule(m, newPath, out); err != nil {
×
113
                        return err
×
114
                }
×
115
        }
116
        return nil
×
117
}
118

119
func (f *MdBookFormatter) renderModule(mod *document.Module, linkPath []string, out *strings.Builder) error {
×
120
        newPath := append([]string{}, linkPath...)
×
121
        newPath = append(newPath, mod.GetFileName())
×
122

×
123
        pathStr := path.Join(newPath...)
×
124

×
125
        modFile, err := f.ToLinkPath(pathStr, "module")
×
126
        if err != nil {
×
127
                return err
×
128
        }
×
129

130
        fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", 2*len(linkPath), "", mod.GetName(), modFile)
×
131

×
132
        for _, s := range mod.Structs {
×
133
                memPath, err := f.ToLinkPath(path.Join(pathStr, s.GetFileName(), ""), "")
×
134
                if err != nil {
×
135
                        return err
×
136
                }
×
137
                fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", 2*len(linkPath)+2, "", s.GetName(), memPath)
×
138
        }
139
        for _, tr := range mod.Traits {
×
140
                memPath, err := f.ToLinkPath(path.Join(pathStr, tr.GetFileName(), ""), "")
×
141
                if err != nil {
×
142
                        return err
×
143
                }
×
144
                fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", 2*len(linkPath)+2, "", tr.GetName(), memPath)
×
145
        }
146
        for _, ff := range mod.Functions {
×
147
                memPath, err := f.ToLinkPath(path.Join(pathStr, ff.GetFileName(), ""), "")
×
148
                if err != nil {
×
149
                        return err
×
150
                }
×
151
                fmt.Fprintf(out, "%-*s- [`%s`](%s)\n", 2*len(linkPath)+2, "", ff.GetName(), memPath)
×
152
        }
153
        return nil
×
154
}
155

156
func (f *MdBookFormatter) writeToml(p *document.Package, dir string, t *template.Template) error {
×
157
        toml, err := f.renderToml(p, t)
×
158
        if err != nil {
×
159
                return err
×
160
        }
×
161
        tomlPath := path.Join(dir, "book.toml")
×
162
        if err := os.WriteFile(tomlPath, []byte(toml), 0666); err != nil {
×
163
                return err
×
164
        }
×
165
        return nil
×
166
}
167

168
func (f *MdBookFormatter) renderToml(p *document.Package, t *template.Template) (string, error) {
×
169
        b := strings.Builder{}
×
170
        if err := t.ExecuteTemplate(&b, "book.toml", p); err != nil {
×
171
                return "", err
×
172
        }
×
173
        return b.String(), nil
×
174
}
175

176
func (f *MdBookFormatter) writeCss(dir string) error {
×
177
        cssDir := path.Join(dir, "css")
×
178
        if err := os.MkdirAll(cssDir, os.ModePerm); err != nil && !os.IsExist(err) {
×
179
                return err
×
180
        }
×
181
        css, err := fs.ReadFile(assets.CSS, "css/mdbook.css")
×
182
        if err != nil {
×
183
                return err
×
184
        }
×
185
        if err := os.WriteFile(path.Join(cssDir, "custom.css"), css, 0666); err != nil {
×
186
                return err
×
187
        }
×
188
        return nil
×
189
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2025 Coveralls, Inc