12856602807

Committed 19 Jan 2025 07:39PM CUT coverage: 59.246%. Remained the same

Build # 12856602807

Build Type

push

github

Committed by

web-flow

Commit Message

Add docstrings for top-level methods (#70)

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

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
}

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

mlange-42 / modo / 12856602807

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