11216909938

Committed 07 Oct 2024 01:45PM UTC coverage: 90.416% (-0.03%) from 90.447%

Build # 11216909938

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #123 from UiPath/feature/command-builder

Create command abstraction and split up command builder

Run Details

460 of 475 new or added lines in 8 files covered. (96.84%)

1 existing line in 1 file now uncovered.

4264 of 4716 relevant lines covered (90.42%)

1.02 hits per line

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

92.99

/commandline/cli.go

// Package commandline is responsible for creating, parsing and validating
// command line arguments.
package commandline

import (
        "fmt"
        "io"

        "github.com/UiPath/uipathcli/config"
        "github.com/UiPath/uipathcli/executor"
        "github.com/UiPath/uipathcli/utils"
        "github.com/urfave/cli/v2"
)

// Cli is a wrapper for building the CLI commands.
type Cli struct {
        stdIn              io.Reader
        stdOut             io.Writer
        stdErr             io.Writer
        coloredOutput      bool
        definitionProvider DefinitionProvider
        configProvider     config.ConfigProvider
        executor           executor.Executor
        pluginExecutor     executor.Executor
}

func (c Cli) run(args []string, input utils.Stream) error {
        err := c.configProvider.Load()
        if err != nil {
                return err
        }

        CommandBuilder := CommandBuilder{
                Input:              input,
                StdIn:              c.stdIn,
                StdOut:             c.stdOut,
                StdErr:             c.stdErr,
                ConfigProvider:     c.configProvider,
                Executor:           c.executor,
                PluginExecutor:     c.pluginExecutor,
                DefinitionProvider: c.definitionProvider,
        }

        flags := NewFlagBuilder().
                AddDefaultFlags(false).
                Build()

        commands, err := CommandBuilder.Create(args)
        if err != nil {
                return err
        }

        app := &cli.App{
                Name:                      "uipath",
                Usage:                     "Command-Line Interface for UiPath Services",
                UsageText:                 "uipath <service> <operation> --parameter",
                Version:                   "1.0",
                Flags:                     c.convertFlags(flags...),
                Commands:                  c.convertCommands(commands...),
                Writer:                    c.stdOut,
                ErrWriter:                 c.stdErr,
                HideVersion:               true,
                HideHelpCommand:           true,
                DisableSliceFlagSeparator: true,
        }
        return app.Run(args)
}

const colorRed = "\033[31m"
const colorReset = "\033[0m"

func (c Cli) Run(args []string, input utils.Stream) error {
        err := c.run(args, input)
        if err != nil {
                message := err.Error()
                if c.coloredOutput {
                        message = colorRed + err.Error() + colorReset
                }
                fmt.Fprintln(c.stdErr, message)
        }
        return err
}

func NewCli(
        stdIn io.Reader,
        stdOut io.Writer,
        stdErr io.Writer,
        colors bool,
        definitionProvider DefinitionProvider,
        configProvider config.ConfigProvider,
        executor executor.Executor,
        pluginExecutor executor.Executor,
) *Cli {
        return &Cli{stdIn, stdOut, stdErr, colors, definitionProvider, configProvider, executor, pluginExecutor}
}

func (c Cli) convertCommand(command *CommandDefinition) *cli.Command {
        result := cli.Command{
                Name:               command.Name,
                Usage:              command.Summary,
                Description:        command.Description,
                Flags:              c.convertFlags(command.Flags...),
                Subcommands:        c.convertCommands(command.Subcommands...),
                CustomHelpTemplate: command.HelpTemplate,
                Hidden:             command.Hidden,
                HideHelp:           true,
        }
        if command.Action != nil {
                result.Action = func(context *cli.Context) error {
                        return command.Action(&CommandExecContext{context})
                }
        }
        return &result
}

func (c Cli) convertCommands(commands ...*CommandDefinition) []*cli.Command {
        result := []*cli.Command{}
        for _, command := range commands {
                result = append(result, c.convertCommand(command))
        }
        return result
}

func (c Cli) convertStringSliceFlag(flag *FlagDefinition) *cli.StringSliceFlag {
        envVars := []string{}
        if flag.EnvVarName != "" {
                envVars = append(envVars, flag.EnvVarName)
        }
        var value *cli.StringSlice
        if flag.DefaultValue != nil {
                value = cli.NewStringSlice(flag.DefaultValue.([]string)...)
        }
        return &cli.StringSliceFlag{
                Name:     flag.Name,
                Usage:    flag.Summary,
                EnvVars:  envVars,
                Required: flag.Required,
                Hidden:   flag.Hidden,
                Value:    value,
        }
}

func (c Cli) convertIntFlag(flag *FlagDefinition) *cli.IntFlag {
        envVars := []string{}
        if flag.EnvVarName != "" {
                envVars = append(envVars, flag.EnvVarName)
        }
        var value int
        if flag.DefaultValue != nil {
                value = flag.DefaultValue.(int)
        }
        return &cli.IntFlag{
                Name:     flag.Name,
                Usage:    flag.Summary,
                EnvVars:  envVars,
                Required: flag.Required,
                Hidden:   flag.Hidden,
                Value:    value,
        }
}

func (c Cli) convertBoolFlag(flag *FlagDefinition) *cli.BoolFlag {
        envVars := []string{}
        if flag.EnvVarName != "" {
                envVars = append(envVars, flag.EnvVarName)
        }
        var value bool
        if flag.DefaultValue != nil {
                value = flag.DefaultValue.(bool)
        }
        return &cli.BoolFlag{
                Name:     flag.Name,
                Usage:    flag.Summary,
                EnvVars:  envVars,
                Required: flag.Required,
                Hidden:   flag.Hidden,
                Value:    value,
        }
}

func (c Cli) convertStringFlag(flag *FlagDefinition) *cli.StringFlag {
        envVars := []string{}
        if flag.EnvVarName != "" {
                envVars = append(envVars, flag.EnvVarName)
        }
        var value string
        if flag.DefaultValue != nil {
                value = flag.DefaultValue.(string)
        }
        return &cli.StringFlag{
                Name:     flag.Name,
                Usage:    flag.Summary,
                EnvVars:  envVars,
                Required: flag.Required,
                Hidden:   flag.Hidden,
                Value:    value,
        }
}

func (c Cli) convertFlag(flag *FlagDefinition) cli.Flag {
        switch flag.Type {
        case FlagTypeStringArray:
                return c.convertStringSliceFlag(flag)
        case FlagTypeInteger:
                return c.convertIntFlag(flag)
        case FlagTypeBoolean:
                return c.convertBoolFlag(flag)
        case FlagTypeString:
                return c.convertStringFlag(flag)
        }
        panic(fmt.Sprintf("Unknown flag type: %s", flag.Type.String()))
}

func (c Cli) convertFlags(flags ...*FlagDefinition) []cli.Flag {
        result := []cli.Flag{}
        for _, flag := range flags {
                result = append(result, c.convertFlag(flag))
        }
        return result
}

1	// Package commandline is responsible for creating, parsing and validating
2	// command line arguments.
3	package commandline
4
5	import (
6	"fmt"
7	"io"
8
9	"github.com/UiPath/uipathcli/config"
10	"github.com/UiPath/uipathcli/executor"
11	"github.com/UiPath/uipathcli/utils"
12	"github.com/urfave/cli/v2"
13	)
14
15	// Cli is a wrapper for building the CLI commands.
16	type Cli struct {
17	stdIn io.Reader
18	stdOut io.Writer
19	stdErr io.Writer
20	coloredOutput bool
21	definitionProvider DefinitionProvider
22	configProvider config.ConfigProvider
23	executor executor.Executor
24	pluginExecutor executor.Executor
25	}
26
27	func (c Cli) run(args []string, input utils.Stream) error {	1✔
28	err := c.configProvider.Load()	1✔
29	if err != nil {	1✔
30	return err	×
31	}	×
32
33	CommandBuilder := CommandBuilder{	1✔
34	Input: input,	1✔
35	StdIn: c.stdIn,	1✔
36	StdOut: c.stdOut,	1✔
37	StdErr: c.stdErr,	1✔
38	ConfigProvider: c.configProvider,	1✔
39	Executor: c.executor,	1✔
40	PluginExecutor: c.pluginExecutor,	1✔
41	DefinitionProvider: c.definitionProvider,	1✔
42	}	1✔
43		1✔
44	flags := NewFlagBuilder().	1✔
45	AddDefaultFlags(false).	1✔
46	Build()	1✔
47		1✔
48	commands, err := CommandBuilder.Create(args)	1✔
49	if err != nil {	2✔
50	return err	1✔
51	}	1✔
52
53	app := &cli.App{	1✔
54	Name: "uipath",	1✔
55	Usage: "Command-Line Interface for UiPath Services",	1✔
56	UsageText: "uipath <service> <operation> --parameter",	1✔
57	Version: "1.0",	1✔
58	Flags: c.convertFlags(flags...),	1✔
59	Commands: c.convertCommands(commands...),	1✔
60	Writer: c.stdOut,	1✔
61	ErrWriter: c.stdErr,	1✔
62	HideVersion: true,	1✔
63	HideHelpCommand: true,	1✔
64	DisableSliceFlagSeparator: true,	1✔
65	}	1✔
66	return app.Run(args)	1✔
67	}
68
69	const colorRed = "\033[31m"
70	const colorReset = "\033[0m"
71
72	func (c Cli) Run(args []string, input utils.Stream) error {	1✔
73	err := c.run(args, input)	1✔
74	if err != nil {	2✔
75	message := err.Error()	1✔
76	if c.coloredOutput {	1✔
77	message = colorRed + err.Error() + colorReset	×
78	}	×
79	fmt.Fprintln(c.stdErr, message)	1✔
80	}
81	return err	1✔
82	}
83
84	func NewCli(
85	stdIn io.Reader,
86	stdOut io.Writer,
87	stdErr io.Writer,
88	colors bool,
89	definitionProvider DefinitionProvider,
90	configProvider config.ConfigProvider,
91	executor executor.Executor,
92	pluginExecutor executor.Executor,
93	) *Cli {	1✔
94	return &Cli{stdIn, stdOut, stdErr, colors, definitionProvider, configProvider, executor, pluginExecutor}	1✔
95	}	1✔
96
97	func (c Cli) convertCommand(command CommandDefinition) cli.Command {	1✔
98	result := cli.Command{	1✔
99	Name: command.Name,	1✔
100	Usage: command.Summary,	1✔
101	Description: command.Description,	1✔
102	Flags: c.convertFlags(command.Flags...),	1✔
103	Subcommands: c.convertCommands(command.Subcommands...),	1✔
104	CustomHelpTemplate: command.HelpTemplate,	1✔
105	Hidden: command.Hidden,	1✔
106	HideHelp: true,	1✔
107	}	1✔
108	if command.Action != nil {	2✔
109	result.Action = func(context *cli.Context) error {	2✔
110	return command.Action(&CommandExecContext{context})	1✔
111	}	1✔
112	}
113	return &result	1✔
114	}
115
116	func (c Cli) convertCommands(commands ...CommandDefinition) []cli.Command {	1✔
117	result := []*cli.Command{}	1✔
118	for _, command := range commands {	2✔
119	result = append(result, c.convertCommand(command))	1✔
120	}	1✔
121	return result	1✔
122	}
123
124	func (c Cli) convertStringSliceFlag(flag FlagDefinition) cli.StringSliceFlag {	1✔
125	envVars := []string{}	1✔
126	if flag.EnvVarName != "" {	1✔
NEW 127	envVars = append(envVars, flag.EnvVarName)	×
NEW 128	}	×
129	var value *cli.StringSlice	1✔
130	if flag.DefaultValue != nil {	1✔
NEW 131	value = cli.NewStringSlice(flag.DefaultValue.([]string)...)	×
NEW 132	}	×
133	return &cli.StringSliceFlag{	1✔
134	Name: flag.Name,	1✔
135	Usage: flag.Summary,	1✔
136	EnvVars: envVars,	1✔
137	Required: flag.Required,	1✔
138	Hidden: flag.Hidden,	1✔
139	Value: value,	1✔
140	}	1✔
141	}
142
143	func (c Cli) convertIntFlag(flag FlagDefinition) cli.IntFlag {	1✔
144	envVars := []string{}	1✔
145	if flag.EnvVarName != "" {	1✔
NEW 146	envVars = append(envVars, flag.EnvVarName)	×
NEW 147	}	×
148	var value int	1✔
149	if flag.DefaultValue != nil {	2✔
150	value = flag.DefaultValue.(int)	1✔
151	}	1✔
152	return &cli.IntFlag{	1✔
153	Name: flag.Name,	1✔
154	Usage: flag.Summary,	1✔
155	EnvVars: envVars,	1✔
156	Required: flag.Required,	1✔
157	Hidden: flag.Hidden,	1✔
158	Value: value,	1✔
159	}	1✔
160	}
161
162	func (c Cli) convertBoolFlag(flag FlagDefinition) cli.BoolFlag {	1✔
163	envVars := []string{}	1✔
164	if flag.EnvVarName != "" {	2✔
165	envVars = append(envVars, flag.EnvVarName)	1✔
166	}	1✔
167	var value bool	1✔
168	if flag.DefaultValue != nil {	2✔
169	value = flag.DefaultValue.(bool)	1✔
170	}	1✔
171	return &cli.BoolFlag{	1✔
172	Name: flag.Name,	1✔
173	Usage: flag.Summary,	1✔
174	EnvVars: envVars,	1✔
175	Required: flag.Required,	1✔
176	Hidden: flag.Hidden,	1✔
177	Value: value,	1✔
178	}	1✔
179	}
180
181	func (c Cli) convertStringFlag(flag FlagDefinition) cli.StringFlag {	1✔
182	envVars := []string{}	1✔
183	if flag.EnvVarName != "" {	2✔
184	envVars = append(envVars, flag.EnvVarName)	1✔
185	}	1✔
186	var value string	1✔
187	if flag.DefaultValue != nil {	2✔
188	value = flag.DefaultValue.(string)	1✔
189	}	1✔
190	return &cli.StringFlag{	1✔
191	Name: flag.Name,	1✔
192	Usage: flag.Summary,	1✔
193	EnvVars: envVars,	1✔
194	Required: flag.Required,	1✔
195	Hidden: flag.Hidden,	1✔
196	Value: value,	1✔
197	}	1✔
198	}
199
200	func (c Cli) convertFlag(flag *FlagDefinition) cli.Flag {	1✔
201	switch flag.Type {	1✔
202	case FlagTypeStringArray:	1✔
203	return c.convertStringSliceFlag(flag)	1✔
204	case FlagTypeInteger:	1✔
205	return c.convertIntFlag(flag)	1✔
206	case FlagTypeBoolean:	1✔
207	return c.convertBoolFlag(flag)	1✔
208	case FlagTypeString:	1✔
209	return c.convertStringFlag(flag)	1✔
210	}
NEW 211	panic(fmt.Sprintf("Unknown flag type: %s", flag.Type.String()))	×
212	}
213
214	func (c Cli) convertFlags(flags ...*FlagDefinition) []cli.Flag {	1✔
215	result := []cli.Flag{}	1✔
216	for _, flag := range flags {	2✔
217	result = append(result, c.convertFlag(flag))	1✔
218	}	1✔
219	return result	1✔
220	}

UiPath / uipathcli / 11216909938

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