13022912844

Committed 29 Jan 2025 01:33AM CUT coverage: 66.921% (-0.3%) from 67.178%

Build # 13022912844

Build Type

push

github

Committed by

web-flow

Commit Message

Fall back to rendering everything when no re-exports (#150)

Run Details

1 of 10 new or added lines in 1 file covered. (10.0%)

1226 of 1832 relevant lines covered (66.92%)

28.88 hits per line

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

83.17

/document/filter.go

package document

import (
        "fmt"
        "strings"
)

// 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{}
        proc.linkExportsReverse = map[string]*exportError{}
        anyExports, err := proc.collectExports(proc.Docs.Decl, nil)
        if err != nil {
                return err
        }

        if proc.Config.UseExports && !anyExports {
                msg := "no package re-exports found. As 'exports' are enabled, there would be no output.\n" +
                        "       Add re-exports or run without 'exports' enabled"
                if !proc.Config.Strict {
                        msg += "\n       Falling back to rendering everything."
                }
                if err := proc.warnOrError("%s", msg); err != nil {
                        return err
                }
                proc.Config.UseExports = false
        }

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

        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)

        errs := []*exportError{}
        for _, expErr := range proc.linkExportsReverse {
                if len(expErr.OldPaths) > 1 {
                        errs = append(errs, expErr)
                }
        }
        if len(errs) == 0 {
                return nil
        }
        msg := strings.Builder{}
        msg.WriteString(fmt.Sprintln("Name collisions in package re-exports:"))
        for _, expErr := range errs {
                msg.WriteString(fmt.Sprintf(" - %s (", expErr.NewPath))
                for i, pOld := range expErr.OldPaths {
                        if i > 0 {
                                msg.WriteString(", ")
                        }
                        msg.WriteString(pOld)
                }
                msg.WriteString(")\n")
        }

        return fmt.Errorf("%s", msg.String())
}

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.Aliases {
                proc.collectExportsAlias(elem, oldPath, newPath)
        }
        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)

                collectExportsList(proc, src.Aliases, 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.Aliases {
                if _, ok := toCrawl[elem.Name]; ok {
                        rootOut.Aliases = append(rootOut.Aliases, elem)
                        proc.collectExportsAlias(elem, oldPath, newPath)
                }
        }
        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.Aliases, oldPath, newPath)
        collectExportsList(proc, s.Parameters, oldPath, newPath)
        collectExportsList(proc, s.Fields, oldPath, newPath)
        collectExportsList(proc, s.Functions, oldPath, newPath)
}

func (proc *Processor) collectExportsAlias(a *Alias, oldPath []string, newPath []string) {
        oldPath = appendNew(oldPath, a.Name)
        newPath = appendNew(newPath, a.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)

        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	"strings"
6	)
7
8	// Filters and re-structures docs for package re-exports.
9	//
10	// Also collects a lookup, mapping from original to altered cross-refs.
11	func (proc *Processor) filterPackages() error {	8✔
12	proc.linkExports = map[string]string{}	8✔
13	proc.linkExportsReverse = map[string]*exportError{}	8✔
14	anyExports, err := proc.collectExports(proc.Docs.Decl, nil)	8✔
15	if err != nil {	8✔
16	return err	×
17	}	×
18
19	if proc.Config.UseExports && !anyExports {	8✔
NEW 20	msg := "no package re-exports found. As 'exports' are enabled, there would be no output.\n" +	×
NEW 21	" Add re-exports or run without 'exports' enabled"	×
NEW 22	if !proc.Config.Strict {	×
NEW 23	msg += "\n Falling back to rendering everything."	×
NEW 24	}	×
NEW 25	if err := proc.warnOrError("%s", msg); err != nil {	×
NEW 26	return err	×
NEW 27	}	×
NEW 28	proc.Config.UseExports = false	×
29	}
30
31	if !proc.Config.UseExports {	11✔
32	proc.ExportDocs = &Docs{	3✔
33	Version: proc.Docs.Version,	3✔
34	Decl: proc.Docs.Decl,	3✔
35	}	3✔
36	return nil	3✔
37	}	3✔
38
39	proc.ExportDocs = &Docs{	5✔
40	Version: proc.Docs.Version,	5✔
41	Decl: proc.Docs.Decl.linkedCopy(),	5✔
42	}	5✔
43	proc.addLinkExport([]string{proc.Docs.Decl.Name}, []string{proc.Docs.Decl.Name})	5✔
44	proc.filterPackage(proc.Docs.Decl, proc.ExportDocs.Decl, nil, nil)	5✔
45		5✔
46	errs := []*exportError{}	5✔
47	for _, expErr := range proc.linkExportsReverse {	79✔
48	if len(expErr.OldPaths) > 1 {	74✔
49	errs = append(errs, expErr)	×
50	}	×
51	}
52	if len(errs) == 0 {	10✔
53	return nil	5✔
54	}	5✔
55	msg := strings.Builder{}	×
56	msg.WriteString(fmt.Sprintln("Name collisions in package re-exports:"))	×
57	for _, expErr := range errs {	×
58	msg.WriteString(fmt.Sprintf(" - %s (", expErr.NewPath))	×
59	for i, pOld := range expErr.OldPaths {	×
60	if i > 0 {	×
61	msg.WriteString(", ")	×
62	}	×
63	msg.WriteString(pOld)	×
64	}
65	msg.WriteString(")\n")	×
66	}
67
68	return fmt.Errorf("%s", msg.String())	×
69	}
70
71	func (proc Processor) filterPackage(src, rootOut Package, oldPath, newPath []string) {	9✔
72	rootExports := map[string]*members{}	9✔
73	collectExportsPackage(src, rootExports)	9✔
74		9✔
75	oldPath = appendNew(oldPath, src.Name)	9✔
76	newPath = appendNew(newPath, src.Name)	9✔
77		9✔
78	for _, mod := range src.Modules {	23✔
79	if mems, ok := rootExports[mod.Name]; ok {	28✔
80	proc.collectModuleExports(mod, rootOut, oldPath, newPath, mems)	14✔
81	}	14✔
82	}
83
84	for _, pkg := range src.Packages {	13✔
85	if mems, ok := rootExports[pkg.Name]; ok {	8✔
86	proc.collectPackageExports(pkg, rootOut, oldPath, newPath, mems)	4✔
87	}	4✔
88	}
89	}
90
91	func (proc Processor) collectPackageExports(src, rootOut Package, oldPath, newPath []string, rootMembers *members) {	4✔
92	selfIncluded, toCrawl := collectExportMembers(rootMembers)	4✔
93		4✔
94	if selfIncluded {	8✔
95	newPkg := src.linkedCopy()	4✔
96	proc.filterPackage(src, newPkg, oldPath, newPath)	4✔
97	rootOut.Packages = append(rootOut.Packages, newPkg)	4✔
98		4✔
99	tempOldPath := appendNew(oldPath, src.Name)	4✔
100	tempNewPath := appendNew(newPath, src.Name)	4✔
101	proc.addLinkExport(tempOldPath, tempNewPath)	4✔
102	}	4✔
103	oldPath = appendNew(oldPath, src.Name)	4✔
104		4✔
105	for _, mod := range src.Modules {	8✔
106	if mems, ok := toCrawl[mod.Name]; ok {	6✔
107	proc.collectModuleExports(mod, rootOut, oldPath, newPath, mems)	2✔
108	}	2✔
109	}
110
111	for _, pkg := range src.Packages {	4✔
112	if mems, ok := toCrawl[pkg.Name]; ok {	×
113	proc.collectPackageExports(pkg, rootOut, oldPath, newPath, mems)	×
114	}	×
115	}
116
117	for _, elem := range src.Aliases {	4✔
118	proc.collectExportsAlias(elem, oldPath, newPath)	×
119	}	×
120	for _, elem := range src.Structs {	4✔
121	proc.collectExportsStruct(elem, oldPath, newPath)	×
122	}	×
123	for _, elem := range src.Traits {	4✔
124	proc.collectExportsTrait(elem, oldPath, newPath)	×
125	}	×
126	for _, elem := range src.Functions {	4✔
127	proc.collectExportsFunction(elem, oldPath, newPath)	×
128	}	×
129	}
130
131	func (proc Processor) collectModuleExports(src Module, rootOut Package, oldPath, newPath []string, rootMembers members) {	16✔
132	selfIncluded, toCrawl := collectExportMembers(rootMembers)	16✔
133		16✔
134	oldPath = appendNew(oldPath, src.Name)	16✔
135	if selfIncluded {	25✔
136	rootOut.Modules = append(rootOut.Modules, src)	9✔
137		9✔
138	tempNewPath := appendNew(newPath, src.Name)	9✔
139	proc.addLinkExport(oldPath, tempNewPath)	9✔
140		9✔
141	collectExportsList(proc, src.Aliases, oldPath, tempNewPath)	9✔
142	for _, elem := range src.Structs {	18✔
143	proc.collectExportsStruct(elem, oldPath, tempNewPath)	9✔
144	}	9✔
145	for _, elem := range src.Traits {	10✔
146	proc.collectExportsTrait(elem, oldPath, tempNewPath)	1✔
147	}	1✔
148	for _, elem := range src.Functions {	10✔
149	proc.collectExportsFunction(elem, oldPath, tempNewPath)	1✔
150	}	1✔
151	}
152
153	for _, elem := range src.Aliases {	23✔
154	if _, ok := toCrawl[elem.Name]; ok {	9✔
155	rootOut.Aliases = append(rootOut.Aliases, elem)	2✔
156	proc.collectExportsAlias(elem, oldPath, newPath)	2✔
157	}	2✔
158	}
159	for _, elem := range src.Structs {	34✔
160	if _, ok := toCrawl[elem.Name]; ok {	27✔
161	rootOut.Structs = append(rootOut.Structs, elem)	9✔
162	proc.collectExportsStruct(elem, oldPath, newPath)	9✔
163	}	9✔
164	}
165	for _, elem := range src.Traits {	21✔
166	if _, ok := toCrawl[elem.Name]; ok {	7✔
167	rootOut.Traits = append(rootOut.Traits, elem)	2✔
168	proc.collectExportsTrait(elem, oldPath, newPath)	2✔
169	}	2✔
170	}
171	for _, elem := range src.Functions {	21✔
172	if _, ok := toCrawl[elem.Name]; ok {	9✔
173	rootOut.Functions = append(rootOut.Functions, elem)	4✔
174	proc.collectExportsFunction(elem, oldPath, newPath)	4✔
175	}	4✔
176	}
177	}
178
179	func (proc Processor) collectExportsStruct(s Struct, oldPath []string, newPath []string) {	18✔
180	oldPath = appendNew(oldPath, s.Name)	18✔
181	newPath = appendNew(newPath, s.Name)	18✔
182		18✔
183	proc.addLinkExport(oldPath, newPath)	18✔
184		18✔
185	collectExportsList(proc, s.Aliases, oldPath, newPath)	18✔
186	collectExportsList(proc, s.Parameters, oldPath, newPath)	18✔
187	collectExportsList(proc, s.Fields, oldPath, newPath)	18✔
188	collectExportsList(proc, s.Functions, oldPath, newPath)	18✔
189	}	18✔
190
191	func (proc Processor) collectExportsAlias(a Alias, oldPath []string, newPath []string) {	2✔
192	oldPath = appendNew(oldPath, a.Name)	2✔
193	newPath = appendNew(newPath, a.Name)	2✔
194		2✔
195	proc.addLinkExport(oldPath, newPath)	2✔
196	}	2✔
197
198	func (proc Processor) collectExportsTrait(s Trait, oldPath []string, newPath []string) {	3✔
199	oldPath = appendNew(oldPath, s.Name)	3✔
200	newPath = appendNew(newPath, s.Name)	3✔
201		3✔
202	proc.addLinkExport(oldPath, newPath)	3✔
203		3✔
204	collectExportsList(proc, s.Fields, oldPath, newPath)	3✔
205	collectExportsList(proc, s.Functions, oldPath, newPath)	3✔
206	}	3✔
207
208	func (proc Processor) collectExportsFunction(s Function, oldPath []string, newPath []string) {	5✔
209	oldPath = appendNew(oldPath, s.Name)	5✔
210	newPath = appendNew(newPath, s.Name)	5✔
211		5✔
212	proc.addLinkExport(oldPath, newPath)	5✔
213	}	5✔
214
215	func collectExportsList[T Named](proc *Processor, sl []T, oldPath, newPath []string) {	87✔
216	for _, elem := range sl {	115✔
217	oldPath := appendNew(oldPath, elem.GetName())	28✔
218	newPath := appendNew(newPath, elem.GetName())	28✔
219	proc.addLinkExport(oldPath, newPath)	28✔
220	}	28✔
221	}
222
223	type members struct {
224	Members []member
225	}
226
227	type member struct {
228	Include bool
229	RelPath []string
230	}
231
232	func collectExportMembers(parentMember members) (selfIncluded bool, toCrawl map[string]members) {	20✔
233	selfIncluded = false	20✔
234	toCrawl = map[string]*members{}	20✔
235		20✔
236	for _, mem := range parentMember.Members {	54✔
237	if mem.Include {	47✔
238	selfIncluded = true	13✔
239	continue	13✔
240	}
241	var newMember member	21✔
242	if len(mem.RelPath) == 1 {	40✔
243	newMember = member{Include: true}	19✔
244	} else {	21✔
245	newMember = member{RelPath: mem.RelPath[1:]}	2✔
246	}	2✔
247	if members, ok := toCrawl[mem.RelPath[0]]; ok {	23✔
248	members.Members = append(members.Members, newMember)	2✔
249	continue	2✔
250	}
251	toCrawl[mem.RelPath[0]] = &members{Members: []member{newMember}}	19✔
252	}
253
254	return	20✔
255	}
256
257	func collectExportsPackage(p Package, out map[string]members) {	9✔
258	for _, ex := range p.exports {	39✔
259	var newMember member	30✔
260	if len(ex.Short) == 1 {	41✔
261	newMember = member{Include: true}	11✔
262	} else {	30✔
263	newMember = member{RelPath: ex.Short[1:]}	19✔
264	}	19✔
265	if members, ok := out[ex.Short[0]]; ok {	42✔
266	members.Members = append(members.Members, newMember)	12✔
267	continue	12✔
268	}
269	out[ex.Short[0]] = &members{Members: []member{newMember}}	18✔
270	}
271	}

mlange-42 / modo / 13022912844

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