12855871165

Committed 19 Jan 2025 05:55PM CUT coverage: 58.921% (-0.03%) from 58.946%

Build # 12855871165

Build Type

push

github

Committed by

web-flow

Commit Message

Strict mode, check re-exports (#68)

Run Details

80 of 109 new or added lines in 7 files covered. (73.39%)

5 existing lines in 1 file now uncovered.

819 of 1390 relevant lines covered (58.92%)

7.89 hits per line

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

90.3

/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, err := proc.collectExports(proc.Docs.Decl, nil)
        if err != nil {
                return err
        }

        if !proc.Config.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.addLinkExport([]string{proc.Docs.Decl.Name}, []string{proc.Docs.Decl.Name})
        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 {
                        proc.collectExportsStruct(elem, oldPath, tempNewPath)
                }
                for _, elem := range src.Traits {
                        proc.collectExportsTrait(elem, oldPath, tempNewPath)
                }
                for _, elem := range src.Functions {
                        proc.collectExportsFunction(elem, 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)

        collectExportsList(proc, s.Parameters, oldPath, newPath)
        collectExportsList(proc, s.Fields, oldPath, newPath)
        collectExportsList(proc, s.Functions, 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)

        collectExportsList(proc, s.Fields, oldPath, newPath)
        collectExportsList(proc, s.Functions, 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)
}

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

mlange-42 / modo / 12855871165

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