Beispiel #1
0
			parser.Opt("--one", args.IsString())
			parser.Opt("--two", args.IsString())
			parser.Opt("--three", args.IsString())
			cmdLine := []string{"--three", "this is three value", "--one", "this is from the cmd line"}
			opt, err := parser.ParseArgs(&cmdLine)
			input := []byte("one=this is one value\ntwo=this is two value\n")
			opt, err = parser.ParseIni(input)
			Expect(err).To(BeNil())
			Expect(opt.String("one")).To(Equal("this is from the cmd line"))
			Expect(opt.String("three")).To(Equal("this is three value"))
		})

		It("Should clear any pre existing slices in the struct before assignment", func() {
			parser := args.Parser()
			var list []string
			parser.Opt("--list", args.StoreSlice(&list), args.Default("foo,bar,bit"))

			opt, err := parser.ParseArgs(nil)
			Expect(err).To(BeNil())
			Expect(opt.Slice("list")).To(Equal([]string{"foo", "bar", "bit"}))
			Expect(list).To(Equal([]string{"foo", "bar", "bit"}))

			input := []byte("list=six,five,four\n")
			opt, err = parser.ParseIni(input)
			Expect(err).To(BeNil())
			Expect(opt.Slice("list")).To(Equal([]string{"six", "five", "four"}))
			Expect(list).To(Equal([]string{"six", "five", "four"}))
		})
	})

	Describe("args.ParseArgs(nil)", func() {
Beispiel #2
0
func main() {
	var conf Config

	//parser := args.Parser(args.WarnUnknownArgs(), args.UsageName("my-program"))
	parser := args.Parser()

	// Positional Argument, there can be more than one argument and the result will be an array
	parser.Pos("count", args.Append(), args.IsInt(), args.Help("Count the numbers provided"))

	// Optional Positional Argument, the order the positional arguments are
	// defined is the order they are expected on the command line
	parser.Pos("infile", args.Optional(), args.IsString(), args.Help("Output file, If none supplied reads from stdin"))
	parser.Pos("outfile", args.Optional(), args.IsString(), args.Help("Input file, If none supplied writes to stdout"))

	// Counts the number of instances a flag is seen and stores the count as an integer
	parser.Opt("--verbose", args.Alias("-v"), args.Count(),
		args.Help("Prints Stuff and things"))

	// String with default option and Environment option (VarName defines the help message value name)
	parser.Opt("--bind", args.Alias("-b"), args.IsString(), args.VarName("ADDRESS"), args.Default("localhost:8080"),
		args.Env("BIND_ADDRESS"), args.Store(&conf.Bind), args.Help("The network interface to bind too"))

	// Unusual option indicators
	parser.Opt("++unusual", args.Alias("+u"), args.IsBool(), args.Default(false),
		args.Help("Unusual option indicator"))
	parser.Opt("-short", args.Alias("-s"), args.IsBool(), args.Default(false),
		args.Help("Short option indicator"))

	// Booleans
	parser.Opt("--debug", args.Alias("-d"), args.IsBool(), args.Default(false),
		args.Help("Turns on debug messages"))

	// Append stores an array, and appends each argument value to the array. This allows an option to be specified multiple times.
	parser.Opt("--endpoint", args.Alias("-e"), args.Append(), args.IsString(),
		args.Default([]string{"http://google.com"}), args.Help("The endpoints to proxy for"))

	// Take an option and split the arguments IE: --terms one,two,three
	parser.Opt("--terms", args.Alias("-t"), args.Array(), args.IsString(),
		args.Default([]string{"foo", "bar"}), args.Help("The terms used to search google with"))

	// Give the user choices
	parser.Opt("--choice", args.Alias("-c"), args.Choice(), args.IsInt(),
		args.Default([]int{1, 2, 3}), args.Help("You can only choose 1,2 or 3"))

	// Give the option is required (Required options can not have defaults)
	parser.Opt("--required", args.Alias("-r"), args.Required(), args.IsString(),
		args.Help("This option is required"))

	// Display Help
	parser.Opt("--help", args.Alias("-h"), args.IsBool(), args.Help("Display this help message"))

	//opts, err := parser.ParseArgs([]string{"-p", "-vvv"})
	opts, err := parser.Parse()
	if err != nil {
		fmt.Println("-- %s", err.Error())
		opts.PrintUsage()
		os.Exit(-1)
	}

	// If user asked for --help or there were no options passed
	if opts.NoArgs() && opts.Bool("help") {
		opts.PrintHelp()
		os.Exit(-1)
	}

	fmt.Printf("Bind Address from opts: %s", opts.String("bind"))
	fmt.Printf("Bind Address from Config struct: %s", conf.Bind)

	fmt.Printf("Verbose Count: %d", opts.Int("verbose"))
	fmt.Printf("Debug Boolean: %b", opts.Bool("debug"))

	for _, endpoint := range opts.Array("endpoint").([]string) {
		fmt.Println("Endpoint: %s", endpoint)
	}

	// Parent that provides shared options
	parent := args.Parser()
	parent.Opt("verbose", args.Alias("-v"), args.Count(), args.Help("Be verbose"))

	// Sub Parser, Any arguments past the positional arg 'sub1' will be considered by this sub
	sub := parser.SubParser("volume")

	// parser and will inherit all the opts from the parent parser
	list := sub.SubParser("list", args.Inherit(parent))

	list.Opt("filter", args.Alias("-f"), args.IsBool(), args.Help("Filter the list by this thingy"))

}
Beispiel #3
0
func main() {
	var conf Config

	// Create the parser
	parser := args.Parser(args.Name("example"))

	// Store Integers directly into a struct with a default value
	parser.Opt("--power-level", args.Alias("-p"), args.StoreInt(&conf.PowerLevel),
		args.Env("POWER_LEVEL"), args.Default("10000"), args.Help("set our power level"))

	// Options can begin with -name, --name or even ++name. Most alpha non word character are supported
	parser.Opt("++power", args.Alias("+p"), args.IsString(), args.Default("11,000"),
		args.Help("prefix demo"))

	// Use the args.Env() function to define an environment variable
	parser.Opt("--message", args.Alias("-m"), args.StoreStr(&conf.Message),
		args.Env("MESSAGE"), args.Default("over-ten-thousand"), args.Help("send a message"))

	// Pass a comma seperated list of strings and get a []string
	parser.Opt("--slice", args.Alias("-s"), args.StoreSlice(&conf.Slice),
		args.Env("LIST"), args.Default("one,two,three"), args.Help("list of messages"))

	// Count the number of times an argument is seen
	parser.Opt("--verbose", args.Alias("-v"), args.Count(), args.StoreInt(&conf.Verbose),
		args.Help("be verbose"))

	// Set bool to true if the argument is present on the command line
	parser.Opt("--debug", args.Alias("-d"), args.IsTrue(), args.Help("turn on Debug"))

	// Specify the type of the arg with IsInt(), IsString(), IsBool() or IsTrue()
	parser.Opt("--help", args.Alias("-h"), args.IsTrue(), args.Help("show this help message"))

	// Pass our own argument list, or nil to parse os.Args[]
	opt, err := parser.ParseArgs(nil)
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(-1)
	}

	// Fetch values by using the Cast functions
	fmt.Printf("CAST Power     '%d'\n", opt.Int("power-level"))
	fmt.Printf("CAST Message   '%s'\n", opt.String("message"))
	fmt.Printf("CAST Slice     '%s'\n", opt.Slice("slice"))
	fmt.Printf("CAST Verbose   '%d'\n", opt.Int("verbose"))
	fmt.Printf("CAST Debug     '%t'\n", opt.Bool("debug"))
	fmt.Println("")

	// Values can also be stored in a struct
	fmt.Printf("STRUCT Power   '%d'\n", conf.PowerLevel)
	fmt.Printf("STRUCT Message '%s'\n", conf.Message)
	fmt.Printf("STRUCT Slice   '%s'\n", conf.Slice)
	fmt.Printf("STRUCT Verbose '%d'\n", conf.Verbose)
	fmt.Printf("STRUCT Debug   '%t'\n", opt.Bool("debug"))
	fmt.Println("")

	iniFile := []byte(`
		power-level=20000
		message=OVER-THEN-THOUSAND!
		slice=three,four,five,six
		verbose=5
		debug=true
    `)

	// Make configuration simply by reading arguments from an INI file
	opt, err = parser.ParseIni(iniFile)
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(-1)
	}

	// Values from the config file are used only if the argument is not present
	// on the commandline
	fmt.Printf("INI Power      '%d'\n", conf.PowerLevel)
	fmt.Printf("INI Message    '%s'\n", conf.Message)
	fmt.Printf("INI Slice      '%s'\n", conf.Slice)
	fmt.Printf("INI Verbose    '%d'\n", conf.Verbose)
	fmt.Printf("INI Debug      '%t'\n", opt.Bool("debug"))
	fmt.Println("")

	// If user asked for --help or there were no options passed
	if opt.NoArgs() || opt.Bool("help") {
		parser.PrintHelp()
		os.Exit(-1)
	}
}