12810176069

Committed 16 Jan 2025 01:43PM CUT coverage: 36.569% (+1.8%) from 34.803%

Build # 12810176069

Build Type

push

github

Committed by

web-flow

Commit Message

Implement re-exports on package level (#42)

Run Details

235 of 505 new or added lines in 11 files covered. (46.53%)

41 existing lines in 4 files now uncovered.

437 of 1195 relevant lines covered (36.57%)

2.65 hits per line

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

71.43

/document/filter.go

package document

import (
        "strings"
)

func (proc *Processor) filterPackages() {
        proc.linkExports = map[string]string{}
        proc.collectExports(proc.Docs.Decl, nil)

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

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

mlange-42 / modo / 12810176069

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