12856315602

Committed 19 Jan 2025 06:58PM CUT coverage: 59.246% (+0.3%) from 58.921%

Build # 12856315602

Build Type

push

github

Committed by

web-flow

Commit Message

Allow cross-refs to aliases in modules and structs (#69)

Run Details

14 of 16 new or added lines in 3 files covered. (87.5%)

833 of 1406 relevant lines covered (59.25%)

7.94 hits per line

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

87.36

/document/exports.go

package document

import (
        "bufio"
        "strings"
)

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

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

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 {
                                if err := proc.warnOrError("Unresolved package re-export '%s' in %s", strings.Join(ex.Long, "."), strings.Join(newElems, ".")); err != nil {
                                        return anyExports, err
                                }
                        }
                }
                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	"strings"
6	)
7
8	const exportsMarker = "Exports:"
9	const exportsPrefix = "- "
10	const codeFence3 = "```"
11	const codeFence4 = "````"
12
13	type packageExport struct {
14	Short []string
15	Long []string
16	}
17
18	func (proc Processor) collectExports(p Package, elems []string) (bool, error) {	8✔
19	anyExports := false	8✔
20		8✔
21	newElems := appendNew(elems, p.Name)	8✔
22	for _, pkg := range p.Packages {	10✔
23	anyHere, err := proc.collectExports(pkg, newElems)	2✔
24	if err != nil {	2✔
25	return anyExports, err	×
26	}	×
27	if anyHere {	4✔
28	anyExports = true	2✔
29	}	2✔
30	}
31
32	if proc.Config.UseExports {	13✔
33	var anyHere bool	5✔
34	p.exports, p.Description, anyHere = proc.parseExports(p.Description, newElems, true)	5✔
35	if anyHere {	10✔
36	anyExports = true	5✔
37	}	5✔
38	for _, ex := range p.exports {	21✔
39	if _, ok := proc.allPaths[strings.Join(ex.Long, ".")]; !ok {	30✔
40	if err := proc.warnOrError("Unresolved package re-export '%s' in %s", strings.Join(ex.Long, "."), strings.Join(newElems, ".")); err != nil {	14✔
41	return anyExports, err	×
42	}	×
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() {	56✔
71	origLine := scanner.Text()	50✔
72	line := strings.TrimSpace(origLine)	50✔
73		50✔
74	fenced := false	50✔
75	if strings.HasPrefix(origLine, codeFence3) {	52✔
76	fenced3 = !fenced3	2✔
77	fenced = true	2✔
78	}	2✔
79	if strings.HasPrefix(origLine, codeFence4) {	50✔
80	fenced4 = !fenced4	×
81	fenced = true	×
82	}	×
83	if fenced \|\| fenced3 \|\| fenced4 {	56✔
84	isExport = false	6✔
85	outText.WriteString(origLine)	6✔
86	outText.WriteRune('\n')	6✔
87	continue	6✔
88	}
89
90	if isExport {	67✔
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 {	21✔
106	if line == exportsMarker {	28✔
107	isExport = true	7✔
108	exportIndex = 0	7✔
109	continue	7✔
110	}
111	outText.WriteString(origLine)	14✔
112	outText.WriteRune('\n')	14✔
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 / 12856315602

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