extract opts, args and helptext to cmdsutils subpackage

this way we can share the code with the legace commands package and don't have to convert everything

Author: keks

argument.go

@@ -0,0 +1,56 @@
+package cmdsutil
+
+type ArgumentType int
+
+const (
+	ArgString ArgumentType = iota
+	ArgFile
+)
+
+type Argument struct {
+	Name          string
+	Type          ArgumentType
+	Required      bool // error if no value is specified
+	Variadic      bool // unlimited values can be specfied
+	SupportsStdin bool // can accept stdin as a value
+	Recursive     bool // supports recursive file adding (with '-r' flag)
+	Description   string
+}
+
+func StringArg(name string, required, variadic bool, description string) Argument {
+	return Argument{
+		Name:        name,
+		Type:        ArgString,
+		Required:    required,
+		Variadic:    variadic,
+		Description: description,
+	}
+}
+
+func FileArg(name string, required, variadic bool, description string) Argument {
+	return Argument{
+		Name:        name,
+		Type:        ArgFile,
+		Required:    required,
+		Variadic:    variadic,
+		Description: description,
+	}
+}
+
+// TODO: modifiers might need a different API?
+//       e.g. passing enum values into arg constructors variadically
+//       (`FileArg("file", ArgRequired, ArgStdin, ArgRecursive)`)
+
+func (a Argument) EnableStdin() Argument {
+	a.SupportsStdin = true
+	return a
+}
+
+func (a Argument) EnableRecursive() Argument {
+	if a.Type != ArgFile {
+		panic("Only FileArgs can enable recursive")
+	}
+
+	a.Recursive = true
+	return a
+}

error.go

@@ -0,0 +1,22 @@
+package cmdsutil
+
+// ErrorType signfies a category of errors
+type ErrorType uint
+
+// ErrorTypes convey what category of error ocurred
+const (
+	ErrNormal         ErrorType = iota // general errors
+	ErrClient                          // error was caused by the client, (e.g. invalid CLI usage)
+	ErrImplementation                  // programmer error in the server
+	// TODO: add more types of errors for better error-specific handling
+)
+
+// Error is a struct for marshalling errors
+type Error struct {
+	Message string
+	Code    ErrorType
+}
+
+func (e Error) Error() string {
+	return e.Message
+}

helptext.go

@@ -0,0 +1,18 @@
+package cmdsutil
+
+// HelpText is a set of strings used to generate command help text. The help
+// text follows formats similar to man pages, but not exactly the same.
+type HelpText struct {
+	// required
+	Tagline               string            // used in <cmd usage>
+	ShortDescription      string            // used in DESCRIPTION
+	SynopsisOptionsValues map[string]string // mappings for synopsis generator
+
+	// optional - whole section overrides
+	Usage           string // overrides USAGE section
+	LongDescription string // overrides DESCRIPTION section
+	Options         string // overrides OPTIONS section
+	Arguments       string // overrides ARGUMENTS section
+	Subcommands     string // overrides SUBCOMMANDS section
+	Synopsis        string // overrides SYNOPSIS field
+}

option.go

@@ -0,0 +1,199 @@
+package cmdsutil
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"gx/ipfs/Qmb912gdngC1UWwTkhuW8knyRbcWeu5kqkxBpveLmW8bSr/go-ipfs-util"
+)
+
+// Types of Command options
+const (
+	Invalid = reflect.Invalid
+	Bool    = reflect.Bool
+	Int     = reflect.Int
+	Uint    = reflect.Uint
+	Float   = reflect.Float64
+	String  = reflect.String
+)
+
+type OptMap map[string]interface{}
+
+// Option is used to specify a field that will be provided by a consumer
+type Option interface {
+	Names() []string            // a list of unique names matched with user-provided flags
+	Type() reflect.Kind         // value must be this type
+	Description() string        // a short string that describes this option
+	Default(interface{}) Option // sets the default value of the option
+	DefaultVal() interface{}
+}
+
+type option struct {
+	names       []string
+	kind        reflect.Kind
+	description string
+	defaultVal  interface{}
+}
+
+func (o *option) Names() []string {
+	return o.names
+}
+
+func (o *option) Type() reflect.Kind {
+	return o.kind
+}
+
+func (o *option) Description() string {
+	if len(o.description) == 0 {
+		return ""
+	}
+	if !strings.HasSuffix(o.description, ".") {
+		o.description += "."
+	}
+	if o.defaultVal != nil {
+		if strings.Contains(o.description, "<<default>>") {
+			return strings.Replace(o.description, "<<default>>",
+				fmt.Sprintf("Default: %v.", o.defaultVal), -1)
+		} else {
+			return fmt.Sprintf("%s Default: %v.", o.description, o.defaultVal)
+		}
+	}
+	return o.description
+}
+
+// constructor helper functions
+func NewOption(kind reflect.Kind, names ...string) Option {
+	if len(names) < 2 {
+		// FIXME(btc) don't panic (fix_before_merge)
+		panic("Options require at least two string values (name and description)")
+	}
+
+	desc := names[len(names)-1]
+	names = names[:len(names)-1]
+
+	return &option{
+		names:       names,
+		kind:        kind,
+		description: desc,
+	}
+}
+
+func (o *option) Default(v interface{}) Option {
+	o.defaultVal = v
+	return o
+}
+
+func (o *option) DefaultVal() interface{} {
+	return o.defaultVal
+}
+
+// TODO handle description separately. this will take care of the panic case in
+// NewOption
+
+// For all func {Type}Option(...string) functions, the last variadic argument
+// is treated as the description field.
+
+func BoolOption(names ...string) Option {
+	return NewOption(Bool, names...)
+}
+func IntOption(names ...string) Option {
+	return NewOption(Int, names...)
+}
+func UintOption(names ...string) Option {
+	return NewOption(Uint, names...)
+}
+func FloatOption(names ...string) Option {
+	return NewOption(Float, names...)
+}
+func StringOption(names ...string) Option {
+	return NewOption(String, names...)
+}
+
+type OptionValue struct {
+	Value      interface{}
+	ValueFound bool
+	Def        Option
+}
+
+// Found returns true if the option value was provided by the user (not a default value)
+func (ov OptionValue) Found() bool {
+	return ov.ValueFound
+}
+
+// Definition returns the option definition for the provided value
+func (ov OptionValue) Definition() Option {
+	return ov.Def
+}
+
+// value accessor methods, gets the value as a certain type
+func (ov OptionValue) Bool() (value bool, found bool, err error) {
+	if !ov.ValueFound && ov.Value == nil {
+		return false, false, nil
+	}
+	val, ok := ov.Value.(bool)
+	if !ok {
+		err = util.ErrCast()
+	}
+	return val, ov.ValueFound, err
+}
+
+func (ov OptionValue) Int() (value int, found bool, err error) {
+	if !ov.ValueFound && ov.Value == nil {
+		return 0, false, nil
+	}
+	val, ok := ov.Value.(int)
+	if !ok {
+		err = util.ErrCast()
+	}
+	return val, ov.ValueFound, err
+}
+
+func (ov OptionValue) Uint() (value uint, found bool, err error) {
+	if !ov.ValueFound && ov.Value == nil {
+		return 0, false, nil
+	}
+	val, ok := ov.Value.(uint)
+	if !ok {
+		err = util.ErrCast()
+	}
+	return val, ov.ValueFound, err
+}
+
+func (ov OptionValue) Float() (value float64, found bool, err error) {
+	if !ov.ValueFound && ov.Value == nil {
+		return 0, false, nil
+	}
+	val, ok := ov.Value.(float64)
+	if !ok {
+		err = util.ErrCast()
+	}
+	return val, ov.ValueFound, err
+}
+
+func (ov OptionValue) String() (value string, found bool, err error) {
+	if !ov.ValueFound && ov.Value == nil {
+		return "", false, nil
+	}
+	val, ok := ov.Value.(string)
+	if !ok {
+		err = util.ErrCast()
+	}
+	return val, ov.ValueFound, err
+}
+
+// Flag names
+const (
+	EncShort   = "enc"
+	EncLong    = "encoding"
+	RecShort   = "r"
+	RecLong    = "recursive"
+	ChanOpt    = "stream-channels"
+	TimeoutOpt = "timeout"
+)
+
+// options that are used by this package
+var OptionEncodingType = StringOption(EncLong, EncShort, "The encoding type the output should be encoded with (json, xml, or text)")
+var OptionRecursivePath = BoolOption(RecLong, RecShort, "Add directory paths recursively").Default(false)
+var OptionStreamChannels = BoolOption(ChanOpt, "Stream channel output")
+var OptionTimeout = StringOption(TimeoutOpt, "set a global timeout on the command")

option_test.go

@@ -0,0 +1,45 @@
+package cmdsutil
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestOptionValueExtractBoolNotFound(t *testing.T) {
+	t.Log("ensure that no error is returned when value is not found")
+	optval := &OptionValue{found: false}
+	_, _, err := optval.Bool()
+	if err != nil {
+		t.Fatal("Found was false. Err should have been nil")
+	}
+}
+
+func TestOptionValueExtractWrongType(t *testing.T) {
+
+	t.Log("ensure that error is returned when value if of wrong type")
+
+	optval := &OptionValue{value: "wrong type: a string", found: true}
+	_, _, err := optval.Bool()
+	if err == nil {
+		t.Fatal("No error returned. Failure.")
+	}
+
+	optval = &OptionValue{value: "wrong type: a string", found: true}
+	_, _, err = optval.Int()
+	if err == nil {
+		t.Fatal("No error returned. Failure.")
+	}
+}
+
+func TestLackOfDescriptionOfOptionDoesNotPanic(t *testing.T) {
+	opt := BoolOption("a", "")
+	opt.Description()
+}
+
+func TestDotIsAddedInDescripton(t *testing.T) {
+	opt := BoolOption("a", "desc without dot")
+	dest := opt.Description()
+	if !strings.HasSuffix(dest, ".") {
+		t.Fatal("dot should have been added at the end of description")
+	}
+}