13103549969

Committed 02 Feb 2025 11:37PM CUT coverage: 73.186% (-0.1%) from 73.324%

Build # 13103549969

Build Type

Pull #189

github

Committed by

web-flow

Commit Message

Merge 45bd4a4ee into 85ef42e0b

Pull Request Pull Request #189: Parse and register exports-as renames

Run Details

21 of 32 new or added lines in 1 file covered. (65.63%)

1 existing line in 1 file now uncovered.

1523 of 2081 relevant lines covered (73.19%)

24.73 hits per line

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

81.65

/document/exports.go

package document

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

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

type packageExport struct {
        Short   []string
        Renamed []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
                var err error
                p.exports, p.Description, anyHere, err = proc.parseExports(p.Description, newElems, true)
                if err != nil {
                        return anyExports, err
                }
                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},
                        Renamed: []string{pkg.Name},
                        Long:    appendNew(newElems, pkg.Name),
                })
        }
        for _, mod := range p.Modules {
                p.exports = append(p.exports, &packageExport{
                        Short:   []string{mod.Name},
                        Renamed: []string{mod.Name},
                        Long:    appendNew(newElems, mod.Name),
                })
        }

        return anyExports, nil
}

func (proc *Processor) parseExports(pkgDocs string, basePath []string, remove bool) ([]*packageExport, string, bool, error) {
        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
                        }
                        exportsAs := strings.Split(line[len(exportsPrefix):], " ")
                        short := exportsAs[0]
                        partsShort := strings.Split(short, ".")
                        renamed := partsShort[len(partsShort)-1]
                        if len(exportsAs) == 3 && exportsAs[1] == "as" {
                                renamed = exportsAs[2]
                        } else if len(exportsAs) != 1 {
                                if err := proc.warnOrError("invalid syntax in package re-export '%s' in %s", line[len(exportsPrefix):], strings.Join(basePath, ".")); err != nil {
                                        return nil, "", false, err
                                }
                        }
                        exports = append(exports, &packageExport{
                                Short:   partsShort,
                                Renamed: appendNew(partsShort[:len(partsShort)-1], renamed),
                                Long:    appendNew(basePath, partsShort...)})
                        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, strings.TrimSuffix(outText.String(), "\n"), anyExports, nil
        }
        return exports, pkgDocs, anyExports, nil
}

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

mlange-42 / modo / 13103549969

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