14705937292

Committed 28 Apr 2025 10:49AM UTC coverage: 87.541% (-2.9%) from 90.419%

Build # 14705937292

Build Type

push

github

Committed by

thschmitt

Commit Message

Add support for UiPath DataService

Run Details

104 of 347 new or added lines in 5 files covered. (29.97%)

6394 of 7304 relevant lines covered (87.54%)

0.99 hits per line

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

97.65

/commandline/args_parser.go

package commandline

import (
        "fmt"
        "os"
        "strings"

        "github.com/UiPath/uipathcli/parser"
)

const longNamedPrefix = "--"

type ArgsParser struct {
        serviceName   string
        resourceName  string
        operationName string
        values        map[string]any
}

func (p ArgsParser) GetServiceName() any {
        return p.serviceName
}

func (p ArgsParser) GetResourceName() any {
        return p.resourceName
}

func (p ArgsParser) GetOperationName() any {
        return p.operationName
}

func (p ArgsParser) GetValue(name string) any {
        return p.values[name]
}

func parseNameArgs(args []string) (string, string, string, []string) {
        serviceName := ""
        resourceName := ""
        operationName := ""

        longNamedArgs := args[1:]
        for i, arg := range args {
                if i > 3 || strings.HasPrefix(arg, longNamedPrefix) {
                        break
                }

                if i == 1 {
                        serviceName = arg
                } else if i == 2 {
                        resourceName = arg
                } else if i == 3 {
                        operationName = arg
                }
                longNamedArgs = args[i+1:]
        }
        return serviceName, resourceName, operationName, longNamedArgs
}

func parseLongNamedArgValue(value string, flag *FlagDefinition) (any, error) {
        var flagType string
        switch flag.Type {
        case FlagTypeBoolean:
                flagType = parser.ParameterTypeBoolean
        case FlagTypeInteger:
                flagType = parser.ParameterTypeInteger
        case FlagTypeStringArray:
                flagType = parser.ParameterTypeStringArray
        default:
                flagType = parser.ParameterTypeString
        }
        typeConverter := newTypeConverter()
        return typeConverter.Convert(value, *parser.NewParameter(flag.Name, flagType, "", "", "", true, nil, nil, nil))
}

func parseLongNamedArgValues(args []string) (map[string]string, error) {
        values := map[string]string{}
        name := ""
        for _, arg := range append(args, longNamedPrefix) {
                if strings.HasPrefix(arg, longNamedPrefix) {
                        if name != "" {
                                values[name] = "true"
                        }
                        name = arg[2:]
                } else if name != "" {
                        values[name] = arg
                        name = ""
                } else {
                        return map[string]string{}, fmt.Errorf("Unknown argument '%s'", arg)
                }
        }
        return values, nil
}

func parseLongNamedFlagValues(args []string, flags []*FlagDefinition) (map[string]any, error) {
        values, err := parseLongNamedArgValues(args)
        if err != nil {
                return map[string]any{}, err
        }

        result := map[string]any{}
        for _, flag := range flags {
                value, ok := values[flag.Name]
                if !ok {
                        value, ok = os.LookupEnv(flag.EnvVarName)
                }

                if ok {
                        parsedValue, err := parseLongNamedArgValue(value, flag)
                        if err != nil {
                                return result, err
                        }
                        result[flag.Name] = parsedValue
                } else if flag.DefaultValue != nil {
                        result[flag.Name] = flag.DefaultValue
                }
        }
        return result, nil
}

func NewArgsParser(args []string, flags []*FlagDefinition) (*ArgsParser, error) {
        serviceName, resourceName, operationName, longNamedArgs := parseNameArgs(args)
        values, err := parseLongNamedFlagValues(longNamedArgs, flags)
        return &ArgsParser{serviceName, resourceName, operationName, values}, err
}

1	package commandline
2
3	import (
4	"fmt"
5	"os"
6	"strings"
7
8	"github.com/UiPath/uipathcli/parser"
9	)
10
11	const longNamedPrefix = "--"
12
13	type ArgsParser struct {
14	serviceName string
15	resourceName string
16	operationName string
17	values map[string]any
18	}
19
20	func (p ArgsParser) GetServiceName() any {	1✔
21	return p.serviceName	1✔
22	}	1✔
23
24	func (p ArgsParser) GetResourceName() any {	1✔
25	return p.resourceName	1✔
26	}	1✔
27
28	func (p ArgsParser) GetOperationName() any {	1✔
29	return p.operationName	1✔
30	}	1✔
31
32	func (p ArgsParser) GetValue(name string) any {	1✔
33	return p.values[name]	1✔
34	}	1✔
35
36	func parseNameArgs(args []string) (string, string, string, []string) {	1✔
37	serviceName := ""	1✔
38	resourceName := ""	1✔
39	operationName := ""	1✔
40		1✔
41	longNamedArgs := args[1:]	1✔
42	for i, arg := range args {	2✔
43	if i > 3 \|\| strings.HasPrefix(arg, longNamedPrefix) {	2✔
44	break	1✔
45	}
46
47	if i == 1 {	2✔
48	serviceName = arg	1✔
49	} else if i == 2 {	3✔
50	resourceName = arg	1✔
51	} else if i == 3 {	3✔
52	operationName = arg	1✔
53	}	1✔
54	longNamedArgs = args[i+1:]	1✔
55	}
56	return serviceName, resourceName, operationName, longNamedArgs	1✔
57	}
58
59	func parseLongNamedArgValue(value string, flag *FlagDefinition) (any, error) {	1✔
60	var flagType string	1✔
61	switch flag.Type {	1✔
62	case FlagTypeBoolean:	1✔
63	flagType = parser.ParameterTypeBoolean	1✔
64	case FlagTypeInteger:	1✔
65	flagType = parser.ParameterTypeInteger	1✔
NEW 66	case FlagTypeStringArray:	×
NEW 67	flagType = parser.ParameterTypeStringArray	×
68	default:	1✔
69	flagType = parser.ParameterTypeString	1✔
70	}
71	typeConverter := newTypeConverter()	1✔
72	return typeConverter.Convert(value, *parser.NewParameter(flag.Name, flagType, "", "", "", true, nil, nil, nil))	1✔
73	}
74
75	func parseLongNamedArgValues(args []string) (map[string]string, error) {	1✔
76	values := map[string]string{}	1✔
77	name := ""	1✔
78	for _, arg := range append(args, longNamedPrefix) {	2✔
79	if strings.HasPrefix(arg, longNamedPrefix) {	2✔
80	if name != "" {	2✔
81	values[name] = "true"	1✔
82	}	1✔
83	name = arg[2:]	1✔
84	} else if name != "" {	2✔
85	values[name] = arg	1✔
86	name = ""	1✔
87	} else {	2✔
88	return map[string]string{}, fmt.Errorf("Unknown argument '%s'", arg)	1✔
89	}	1✔
90	}
91	return values, nil	1✔
92	}
93
94	func parseLongNamedFlagValues(args []string, flags []*FlagDefinition) (map[string]any, error) {	1✔
95	values, err := parseLongNamedArgValues(args)	1✔
96	if err != nil {	2✔
97	return map[string]any{}, err	1✔
98	}	1✔
99
100	result := map[string]any{}	1✔
101	for _, flag := range flags {	2✔
102	value, ok := values[flag.Name]	1✔
103	if !ok {	2✔
104	value, ok = os.LookupEnv(flag.EnvVarName)	1✔
105	}	1✔
106
107	if ok {	2✔
108	parsedValue, err := parseLongNamedArgValue(value, flag)	1✔
109	if err != nil {	2✔
110	return result, err	1✔
111	}	1✔
112	result[flag.Name] = parsedValue	1✔
113	} else if flag.DefaultValue != nil {	2✔
114	result[flag.Name] = flag.DefaultValue	1✔
115	}	1✔
116	}
117	return result, nil	1✔
118	}
119
120	func NewArgsParser(args []string, flags []FlagDefinition) (ArgsParser, error) {	1✔
121	serviceName, resourceName, operationName, longNamedArgs := parseNameArgs(args)	1✔
122	values, err := parseLongNamedFlagValues(longNamedArgs, flags)	1✔
123	return &ArgsParser{serviceName, resourceName, operationName, values}, err	1✔
124	}	1✔

UiPath / uipathcli / 14705937292

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