func (g *GeneratorArgs) AddFlags(fs *pflag.FlagSet) { fs.StringSliceVarP(&g.InputDirs, "input-dirs", "i", g.InputDirs, "Comma-separated list of import paths to get input types from.") fs.StringVarP(&g.OutputBase, "output-base", "o", g.OutputBase, "Output base; defaults to $GOPATH/src/ or ./ if $GOPATH is not set.") fs.StringVarP(&g.OutputPackagePath, "output-package", "p", g.OutputPackagePath, "Base package path.") fs.StringVarP(&g.GoHeaderFilePath, "go-header-file", "h", g.GoHeaderFilePath, "File containing boilerplate header text. The string YEAR will be replaced with the current 4-digit year.") fs.BoolVar(&g.VerifyOnly, "verify-only", g.VerifyOnly, "If true, only verify existing output, do not write anything.") }
func flags(set *pflag.FlagSet) { // Unused cli args set.StringVarP(&buildDir, "build", "b", "", "Path to target directory to place generated CSS, relative paths inside project directory are preserved") set.BoolVarP(&comments, "comment", "", false, "Turn on source comments") set.BoolVar(&debug, "debug", false, "Show detailed debug information") var nothingb bool set.BoolVar(&debug, "debug-info", false, "") set.MarkDeprecated("debug-info", "Use --debug instead") set.StringVarP(&dir, "dir", "d", "", "Path to locate images for spriting and image functions") set.StringVar(&dir, "images-dir", "", "") set.MarkDeprecated("images-dir", "Use -d instead") set.StringVar(&font, "font", ".", "Path to directory containing fonts") set.StringVar(&gen, "generated-images-path", "", "") set.MarkDeprecated("generated-images-path", "Use --gen instead") set.StringVar(&gen, "gen", ".", "Path to place generated images") set.StringVarP(&proj, "proj", "p", "", "Path to directory containing Sass stylesheets") set.BoolVar(¬hingb, "no-line-comments", false, "UNSUPPORTED: Disable line comments, use comments") set.MarkDeprecated("no-line-comments", "Use --comments instead") set.BoolVar(&relativeAssets, "relative-assets", false, "UNSUPPORTED: Make compass asset helpers generate relative urls to assets.") set.BoolVar(&sourceMap, "source-map", false, "Enable emitting of source maps, must specify build directory to use this") set.BoolVarP(&showVersion, "version", "v", false, "Show the app version") set.StringVar(&cachebust, "cachebust", "", "Defeat cache by appending timestamps to static assets ie. ts, sum, timestamp") set.StringVarP(&style, "style", "s", "nested", `nested style of output CSS available options: nested, expanded, compact, compressed`) set.StringVar(&style, "output-style", "nested", "") set.MarkDeprecated("output-style", "Use --style instead") set.BoolVar(&timeB, "time", false, "Retrieve timing information") var nothing string set.StringVar(¬hing, "require", "", "") set.MarkDeprecated("require", "Compass backwards compat, Not supported") set.MarkDeprecated("require", "Not supported") set.StringVar(¬hing, "environment", "", "") set.MarkDeprecated("environment", "Not supported") set.StringSliceVar(&includes, "includes", nil, "Include Sass from additional directories") set.StringSliceVarP(&includes, "", "I", nil, "") set.MarkDeprecated("I", "Compass backwards compat, use --includes instead") set.StringVar(&buildDir, "css-dir", "", "Compass backwards compat. Reference locations relative to Sass project directory") set.MarkDeprecated("css-dir", "Use -b instead") set.StringVar(&jsDir, "javascripts-dir", "", "") set.MarkDeprecated("javascripts-dir", "Compass backwards compat, ignored") set.StringSliceVar(&includes, "sass-dir", nil, "Compass backwards compat, use --includes instead") set.StringVarP(&config, "config", "c", "", "Temporarily disabled: Location of the config file") set.StringVar(&cpuprofile, "cpuprofile", "", "Go runtime cpu profilling for debugging") }
func (g *GeneratorArgs) AddFlags(fs *pflag.FlagSet) { fs.StringSliceVarP(&g.InputDirs, "input-dirs", "i", g.InputDirs, "Comma-separated list of import paths to get input types from.") fs.StringVarP(&g.OutputBase, "output-base", "o", g.OutputBase, "Output base; defaults to $GOPATH/src/ or ./ if $GOPATH is not set.") fs.StringVarP(&g.OutputPackagePath, "output-package", "p", g.OutputPackagePath, "Base package path.") fs.StringVarP(&g.OutputFileBaseName, "output-file-base", "O", g.OutputFileBaseName, "Base name (without .go suffix) for output files.") fs.StringVarP(&g.GoHeaderFilePath, "go-header-file", "h", g.GoHeaderFilePath, "File containing boilerplate header text. The string YEAR will be replaced with the current 4-digit year.") fs.BoolVar(&g.VerifyOnly, "verify-only", g.VerifyOnly, "If true, only verify existing output, do not write anything.") fs.StringVar(&g.GeneratedBuildTag, "build-tag", g.GeneratedBuildTag, "A Go build tag to use to identify files generated by this command. Should be unique.") }
func initDeploymentFlags(fs *pflag.FlagSet, f *fg.Flags) { fs.StringVarP(&f.JobPath, "job", "j", defaultJobPath, "filename of the job description") fs.StringVarP(&f.ClusterPath, "cluster", "c", defaultClusterPath, "cluster description name or filename") fs.StringVarP(&f.TunnelOverride, "tunnel", "t", defaultTunnelOverride, "SSH endpoint to tunnel through with fleet (cluster override)") fs.StringSliceVarP(&f.Groups, "groups", "g", defaultGroups, "target task groups to deploy") fs.BoolVarP(&f.Force, "force", "f", defaultForce, "wheather to confirm destroy or not") fs.BoolVarP(&f.AutoContinue, "yes", "y", false, "auto continue on confirmation") fs.BoolVarP(&f.DryRun, "dry-run", "d", defaultDryRun, "wheather to schedule units or not") fs.UintVar(&f.ScalingGroup, "scaling-group", defaultScalingGroup, "scaling group to deploy") fs.BoolVarP(&f.Local, "local", "l", defaultLocal, "User local vagrant test cluster") fs.DurationVar(&f.StopDelay, "stop-delay", defaultStopDelay, "Time between stop and destroy") fs.DurationVar(&f.DestroyDelay, "destroy-delay", defaultDestroyDelay, "Time between destroy and re-create") fs.DurationVar(&f.SliceDelay, "slice-delay", defaultSliceDelay, "Time between update of scaling slices") fs.VarP(&f.Options, "option", "o", "Set an option (key=value)") f.VaultCACert = os.Getenv("VAULT_CACERT") f.VaultCAPath = os.Getenv("VAULT_CAPATH") fs.StringVar(&f.VaultAddr, "vault-addr", "", "URL of the vault (defaults to VAULT_ADDR environment variable)") fs.StringVar(&f.VaultCACert, "vault-cacert", f.VaultCACert, "Path to a PEM-encoded CA cert file to use to verify the Vault server SSL certificate") fs.StringVar(&f.VaultCAPath, "vault-capath", f.VaultCAPath, "Path to a directory of PEM-encoded CA cert files to verify the Vault server SSL certificate") fs.StringVarP(&f.GithubToken, "github-token", "G", "", "Personal github token for secret logins") fs.StringVar(&f.GithubTokenPath, "github-token-path", defaultGithubTokenPath, "Path of a file containing your github token") }
// BindListFlag binds a flag that expects a kube list value. Note that if the target // comes pre-populated, that list is not erased; anything the user puts in the flag // is added on. This is probably a bug in k8s impl of StringList. func (i FlagInfo) BindListFlag(flags *pflag.FlagSet, target *[]string) { // assume flags with no longname are not desired if len(i.LongName) > 0 { flags.StringSliceVarP(target, i.LongName, i.ShortName, *target, i.Description) } }
func execTags(in interface{}, fs *pflag.FlagSet) error { if reflect.TypeOf(in).Kind() != reflect.Ptr { return errors.New("Calling parser with non-pointer") } if reflect.ValueOf(in).Elem().Kind() != reflect.Struct { return errors.New("Calling parser with pointer to non-struct") } st := reflect.ValueOf(in).Elem() for i := 0; i < st.NumField(); i++ { valField := st.Field(i) typeField := st.Type().Field(i) if typeField.Tag.Get("default") == "" && typeField.Tag.Get("env") == "" && typeField.Tag.Get("flag") == "" && typeField.Type.Kind() != reflect.Struct { // None of our supported tags is present and it's not a sub-struct continue } value := varDefault(typeField.Tag.Get("vardefault"), typeField.Tag.Get("default")) value = envDefault(typeField.Tag.Get("env"), value) parts := strings.Split(typeField.Tag.Get("flag"), ",") switch typeField.Type.Kind() { case reflect.String: if typeField.Tag.Get("flag") != "" { if len(parts) == 1 { fs.StringVar(valField.Addr().Interface().(*string), parts[0], value, typeField.Tag.Get("description")) } else { fs.StringVarP(valField.Addr().Interface().(*string), parts[0], parts[1], value, typeField.Tag.Get("description")) } } else { valField.SetString(value) } case reflect.Bool: v := value == "true" if typeField.Tag.Get("flag") != "" { if len(parts) == 1 { fs.BoolVar(valField.Addr().Interface().(*bool), parts[0], v, typeField.Tag.Get("description")) } else { fs.BoolVarP(valField.Addr().Interface().(*bool), parts[0], parts[1], v, typeField.Tag.Get("description")) } } else { valField.SetBool(v) } case reflect.Int, reflect.Int8, reflect.Int32, reflect.Int64: vt, err := strconv.ParseInt(value, 10, 64) if err != nil { if value == "" { vt = 0 } else { return err } } if typeField.Tag.Get("flag") != "" { registerFlagInt(typeField.Type.Kind(), fs, valField.Addr().Interface(), parts, vt, typeField.Tag.Get("description")) } else { valField.SetInt(vt) } case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: vt, err := strconv.ParseUint(value, 10, 64) if err != nil { if value == "" { vt = 0 } else { return err } } if typeField.Tag.Get("flag") != "" { registerFlagUint(typeField.Type.Kind(), fs, valField.Addr().Interface(), parts, vt, typeField.Tag.Get("description")) } else { valField.SetUint(vt) } case reflect.Float32, reflect.Float64: vt, err := strconv.ParseFloat(value, 64) if err != nil { if value == "" { vt = 0.0 } else { return err } } if typeField.Tag.Get("flag") != "" { registerFlagFloat(typeField.Type.Kind(), fs, valField.Addr().Interface(), parts, vt, typeField.Tag.Get("description")) } else { valField.SetFloat(vt) } case reflect.Struct: if err := execTags(valField.Addr().Interface(), fs); err != nil { return err } case reflect.Slice: switch typeField.Type.Elem().Kind() { case reflect.Int: def := []int{} for _, v := range strings.Split(value, ",") { it, err := strconv.ParseInt(strings.TrimSpace(v), 10, 64) if err != nil { return err } def = append(def, int(it)) } if len(parts) == 1 { fs.IntSliceVar(valField.Addr().Interface().(*[]int), parts[0], def, typeField.Tag.Get("description")) } else { fs.IntSliceVarP(valField.Addr().Interface().(*[]int), parts[0], parts[1], def, typeField.Tag.Get("description")) } case reflect.String: del := typeField.Tag.Get("delimiter") if len(del) == 0 { del = "," } def := strings.Split(value, del) if len(parts) == 1 { fs.StringSliceVar(valField.Addr().Interface().(*[]string), parts[0], def, typeField.Tag.Get("description")) } else { fs.StringSliceVarP(valField.Addr().Interface().(*[]string), parts[0], parts[1], def, typeField.Tag.Get("description")) } } } } return nil }
func (c *Config) stringSliceVarP(fset *flag.FlagSet, name string, aof *[]string) *flag.Flag { i := keys[name] fset.StringSliceVarP( aof, name, i.Shorthand, c.Viper.GetStringSlice(name), i.Description) return fset.Lookup(name) }