12828585719

Committed 17 Jan 2025 11:57AM CUT coverage: 47.571% (+11.0%) from 36.563%

Build # 12828585719

Build Type

Pull #54

github

Committed by

web-flow

Commit Message

Merge f8c9ff6fe into 41ff6f833

Pull Request Pull Request #54: More unit tests

Run Details

21 of 36 new or added lines in 3 files covered. (58.33%)

13 existing lines in 2 files now uncovered.

617 of 1297 relevant lines covered (47.57%)

3.96 hits per line

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

70.91

/document/filter.go

package document

import (
        "fmt"
)

// Filters and re-structures docs for package re-exports.
//
// Also collects a lookup, mapping from original to altered cross-refs.
func (proc *Processor) filterPackages() error {
        proc.linkExports = map[string]string{}
        anyExports := proc.collectExports(proc.Docs.Decl, nil)

        if !proc.UseExports {
                proc.ExportDocs = &Docs{
                        Version: proc.Docs.Version,
                        Decl:    proc.Docs.Decl,
                }
                return nil
        }

        if !anyExports {
                return fmt.Errorf("no package re-exports found. Given flag '--exports', there will be no output.\n       Add exports or run without flag '--exports'")
        }

        proc.ExportDocs = &Docs{
                Version: proc.Docs.Version,
                Decl:    proc.Docs.Decl.linkedCopy(),
        }
        proc.filterPackage(proc.Docs.Decl, proc.ExportDocs.Decl, nil, nil)
        return nil
}

func (proc *Processor) filterPackage(src, rootOut *Package, oldPath, newPath []string) {
        rootExports := map[string]*members{}
        collectExportsPackage(src, rootExports)

        oldPath = AppendNew(oldPath, src.Name)
        newPath = AppendNew(newPath, src.Name)

        for _, mod := range src.Modules {
                if mems, ok := rootExports[mod.Name]; ok {
                        proc.collectModuleExports(mod, rootOut, oldPath, newPath, mems)
                }
        }

        for _, pkg := range src.Packages {
                if mems, ok := rootExports[pkg.Name]; ok {
                        proc.collectPackageExports(pkg, rootOut, oldPath, newPath, mems)
                }
        }
}

func (proc *Processor) collectPackageExports(src, rootOut *Package, oldPath, newPath []string, rootMembers *members) {
        selfIncluded, toCrawl := collectExportMembers(rootMembers)

        if selfIncluded {
                newPkg := src.linkedCopy()
                proc.filterPackage(src, newPkg, oldPath, newPath)
                rootOut.Packages = append(rootOut.Packages, newPkg)

                tempOldPath := AppendNew(oldPath, src.Name)
                tempNewPath := AppendNew(newPath, src.Name)
                proc.addLinkExport(tempOldPath, tempNewPath)
        }
        oldPath = AppendNew(oldPath, src.Name)

        for _, mod := range src.Modules {
                if mems, ok := toCrawl[mod.Name]; ok {
                        proc.collectModuleExports(mod, rootOut, oldPath, newPath, mems)
                }
        }

        for _, pkg := range src.Packages {
                if mems, ok := toCrawl[pkg.Name]; ok {
                        proc.collectPackageExports(pkg, rootOut, oldPath, newPath, mems)
                }
        }

        for _, elem := range src.Structs {
                proc.collectExportsStruct(elem, oldPath, newPath)
        }
        for _, elem := range src.Traits {
                proc.collectExportsTrait(elem, oldPath, newPath)
        }
        for _, elem := range src.Functions {
                proc.collectExportsFunction(elem, oldPath, newPath)
        }
}

func (proc *Processor) collectModuleExports(src *Module, rootOut *Package, oldPath, newPath []string, rootMembers *members) {
        selfIncluded, toCrawl := collectExportMembers(rootMembers)

        oldPath = AppendNew(oldPath, src.Name)
        if selfIncluded {
                rootOut.Modules = append(rootOut.Modules, src)

                tempNewPath := AppendNew(newPath, src.Name)
                proc.addLinkExport(oldPath, tempNewPath)
        }

        for _, elem := range src.Structs {
                if _, ok := toCrawl[elem.Name]; ok {
                        rootOut.Structs = append(rootOut.Structs, elem)
                        proc.collectExportsStruct(elem, oldPath, newPath)
                }
        }
        for _, elem := range src.Traits {
                if _, ok := toCrawl[elem.Name]; ok {
                        rootOut.Traits = append(rootOut.Traits, elem)
                        proc.collectExportsTrait(elem, oldPath, newPath)
                }
        }
        for _, elem := range src.Functions {
                if _, ok := toCrawl[elem.Name]; ok {
                        rootOut.Functions = append(rootOut.Functions, elem)
                        proc.collectExportsFunction(elem, oldPath, newPath)
                }
        }
}

func (proc *Processor) collectExportsStruct(s *Struct, oldPath []string, newPath []string) {
        oldPath = AppendNew(oldPath, s.Name)
        newPath = AppendNew(newPath, s.Name)

        proc.addLinkExport(oldPath, newPath)

        for _, elem := range s.Parameters {
                oldPath := AppendNew(oldPath, elem.Name)
                newPath := AppendNew(newPath, elem.Name)
                proc.addLinkExport(oldPath, newPath)
        }
        for _, elem := range s.Fields {
                oldPath := AppendNew(oldPath, elem.Name)
                newPath := AppendNew(newPath, elem.Name)
                proc.addLinkExport(oldPath, newPath)
        }
        for _, elem := range s.Functions {
                oldPath := AppendNew(oldPath, elem.Name)
                newPath := AppendNew(newPath, elem.Name)
                proc.addLinkExport(oldPath, newPath)
        }
}

func (proc *Processor) collectExportsTrait(s *Trait, oldPath []string, newPath []string) {
        oldPath = AppendNew(oldPath, s.Name)
        newPath = AppendNew(newPath, s.Name)

        proc.addLinkExport(oldPath, newPath)

        for _, elem := range s.Fields {
                oldPath := AppendNew(oldPath, elem.Name)
                newPath := AppendNew(newPath, elem.Name)
                proc.addLinkExport(oldPath, newPath)
        }
        for _, elem := range s.Functions {
                oldPath := AppendNew(oldPath, elem.Name)
                newPath := AppendNew(newPath, elem.Name)
                proc.addLinkExport(oldPath, newPath)
        }
}

func (proc *Processor) collectExportsFunction(s *Function, oldPath []string, newPath []string) {
        oldPath = AppendNew(oldPath, s.Name)
        newPath = AppendNew(newPath, s.Name)

        proc.addLinkExport(oldPath, newPath)
}

type members struct {
        Members []member
}

type member struct {
        Include bool
        RelPath []string
}

func collectExportMembers(parentMember *members) (selfIncluded bool, toCrawl map[string]*members) {
        selfIncluded = false
        toCrawl = map[string]*members{}

        for _, mem := range parentMember.Members {
                if mem.Include {
                        selfIncluded = true
                        continue
                }
                var newMember member
                if len(mem.RelPath) == 1 {
                        newMember = member{Include: true}
                } else {
                        newMember = member{RelPath: mem.RelPath[1:]}
                }
                if members, ok := toCrawl[mem.RelPath[0]]; ok {
                        members.Members = append(members.Members, newMember)
                        continue
                }
                toCrawl[mem.RelPath[0]] = &members{Members: []member{newMember}}
        }

        return
}

func collectExportsPackage(p *Package, out map[string]*members) {
        for _, ex := range p.Exports {
                var newMember member
                if len(ex.Short) == 1 {
                        newMember = member{Include: true}
                } else {
                        newMember = member{RelPath: ex.Short[1:]}
                }
                if members, ok := out[ex.Short[0]]; ok {
                        members.Members = append(members.Members, newMember)
                        continue
                }
                out[ex.Short[0]] = &members{Members: []member{newMember}}
        }
}

1	package document
2
3	import (
4	"fmt"
5	)
6
7	// Filters and re-structures docs for package re-exports.
8	//
9	// Also collects a lookup, mapping from original to altered cross-refs.
10	func (proc *Processor) filterPackages() error {	3✔
11	proc.linkExports = map[string]string{}	3✔
12	anyExports := proc.collectExports(proc.Docs.Decl, nil)	3✔
13		3✔
14	if !proc.UseExports {	3✔
15	proc.ExportDocs = &Docs{	×
16	Version: proc.Docs.Version,	×
17	Decl: proc.Docs.Decl,	×
18	}	×
19	return nil	×
20	}	×
21
22	if !anyExports {	3✔
23	return fmt.Errorf("no package re-exports found. Given flag '--exports', there will be no output.\n Add exports or run without flag '--exports'")	×
24	}	×
25
26	proc.ExportDocs = &Docs{	3✔
27	Version: proc.Docs.Version,	3✔
28	Decl: proc.Docs.Decl.linkedCopy(),	3✔
29	}	3✔
30	proc.filterPackage(proc.Docs.Decl, proc.ExportDocs.Decl, nil, nil)	3✔
31	return nil	3✔
32	}
33
34	func (proc Processor) filterPackage(src, rootOut Package, oldPath, newPath []string) {	5✔
35	rootExports := map[string]*members{}	5✔
36	collectExportsPackage(src, rootExports)	5✔
37		5✔
38	oldPath = AppendNew(oldPath, src.Name)	5✔
39	newPath = AppendNew(newPath, src.Name)	5✔
40		5✔
41	for _, mod := range src.Modules {	13✔
42	if mems, ok := rootExports[mod.Name]; ok {	16✔
43	proc.collectModuleExports(mod, rootOut, oldPath, newPath, mems)	8✔
44	}	8✔
45	}
46
47	for _, pkg := range src.Packages {	7✔
48	if mems, ok := rootExports[pkg.Name]; ok {	4✔
49	proc.collectPackageExports(pkg, rootOut, oldPath, newPath, mems)	2✔
50	}	2✔
51	}
52	}
53
54	func (proc Processor) collectPackageExports(src, rootOut Package, oldPath, newPath []string, rootMembers *members) {	2✔
55	selfIncluded, toCrawl := collectExportMembers(rootMembers)	2✔
56		2✔
57	if selfIncluded {	4✔
58	newPkg := src.linkedCopy()	2✔
59	proc.filterPackage(src, newPkg, oldPath, newPath)	2✔
60	rootOut.Packages = append(rootOut.Packages, newPkg)	2✔
61		2✔
62	tempOldPath := AppendNew(oldPath, src.Name)	2✔
63	tempNewPath := AppendNew(newPath, src.Name)	2✔
64	proc.addLinkExport(tempOldPath, tempNewPath)	2✔
65	}	2✔
66	oldPath = AppendNew(oldPath, src.Name)	2✔
67		2✔
68	for _, mod := range src.Modules {	4✔
69	if mems, ok := toCrawl[mod.Name]; ok {	4✔
70	proc.collectModuleExports(mod, rootOut, oldPath, newPath, mems)	2✔
71	}	2✔
72	}
73
74	for _, pkg := range src.Packages {	2✔
75	if mems, ok := toCrawl[pkg.Name]; ok {	×
76	proc.collectPackageExports(pkg, rootOut, oldPath, newPath, mems)	×
77	}	×
78	}
79
80	for _, elem := range src.Structs {	2✔
81	proc.collectExportsStruct(elem, oldPath, newPath)	×
82	}	×
83	for _, elem := range src.Traits {	2✔
84	proc.collectExportsTrait(elem, oldPath, newPath)	×
85	}	×
86	for _, elem := range src.Functions {	2✔
87	proc.collectExportsFunction(elem, oldPath, newPath)	×
88	}	×
89	}
90
91	func (proc Processor) collectModuleExports(src Module, rootOut Package, oldPath, newPath []string, rootMembers members) {	10✔
92	selfIncluded, toCrawl := collectExportMembers(rootMembers)	10✔
93		10✔
94	oldPath = AppendNew(oldPath, src.Name)	10✔
95	if selfIncluded {	15✔
96	rootOut.Modules = append(rootOut.Modules, src)	5✔
97		5✔
98	tempNewPath := AppendNew(newPath, src.Name)	5✔
99	proc.addLinkExport(oldPath, tempNewPath)	5✔
100	}	5✔
101
102	for _, elem := range src.Structs {	22✔
103	if _, ok := toCrawl[elem.Name]; ok {	19✔
104	rootOut.Structs = append(rootOut.Structs, elem)	7✔
105	proc.collectExportsStruct(elem, oldPath, newPath)	7✔
106	}	7✔
107	}
108	for _, elem := range src.Traits {	13✔
109	if _, ok := toCrawl[elem.Name]; ok {	3✔
110	rootOut.Traits = append(rootOut.Traits, elem)	×
111	proc.collectExportsTrait(elem, oldPath, newPath)	×
112	}	×
113	}
114	for _, elem := range src.Functions {	13✔
115	if _, ok := toCrawl[elem.Name]; ok {	5✔
116	rootOut.Functions = append(rootOut.Functions, elem)	2✔
117	proc.collectExportsFunction(elem, oldPath, newPath)	2✔
118	}	2✔
119	}
120	}
121
122	func (proc Processor) collectExportsStruct(s Struct, oldPath []string, newPath []string) {	7✔
123	oldPath = AppendNew(oldPath, s.Name)	7✔
124	newPath = AppendNew(newPath, s.Name)	7✔
125		7✔
126	proc.addLinkExport(oldPath, newPath)	7✔
127		7✔
128	for _, elem := range s.Parameters {	7✔
129	oldPath := AppendNew(oldPath, elem.Name)	×
130	newPath := AppendNew(newPath, elem.Name)	×
131	proc.addLinkExport(oldPath, newPath)	×
132	}	×
133	for _, elem := range s.Fields {	7✔
134	oldPath := AppendNew(oldPath, elem.Name)	×
135	newPath := AppendNew(newPath, elem.Name)	×
136	proc.addLinkExport(oldPath, newPath)	×
137	}	×
138	for _, elem := range s.Functions {	7✔
139	oldPath := AppendNew(oldPath, elem.Name)	×
140	newPath := AppendNew(newPath, elem.Name)	×
141	proc.addLinkExport(oldPath, newPath)	×
142	}	×
143	}
144
145	func (proc Processor) collectExportsTrait(s Trait, oldPath []string, newPath []string) {	×
146	oldPath = AppendNew(oldPath, s.Name)	×
147	newPath = AppendNew(newPath, s.Name)	×
148		×
149	proc.addLinkExport(oldPath, newPath)	×
150		×
151	for _, elem := range s.Fields {	×
152	oldPath := AppendNew(oldPath, elem.Name)	×
153	newPath := AppendNew(newPath, elem.Name)	×
154	proc.addLinkExport(oldPath, newPath)	×
155	}	×
156	for _, elem := range s.Functions {	×
157	oldPath := AppendNew(oldPath, elem.Name)	×
158	newPath := AppendNew(newPath, elem.Name)	×
159	proc.addLinkExport(oldPath, newPath)	×
160	}	×
161	}
162
163	func (proc Processor) collectExportsFunction(s Function, oldPath []string, newPath []string) {	2✔
164	oldPath = AppendNew(oldPath, s.Name)	2✔
165	newPath = AppendNew(newPath, s.Name)	2✔
166		2✔
167	proc.addLinkExport(oldPath, newPath)	2✔
168	}	2✔
169
170	type members struct {
171	Members []member
172	}
173
174	type member struct {
175	Include bool
176	RelPath []string
177	}
178
179	func collectExportMembers(parentMember members) (selfIncluded bool, toCrawl map[string]members) {	12✔
180	selfIncluded = false	12✔
181	toCrawl = map[string]*members{}	12✔
182		12✔
183	for _, mem := range parentMember.Members {	32✔
184	if mem.Include {	27✔
185	selfIncluded = true	7✔
186	continue	7✔
187	}
188	var newMember member	13✔
189	if len(mem.RelPath) == 1 {	24✔
190	newMember = member{Include: true}	11✔
191	} else {	13✔
192	newMember = member{RelPath: mem.RelPath[1:]}	2✔
193	}	2✔
194	if members, ok := toCrawl[mem.RelPath[0]]; ok {	15✔
195	members.Members = append(members.Members, newMember)	2✔
196	continue	2✔
197	}
198	toCrawl[mem.RelPath[0]] = &members{Members: []member{newMember}}	11✔
199	}
200
201	return	12✔
202	}
203
204	func collectExportsPackage(p Package, out map[string]members) {	5✔
205	for _, ex := range p.Exports {	21✔
206	var newMember member	16✔
207	if len(ex.Short) == 1 {	21✔
208	newMember = member{Include: true}	5✔
209	} else {	16✔
210	newMember = member{RelPath: ex.Short[1:]}	11✔
211	}	11✔
212	if members, ok := out[ex.Short[0]]; ok {	22✔
213	members.Members = append(members.Members, newMember)	6✔
214	continue	6✔
215	}
216	out[ex.Short[0]] = &members{Members: []member{newMember}}	10✔
217	}
218	}

mlange-42 / modo / 12828585719

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