13180577064

Committed 06 Feb 2025 02:07PM CUT coverage: 73.089% (-1.0%) from 74.08%

Build # 13180577064

Build Type

Pull #212

github

Committed by

web-flow

Commit Message

Merge 98d3dc552 into 1566231bf

Pull Request Pull Request #212: Add tests for CLI commands

Run Details

36 of 54 new or added lines in 6 files covered. (66.67%)

2314 of 3166 relevant lines covered (73.09%)

40.88 hits per line

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

61.02

/internal/document/transclude.go

package document

import (
        "fmt"
        "strings"
)

func (proc *Processor) processTranscludes(docs *Docs) error {
        return proc.replaceTranscludesPackage(docs.Decl, []string{})
}

func (proc *Processor) replaceTranscludesPackage(p *Package, elems []string) error {
        newElems := appendNew(elems, p.Name)
        for _, pkg := range p.Packages {
                if err := proc.replaceTranscludesPackage(pkg, newElems); err != nil {
                        return err
                }
        }
        for _, mod := range p.Modules {
                if err := proc.replaceTranscludesModule(mod, newElems); err != nil {
                        return err
                }
        }
        return nil
}

func (proc *Processor) replaceTranscludesModule(m *Module, elems []string) error {
        newElems := appendNew(elems, m.Name)
        for _, s := range m.Structs {
                structElems := appendNew(newElems, s.Name)
                for _, f := range s.Functions {
                        if len(f.Overloads) == 0 {
                                if err := proc.replaceTranscludes(f, structElems, len(newElems)); err != nil {
                                        return err
                                }
                        } else {
                                for _, o := range f.Overloads {
                                        if err := proc.replaceTranscludes(o, structElems, len(newElems)); err != nil {
                                                return err
                                        }
                                }
                        }
                }

        }
        return nil
}

func (proc *Processor) replaceTranscludes(elem *Function, elems []string, modElems int) error {
        indices, err := findLinks(elem.Summary, transcludeRegex, false)
        if err != nil {
                return err
        }
        if len(indices) == 0 {
                return nil
        }
        if len(indices) > 2 {
                return fmt.Errorf("multiple doc transclusions in %s", strings.Join(elems, "."))
        }
        start, end := indices[0], indices[1]
        link := elem.Summary[start+1 : end-1]

        content, ok, err := proc.refToPlaceholder(link, elems, modElems, false)
        if err != nil {
                return err
        }
        if !ok {
                return nil
        }

        from, ok := proc.allPaths[content]
        if !ok {
                return fmt.Errorf("doc transclusions source %s (%s) in %s not found", link, content, strings.Join(elems, "."))
        }
        trait, ok := from.(*Trait)
        if !ok {
                return fmt.Errorf("doc transclusions source %s (%s) in %s is not a trait", link, content, strings.Join(elems, "."))
        }

        sourceFunc, ok := findImplementedFunction(elem, trait)
        if !ok {
                return fmt.Errorf("no matching doc transclusion found for %s.%s in %s. Required signature: %s", link, elem.Name, strings.Join(elems, "."), elem.Signature)
        }

        elem.MemberSummary = sourceFunc.MemberSummary
        elem.Description = sourceFunc.Description
        elem.ReturnsDoc = sourceFunc.ReturnsDoc
        elem.RaisesDoc = sourceFunc.RaisesDoc

        for i, arg := range sourceFunc.Args {
                elem.Args[i].Description = arg.Description
        }
        for i, par := range sourceFunc.Parameters {
                elem.Parameters[i].Description = par.Description
        }

        return nil
}

func findImplementedFunction(structFunc *Function, trait *Trait) (*Function, bool) {
        var sourceFunc *Function
        for _, f := range trait.Functions {
                if f.Name != structFunc.Name {
                        continue
                }
                if len(f.Overloads) == 0 {
                        if functionsMatch(structFunc, f) {
                                sourceFunc = f
                        }
                        break
                }
                for _, o := range f.Overloads {
                        if functionsMatch(structFunc, o) {
                                sourceFunc = o
                                break
                        }
                }
                break
        }
        return sourceFunc, sourceFunc != nil
}

func functionsMatch(s, t *Function) bool {
        if len(s.Args) != len(t.Args) {
                return false
        }
        if len(s.Parameters) != len(t.Parameters) {
                return false
        }

        for i := range s.Args {
                argS, argT := s.Args[i], t.Args[i]
                if argS.Type != argT.Type {
                        if !(argS.Type == "Self" && argT.Type == "_Self") {
                                return false
                        }
                }
                if argS.PassingKind != argT.PassingKind {
                        return false
                }
                if argS.Convention != argT.Convention {
                        return false
                }
        }

        for i := range s.Parameters {
                parS, parT := s.Parameters[i], t.Parameters[i]
                if parS.Type != parT.Type {
                        return false
                }
                if parS.PassingKind != parT.PassingKind {
                        return false
                }
        }

        return true
}

1	package document
2
3	import (
4	"fmt"
5	"strings"
6	)
7
8	func (proc Processor) processTranscludes(docs Docs) error {	8✔
9	return proc.replaceTranscludesPackage(docs.Decl, []string{})	8✔
10	}	8✔
11
12	func (proc Processor) replaceTranscludesPackage(p Package, elems []string) error {	12✔
13	newElems := appendNew(elems, p.Name)	12✔
14	for _, pkg := range p.Packages {	16✔
15	if err := proc.replaceTranscludesPackage(pkg, newElems); err != nil {	4✔
16	return err	×
17	}	×
18	}
19	for _, mod := range p.Modules {	29✔
20	if err := proc.replaceTranscludesModule(mod, newElems); err != nil {	17✔
21	return err	×
22	}	×
23	}
24	return nil	12✔
25	}
26
27	func (proc Processor) replaceTranscludesModule(m Module, elems []string) error {	17✔
28	newElems := appendNew(elems, m.Name)	17✔
29	for _, s := range m.Structs {	32✔
30	structElems := appendNew(newElems, s.Name)	15✔
31	for _, f := range s.Functions {	32✔
32	if len(f.Overloads) == 0 {	17✔
33	if err := proc.replaceTranscludes(f, structElems, len(newElems)); err != nil {	×
34	return err	×
35	}	×
36	} else {	17✔
37	for _, o := range f.Overloads {	34✔
38	if err := proc.replaceTranscludes(o, structElems, len(newElems)); err != nil {	17✔
39	return err	×
40	}	×
41	}
42	}
43	}
44
45	}
46	return nil	17✔
47	}
48
49	func (proc Processor) replaceTranscludes(elem Function, elems []string, modElems int) error {	17✔
50	indices, err := findLinks(elem.Summary, transcludeRegex, false)	17✔
51	if err != nil {	17✔
52	return err	×
53	}	×
54	if len(indices) == 0 {	30✔
55	return nil	13✔
56	}	13✔
57	if len(indices) > 2 {	4✔
58	return fmt.Errorf("multiple doc transclusions in %s", strings.Join(elems, "."))	×
59	}	×
60	start, end := indices[0], indices[1]	4✔
61	link := elem.Summary[start+1 : end-1]	4✔
62		4✔
63	content, ok, err := proc.refToPlaceholder(link, elems, modElems, false)	4✔
64	if err != nil {	4✔
65	return err	×
66	}	×
67	if !ok {	4✔
68	return nil	×
69	}	×
70
71	from, ok := proc.allPaths[content]	4✔
72	if !ok {	4✔
73	return fmt.Errorf("doc transclusions source %s (%s) in %s not found", link, content, strings.Join(elems, "."))	×
74	}	×
75	trait, ok := from.(*Trait)	4✔
76	if !ok {	4✔
77	return fmt.Errorf("doc transclusions source %s (%s) in %s is not a trait", link, content, strings.Join(elems, "."))	×
78	}	×
79
80	sourceFunc, ok := findImplementedFunction(elem, trait)	4✔
81	if !ok {	4✔
82	return fmt.Errorf("no matching doc transclusion found for %s.%s in %s. Required signature: %s", link, elem.Name, strings.Join(elems, "."), elem.Signature)	×
83	}	×
84
85	elem.MemberSummary = sourceFunc.MemberSummary	4✔
86	elem.Description = sourceFunc.Description	4✔
87	elem.ReturnsDoc = sourceFunc.ReturnsDoc	4✔
88	elem.RaisesDoc = sourceFunc.RaisesDoc	4✔
89		4✔
90	for i, arg := range sourceFunc.Args {	12✔
91	elem.Args[i].Description = arg.Description	8✔
92	}	8✔
93	for i, par := range sourceFunc.Parameters {	4✔
94	elem.Parameters[i].Description = par.Description	×
95	}	×
96
97	return nil	4✔
98	}
99
100	func findImplementedFunction(structFunc Function, trait Trait) (*Function, bool) {	4✔
101	var sourceFunc *Function	4✔
102	for _, f := range trait.Functions {	12✔
103	if f.Name != structFunc.Name {	12✔
104	continue	4✔
105	}
106	if len(f.Overloads) == 0 {	4✔
107	if functionsMatch(structFunc, f) {	×
108	sourceFunc = f	×
109	}	×
110	break	×
111	}
112	for _, o := range f.Overloads {	8✔
113	if functionsMatch(structFunc, o) {	8✔
114	sourceFunc = o	4✔
115	break	4✔
116	}
117	}
118	break	4✔
119	}
120	return sourceFunc, sourceFunc != nil	4✔
121	}
122
123	func functionsMatch(s, t *Function) bool {	4✔
124	if len(s.Args) != len(t.Args) {	4✔
125	return false	×
126	}	×
127	if len(s.Parameters) != len(t.Parameters) {	4✔
128	return false	×
129	}	×
130
131	for i := range s.Args {	12✔
132	argS, argT := s.Args[i], t.Args[i]	8✔
133	if argS.Type != argT.Type {	12✔
134	if !(argS.Type == "Self" && argT.Type == "_Self") {	4✔
135	return false	×
136	}	×
137	}
138	if argS.PassingKind != argT.PassingKind {	8✔
139	return false	×
140	}	×
141	if argS.Convention != argT.Convention {	8✔
142	return false	×
143	}	×
144	}
145
146	for i := range s.Parameters {	4✔
147	parS, parT := s.Parameters[i], t.Parameters[i]	×
148	if parS.Type != parT.Type {	×
149	return false	×
150	}	×
151	if parS.PassingKind != parT.PassingKind {	×
152	return false	×
153	}	×
154	}
155
156	return true	4✔
157	}

mlange-42 / modo / 13180577064

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