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

mlange-42 / modo / 12820268563

17 Jan 2025 12:39AM CUT coverage: 36.563%. Remained the same
12820268563

Pull #51

github

web-flow
Merge c0aa9b89b into fe50b7496
Pull Request #51: Add Mojo and Modo emojis

468 of 1280 relevant lines covered (36.56%)

2.63 hits per line

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

70.91
/document/filter.go
1
package document
2

3
import (
4
        "fmt"
5
)
6

7
// Filters and re-structures docs for package re-exports.
8
//
9
// Also collects a lookup, mapping from original to altered cross-refs.
10
func (proc *Processor) filterPackages() error {
2✔
11
        proc.linkExports = map[string]string{}
2✔
12
        anyExports := proc.collectExports(proc.Docs.Decl, nil)
2✔
13

2✔
14
        if !proc.UseExports {
2✔
15
                proc.ExportDocs = &Docs{
×
16
                        Version: proc.Docs.Version,
×
17
                        Decl:    proc.Docs.Decl,
×
18
                }
×
19
                return nil
×
20
        }
×
21

22
        if !anyExports {
2✔
23
                return fmt.Errorf("no package re-exports found. Given flag '--exports', there will be no output.\n       Add exports or run without flag '--exports'")
×
24
        }
×
25

26
        proc.ExportDocs = &Docs{
2✔
27
                Version: proc.Docs.Version,
2✔
28
                Decl:    proc.Docs.Decl.linkedCopy(),
2✔
29
        }
2✔
30
        proc.filterPackage(proc.Docs.Decl, proc.ExportDocs.Decl, nil, nil)
2✔
31
        return nil
2✔
32
}
33

34
func (proc *Processor) filterPackage(src, rootOut *Package, oldPath, newPath []string) {
4✔
35
        rootExports := map[string]*members{}
4✔
36
        collectExportsPackage(src, rootExports)
4✔
37

4✔
38
        oldPath = AppendNew(oldPath, src.Name)
4✔
39
        newPath = AppendNew(newPath, src.Name)
4✔
40

4✔
41
        for _, mod := range src.Modules {
10✔
42
                if mems, ok := rootExports[mod.Name]; ok {
12✔
43
                        proc.collectModuleExports(mod, rootOut, oldPath, newPath, mems)
6✔
44
                }
6✔
45
        }
46

47
        for _, pkg := range src.Packages {
6✔
48
                if mems, ok := rootExports[pkg.Name]; ok {
4✔
49
                        proc.collectPackageExports(pkg, rootOut, oldPath, newPath, mems)
2✔
50
                }
2✔
51
        }
52
}
53

54
func (proc *Processor) collectPackageExports(src, rootOut *Package, oldPath, newPath []string, rootMembers *members) {
2✔
55
        selfIncluded, toCrawl := collectExportMembers(rootMembers)
2✔
56

2✔
57
        if selfIncluded {
4✔
58
                newPkg := src.linkedCopy()
2✔
59
                proc.filterPackage(src, newPkg, oldPath, newPath)
2✔
60
                rootOut.Packages = append(rootOut.Packages, newPkg)
2✔
61

2✔
62
                tempOldPath := AppendNew(oldPath, src.Name)
2✔
63
                tempNewPath := AppendNew(newPath, src.Name)
2✔
64
                proc.addLinkExport(tempOldPath, tempNewPath)
2✔
65
        }
2✔
66
        oldPath = AppendNew(oldPath, src.Name)
2✔
67

2✔
68
        for _, mod := range src.Modules {
4✔
69
                if mems, ok := toCrawl[mod.Name]; ok {
4✔
70
                        proc.collectModuleExports(mod, rootOut, oldPath, newPath, mems)
2✔
71
                }
2✔
72
        }
73

74
        for _, pkg := range src.Packages {
2✔
75
                if mems, ok := toCrawl[pkg.Name]; ok {
×
76
                        proc.collectPackageExports(pkg, rootOut, oldPath, newPath, mems)
×
77
                }
×
78
        }
79

80
        for _, elem := range src.Structs {
2✔
81
                proc.collectExportsStruct(elem, oldPath, newPath)
×
82
        }
×
83
        for _, elem := range src.Traits {
2✔
84
                proc.collectExportsTrait(elem, oldPath, newPath)
×
85
        }
×
86
        for _, elem := range src.Functions {
2✔
87
                proc.collectExportsFunction(elem, oldPath, newPath)
×
88
        }
×
89
}
90

91
func (proc *Processor) collectModuleExports(src *Module, rootOut *Package, oldPath, newPath []string, rootMembers *members) {
8✔
92
        selfIncluded, toCrawl := collectExportMembers(rootMembers)
8✔
93

8✔
94
        oldPath = AppendNew(oldPath, src.Name)
8✔
95
        if selfIncluded {
12✔
96
                rootOut.Modules = append(rootOut.Modules, src)
4✔
97

4✔
98
                tempNewPath := AppendNew(newPath, src.Name)
4✔
99
                proc.addLinkExport(oldPath, tempNewPath)
4✔
100
        }
4✔
101

102
        for _, elem := range src.Structs {
18✔
103
                if _, ok := toCrawl[elem.Name]; ok {
16✔
104
                        rootOut.Structs = append(rootOut.Structs, elem)
6✔
105
                        proc.collectExportsStruct(elem, oldPath, newPath)
6✔
106
                }
6✔
107
        }
108
        for _, elem := range src.Traits {
10✔
109
                if _, ok := toCrawl[elem.Name]; ok {
2✔
110
                        rootOut.Traits = append(rootOut.Traits, elem)
×
111
                        proc.collectExportsTrait(elem, oldPath, newPath)
×
112
                }
×
113
        }
114
        for _, elem := range src.Functions {
10✔
115
                if _, ok := toCrawl[elem.Name]; ok {
4✔
116
                        rootOut.Functions = append(rootOut.Functions, elem)
2✔
117
                        proc.collectExportsFunction(elem, oldPath, newPath)
2✔
118
                }
2✔
119
        }
120
}
121

122
func (proc *Processor) collectExportsStruct(s *Struct, oldPath []string, newPath []string) {
6✔
123
        oldPath = AppendNew(oldPath, s.Name)
6✔
124
        newPath = AppendNew(newPath, s.Name)
6✔
125

6✔
126
        proc.addLinkExport(oldPath, newPath)
6✔
127

6✔
128
        for _, elem := range s.Parameters {
6✔
129
                oldPath := AppendNew(oldPath, elem.Name)
×
130
                newPath := AppendNew(newPath, elem.Name)
×
131
                proc.addLinkExport(oldPath, newPath)
×
132
        }
×
133
        for _, elem := range s.Fields {
6✔
134
                oldPath := AppendNew(oldPath, elem.Name)
×
135
                newPath := AppendNew(newPath, elem.Name)
×
136
                proc.addLinkExport(oldPath, newPath)
×
137
        }
×
138
        for _, elem := range s.Functions {
6✔
139
                oldPath := AppendNew(oldPath, elem.Name)
×
140
                newPath := AppendNew(newPath, elem.Name)
×
141
                proc.addLinkExport(oldPath, newPath)
×
142
        }
×
143
}
144

145
func (proc *Processor) collectExportsTrait(s *Trait, oldPath []string, newPath []string) {
×
146
        oldPath = AppendNew(oldPath, s.Name)
×
147
        newPath = AppendNew(newPath, s.Name)
×
148

×
149
        proc.addLinkExport(oldPath, newPath)
×
150

×
151
        for _, elem := range s.Fields {
×
152
                oldPath := AppendNew(oldPath, elem.Name)
×
153
                newPath := AppendNew(newPath, elem.Name)
×
154
                proc.addLinkExport(oldPath, newPath)
×
155
        }
×
156
        for _, elem := range s.Functions {
×
157
                oldPath := AppendNew(oldPath, elem.Name)
×
158
                newPath := AppendNew(newPath, elem.Name)
×
159
                proc.addLinkExport(oldPath, newPath)
×
160
        }
×
161
}
162

163
func (proc *Processor) collectExportsFunction(s *Function, oldPath []string, newPath []string) {
2✔
164
        oldPath = AppendNew(oldPath, s.Name)
2✔
165
        newPath = AppendNew(newPath, s.Name)
2✔
166

2✔
167
        proc.addLinkExport(oldPath, newPath)
2✔
168
}
2✔
169

170
type members struct {
171
        Members []member
172
}
173

174
type member struct {
175
        Include bool
176
        RelPath []string
177
}
178

179
func collectExportMembers(parentMember *members) (selfIncluded bool, toCrawl map[string]*members) {
10✔
180
        selfIncluded = false
10✔
181
        toCrawl = map[string]*members{}
10✔
182

10✔
183
        for _, mem := range parentMember.Members {
28✔
184
                if mem.Include {
24✔
185
                        selfIncluded = true
6✔
186
                        continue
6✔
187
                }
188
                var newMember member
12✔
189
                if len(mem.RelPath) == 1 {
22✔
190
                        newMember = member{Include: true}
10✔
191
                } else {
12✔
192
                        newMember = member{RelPath: mem.RelPath[1:]}
2✔
193
                }
2✔
194
                if members, ok := toCrawl[mem.RelPath[0]]; ok {
14✔
195
                        members.Members = append(members.Members, newMember)
2✔
196
                        continue
2✔
197
                }
198
                toCrawl[mem.RelPath[0]] = &members{Members: []member{newMember}}
10✔
199
        }
200

201
        return
10✔
202
}
203

204
func collectExportsPackage(p *Package, out map[string]*members) {
4✔
205
        for _, ex := range p.Exports {
18✔
206
                var newMember member
14✔
207
                if len(ex.Short) == 1 {
18✔
208
                        newMember = member{Include: true}
4✔
209
                } else {
14✔
210
                        newMember = member{RelPath: ex.Short[1:]}
10✔
211
                }
10✔
212
                if members, ok := out[ex.Short[0]]; ok {
20✔
213
                        members.Members = append(members.Members, newMember)
6✔
214
                        continue
6✔
215
                }
216
                out[ex.Short[0]] = &members{Members: []member{newMember}}
8✔
217
        }
218
}
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