14267892308

Committed 04 Apr 2025 02:41PM UTC coverage: 6.101% (-0.07%) from 6.172%

Build # 14267892308

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #110 from foomo/feature/v0.11.0

feat: v0.11.0

Run Details

3 of 122 new or added lines in 9 files covered. (2.46%)

5 existing lines in 2 files now uncovered.

159 of 2606 relevant lines covered (6.1%)

0.71 hits per line

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

26.88

/pkg/command/tree/root.go

package tree

import (
        "context"
        "sort"

        "github.com/foomo/posh/pkg/prompt/goprompt"
        "github.com/foomo/posh/pkg/readline"
)

type Root interface {
        Node() *Node
        Complete(ctx context.Context, r *readline.Readline) []goprompt.Suggest
        Execute(ctx context.Context, r *readline.Readline) error
        Help(ctx context.Context, r *readline.Readline) string
}

type root struct {
        node *Node
}

// ------------------------------------------------------------------------------------------------
// ~ Constructor
// ------------------------------------------------------------------------------------------------

func New(node *Node) Root {
        return &root{
                node: node,
        }
}

// ------------------------------------------------------------------------------------------------
// ~ Public methods
// ------------------------------------------------------------------------------------------------

func (t *root) Node() *Node {
        return t.node
}

func (t *root) Complete(ctx context.Context, r *readline.Readline) []goprompt.Suggest {
        var suggests []goprompt.Suggest
        switch r.Mode() {
        case readline.ModeArgs:
                if r.Args().LenLte(1) && len(t.node.Nodes) > 0 {
                        for _, command := range t.node.Nodes {
                                if command.Values != nil {
                                        suggests = command.Values(ctx, r)
                                } else {
                                        suggests = append(suggests, goprompt.Suggest{Text: command.Name, Description: command.Description})
                                }
                        }
                } else if cmd, i := t.node.find(ctx, r, 0); cmd == nil && t.node != nil {
                        if err := t.node.setFlags(ctx, r, false); err != nil {
                                return nil
                        } else {
                                suggests = t.node.completeArguments(ctx, t, r, 0)
                        }
                } else if cmd == nil {
                        return nil
                } else if err := cmd.setFlags(ctx, r, false); err != nil {
                        return nil
                } else {
                        suggests = cmd.completeArguments(ctx, t, r, i)
                }
        case readline.ModeFlags:
                if cmd, _ := t.node.find(ctx, r, 0); cmd == nil && t.node != nil {
                        if err := t.node.setFlags(ctx, r, false); err != nil {
                                return nil
                        } else {
                                suggests = t.node.completeFlags(r)
                        }
                } else if cmd == nil {
                        return nil
                } else if err := cmd.setFlags(ctx, r, false); err != nil {
                        return nil
                } else {
                        suggests = cmd.completeFlags(r)
                }
        case readline.ModeAdditionalArgs:
                // do nothing
        }
        sort.Slice(suggests, func(i, j int) bool {
                return suggests[i].Text < suggests[j].Text
        })
        return suggests
}

func (t *root) Execute(ctx context.Context, r *readline.Readline) error {
        var (
                cmd   *Node
                index int
        )

        if t.node == nil {
                return ErrNoop
        }

        if r.Args().LenIs(0) {
                cmd = t.node
        } else if found, i := t.node.find(ctx, r, 0); found != nil {
                cmd = found
                index = i
        } else if t.node == nil {
                return ErrInvalidCommand
        } else {
                cmd = t.node
        }

        if err := cmd.setFlags(ctx, r, true); err != nil {
                return err
        } else if err := cmd.execute(ctx, r, index); err != nil {
                return err
        }
        return nil
}

func (t *root) Help(ctx context.Context, r *readline.Readline) string {
        var (
                cmd *Node
        )

        if t.node == nil {
                return "command not found"
        } else if r.Args().LenIs(1) {
                cmd = t.node
        } else if len(t.node.Nodes) == 0 {
                return "command not found"
        } else if found, _ := t.node.find(ctx, r, 1); found != nil {
                cmd = found
        } else {
                cmd = t.node
        }

        return cmd.help(ctx, r)
}

1	package tree
2
3	import (
4	"context"
5	"sort"
6
7	"github.com/foomo/posh/pkg/prompt/goprompt"
8	"github.com/foomo/posh/pkg/readline"
9	)
10
11	type Root interface {
12	Node() *Node
13	Complete(ctx context.Context, r *readline.Readline) []goprompt.Suggest
14	Execute(ctx context.Context, r *readline.Readline) error
15	Help(ctx context.Context, r *readline.Readline) string
16	}
17
18	type root struct {
19	node *Node
20	}
21
22	// ------------------------------------------------------------------------------------------------
23	// ~ Constructor
24	// ------------------------------------------------------------------------------------------------
25
26	func New(node *Node) Root {	11✔
27	return &root{	11✔
28	node: node,	11✔
29	}	11✔
30	}	11✔
31
32	// ------------------------------------------------------------------------------------------------
33	// ~ Public methods
34	// ------------------------------------------------------------------------------------------------
35
36	func (t root) Node() Node {	×
37	return t.node	×
38	}	×
39
40	func (t root) Complete(ctx context.Context, r readline.Readline) []goprompt.Suggest {	×
41	var suggests []goprompt.Suggest	×
42	switch r.Mode() {	×
43	case readline.ModeArgs:	×
44	if r.Args().LenLte(1) && len(t.node.Nodes) > 0 {	×
45	for _, command := range t.node.Nodes {	×
46	if command.Values != nil {	×
47	suggests = command.Values(ctx, r)	×
48	} else {	×
49	suggests = append(suggests, goprompt.Suggest{Text: command.Name, Description: command.Description})	×
50	}	×
51	}
52	} else if cmd, i := t.node.find(ctx, r, 0); cmd == nil && t.node != nil {	×
53	if err := t.node.setFlags(ctx, r, false); err != nil {	×
54	return nil	×
55	} else {	×
56	suggests = t.node.completeArguments(ctx, t, r, 0)	×
57	}	×
58	} else if cmd == nil {	×
59	return nil	×
60	} else if err := cmd.setFlags(ctx, r, false); err != nil {	×
61	return nil	×
62	} else {	×
NEW 63	suggests = cmd.completeArguments(ctx, t, r, i)	×
64	}	×
65	case readline.ModeFlags:	×
66	if cmd, _ := t.node.find(ctx, r, 0); cmd == nil && t.node != nil {	×
67	if err := t.node.setFlags(ctx, r, false); err != nil {	×
68	return nil	×
69	} else {	×
70	suggests = t.node.completeFlags(r)	×
71	}	×
72	} else if cmd == nil {	×
73	return nil	×
74	} else if err := cmd.setFlags(ctx, r, false); err != nil {	×
75	return nil	×
76	} else {	×
77	suggests = cmd.completeFlags(r)	×
78	}	×
79	case readline.ModeAdditionalArgs:	×
80	// do nothing
81	}
82	sort.Slice(suggests, func(i, j int) bool {	×
83	return suggests[i].Text < suggests[j].Text	×
84	})	×
85	return suggests	×
86	}
87
88	func (t root) Execute(ctx context.Context, r readline.Readline) error {	21✔
89	var (	21✔
90	cmd *Node	21✔
91	index int	21✔
92	)	21✔
93		21✔
94	if t.node == nil {	21✔
95	return ErrNoop	×
96	}	×
97
98	if r.Args().LenIs(0) {	28✔
99	cmd = t.node	7✔
100	} else if found, i := t.node.find(ctx, r, 0); found != nil {	30✔
101	cmd = found	9✔
102	index = i	9✔
103	} else if t.node == nil {	14✔
104	return ErrInvalidCommand	×
105	} else {	5✔
106	cmd = t.node	5✔
107	}	5✔
108
109	if err := cmd.setFlags(ctx, r, true); err != nil {	21✔
110	return err	×
111	} else if err := cmd.execute(ctx, r, index); err != nil {	42✔
112	return err	21✔
113	}	21✔
114	return nil	×
115	}
116
117	func (t root) Help(ctx context.Context, r readline.Readline) string {	×
118	var (	×
119	cmd *Node	×
120	)	×
121		×
122	if t.node == nil {	×
123	return "command not found"	×
124	} else if r.Args().LenIs(1) {	×
125	cmd = t.node	×
126	} else if len(t.node.Nodes) == 0 {	×
127	return "command not found"	×
128	} else if found, _ := t.node.find(ctx, r, 1); found != nil {	×
129	cmd = found	×
130	} else {	×
131	cmd = t.node	×
132	}	×
133
134	return cmd.help(ctx, r)	×
135	}

foomo / posh / 14267892308

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