14726707652

Committed 29 Apr 2025 08:23AM UTC coverage: 87.541% (-2.9%) from 90.419%

Build # 14726707652

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.98 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
                }

                switch i {
                case 1:
                        serviceName = arg
                case 2:
                        resourceName = arg
                case 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	switch i {	1✔
48	case 1:	1✔
49	serviceName = arg	1✔
50	case 2:	1✔
51	resourceName = arg	1✔
52	case 3:	1✔
53	operationName = arg	1✔
54	}
55	longNamedArgs = args[i+1:]	1✔
56	}
57	return serviceName, resourceName, operationName, longNamedArgs	1✔
58	}
59
60	func parseLongNamedArgValue(value string, flag *FlagDefinition) (any, error) {	1✔
61	var flagType string	1✔
62	switch flag.Type {	1✔
63	case FlagTypeBoolean:	1✔
64	flagType = parser.ParameterTypeBoolean	1✔
65	case FlagTypeInteger:	1✔
66	flagType = parser.ParameterTypeInteger	1✔
NEW 67	case FlagTypeStringArray:	×
NEW 68	flagType = parser.ParameterTypeStringArray	×
69	default:	1✔
70	flagType = parser.ParameterTypeString	1✔
71	}
72	typeConverter := newTypeConverter()	1✔
73	return typeConverter.Convert(value, *parser.NewParameter(flag.Name, flagType, "", "", "", true, nil, nil, nil))	1✔
74	}
75
76	func parseLongNamedArgValues(args []string) (map[string]string, error) {	1✔
77	values := map[string]string{}	1✔
78	name := ""	1✔
79	for _, arg := range append(args, longNamedPrefix) {	2✔
80	if strings.HasPrefix(arg, longNamedPrefix) {	2✔
81	if name != "" {	2✔
82	values[name] = "true"	1✔
83	}	1✔
84	name = arg[2:]	1✔
85	} else if name != "" {	2✔
86	values[name] = arg	1✔
87	name = ""	1✔
88	} else {	2✔
89	return map[string]string{}, fmt.Errorf("Unknown argument '%s'", arg)	1✔
90	}	1✔
91	}
92	return values, nil	1✔
93	}
94
95	func parseLongNamedFlagValues(args []string, flags []*FlagDefinition) (map[string]any, error) {	1✔
96	values, err := parseLongNamedArgValues(args)	1✔
97	if err != nil {	2✔
98	return map[string]any{}, err	1✔
99	}	1✔
100
101	result := map[string]any{}	1✔
102	for _, flag := range flags {	2✔
103	value, ok := values[flag.Name]	1✔
104	if !ok {	2✔
105	value, ok = os.LookupEnv(flag.EnvVarName)	1✔
106	}	1✔
107
108	if ok {	2✔
109	parsedValue, err := parseLongNamedArgValue(value, flag)	1✔
110	if err != nil {	2✔
111	return result, err	1✔
112	}	1✔
113	result[flag.Name] = parsedValue	1✔
114	} else if flag.DefaultValue != nil {	2✔
115	result[flag.Name] = flag.DefaultValue	1✔
116	}	1✔
117	}
118	return result, nil	1✔
119	}
120
121	func NewArgsParser(args []string, flags []FlagDefinition) (ArgsParser, error) {	1✔
122	serviceName, resourceName, operationName, longNamedArgs := parseNameArgs(args)	1✔
123	values, err := parseLongNamedFlagValues(longNamedArgs, flags)	1✔
124	return &ArgsParser{serviceName, resourceName, operationName, values}, err	1✔
125	}	1✔

UiPath / uipathcli / 14726707652

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