12810588007

Committed 16 Jan 2025 02:06PM CUT coverage: 36.851% (+0.3%) from 36.569%

Build # 12810588007

Build Type

push

github

Committed by

web-flow

Commit Message

Error on no exports, silence help (#43)

Run Details

20 of 33 new or added lines in 4 files covered. (60.61%)

2 existing lines in 2 files now uncovered.

447 of 1213 relevant lines covered (36.85%)

2.66 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"
        "strings"
)

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

mlange-42 / modo / 12810588007

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