FilesExpand file tree

trunk

/

args.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

118 lines (99 loc) · 2.87 KB

trunk

/

args.go

Copy path

Top

File metadata and controls

• Code
• Blame

118 lines (99 loc) · 2.87 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

package cmdutil

import (

"fmt"

"path/filepath"

"github.com/spf13/cobra"

"github.com/spf13/pflag"

)

func MinimumArgs(n int, msg string) cobra.PositionalArgs {

if msg == "" {

return cobra.MinimumNArgs(1)

}

return func(cmd *cobra.Command, args []string) error {

if len(args) < n {

return FlagErrorf("%s", msg)

}

return nil

}

}

func ExactArgs(n int, msg string) cobra.PositionalArgs {

return func(cmd *cobra.Command, args []string) error {

if len(args) > n {

return FlagErrorf("too many arguments")

}

if len(args) < n {

return FlagErrorf("%s", msg)

}

return nil

}

}

// RangeArgs is cobra.RangeArgs with the usage errors ExactArgs gives: more

// than max arguments is "too many arguments", and fewer than min is msg, so

// the command can say which argument is missing. Both are flag errors, which

// print the usage.

func RangeArgs(min, max int, msg string) cobra.PositionalArgs {

return func(cmd *cobra.Command, args []string) error {

if len(args) > max {

return FlagErrorf("too many arguments")

}

if len(args) < min {

return FlagErrorf("%s", msg)

}

return nil

}

}

func NoArgsQuoteReminder(cmd *cobra.Command, args []string) error {

if len(args) < 1 {

return nil

}

errMsg := fmt.Sprintf("unknown argument %q", args[0])

if len(args) > 1 {

errMsg = fmt.Sprintf("unknown arguments %q", args)

}

hasValueFlag := false

cmd.Flags().Visit(func(f *pflag.Flag) {

if f.Value.Type() != "bool" {

hasValueFlag = true

}

})

if hasValueFlag {

errMsg += "; please quote all values that have spaces"

}

return FlagErrorf("%s", errMsg)

}

// Partition takes a slice of any type T and separates it into two slices

// of the same type based on the provided predicate function. Any item

// that returns true for the predicate will be included in the first slice

// returned, and any item that returns false for the predicate will be

// included in the second slice returned.

func Partition[T any](slice []T, predicate func(T) bool) ([]T, []T) {

var matching, nonMatching []T

for _, item := range slice {

if predicate(item) {

matching = append(matching, item)

} else {

nonMatching = append(nonMatching, item)

}

}

return matching, nonMatching

}

// GlobPaths expands a list of file patterns into a list of file paths.

// If no files match a pattern, that pattern will return an error.

// If no pattern is passed, this returns an empty list and no error.

//

// For information on supported glob patterns, see

// https://pkg.go.dev/path/filepath#Match

func GlobPaths(patterns []string) ([]string, error) {

expansions := []string{}

for _, pattern := range patterns {

matches, err := filepath.Glob(pattern)

if err != nil {

return nil, fmt.Errorf("%s: %v", pattern, err)

}

if len(matches) == 0 {

return []string{}, fmt.Errorf("no matches found for `%s`", pattern)

}

expansions = append(expansions, matches...)

}

return expansions, nil

}