12816549311

Committed 16 Jan 2025 07:54PM CUT coverage: 34.117% (-3.0%) from 37.068%

Build # 12816549311

Build Type

Pull #46

github

Committed by

web-flow

Commit Message

Merge bad20b0e7 into cd52159d3

Pull Request Pull Request #46: Fix overwritten cross-refs for multi re-export

Run Details

0 of 105 new or added lines in 3 files covered. (0.0%)

450 of 1319 relevant lines covered (34.12%)

2.48 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"
)

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

mlange-42 / modo / 12816549311

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