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

mlange-42 / modo / 13167602008

05 Feb 2025 10:17PM CUT coverage: 72.06% (-0.6%) from 72.707%
13167602008

Pull #208

github

web-flow
Merge 72ae975c1 into c98120bba
Pull Request #208: Inheritance for method docs from parent trait

141 of 193 new or added lines in 4 files covered. (73.06%)

25 existing lines in 1 file now uncovered.

1728 of 2398 relevant lines covered (72.06%)

26.87 hits per line

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

98.18
/internal/document/paths.go
1
package document
2

3
import (
4
        "strings"
5
)
6

7
type elemPath struct {
8
        Elements  []string
9
        Kind      string
10
        IsSection bool
11
}
12

13
type addPathFunc = func(Named, []string, []string, string, bool)
14

15
// Collects lookup for link target paths.
16
// Runs on the re-structured package.
17
func (proc *Processor) collectPaths() {
7✔
18
        proc.linkTargets = map[string]elemPath{}
7✔
19
        proc.collectPathsPackage(proc.ExportDocs.Decl, []string{}, []string{}, proc.addLinkTarget, false)
7✔
20
}
7✔
21

22
// Collects the paths of all (sub)-elements in the original structure.
23
func (proc *Processor) collectElementPaths() {
8✔
24
        proc.allPaths = map[string]Named{}
8✔
25
        proc.collectPathsPackage(proc.Docs.Decl, []string{}, []string{}, proc.addElementPath, true)
8✔
26
}
8✔
27

28
func (proc *Processor) collectPathsPackage(p *Package, elems []string, pathElem []string, add addPathFunc, isOriginal bool) {
22✔
29
        newElems := appendNew(elems, p.GetName())
22✔
30
        newPath := appendNew(pathElem, p.GetFileName())
22✔
31
        if isOriginal {
34✔
32
                p.SetLink(newElems, p.Kind)
12✔
33
        }
12✔
34
        add(p, newElems, newPath, "package", false)
22✔
35

22✔
36
        for _, pkg := range p.Packages {
29✔
37
                proc.collectPathsPackage(pkg, newElems, newPath, add, isOriginal)
7✔
38
        }
7✔
39
        for _, mod := range p.Modules {
48✔
40
                proc.collectPathsModule(mod, newElems, newPath, add, isOriginal)
26✔
41
        }
26✔
42

43
        for _, e := range p.Structs {
25✔
44
                proc.collectPathsStruct(e, newElems, newPath, add, isOriginal)
3✔
45
        }
3✔
46

47
        for _, e := range p.Traits {
24✔
48
                proc.collectPathsTrait(e, newElems, newPath, add, isOriginal)
2✔
49
        }
2✔
50
        for _, e := range p.Aliases {
26✔
51
                newElems := appendNew(newElems, e.GetName())
4✔
52
                newPath := appendNew(newPath, "#aliases")
4✔
53
                add(e, newElems, newPath, "package", true) // kind=package for correct link paths
4✔
54
        }
4✔
55
        for _, e := range p.Functions {
24✔
56
                if isOriginal {
2✔
NEW
57
                        e.SetLink(newElems, e.Kind)
×
58
                }
×
59
                newElems := appendNew(newElems, e.GetName())
2✔
60
                newPath := appendNew(newPath, e.GetFileName())
2✔
61
                add(e, newElems, newPath, "function", false)
2✔
62
        }
63
}
64

65
func (proc *Processor) collectPathsModule(m *Module, elems []string, pathElem []string, add addPathFunc, isOriginal bool) {
26✔
66
        newElems := appendNew(elems, m.GetName())
26✔
67
        newPath := appendNew(pathElem, m.GetFileName())
26✔
68
        m.SetLink(newElems, m.Kind)
26✔
69
        add(m, newElems, newPath, "module", false)
26✔
70

26✔
71
        for _, e := range m.Structs {
50✔
72
                proc.collectPathsStruct(e, newElems, newPath, add, isOriginal)
24✔
73
        }
24✔
74
        for _, e := range m.Traits {
35✔
75
                proc.collectPathsTrait(e, newElems, newPath, add, isOriginal)
9✔
76
        }
9✔
77
        for _, e := range m.Aliases {
38✔
78
                newElems := appendNew(newElems, e.GetName())
12✔
79
                newPath := appendNew(newPath, "#aliases")
12✔
80
                add(e, newElems, newPath, "module", true) // kind=module for correct link paths
12✔
81
        }
12✔
82
        for _, f := range m.Functions {
35✔
83
                if isOriginal {
15✔
84
                        f.SetLink(newElems, f.Kind)
6✔
85
                }
6✔
86
                newElems := appendNew(newElems, f.GetName())
9✔
87
                newPath := appendNew(newPath, f.GetFileName())
9✔
88
                add(f, newElems, newPath, "function", false)
9✔
89
        }
90
}
91

92
func (proc *Processor) collectPathsStruct(s *Struct, elems []string, pathElem []string, add addPathFunc, isOriginal bool) {
27✔
93
        newElems := appendNew(elems, s.GetName())
27✔
94
        newPath := appendNew(pathElem, s.GetFileName())
27✔
95
        if isOriginal {
44✔
96
                s.SetLink(elems, s.Kind)
17✔
97
        }
17✔
98
        add(s, newElems, newPath, "struct", false)
27✔
99

27✔
100
        for _, e := range s.Aliases {
41✔
101
                newElems := appendNew(newElems, e.GetName())
14✔
102
                newPath := appendNew(newPath, "#aliases")
14✔
103
                add(e, newElems, newPath, "member", true)
14✔
104
        }
14✔
105
        for _, e := range s.Parameters {
38✔
106
                newElems := appendNew(newElems, e.GetName())
11✔
107
                newPath := appendNew(newPath, "#parameters")
11✔
108
                add(e, newElems, newPath, "member", true)
11✔
109
        }
11✔
110
        for _, e := range s.Fields {
40✔
111
                newElems := appendNew(newElems, e.GetName())
13✔
112
                newPath := appendNew(newPath, "#fields")
13✔
113
                add(e, newElems, newPath, "member", true)
13✔
114
        }
13✔
115
        for _, e := range s.Functions {
46✔
116
                newElems := appendNew(newElems, e.GetName())
19✔
117
                newPath := appendNew(newPath, "#"+strings.ToLower(e.GetName()))
19✔
118
                add(e, newElems, newPath, "member", true)
19✔
119
        }
19✔
120
}
121

122
func (proc *Processor) collectPathsTrait(t *Trait, elems []string, pathElem []string, add addPathFunc, isOriginal bool) {
11✔
123
        newElems := appendNew(elems, t.GetName())
11✔
124
        newPath := appendNew(pathElem, t.GetFileName())
11✔
125
        if isOriginal {
17✔
126
                t.SetLink(elems, t.Kind)
6✔
127
        }
6✔
128
        add(t, newElems, newPath, "trait", false)
11✔
129

11✔
130
        for _, e := range t.Fields {
14✔
131
                newElems := appendNew(newElems, e.GetName())
3✔
132
                newPath := appendNew(newPath, "#fields")
3✔
133
                add(e, newElems, newPath, "member", true)
3✔
134
        }
3✔
135
        for _, e := range t.Functions {
22✔
136
                newElems := appendNew(newElems, e.GetName())
11✔
137
                newPath := appendNew(newPath, "#"+strings.ToLower(e.GetName()))
11✔
138
                add(e, newElems, newPath, "member", true)
11✔
139
        }
11✔
140
}
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