14906409570

Committed 08 May 2025 12:25PM CUT coverage: 73.859% (-0.3%) from 74.172%

Build # 14906409570

Build Type

Pull #235

github

Committed by

web-flow

Commit Message

Merge 8cdafcb4d into ff24fc512

Pull Request Pull Request #235: Add support for aliases in traits

Run Details

4 of 19 new or added lines in 4 files covered. (21.05%)

2379 of 3221 relevant lines covered (73.86%)

48.03 hits per line

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

48.85

/internal/document/walk_docs.go

package document

type walkFunc = func(text string, elems []string, modElems int) (string, error)
type nameFunc = func(elem Named) string

type walker struct {
        Func     walkFunc
        NameFunc nameFunc
}

func (w *walker) walkAllDocStrings(docs *Docs) error {
        return w.walkAllDocStringsPackage(docs.Decl, []string{})
}

func (w *walker) walkAllDocStringsPackage(p *Package, elems []string) error {
        newElems := appendNew(elems, w.NameFunc(p))

        var err error
        if p.Summary, err = w.Func(p.Summary, newElems, len(newElems)); err != nil {
                return err
        }
        if p.Description, err = w.Func(p.Description, newElems, len(newElems)); err != nil {
                return err
        }

        for _, pkg := range p.Packages {
                if err := w.walkAllDocStringsPackage(pkg, newElems); err != nil {
                        return err
                }
        }
        for _, mod := range p.Modules {
                if err := w.walkAllDocStringsModule(mod, newElems); err != nil {
                        return err
                }
        }

        for _, a := range p.Aliases {
                if err := w.walkAllDocStringsModuleAlias(a, newElems); err != nil {
                        return err
                }
        }
        for _, f := range p.Functions {
                if err := w.walkAllDocStringsFunction(f, newElems); err != nil {
                        return err
                }
        }
        for _, s := range p.Structs {
                if err := w.walkAllDocStringsStruct(s, newElems); err != nil {
                        return err
                }
        }
        for _, tr := range p.Traits {
                if err := w.walkAllDocStringsTrait(tr, newElems); err != nil {
                        return err
                }
        }
        return nil
}

func (w *walker) walkAllDocStringsModule(m *Module, elems []string) error {
        newElems := appendNew(elems, w.NameFunc(m))

        var err error
        if m.Summary, err = w.Func(m.Summary, newElems, len(newElems)); err != nil {
                return err
        }
        if m.Description, err = w.Func(m.Description, newElems, len(newElems)); err != nil {
                return err
        }

        for _, a := range m.Aliases {
                if err := w.walkAllDocStringsModuleAlias(a, newElems); err != nil {
                        return err
                }
        }
        for _, f := range m.Functions {
                if err := w.walkAllDocStringsFunction(f, newElems); err != nil {
                        return err
                }
        }
        for _, s := range m.Structs {
                if err := w.walkAllDocStringsStruct(s, newElems); err != nil {
                        return err
                }
        }
        for _, tr := range m.Traits {
                if err := w.walkAllDocStringsTrait(tr, newElems); err != nil {
                        return err
                }
        }
        return nil
}

func (w *walker) walkAllDocStringsStruct(s *Struct, elems []string) error {
        newElems := appendNew(elems, w.NameFunc(s))

        var err error
        if s.Summary, err = w.Func(s.Summary, newElems, len(elems)); err != nil {
                return err
        }
        if s.Description, err = w.Func(s.Description, newElems, len(elems)); err != nil {
                return err
        }
        if s.Deprecated, err = w.Func(s.Deprecated, newElems, len(elems)); err != nil {
                return err
        }

        for _, a := range s.Aliases {
                if a.Summary, err = w.Func(a.Summary, newElems, len(elems)); err != nil {
                        return err
                }
                if a.Description, err = w.Func(a.Description, newElems, len(elems)); err != nil {
                        return err
                }
                if a.Deprecated, err = w.Func(a.Deprecated, newElems, len(elems)); err != nil {
                        return err
                }
        }
        for _, p := range s.Parameters {
                if p.Description, err = w.Func(p.Description, newElems, len(elems)); err != nil {
                        return err
                }
        }
        for _, f := range s.Fields {
                if f.Summary, err = w.Func(f.Summary, newElems, len(elems)); err != nil {
                        return err
                }
                if f.Description, err = w.Func(f.Description, newElems, len(elems)); err != nil {
                        return err
                }
        }
        for _, f := range s.Functions {
                if err := w.walkAllDocStringsMethod(f, newElems); err != nil {
                        return err
                }
        }

        return nil
}

func (w *walker) walkAllDocStringsTrait(tr *Trait, elems []string) error {
        newElems := appendNew(elems, w.NameFunc(tr))

        var err error
        if tr.Summary, err = w.Func(tr.Summary, newElems, len(elems)); err != nil {
                return err
        }
        if tr.Description, err = w.Func(tr.Description, newElems, len(elems)); err != nil {
                return err
        }
        if tr.Deprecated, err = w.Func(tr.Deprecated, newElems, len(elems)); err != nil {
                return err
        }

        for _, a := range tr.Aliases {
                if a.Summary, err = w.Func(a.Summary, newElems, len(elems)); err != nil {
                        return err
                }
                if a.Description, err = w.Func(a.Description, newElems, len(elems)); err != nil {
                        return err
                }
                if a.Deprecated, err = w.Func(a.Deprecated, newElems, len(elems)); err != nil {
                        return err
                }
        }
        // TODO: add when traits support parameters
        /*for _, p := range tr.Parameters {
                p.Description, err = replaceLinks(p.Description, newElems, len(elems), lookup, t)
                if err != nil {
                        return err
                }
        }*/
        for _, f := range tr.Fields {
                if f.Summary, err = w.Func(f.Summary, newElems, len(elems)); err != nil {
                        return err
                }
                if f.Description, err = w.Func(f.Description, newElems, len(elems)); err != nil {
                        return err
                }
        }
        for _, f := range tr.Functions {
                if err := w.walkAllDocStringsMethod(f, newElems); err != nil {
                        return err
                }
        }

        return nil
}

func (w *walker) walkAllDocStringsFunction(f *Function, elems []string) error {
        newElems := appendNew(elems, w.NameFunc(f))

        var err error
        if f.Summary, err = w.Func(f.Summary, newElems, len(elems)); err != nil {
                return err
        }
        if f.Description, err = w.Func(f.Description, newElems, len(elems)); err != nil {
                return err
        }
        if f.Deprecated, err = w.Func(f.Deprecated, newElems, len(elems)); err != nil {
                return err
        }
        if f.ReturnsDoc, err = w.Func(f.ReturnsDoc, newElems, len(elems)); err != nil {
                return err
        }
        if f.RaisesDoc, err = w.Func(f.RaisesDoc, newElems, len(elems)); err != nil {
                return err
        }

        for _, a := range f.Args {
                if a.Description, err = w.Func(a.Description, newElems, len(elems)); err != nil {
                        return err
                }
        }
        for _, p := range f.Parameters {
                if p.Description, err = w.Func(p.Description, newElems, len(elems)); err != nil {
                        return err
                }
        }

        for _, o := range f.Overloads {
                err := w.walkAllDocStringsFunction(o, elems)
                if err != nil {
                        return err
                }
        }

        return nil
}

func (w *walker) walkAllDocStringsModuleAlias(a *Alias, elems []string) error {
        newElems := appendNew(elems, w.NameFunc(a))

        var err error
        if a.Summary, err = w.Func(a.Summary, newElems, len(elems)); err != nil {
                return err
        }
        if a.Description, err = w.Func(a.Description, newElems, len(elems)); err != nil {
                return err
        }
        if a.Deprecated, err = w.Func(a.Deprecated, newElems, len(elems)); err != nil {
                return err
        }
        return nil
}

func (w *walker) walkAllDocStringsMethod(f *Function, elems []string) error {
        var err error
        if f.Summary, err = w.Func(f.Summary, elems, len(elems)-1); err != nil {
                return err
        }
        if f.Description, err = w.Func(f.Description, elems, len(elems)-1); err != nil {
                return err
        }
        if f.Deprecated, err = w.Func(f.Deprecated, elems, len(elems)-1); err != nil {
                return err
        }
        if f.ReturnsDoc, err = w.Func(f.ReturnsDoc, elems, len(elems)-1); err != nil {
                return err
        }
        if f.RaisesDoc, err = w.Func(f.RaisesDoc, elems, len(elems)-1); err != nil {
                return err
        }

        for _, a := range f.Args {
                if a.Description, err = w.Func(a.Description, elems, len(elems)-1); err != nil {
                        return err
                }
        }
        for _, p := range f.Parameters {
                if p.Description, err = w.Func(p.Description, elems, len(elems)-1); err != nil {
                        return err
                }
        }

        for _, o := range f.Overloads {
                err := w.walkAllDocStringsMethod(o, elems)
                if err != nil {
                        return err
                }
        }

        return nil
}

1	package document
2
3	type walkFunc = func(text string, elems []string, modElems int) (string, error)
4	type nameFunc = func(elem Named) string
5
6	type walker struct {
7	Func walkFunc
8	NameFunc nameFunc
9	}
10
11	func (w walker) walkAllDocStrings(docs Docs) error {	19✔
12	return w.walkAllDocStringsPackage(docs.Decl, []string{})	19✔
13	}	19✔
14
15	func (w walker) walkAllDocStringsPackage(p Package, elems []string) error {	30✔
16	newElems := appendNew(elems, w.NameFunc(p))	30✔
17		30✔
18	var err error	30✔
19	if p.Summary, err = w.Func(p.Summary, newElems, len(newElems)); err != nil {	30✔
20	return err	×
21	}	×
22	if p.Description, err = w.Func(p.Description, newElems, len(newElems)); err != nil {	30✔
23	return err	×
24	}	×
25
26	for _, pkg := range p.Packages {	41✔
27	if err := w.walkAllDocStringsPackage(pkg, newElems); err != nil {	11✔
28	return err	×
29	}	×
30	}
31	for _, mod := range p.Modules {	73✔
32	if err := w.walkAllDocStringsModule(mod, newElems); err != nil {	43✔
33	return err	×
34	}	×
35	}
36
37	for _, a := range p.Aliases {	30✔
38	if err := w.walkAllDocStringsModuleAlias(a, newElems); err != nil {	×
39	return err	×
40	}	×
41	}
42	for _, f := range p.Functions {	30✔
43	if err := w.walkAllDocStringsFunction(f, newElems); err != nil {	×
44	return err	×
45	}	×
46	}
47	for _, s := range p.Structs {	30✔
48	if err := w.walkAllDocStringsStruct(s, newElems); err != nil {	×
49	return err	×
50	}	×
51	}
52	for _, tr := range p.Traits {	30✔
53	if err := w.walkAllDocStringsTrait(tr, newElems); err != nil {	×
54	return err	×
55	}	×
56	}
57	return nil	30✔
58	}
59
60	func (w walker) walkAllDocStringsModule(m Module, elems []string) error {	43✔
61	newElems := appendNew(elems, w.NameFunc(m))	43✔
62		43✔
63	var err error	43✔
64	if m.Summary, err = w.Func(m.Summary, newElems, len(newElems)); err != nil {	43✔
65	return err	×
66	}	×
67	if m.Description, err = w.Func(m.Description, newElems, len(newElems)); err != nil {	43✔
68	return err	×
69	}	×
70
71	for _, a := range m.Aliases {	78✔
72	if err := w.walkAllDocStringsModuleAlias(a, newElems); err != nil {	35✔
73	return err	×
74	}	×
75	}
76	for _, f := range m.Functions {	58✔
77	if err := w.walkAllDocStringsFunction(f, newElems); err != nil {	15✔
78	return err	×
79	}	×
80	}
81	for _, s := range m.Structs {	82✔
82	if err := w.walkAllDocStringsStruct(s, newElems); err != nil {	39✔
83	return err	×
84	}	×
85	}
86	for _, tr := range m.Traits {	58✔
87	if err := w.walkAllDocStringsTrait(tr, newElems); err != nil {	15✔
88	return err	×
89	}	×
90	}
91	return nil	43✔
92	}
93
94	func (w walker) walkAllDocStringsStruct(s Struct, elems []string) error {	39✔
95	newElems := appendNew(elems, w.NameFunc(s))	39✔
96		39✔
97	var err error	39✔
98	if s.Summary, err = w.Func(s.Summary, newElems, len(elems)); err != nil {	39✔
99	return err	×
100	}	×
101	if s.Description, err = w.Func(s.Description, newElems, len(elems)); err != nil {	39✔
102	return err	×
103	}	×
104	if s.Deprecated, err = w.Func(s.Deprecated, newElems, len(elems)); err != nil {	39✔
105	return err	×
106	}	×
107
108	for _, a := range s.Aliases {	74✔
109	if a.Summary, err = w.Func(a.Summary, newElems, len(elems)); err != nil {	35✔
110	return err	×
111	}	×
112	if a.Description, err = w.Func(a.Description, newElems, len(elems)); err != nil {	35✔
113	return err	×
114	}	×
115	if a.Deprecated, err = w.Func(a.Deprecated, newElems, len(elems)); err != nil {	35✔
116	return err	×
117	}	×
118	}
119	for _, p := range s.Parameters {	63✔
120	if p.Description, err = w.Func(p.Description, newElems, len(elems)); err != nil {	24✔
121	return err	×
122	}	×
123	}
124	for _, f := range s.Fields {	65✔
125	if f.Summary, err = w.Func(f.Summary, newElems, len(elems)); err != nil {	26✔
126	return err	×
127	}	×
128	if f.Description, err = w.Func(f.Description, newElems, len(elems)); err != nil {	26✔
129	return err	×
130	}	×
131	}
132	for _, f := range s.Functions {	85✔
133	if err := w.walkAllDocStringsMethod(f, newElems); err != nil {	46✔
134	return err	×
135	}	×
136	}
137
138	return nil	39✔
139	}
140
141	func (w walker) walkAllDocStringsTrait(tr Trait, elems []string) error {	15✔
142	newElems := appendNew(elems, w.NameFunc(tr))	15✔
143		15✔
144	var err error	15✔
145	if tr.Summary, err = w.Func(tr.Summary, newElems, len(elems)); err != nil {	15✔
146	return err	×
147	}	×
148	if tr.Description, err = w.Func(tr.Description, newElems, len(elems)); err != nil {	15✔
149	return err	×
150	}	×
151	if tr.Deprecated, err = w.Func(tr.Deprecated, newElems, len(elems)); err != nil {	15✔
152	return err	×
153	}	×
154
155	for _, a := range tr.Aliases {	15✔
NEW 156	if a.Summary, err = w.Func(a.Summary, newElems, len(elems)); err != nil {	×
NEW 157	return err	×
NEW 158	}	×
NEW 159	if a.Description, err = w.Func(a.Description, newElems, len(elems)); err != nil {	×
NEW 160	return err	×
NEW 161	}	×
NEW 162	if a.Deprecated, err = w.Func(a.Deprecated, newElems, len(elems)); err != nil {	×
NEW 163	return err	×
NEW 164	}	×
165	}
166	// TODO: add when traits support parameters
167	/*for _, p := range tr.Parameters {
168	p.Description, err = replaceLinks(p.Description, newElems, len(elems), lookup, t)
169	if err != nil {
170	return err
171	}
172	}*/
173	for _, f := range tr.Fields {	17✔
174	if f.Summary, err = w.Func(f.Summary, newElems, len(elems)); err != nil {	2✔
175	return err	×
176	}	×
177	if f.Description, err = w.Func(f.Description, newElems, len(elems)); err != nil {	2✔
178	return err	×
179	}	×
180	}
181	for _, f := range tr.Functions {	39✔
182	if err := w.walkAllDocStringsMethod(f, newElems); err != nil {	24✔
183	return err	×
184	}	×
185	}
186
187	return nil	15✔
188	}
189
190	func (w walker) walkAllDocStringsFunction(f Function, elems []string) error {	30✔
191	newElems := appendNew(elems, w.NameFunc(f))	30✔
192		30✔
193	var err error	30✔
194	if f.Summary, err = w.Func(f.Summary, newElems, len(elems)); err != nil {	30✔
195	return err	×
196	}	×
197	if f.Description, err = w.Func(f.Description, newElems, len(elems)); err != nil {	30✔
198	return err	×
199	}	×
200	if f.Deprecated, err = w.Func(f.Deprecated, newElems, len(elems)); err != nil {	30✔
201	return err	×
202	}	×
203	if f.ReturnsDoc, err = w.Func(f.ReturnsDoc, newElems, len(elems)); err != nil {	30✔
204	return err	×
205	}	×
206	if f.RaisesDoc, err = w.Func(f.RaisesDoc, newElems, len(elems)); err != nil {	30✔
207	return err	×
208	}	×
209
210	for _, a := range f.Args {	43✔
211	if a.Description, err = w.Func(a.Description, newElems, len(elems)); err != nil {	13✔
212	return err	×
213	}	×
214	}
215	for _, p := range f.Parameters {	43✔
216	if p.Description, err = w.Func(p.Description, newElems, len(elems)); err != nil {	13✔
217	return err	×
218	}	×
219	}
220
221	for _, o := range f.Overloads {	45✔
222	err := w.walkAllDocStringsFunction(o, elems)	15✔
223	if err != nil {	15✔
224	return err	×
225	}	×
226	}
227
228	return nil	30✔
229	}
230
231	func (w walker) walkAllDocStringsModuleAlias(a Alias, elems []string) error {	35✔
232	newElems := appendNew(elems, w.NameFunc(a))	35✔
233		35✔
234	var err error	35✔
235	if a.Summary, err = w.Func(a.Summary, newElems, len(elems)); err != nil {	35✔
236	return err	×
237	}	×
238	if a.Description, err = w.Func(a.Description, newElems, len(elems)); err != nil {	35✔
239	return err	×
240	}	×
241	if a.Deprecated, err = w.Func(a.Deprecated, newElems, len(elems)); err != nil {	35✔
242	return err	×
243	}	×
244	return nil	35✔
245	}
246
247	func (w walker) walkAllDocStringsMethod(f Function, elems []string) error {	140✔
248	var err error	140✔
249	if f.Summary, err = w.Func(f.Summary, elems, len(elems)-1); err != nil {	140✔
250	return err	×
251	}	×
252	if f.Description, err = w.Func(f.Description, elems, len(elems)-1); err != nil {	140✔
253	return err	×
254	}	×
255	if f.Deprecated, err = w.Func(f.Deprecated, elems, len(elems)-1); err != nil {	140✔
256	return err	×
257	}	×
258	if f.ReturnsDoc, err = w.Func(f.ReturnsDoc, elems, len(elems)-1); err != nil {	140✔
259	return err	×
260	}	×
261	if f.RaisesDoc, err = w.Func(f.RaisesDoc, elems, len(elems)-1); err != nil {	140✔
262	return err	×
263	}	×
264
265	for _, a := range f.Args {	265✔
266	if a.Description, err = w.Func(a.Description, elems, len(elems)-1); err != nil {	125✔
267	return err	×
268	}	×
269	}
270	for _, p := range f.Parameters {	166✔
271	if p.Description, err = w.Func(p.Description, elems, len(elems)-1); err != nil {	26✔
272	return err	×
273	}	×
274	}
275
276	for _, o := range f.Overloads {	210✔
277	err := w.walkAllDocStringsMethod(o, elems)	70✔
278	if err != nil {	70✔
279	return err	×
280	}	×
281	}
282
283	return nil	140✔
284	}

mlange-42 / modo / 14906409570

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

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