12857640190

Committed 19 Jan 2025 10:16PM CUT coverage: 57.418% (-0.4%) from 57.843%

Build # 12857640190

Build Type

push

github

Committed by

web-flow

Commit Message

Check for name conflicts in re-exports (#72)

Run Details

18 of 33 new or added lines in 3 files covered. (54.55%)

4 existing lines in 1 file now uncovered.

836 of 1456 relevant lines covered (57.42%)

8.24 hits per line

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

87.21

/document/exports.go

package document

import (
        "bufio"
        "fmt"
        "strings"
)

const exportsMarker = "Exports:"
const exportsPrefix = "- "
const codeFence3 = "```"
const codeFence4 = "````"

type packageExport struct {
        Short []string
        Long  []string
}

// Parses and collects project re-exports, recursively.
func (proc *Processor) collectExports(p *Package, elems []string) (bool, error) {
        anyExports := false

        newElems := appendNew(elems, p.Name)
        for _, pkg := range p.Packages {
                anyHere, err := proc.collectExports(pkg, newElems)
                if err != nil {
                        return anyExports, err
                }
                if anyHere {
                        anyExports = true
                }
        }

        if proc.Config.UseExports {
                var anyHere bool
                p.exports, p.Description, anyHere = proc.parseExports(p.Description, newElems, true)
                if anyHere {
                        anyExports = true
                }
                for _, ex := range p.exports {
                        if _, ok := proc.allPaths[strings.Join(ex.Long, ".")]; !ok {
                                return anyExports, fmt.Errorf("unresolved package re-export '%s' in %s", strings.Join(ex.Long, "."), strings.Join(newElems, "."))
                        }
                }
                return anyExports, nil
        }

        p.exports = make([]*packageExport, 0, len(p.Packages)+len(p.Modules))
        for _, pkg := range p.Packages {
                p.exports = append(p.exports, &packageExport{Short: []string{pkg.Name}, Long: appendNew(newElems, pkg.Name)})
        }
        for _, mod := range p.Modules {
                p.exports = append(p.exports, &packageExport{Short: []string{mod.Name}, Long: appendNew(newElems, mod.Name)})
        }

        return anyExports, nil
}

func (proc *Processor) parseExports(pkgDocs string, basePath []string, remove bool) ([]*packageExport, string, bool) {
        scanner := bufio.NewScanner(strings.NewReader(pkgDocs))

        outText := strings.Builder{}
        exports := []*packageExport{}
        anyExports := false
        isExport := false
        fenced3 := false
        fenced4 := false

        exportIndex := 0
        for scanner.Scan() {
                origLine := scanner.Text()
                line := strings.TrimSpace(origLine)

                fenced := false
                if strings.HasPrefix(origLine, codeFence3) {
                        fenced3 = !fenced3
                        fenced = true
                }
                if strings.HasPrefix(origLine, codeFence4) {
                        fenced4 = !fenced4
                        fenced = true
                }
                if fenced || fenced3 || fenced4 {
                        isExport = false
                        outText.WriteString(origLine)
                        outText.WriteRune('\n')
                        continue
                }

                if isExport {
                        if exportIndex == 0 && line == "" {
                                continue
                        }
                        if !strings.HasPrefix(line, exportsPrefix) {
                                outText.WriteString(origLine)
                                outText.WriteRune('\n')
                                isExport = false
                                continue
                        }
                        short := line[len(exportsPrefix):]
                        parts := strings.Split(short, ".")
                        exports = append(exports, &packageExport{Short: parts, Long: appendNew(basePath, parts...)})
                        anyExports = true
                        exportIndex++
                } else {
                        if line == exportsMarker {
                                isExport = true
                                exportIndex = 0
                                continue
                        }
                        outText.WriteString(origLine)
                        outText.WriteRune('\n')
                }
        }
        if err := scanner.Err(); err != nil {
                panic(err)
        }
        if remove {
                return exports, outText.String(), anyExports
        }
        return exports, pkgDocs, anyExports
}

1	package document
2
3	import (
4	"bufio"
5	"fmt"
6	"strings"
7	)
8
9	const exportsMarker = "Exports:"
10	const exportsPrefix = "- "
11	const codeFence3 = "```"
12	const codeFence4 = "````"
13
14	type packageExport struct {
15	Short []string
16	Long []string
17	}
18
19	// Parses and collects project re-exports, recursively.
20	func (proc Processor) collectExports(p Package, elems []string) (bool, error) {	8✔
21	anyExports := false	8✔
22		8✔
23	newElems := appendNew(elems, p.Name)	8✔
24	for _, pkg := range p.Packages {	10✔
25	anyHere, err := proc.collectExports(pkg, newElems)	2✔
26	if err != nil {	2✔
27	return anyExports, err	×
28	}	×
29	if anyHere {	4✔
30	anyExports = true	2✔
31	}	2✔
32	}
33
34	if proc.Config.UseExports {	13✔
35	var anyHere bool	5✔
36	p.exports, p.Description, anyHere = proc.parseExports(p.Description, newElems, true)	5✔
37	if anyHere {	10✔
38	anyExports = true	5✔
39	}	5✔
40	for _, ex := range p.exports {	21✔
41	if _, ok := proc.allPaths[strings.Join(ex.Long, ".")]; !ok {	16✔
NEW 42	return anyExports, fmt.Errorf("unresolved package re-export '%s' in %s", strings.Join(ex.Long, "."), strings.Join(newElems, "."))	×
43	}	×
44	}
45	return anyExports, nil	5✔
46	}
47
48	p.exports = make([]*packageExport, 0, len(p.Packages)+len(p.Modules))	3✔
49	for _, pkg := range p.Packages {	3✔
50	p.exports = append(p.exports, &packageExport{Short: []string{pkg.Name}, Long: appendNew(newElems, pkg.Name)})	×
51	}	×
52	for _, mod := range p.Modules {	6✔
53	p.exports = append(p.exports, &packageExport{Short: []string{mod.Name}, Long: appendNew(newElems, mod.Name)})	3✔
54	}	3✔
55
56	return anyExports, nil	3✔
57	}
58
59	func (proc Processor) parseExports(pkgDocs string, basePath []string, remove bool) ([]packageExport, string, bool) {	6✔
60	scanner := bufio.NewScanner(strings.NewReader(pkgDocs))	6✔
61		6✔
62	outText := strings.Builder{}	6✔
63	exports := []*packageExport{}	6✔
64	anyExports := false	6✔
65	isExport := false	6✔
66	fenced3 := false	6✔
67	fenced4 := false	6✔
68		6✔
69	exportIndex := 0	6✔
70	for scanner.Scan() {	58✔
71	origLine := scanner.Text()	52✔
72	line := strings.TrimSpace(origLine)	52✔
73		52✔
74	fenced := false	52✔
75	if strings.HasPrefix(origLine, codeFence3) {	54✔
76	fenced3 = !fenced3	2✔
77	fenced = true	2✔
78	}	2✔
79	if strings.HasPrefix(origLine, codeFence4) {	52✔
80	fenced4 = !fenced4	×
81	fenced = true	×
82	}	×
83	if fenced \|\| fenced3 \|\| fenced4 {	58✔
84	isExport = false	6✔
85	outText.WriteString(origLine)	6✔
86	outText.WriteRune('\n')	6✔
87	continue	6✔
88	}
89
90	if isExport {	69✔
91	if exportIndex == 0 && line == "" {	24✔
92	continue	1✔
93	}
94	if !strings.HasPrefix(line, exportsPrefix) {	24✔
95	outText.WriteString(origLine)	2✔
96	outText.WriteRune('\n')	2✔
97	isExport = false	2✔
98	continue	2✔
99	}
100	short := line[len(exportsPrefix):]	20✔
101	parts := strings.Split(short, ".")	20✔
102	exports = append(exports, &packageExport{Short: parts, Long: appendNew(basePath, parts...)})	20✔
103	anyExports = true	20✔
104	exportIndex++	20✔
105	} else {	23✔
106	if line == exportsMarker {	30✔
107	isExport = true	7✔
108	exportIndex = 0	7✔
109	continue	7✔
110	}
111	outText.WriteString(origLine)	16✔
112	outText.WriteRune('\n')	16✔
113	}
114	}
115	if err := scanner.Err(); err != nil {	6✔
116	panic(err)	×
117	}
118	if remove {	12✔
119	return exports, outText.String(), anyExports	6✔
120	}	6✔
121	return exports, pkgDocs, anyExports	×
122	}

mlange-42 / modo / 12857640190

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