13103109852

Committed 02 Feb 2025 10:34PM CUT coverage: 73.324%. Remained the same

Build # 13103109852

Build Type

push

github

Committed by

web-flow

Commit Message

Extend user guide section on templates (#188)

Run Details

1509 of 2058 relevant lines covered (73.32%)

24.78 hits per line

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

50.72

/document/walk_docs.go

package document

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

func (proc *Processor) walkAllDocStrings(docs *Docs, fn walkFunc, nameFn nameFunc) error {
        return proc.walkAllDocStringsPackage(docs.Decl, []string{}, fn, nameFn)
}

func (proc *Processor) walkAllDocStringsPackage(p *Package, elems []string, fn walkFunc, nameFn nameFunc) error {
        newElems := appendNew(elems, nameFn(p))

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

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

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

func (proc *Processor) walkAllDocStringsModule(m *Module, elems []string, fn walkFunc, nameFn nameFunc) error {
        newElems := appendNew(elems, nameFn(m))

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

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

func (proc *Processor) walkAllDocStringsStruct(s *Struct, elems []string, fn walkFunc, nameFn nameFunc) error {
        newElems := appendNew(elems, nameFn(s))

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

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

        return nil
}

func (proc *Processor) walkAllDocStringsTrait(tr *Trait, elems []string, fn walkFunc, nameFn nameFunc) error {
        newElems := appendNew(elems, nameFn(tr))

        var err error
        if tr.Summary, err = fn(tr.Summary, newElems, len(elems)); err != nil {
                return err
        }
        if tr.Description, err = fn(tr.Description, newElems, len(elems)); err != nil {
                return err
        }
        if tr.Deprecated, err = fn(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 = fn(f.Summary, newElems, len(elems)); err != nil {
                        return err
                }
                if f.Description, err = fn(f.Description, newElems, len(elems)); err != nil {
                        return err
                }
        }
        for _, f := range tr.Functions {
                if err := proc.walkAllDocStringsMethod(f, newElems, fn, nameFn); err != nil {
                        return err
                }
        }

        return nil
}

func (proc *Processor) walkAllDocStringsFunction(f *Function, elems []string, fn walkFunc, nameFn nameFunc) error {
        newElems := appendNew(elems, nameFn(f))

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

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

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

        return nil
}

func (proc *Processor) walkAllDocStringsModuleAlias(a *Alias, elems []string, fn walkFunc, nameFn nameFunc) error {
        newElems := appendNew(elems, nameFn(a))

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

func (proc *Processor) walkAllDocStringsMethod(f *Function, elems []string, fn walkFunc, nameFn nameFunc) error {
        var err error
        if f.Summary, err = fn(f.Summary, elems, len(elems)-1); err != nil {
                return err
        }
        if f.Description, err = fn(f.Description, elems, len(elems)-1); err != nil {
                return err
        }
        if f.Deprecated, err = fn(f.Deprecated, elems, len(elems)-1); err != nil {
                return err
        }
        if f.ReturnsDoc, err = fn(f.ReturnsDoc, elems, len(elems)-1); err != nil {
                return err
        }
        if f.RaisesDoc, err = fn(f.RaisesDoc, elems, len(elems)-1); err != nil {
                return err
        }

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

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

mlange-42 / modo / 13103109852

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