13315440196

Committed 13 Feb 2025 07:21PM CUT coverage: 74.172%. Remained the same

Build # 13315440196

Build Type

Pull #224

github

Committed by

web-flow

Commit Message

Merge 13e86a91b into d78619902

Pull Request Pull Request #224: Add ExtraMojo to README, bump to dev version

Run Details

2375 of 3202 relevant lines covered (74.17%)

48.18 hits per line

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

50.72

/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
        }

        // 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	// TODO: add when traits support parameters
156	/*for _, p := range tr.Parameters {
157	p.Description, err = replaceLinks(p.Description, newElems, len(elems), lookup, t)
158	if err != nil {
159	return err
160	}
161	}*/
162	for _, f := range tr.Fields {	17✔
163	if f.Summary, err = w.Func(f.Summary, newElems, len(elems)); err != nil {	2✔
164	return err	×
165	}	×
166	if f.Description, err = w.Func(f.Description, newElems, len(elems)); err != nil {	2✔
167	return err	×
168	}	×
169	}
170	for _, f := range tr.Functions {	39✔
171	if err := w.walkAllDocStringsMethod(f, newElems); err != nil {	24✔
172	return err	×
173	}	×
174	}
175
176	return nil	15✔
177	}
178
179	func (w walker) walkAllDocStringsFunction(f Function, elems []string) error {	30✔
180	newElems := appendNew(elems, w.NameFunc(f))	30✔
181		30✔
182	var err error	30✔
183	if f.Summary, err = w.Func(f.Summary, newElems, len(elems)); err != nil {	30✔
184	return err	×
185	}	×
186	if f.Description, err = w.Func(f.Description, newElems, len(elems)); err != nil {	30✔
187	return err	×
188	}	×
189	if f.Deprecated, err = w.Func(f.Deprecated, newElems, len(elems)); err != nil {	30✔
190	return err	×
191	}	×
192	if f.ReturnsDoc, err = w.Func(f.ReturnsDoc, newElems, len(elems)); err != nil {	30✔
193	return err	×
194	}	×
195	if f.RaisesDoc, err = w.Func(f.RaisesDoc, newElems, len(elems)); err != nil {	30✔
196	return err	×
197	}	×
198
199	for _, a := range f.Args {	43✔
200	if a.Description, err = w.Func(a.Description, newElems, len(elems)); err != nil {	13✔
201	return err	×
202	}	×
203	}
204	for _, p := range f.Parameters {	43✔
205	if p.Description, err = w.Func(p.Description, newElems, len(elems)); err != nil {	13✔
206	return err	×
207	}	×
208	}
209
210	for _, o := range f.Overloads {	45✔
211	err := w.walkAllDocStringsFunction(o, elems)	15✔
212	if err != nil {	15✔
213	return err	×
214	}	×
215	}
216
217	return nil	30✔
218	}
219
220	func (w walker) walkAllDocStringsModuleAlias(a Alias, elems []string) error {	35✔
221	newElems := appendNew(elems, w.NameFunc(a))	35✔
222		35✔
223	var err error	35✔
224	if a.Summary, err = w.Func(a.Summary, newElems, len(elems)); err != nil {	35✔
225	return err	×
226	}	×
227	if a.Description, err = w.Func(a.Description, newElems, len(elems)); err != nil {	35✔
228	return err	×
229	}	×
230	if a.Deprecated, err = w.Func(a.Deprecated, newElems, len(elems)); err != nil {	35✔
231	return err	×
232	}	×
233	return nil	35✔
234	}
235
236	func (w walker) walkAllDocStringsMethod(f Function, elems []string) error {	140✔
237	var err error	140✔
238	if f.Summary, err = w.Func(f.Summary, elems, len(elems)-1); err != nil {	140✔
239	return err	×
240	}	×
241	if f.Description, err = w.Func(f.Description, elems, len(elems)-1); err != nil {	140✔
242	return err	×
243	}	×
244	if f.Deprecated, err = w.Func(f.Deprecated, elems, len(elems)-1); err != nil {	140✔
245	return err	×
246	}	×
247	if f.ReturnsDoc, err = w.Func(f.ReturnsDoc, elems, len(elems)-1); err != nil {	140✔
248	return err	×
249	}	×
250	if f.RaisesDoc, err = w.Func(f.RaisesDoc, elems, len(elems)-1); err != nil {	140✔
251	return err	×
252	}	×
253
254	for _, a := range f.Args {	265✔
255	if a.Description, err = w.Func(a.Description, elems, len(elems)-1); err != nil {	125✔
256	return err	×
257	}	×
258	}
259	for _, p := range f.Parameters {	166✔
260	if p.Description, err = w.Func(p.Description, elems, len(elems)-1); err != nil {	26✔
261	return err	×
262	}	×
263	}
264
265	for _, o := range f.Overloads {	210✔
266	err := w.walkAllDocStringsMethod(o, elems)	70✔
267	if err != nil {	70✔
268	return err	×
269	}	×
270	}
271
272	return nil	140✔
273	}

mlange-42 / modo / 13315440196

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