13143701660

Committed 04 Feb 2025 07:53PM CUT coverage: 72.635% (+0.04%) from 72.594%

Build # 13143701660

Build Type

Pull #189

github

Committed by

web-flow

Commit Message

Merge 85faab478 into 0caef4bbc

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

Run Details

35 of 47 new or added lines in 3 files covered. (74.47%)

2 existing lines in 1 file now uncovered.

1566 of 2156 relevant lines covered (72.63%)

25.3 hits per line

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

82.14

/document/exports.go

package document

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

const exportsMarker = "Exports:"
const exportsPrefix = "- "

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

mlange-42 / modo / 13143701660

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