first commit

input/value/any.go

@@ -0,0 +1,21 @@
+package value
+
+import "gitoa.ru/go-4devs/console/input"
+
+type Any struct {
+	Empty
+	Val  []interface{}
+	Flag input.Flag
+}
+
+func (a *Any) Any() interface{} {
+	if a.Flag.IsArray() {
+		return a.Val
+	}
+
+	if len(a.Val) > 0 {
+		return a.Val[0]
+	}
+
+	return nil
+}

input/value/bool.go

@@ -0,0 +1,44 @@
+package value
+
+import (
+	"strconv"
+
+	"gitoa.ru/go-4devs/console/input"
+)
+
+type Bool struct {
+	Empty
+	Val  []bool
+	Flag input.Flag
+}
+
+func (b *Bool) Append(in string) error {
+	v, err := strconv.ParseBool(in)
+	if err != nil {
+		return err
+	}
+
+	b.Val = append(b.Val, v)
+
+	return nil
+}
+
+func (b *Bool) Bool() bool {
+	if !b.Flag.IsArray() && len(b.Val) == 1 {
+		return b.Val[0]
+	}
+
+	return false
+}
+
+func (b *Bool) Bools() []bool {
+	return b.Val
+}
+
+func (b *Bool) Any() interface{} {
+	if b.Flag&input.ValueArray > 0 {
+		return b.Bools()
+	}
+
+	return b.Bool()
+}

input/value/duration.go

@@ -0,0 +1,44 @@
+package value
+
+import (
+	"time"
+
+	"gitoa.ru/go-4devs/console/input"
+)
+
+type Duration struct {
+	Empty
+	Val  []time.Duration
+	Flag input.Flag
+}
+
+func (d *Duration) Append(in string) error {
+	v, err := time.ParseDuration(in)
+	if err != nil {
+		return err
+	}
+
+	d.Val = append(d.Val, v)
+
+	return nil
+}
+
+func (d *Duration) Duration() time.Duration {
+	if !d.Flag.IsArray() && len(d.Val) == 1 {
+		return d.Val[0]
+	}
+
+	return 0
+}
+
+func (d *Duration) Durations() []time.Duration {
+	return d.Val
+}
+
+func (d *Duration) Any() interface{} {
+	if d.Flag&input.ValueArray > 0 {
+		return d.Durations()
+	}
+
+	return d.Duration()
+}

input/value/empty.go

@@ -0,0 +1,90 @@
+package value
+
+import (
+	"fmt"
+	"time"
+
+	"gitoa.ru/go-4devs/console/input"
+)
+
+type Empty struct{}
+
+func (e *Empty) Append(string) error {
+	return fmt.Errorf("%w: in empty value", input.ErrInvalidName)
+}
+
+func (e *Empty) String() string {
+	return ""
+}
+
+func (e *Empty) Int() int {
+	return 0
+}
+
+func (e *Empty) Int64() int64 {
+	return 0
+}
+
+func (e *Empty) Uint() uint {
+	return 0
+}
+
+func (e *Empty) Uint64() uint64 {
+	return 0
+}
+
+func (e *Empty) Float64() float64 {
+	return 0
+}
+
+func (e *Empty) Bool() bool {
+	return false
+}
+
+func (e *Empty) Duration() time.Duration {
+	return 0
+}
+
+func (e *Empty) Time() time.Time {
+	return time.Time{}
+}
+
+func (e *Empty) Strings() []string {
+	return nil
+}
+
+func (e *Empty) Ints() []int {
+	return nil
+}
+
+func (e *Empty) Int64s() []int64 {
+	return nil
+}
+
+func (e *Empty) Uints() []uint {
+	return nil
+}
+
+func (e *Empty) Uint64s() []uint64 {
+	return nil
+}
+
+func (e *Empty) Float64s() []float64 {
+	return nil
+}
+
+func (e *Empty) Bools() []bool {
+	return nil
+}
+
+func (e *Empty) Durations() []time.Duration {
+	return nil
+}
+
+func (e *Empty) Times() []time.Time {
+	return nil
+}
+
+func (e *Empty) Any() interface{} {
+	return nil
+}

input/value/float64.go

@@ -0,0 +1,44 @@
+package value
+
+import (
+	"strconv"
+
+	"gitoa.ru/go-4devs/console/input"
+)
+
+type Float64 struct {
+	Empty
+	Val  []float64
+	Flag input.Flag
+}
+
+func (f *Float64) Append(in string) error {
+	v, err := strconv.ParseFloat(in, 64)
+	if err != nil {
+		return err
+	}
+
+	f.Val = append(f.Val, v)
+
+	return nil
+}
+
+func (f *Float64) Float64() float64 {
+	if !f.Flag.IsArray() && len(f.Val) == 1 {
+		return f.Val[0]
+	}
+
+	return 0
+}
+
+func (f *Float64) Float64s() []float64 {
+	return f.Val
+}
+
+func (f *Float64) Any() interface{} {
+	if f.Flag&input.ValueFloat64 > 0 {
+		return f.Float64s()
+	}
+
+	return f.Float64()
+}

input/value/int.go

@@ -0,0 +1,44 @@
+package value
+
+import (
+	"strconv"
+
+	"gitoa.ru/go-4devs/console/input"
+)
+
+type Int struct {
+	Empty
+	Val  []int
+	Flag input.Flag
+}
+
+func (i *Int) Append(in string) error {
+	v, err := strconv.Atoi(in)
+	if err != nil {
+		return err
+	}
+
+	i.Val = append(i.Val, v)
+
+	return nil
+}
+
+func (i *Int) Int() int {
+	if !i.Flag.IsArray() && len(i.Val) == 1 {
+		return i.Val[0]
+	}
+
+	return 0
+}
+
+func (i *Int) Ints() []int {
+	return i.Val
+}
+
+func (i *Int) Any() interface{} {
+	if i.Flag&input.ValueArray > 0 {
+		return i.Ints()
+	}
+
+	return i.Int()
+}

input/value/int64.go

@@ -0,0 +1,44 @@
+package value
+
+import (
+	"strconv"
+
+	"gitoa.ru/go-4devs/console/input"
+)
+
+type Int64 struct {
+	Empty
+	Val  []int64
+	Flag input.Flag
+}
+
+func (i *Int64) Int64() int64 {
+	if !i.Flag.IsArray() && len(i.Val) == 1 {
+		return i.Val[0]
+	}
+
+	return 0
+}
+
+func (i *Int64) Int64s() []int64 {
+	return i.Val
+}
+
+func (i *Int64) Any() interface{} {
+	if i.Flag&input.ValueArray > 0 {
+		return i.Int64s()
+	}
+
+	return i.Int64()
+}
+
+func (i *Int64) Append(in string) error {
+	v, err := strconv.ParseInt(in, 10, 64)
+	if err != nil {
+		return err
+	}
+
+	i.Val = append(i.Val, v)
+
+	return nil
+}

input/value/read.go

@@ -0,0 +1,17 @@
+package value
+
+import (
+	"fmt"
+
+	"gitoa.ru/go-4devs/console/input"
+)
+
+var _ input.AppendValue = (*Read)(nil)
+
+type Read struct {
+	input.Value
+}
+
+func (r *Read) Append(string) error {
+	return fmt.Errorf("%w: read value", input.ErrInvalidName)
+}

input/value/string.go

@@ -0,0 +1,39 @@
+package value
+
+import "gitoa.ru/go-4devs/console/input"
+
+type String struct {
+	Empty
+	Val  []string
+	Flag input.Flag
+}
+
+func (s *String) Append(in string) error {
+	s.Val = append(s.Val, in)
+
+	return nil
+}
+
+func (s *String) String() string {
+	if s.Flag.IsArray() {
+		return ""
+	}
+
+	if len(s.Val) == 1 {
+		return s.Val[0]
+	}
+
+	return ""
+}
+
+func (s *String) Strings() []string {
+	return s.Val
+}
+
+func (s *String) Any() interface{} {
+	if s.Flag.IsArray() {
+		return s.Strings()
+	}
+
+	return s.String()
+}

input/value/time.go

@@ -0,0 +1,44 @@
+package value
+
+import (
+	"time"
+
+	"gitoa.ru/go-4devs/console/input"
+)
+
+type Time struct {
+	Empty
+	Val  []time.Time
+	Flag input.Flag
+}
+
+func (t *Time) Append(in string) error {
+	v, err := time.Parse(time.RFC3339, in)
+	if err != nil {
+		return err
+	}
+
+	t.Val = append(t.Val, v)
+
+	return nil
+}
+
+func (t *Time) Time() time.Time {
+	if !t.Flag.IsArray() && len(t.Val) == 1 {
+		return t.Val[0]
+	}
+
+	return time.Time{}
+}
+
+func (t *Time) Times() []time.Time {
+	return t.Val
+}
+
+func (t *Time) Amy() interface{} {
+	if t.Flag&input.ValueArray > 0 {
+		return t.Times()
+	}
+
+	return t.Time()
+}

input/value/uint.go

@@ -0,0 +1,44 @@
+package value
+
+import (
+	"strconv"
+
+	"gitoa.ru/go-4devs/console/input"
+)
+
+type Uint struct {
+	Empty
+	Val  []uint
+	Flag input.Flag
+}
+
+func (u *Uint) Append(in string) error {
+	v, err := strconv.ParseUint(in, 10, 64)
+	if err != nil {
+		return err
+	}
+
+	u.Val = append(u.Val, uint(v))
+
+	return nil
+}
+
+func (u *Uint) Uint() uint {
+	if !u.Flag.IsArray() && len(u.Val) == 1 {
+		return u.Val[0]
+	}
+
+	return 0
+}
+
+func (u *Uint) Uints() []uint {
+	return u.Val
+}
+
+func (u *Uint) Any() interface{} {
+	if u.Flag&input.ValueArray > 0 {
+		return u.Uints()
+	}
+
+	return u.Uint()
+}

input/value/uint64.go

@@ -0,0 +1,44 @@
+package value
+
+import (
+	"strconv"
+
+	"gitoa.ru/go-4devs/console/input"
+)
+
+type Uint64 struct {
+	Empty
+	Val  []uint64
+	Flag input.Flag
+}
+
+func (u *Uint64) Append(in string) error {
+	v, err := strconv.ParseUint(in, 10, 64)
+	if err != nil {
+		return err
+	}
+
+	u.Val = append(u.Val, v)
+
+	return nil
+}
+
+func (u *Uint64) Uint64() uint64 {
+	if !u.Flag.IsArray() && len(u.Val) == 1 {
+		return u.Val[0]
+	}
+
+	return 0
+}
+
+func (u *Uint64) Uint64s() []uint64 {
+	return u.Val
+}
+
+func (u *Uint64) Any() interface{} {
+	if u.Flag&input.ValueArray > 0 {
+		return u.Uint64s()
+	}
+
+	return u.Uint64()
+}

input/value/value.go

@@ -0,0 +1,84 @@
+package value
+
+import (
+	"time"
+
+	"gitoa.ru/go-4devs/console/input"
+)
+
+//nolint: gocyclo
+func New(v interface{}) input.Value {
+	switch val := v.(type) {
+	case string:
+		return &String{Val: []string{val}, Flag: input.ValueString}
+	case int:
+		return &Int{Val: []int{val}, Flag: input.ValueInt}
+	case int64:
+		return &Int64{Val: []int64{val}, Flag: input.ValueInt64}
+	case uint:
+		return &Uint{Val: []uint{val}, Flag: input.ValueUint}
+	case uint64:
+		return &Uint64{Val: []uint64{val}, Flag: input.ValueUint64}
+	case float64:
+		return &Float64{Val: []float64{val}, Flag: input.ValueFloat64}
+	case bool:
+		return &Bool{Val: []bool{val}, Flag: input.ValueBool}
+	case time.Duration:
+		return &Duration{Val: []time.Duration{val}, Flag: input.ValueDuration}
+	case time.Time:
+		return &Time{Val: []time.Time{val}, Flag: input.ValueTime}
+	case []int64:
+		return &Int64{Val: val, Flag: input.ValueInt64 | input.ValueArray}
+	case []uint:
+		return &Uint{Val: val, Flag: input.ValueUint | input.ValueArray}
+	case []uint64:
+		return &Uint64{Val: val, Flag: input.ValueUint64 | input.ValueArray}
+	case []float64:
+		return &Float64{Val: val, Flag: input.ValueFloat64 | input.ValueArray}
+	case []bool:
+		return &Bool{Val: val, Flag: input.ValueBool | input.ValueArray}
+	case []time.Duration:
+		return &Duration{Val: val, Flag: input.ValueDuration | input.ValueArray}
+	case []time.Time:
+		return &Time{Val: val, Flag: input.ValueTime | input.ValueArray}
+	case []string:
+		return &String{Val: val, Flag: input.ValueString | input.ValueArray}
+	case []int:
+		return &Int{Val: val, Flag: input.ValueInt | input.ValueArray}
+	case []interface{}:
+		return &Any{Val: val, Flag: input.ValueAny | input.ValueArray}
+	case input.Value:
+		return val
+	default:
+		if v != nil {
+			return &Any{Val: []interface{}{v}, Flag: input.ValueAny}
+		}
+
+		return &Empty{}
+	}
+}
+
+func ByFlag(flag input.Flag) input.AppendValue {
+	switch {
+	case flag.IsInt():
+		return &Int{Flag: flag | input.ValueInt}
+	case flag.IsInt64():
+		return &Int64{Flag: flag | input.ValueInt64}
+	case flag.IsUint():
+		return &Uint{Flag: flag | input.ValueUint}
+	case flag.IsUint64():
+		return &Uint64{Flag: flag | input.ValueUint64}
+	case flag.IsFloat64():
+		return &Float64{Flag: flag | input.ValueFloat64}
+	case flag.IsBool():
+		return &Bool{Flag: flag | input.ValueBool}
+	case flag.IsDuration():
+		return &Duration{Flag: flag | input.ValueDuration}
+	case flag.IsTime():
+		return &Time{Flag: flag | input.ValueTime}
+	case flag.IsAny():
+		return &Any{Flag: flag | input.ValueAny}
+	default:
+		return &String{}
+	}
+}