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

mlange-42 / modo / 12820506968

17 Jan 2025 12:58AM CUT coverage: 36.563%. Remained the same
12820506968

push

github

web-flow
Add missed Mojo๐Ÿ”ฅ emoji (#52)

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