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

mlange-42 / modo / 13167566672

05 Feb 2025 10:14PM CUT coverage: 72.072% (-0.6%) from 72.707%
13167566672

Pull #208

github

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

142 of 194 new or added lines in 4 files covered. (73.2%)

25 existing lines in 1 file now uncovered.

1729 of 2399 relevant lines covered (72.07%)

26.86 hits per line

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

61.34
/internal/document/transclude.go
1
package document
2

3
import (
4
        "fmt"
5
        "strings"
6
)
7

8
func (proc *Processor) processTranscludes(docs *Docs) error {
6✔
9
        return proc.replaceTranscludesPackage(docs.Decl, []string{})
6✔
10
}
6✔
11

12
func (proc *Processor) replaceTranscludesPackage(p *Package, elems []string) error {
8✔
13
        newElems := appendNew(elems, p.Name)
8✔
14
        for _, pkg := range p.Packages {
10✔
15
                if err := proc.replaceTranscludesPackage(pkg, newElems); err != nil {
2✔
NEW
16
                        return err
×
NEW
17
                }
×
18
        }
19
        for _, mod := range p.Modules {
19✔
20
                if err := proc.replaceTranscludesModule(mod, newElems); err != nil {
11✔
NEW
21
                        return err
×
NEW
22
                }
×
23
        }
24
        return nil
8✔
25
}
26

27
func (proc *Processor) replaceTranscludesModule(m *Module, elems []string) error {
11✔
28
        newElems := appendNew(elems, m.Name)
11✔
29
        for _, s := range m.Structs {
20✔
30
                structElems := appendNew(newElems, s.Name)
9✔
31
                for _, f := range s.Functions {
18✔
32
                        if len(f.Overloads) == 0 {
9✔
NEW
33
                                if err := proc.replaceTranscludes(f, structElems, len(newElems)); err != nil {
×
NEW
34
                                        return err
×
NEW
35
                                }
×
36
                        } else {
9✔
37
                                for _, o := range f.Overloads {
18✔
38
                                        if err := proc.replaceTranscludes(o, structElems, len(newElems)); err != nil {
9✔
NEW
39
                                                return err
×
NEW
40
                                        }
×
41
                                }
42
                        }
43
                }
44

45
        }
46
        return nil
11✔
47
}
48

49
func (proc *Processor) replaceTranscludes(elem *Function, elems []string, modElems int) error {
9✔
50
        indices, err := findLinks(elem.Summary, transcludeRegex)
9✔
51
        if err != nil {
9✔
NEW
52
                return err
×
NEW
53
        }
×
54
        if len(indices) == 0 {
16✔
55
                return nil
7✔
56
        }
7✔
57
        if len(indices) > 2 {
2✔
NEW
58
                return fmt.Errorf("multiple doc transclusions in %s", strings.Join(elems, "."))
×
NEW
59
        }
×
60
        start, end := indices[0], indices[1]
2✔
61
        link := elem.Summary[start+1 : end-1]
2✔
62

2✔
63
        content, ok, err := proc.refToPlaceholder(link, elems, modElems, false)
2✔
64
        if err != nil {
2✔
NEW
65
                return err
×
NEW
66
        }
×
67
        if !ok {
2✔
NEW
68
                return nil
×
NEW
69
        }
×
70

71
        from, ok := proc.allPaths[content]
2✔
72
        if !ok {
2✔
NEW
73
                return fmt.Errorf("doc transclusions source %s (%s) in %s not found", link, content, strings.Join(elems, "."))
×
NEW
74
        }
×
75
        trait, ok := from.(*Trait)
2✔
76
        if !ok {
2✔
NEW
77
                return fmt.Errorf("doc transclusions source %s (%s) in %s is not a trait", link, content, strings.Join(elems, "."))
×
NEW
78
        }
×
79

80
        sourceFunc, ok := findImplementedFunction(elem, trait)
2✔
81
        if !ok {
2✔
NEW
82
                return fmt.Errorf("no matching doc transclusion found for %s.%s in %s. Required signature: %s", link, elem.Name, strings.Join(elems, "."), elem.Signature)
×
NEW
83
        }
×
84

85
        elem.MemberSummary = sourceFunc.MemberSummary
2✔
86
        elem.Description = sourceFunc.Description
2✔
87
        elem.ReturnsDoc = sourceFunc.ReturnsDoc
2✔
88
        elem.RaisesDoc = sourceFunc.RaisesDoc
2✔
89

2✔
90
        for i, arg := range sourceFunc.Args {
6✔
91
                elem.Args[i].Description = arg.Description
4✔
92
        }
4✔
93
        for i, par := range sourceFunc.Parameters {
2✔
NEW
94
                elem.Parameters[i].Description = par.Description
×
NEW
95
        }
×
96

97
        return nil
2✔
98
}
99

100
func findImplementedFunction(structFunc *Function, trait *Trait) (*Function, bool) {
2✔
101
        var sourceFunc *Function
2✔
102
        for _, f := range trait.Functions {
6✔
103
                if f.Name != structFunc.Name {
6✔
104
                        continue
2✔
105
                }
106
                if len(f.Overloads) == 0 {
2✔
NEW
107
                        if functionsMatch(structFunc, f) {
×
NEW
108
                                sourceFunc = f
×
NEW
109
                        }
×
NEW
110
                        break
×
111
                }
112
                for _, o := range f.Overloads {
4✔
113
                        if functionsMatch(structFunc, o) {
4✔
114
                                sourceFunc = o
2✔
115
                        }
2✔
116
                        break
2✔
117
                }
118
                break
2✔
119
        }
120
        return sourceFunc, sourceFunc != nil
2✔
121
}
122

123
func functionsMatch(s, t *Function) bool {
2✔
124
        if len(s.Args) != len(t.Args) {
2✔
NEW
125
                return false
×
NEW
126
        }
×
127
        if len(s.Parameters) != len(t.Parameters) {
2✔
NEW
128
                return false
×
NEW
129
        }
×
130

131
        for i := range s.Args {
6✔
132
                argS, argT := s.Args[i], t.Args[i]
4✔
133
                if argS.Type != argT.Type {
6✔
134
                        if !(argS.Type == "Self" && argT.Type == "_Self") {
2✔
NEW
135
                                return false
×
NEW
136
                        }
×
137
                }
138
                if argS.PassingKind != argT.PassingKind {
4✔
NEW
139
                        return false
×
NEW
140
                }
×
141
                if argS.Convention != argT.Convention {
4✔
NEW
142
                        return false
×
NEW
143
                }
×
144
        }
145

146
        for i := range s.Parameters {
2✔
NEW
147
                parS, parT := s.Parameters[i], t.Parameters[i]
×
NEW
148
                if parS.Type != parT.Type {
×
NEW
149
                        return false
×
NEW
150
                }
×
NEW
151
                if parS.PassingKind != parT.PassingKind {
×
NEW
152
                        return false
×
NEW
153
                }
×
154
        }
155

156
        return true
2✔
157
}
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