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

mlange-42 / modo / 12816549311

16 Jan 2025 07:54PM CUT coverage: 34.117% (-3.0%) from 37.068%
12816549311

Pull #46

github

web-flow
Merge bad20b0e7 into cd52159d3
Pull Request #46: Fix overwritten cross-refs for multi re-export

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

450 of 1319 relevant lines covered (34.12%)

2.48 hits per line

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

20.59
/format/render.go
1
package format
2

3
import (
4
        "io/fs"
5
        "os"
6
        "path"
7
        "strings"
8
        "text/template"
9

10
        "github.com/mlange-42/modo/assets"
11
        "github.com/mlange-42/modo/document"
12
)
13

14
func Render(docs *document.Docs, dir string, rFormat Format, useExports bool, shortLinks bool) error {
×
15
        formatter := GetFormatter(rFormat)
×
16
        t, err := loadTemplates(formatter)
×
17
        if err != nil {
×
18
                return err
×
19
        }
×
20
        proc := document.NewProcessor(docs, formatter, t, useExports, shortLinks)
×
21
        if err := proc.PrepareDocs(); err != nil {
×
22
                return err
×
23
        }
×
24
        if err := renderPackage(proc.ExportDocs.Decl, dir, &proc); err != nil {
×
25
                return err
×
26
        }
×
27
        if err := proc.Formatter.WriteAuxiliary(proc.ExportDocs.Decl, dir, &proc); err != nil {
×
28
                return err
×
29
        }
×
30
        return nil
×
31
}
32

33
func renderElement(data interface {
34
        document.Named
35
        document.Kinded
36
}, proc *document.Processor) (string, error) {
2✔
37
        b := strings.Builder{}
2✔
38
        err := proc.Template.ExecuteTemplate(&b, data.GetKind()+".md", data)
2✔
39
        if err != nil {
2✔
40
                return "", err
×
41
        }
×
42
        var summary string
2✔
43
        if d, ok := data.(document.Summarized); ok {
4✔
44
                summary = d.GetSummary()
2✔
45
        }
2✔
46
        return proc.Formatter.ProcessMarkdown(data.GetName(), summary, b.String())
2✔
47
}
48

49
func renderPackage(p *document.Package, dir string, proc *document.Processor) error {
×
50
        pkgPath := path.Join(dir, p.GetFileName())
×
51
        if err := mkDirs(pkgPath); err != nil {
×
52
                return err
×
53
        }
×
54

55
        pkgFile, err := proc.Formatter.ToFilePath(pkgPath, "package")
×
56
        if err != nil {
×
57
                return err
×
58
        }
×
59

60
        for _, pkg := range p.Packages {
×
61
                if err := renderPackage(pkg, pkgPath, proc); err != nil {
×
62
                        return err
×
63
                }
×
64
        }
65

66
        for _, mod := range p.Modules {
×
67
                if err := renderModule(mod, pkgPath, proc); err != nil {
×
68
                        return err
×
69
                }
×
70
        }
71

72
        if err := renderList(p.Structs, pkgPath, proc); err != nil {
×
73
                return err
×
74
        }
×
75
        if err := renderList(p.Traits, pkgPath, proc); err != nil {
×
76
                return err
×
77
        }
×
78
        if err := renderList(p.Functions, pkgPath, proc); err != nil {
×
79
                return err
×
80
        }
×
81

82
        text, err := renderElement(p, proc)
×
83
        if err != nil {
×
84
                return err
×
85
        }
×
86
        if err := os.WriteFile(pkgFile, []byte(text), 0666); err != nil {
×
87
                return err
×
88
        }
×
89

90
        return nil
×
91
}
92

93
func renderModule(mod *document.Module, dir string, proc *document.Processor) error {
×
94
        modPath := path.Join(dir, mod.GetFileName())
×
95
        if err := mkDirs(modPath); err != nil {
×
96
                return err
×
97
        }
×
98

99
        modFile, err := proc.Formatter.ToFilePath(modPath, "module")
×
100
        if err != nil {
×
101
                return err
×
102
        }
×
103

104
        if err := renderList(mod.Structs, modPath, proc); err != nil {
×
105
                return err
×
106
        }
×
107
        if err := renderList(mod.Traits, modPath, proc); err != nil {
×
108
                return err
×
109
        }
×
110
        if err := renderList(mod.Functions, modPath, proc); err != nil {
×
111
                return err
×
112
        }
×
113

114
        text, err := renderElement(mod, proc)
×
115
        if err != nil {
×
116
                return err
×
117
        }
×
118
        if err := os.WriteFile(modFile, []byte(text), 0666); err != nil {
×
119
                return err
×
120
        }
×
121

122
        return nil
×
123
}
124

125
func renderList[T interface {
126
        document.Named
127
        document.Kinded
128
}](list []T, dir string, proc *document.Processor) error {
×
129
        for _, elem := range list {
×
130
                text, err := renderElement(elem, proc)
×
131
                if err != nil {
×
132
                        return err
×
133
                }
×
134
                memberPath := path.Join(dir, elem.GetFileName())
×
135

×
136
                memberFile, err := proc.Formatter.ToFilePath(memberPath, elem.GetKind())
×
137
                if err != nil {
×
138
                        return err
×
139
                }
×
140

141
                if err := os.WriteFile(memberFile, []byte(text), 0666); err != nil {
×
142
                        return err
×
143
                }
×
144
        }
145
        return nil
×
146
}
147

148
func loadTemplates(f document.Formatter) (*template.Template, error) {
2✔
149
        allTemplates, err := findTemplates()
2✔
150
        if err != nil {
2✔
151
                return nil, err
×
152
        }
×
153
        templ, err := template.New("all").Funcs(template.FuncMap{
2✔
154
                "toLink": f.ToLinkPath,
2✔
155
        }).ParseFS(assets.Templates, allTemplates...)
2✔
156
        if err != nil {
2✔
157
                return nil, err
×
158
        }
×
159
        return templ, nil
2✔
160
}
161

162
func findTemplates() ([]string, error) {
2✔
163
        allTemplates := []string{}
2✔
164
        err := fs.WalkDir(assets.Templates, ".",
2✔
165
                func(path string, info os.DirEntry, err error) error {
56✔
166
                        if err != nil {
54✔
167
                                return err
×
168
                        }
×
169
                        if !info.IsDir() {
100✔
170
                                allTemplates = append(allTemplates, path)
46✔
171
                        }
46✔
172
                        return nil
54✔
173
                })
174
        if err != nil {
2✔
175
                return nil, err
×
176
        }
×
177
        return allTemplates, nil
2✔
178
}
179

180
func mkDirs(path string) error {
×
181
        if err := os.MkdirAll(path, os.ModePerm); err != nil && !os.IsExist(err) {
×
182
                return err
×
183
        }
×
184
        return nil
×
185
}
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