refactor: drop 'Parsed' prefix on some types, add 'Info' suffix on others

Author: steverusso

builder.go

@@ -16,12 +16,12 @@ var (
 	errReqArgAfterOptional     = "required positional arguments cannot come after optional ones"
 )
 
-func (c Command) Build() *RootCommand {
+func (c CommandInfo) Build() *RootCommandInfo {
 	c.validate()
-	return &RootCommand{c: c}
+	return &RootCommandInfo{c: c}
 }
 
-func (c *Command) validate() {
+func (c *CommandInfo) validate() {
 	// option assertions
 	for i := 0; i < len(c.opts)-1; i++ {
 		for z := i + 1; z < len(c.opts); z++ {
@@ -105,7 +105,7 @@ func (e invalidCmdNameError) String() string {
 	return "invalid command name '" + e.name + "': " + e.reason
 }
 
-func NewCmd(name string) Command {
+func NewCmd(name string) CommandInfo {
 	// assert command name isn't empty and doesn't contain any whitespace
 	if name == "" {
 		panic(errEmptyCmdName)
@@ -120,35 +120,35 @@ func NewCmd(name string) Command {
 		}
 	}
 
-	c := Command{
+	c := CommandInfo{
 		name: name,
 		path: []string{name},
-		opts: make([]Input, 0, 5),
+		opts: make([]InputInfo, 0, 5),
 	}
 	return c.Opt(DefaultHelpInput)
 }
 
-func (c Command) Help(blurb string) Command {
+func (c CommandInfo) Help(blurb string) CommandInfo {
 	c.helpBlurb = blurb
 	return c
 }
 
 // HelpExtra adds an "overview" section to the Command's help message. This is typically
 // for longer-form content that wouldn't fit well within the 1-2 sentence "blurb."
-func (c Command) HelpExtra(extra string) Command {
+func (c CommandInfo) HelpExtra(extra string) CommandInfo {
 	c.helpExtra = extra
 	return c
 }
 
 // HelpUsage overrides the default "usage" lines in the command's help message. These are
 // intended to show the user some different ways to invoke this command using whatever
 // combinations of options / arguments / subcommands.
-func (c Command) HelpUsage(lines ...string) Command {
+func (c CommandInfo) HelpUsage(lines ...string) CommandInfo {
 	c.helpUsage = append(c.helpUsage, lines...)
 	return c
 }
 
-func (c Command) Opt(o Input) Command {
+func (c CommandInfo) Opt(o InputInfo) CommandInfo {
 	// Assert `o` is not a positional arg by making sure it has at least one option name.
 	if o.nameShort == "" && o.nameLong == "" {
 		panic(errEmptyOptNames)
@@ -157,7 +157,7 @@ func (c Command) Opt(o Input) Command {
 	return c
 }
 
-func (c Command) Arg(a Input) Command {
+func (c CommandInfo) Arg(a InputInfo) CommandInfo {
 	if len(c.subcmds) > 0 {
 		panic(errMixingPosArgsAndSubcmds)
 	}
@@ -174,7 +174,7 @@ func (c Command) Arg(a Input) Command {
 	return c
 }
 
-func (c Command) Subcmd(sc Command) Command {
+func (c CommandInfo) Subcmd(sc CommandInfo) CommandInfo {
 	if len(c.args) > 0 {
 		panic(errMixingPosArgsAndSubcmds)
 	}
@@ -190,118 +190,118 @@ func (c Command) Subcmd(sc Command) Command {
 // receive the raw string of any provided value. If id is more than a single character
 // long, it will be this option's long name. If id is only a single character, it will be
 // this option's short name instead. In either case, the long name can be reset using the
-// [Input.Long] method.
-func NewOpt(id string) Input {
+// [InputInfo.Long] method.
+func NewOpt(id string) InputInfo {
 	if id == "" {
 		panic(errEmptyInputID)
 	}
 	if len(id) == 1 {
-		return Input{id: id}.ShortOnly(id[0])
+		return InputInfo{id: id}.ShortOnly(id[0])
 	}
-	return Input{id: id}.Long(id)
+	return InputInfo{id: id}.Long(id)
 }
 
 // NewBoolOpt returns a new boolean option. If no value is provided to this option when
 // parsing, it will have a "parsed" value of true. If any value is provided, the
 // [ParseBool] value parser is used. Any other parser set by the user for this option will
 // be ignored.
-func NewBoolOpt(id string) Input {
+func NewBoolOpt(id string) InputInfo {
 	o := NewOpt(id)
 	o.isBoolOpt = true
 	return o
 }
 
 // NewIntOpt returns a new option that uses the [ParseInt] value parser.
-func NewIntOpt(id string) Input {
+func NewIntOpt(id string) InputInfo {
 	return NewOpt(id).WithParser(ParseInt)
 }
 
 // NewUintOpt returns a new option that uses the [ParseUint] value parser.
-func NewUintOpt(id string) Input {
+func NewUintOpt(id string) InputInfo {
 	return NewOpt(id).WithParser(ParseUint)
 }
 
 // NewFloat32Opt returns a new option that uses the [ParseFloat32] value parser.
-func NewFloat32Opt(id string) Input {
+func NewFloat32Opt(id string) InputInfo {
 	return NewOpt(id).WithParser(ParseFloat32)
 }
 
 // NewFloat64Opt returns a new option that uses the [ParseFloat64] value parser.
-func NewFloat64Opt(id string) Input {
+func NewFloat64Opt(id string) InputInfo {
 	return NewOpt(id).WithParser(ParseFloat64)
 }
 
 // NewArg returns a new positional argument input. By default, the arg's display name will
-// be the provided id, but this can be overidden with [Input.ValueName] method.
-func NewArg(id string) Input {
+// be the provided id, but this can be overidden with [InputInfo.ValueName] method.
+func NewArg(id string) InputInfo {
 	if id == "" {
 		panic(errEmptyInputID)
 	}
-	return Input{id: id, valueName: id}
+	return InputInfo{id: id, valueName: id}
 }
 
-// WithParser sets the Input's parser to the given [ValueParser]. This will override any
+// WithParser sets the InputInfo's parser to the given [ValueParser]. This will override any
 // parser that has been set up until this point. Providing nil as the parser will restore
-// the default behavior of just using the plain string value when this Input is parsed.
-func (in Input) WithParser(vp ValueParser) Input {
+// the default behavior of just using the plain string value when this InputInfo is parsed.
+func (in InputInfo) WithParser(vp ValueParser) InputInfo {
 	in.valueParser = vp
 	return in
 }
 
 // Short sets this option's short name to the given character. In order to create an
-// option that has a short name but no long name, see [Input.ShortOnly].
-func (in Input) Short(c byte) Input {
+// option that has a short name but no long name, see [InputInfo.ShortOnly].
+func (in InputInfo) Short(c byte) InputInfo {
 	in.nameShort = string(c)
 	return in
 }
 
 // ShortOnly sets this option's short name to the given character and removes any long
 // name it may have had at this point. In order to create an option that has both a short
-// and long name, see [Input.Short]. Use [Input.Long] to add a long name back.
-func (in Input) ShortOnly(c byte) Input {
+// and long name, see [InputInfo.Short]. Use [InputInfo.Long] to add a long name back.
+func (in InputInfo) ShortOnly(c byte) InputInfo {
 	in.nameLong = ""
 	return in.Short(c)
 }
 
-func (in Input) Long(name string) Input {
+func (in InputInfo) Long(name string) InputInfo {
 	in.nameLong = name
 	return in
 }
 
-func (in Input) Help(blurb string) Input {
+func (in InputInfo) Help(blurb string) InputInfo {
 	in.helpBlurb = blurb
 	return in
 }
 
-func (in Input) Env(e string) Input {
+func (in InputInfo) Env(e string) InputInfo {
 	in.env = e
 	return in
 }
 
-func (in Input) Required() Input {
+func (in InputInfo) Required() InputInfo {
 	in.isRequired = true
 	return in
 }
 
-// ValueName sets the display name of this Input's argument value. For non-boolean
+// ValueName sets the display name of this InputInfo's argument value. For non-boolean
 // options, it's the argument of the option. For positional arguments, it's the argument
 // name itself.
-func (in Input) ValueName(name string) Input {
+func (in InputInfo) ValueName(name string) InputInfo {
 	in.valueName = name
 	return in
 }
 
-func (in Input) Default(v string) Input {
+func (in InputInfo) Default(v string) InputInfo {
 	in.rawDefaultValue = v
 	in.hasDefaultValue = true
 	return in
 }
 
-func (in Input) HelpGen(hg HelpGenerator) Input {
+func (in InputInfo) HelpGen(hg HelpGenerator) InputInfo {
 	in.helpGen = hg
 	return in
 }
 
-func (in *Input) isOption() bool {
+func (in *InputInfo) isOption() bool {
 	return in.nameShort != "" || in.nameLong != ""
 }