first commit

value/decode.go

@@ -0,0 +1,109 @@
+package value
+
+import (
+	"time"
+
+	"gitoa.ru/go-4devs/config"
+)
+
+var _ config.Value = (*Decode)(nil)
+
+type Decode func(v interface{}) error
+
+func (s Decode) Unmarshal(v interface{}) error {
+	return s(v)
+}
+
+func (s Decode) ParseInt() (v int, err error) {
+	return v, s.Unmarshal(&v)
+}
+
+func (s Decode) ParseInt64() (v int64, err error) {
+	return v, s.Unmarshal(&v)
+}
+
+func (s Decode) ParseUint() (v uint, err error) {
+	return v, s.Unmarshal(&v)
+}
+
+func (s Decode) ParseUint64() (v uint64, err error) {
+	return v, s.Unmarshal(&v)
+}
+
+func (s Decode) ParseFloat64() (v float64, err error) {
+	return v, s.Unmarshal(&v)
+}
+
+func (s Decode) ParseString() (v string, err error) {
+	return v, s.Unmarshal(&v)
+}
+
+func (s Decode) ParseDuration() (v time.Duration, err error) {
+	return v, s.Unmarshal(&v)
+}
+
+func (s Decode) ParseTime() (v time.Time, err error) {
+	return v, s.Unmarshal(&v)
+}
+
+func (s Decode) Int() int {
+	in, _ := s.ParseInt()
+
+	return in
+}
+
+func (s Decode) Int64() int64 {
+	in, _ := s.ParseInt64()
+
+	return in
+}
+
+func (s Decode) Uint() uint {
+	in, _ := s.ParseUint()
+
+	return in
+}
+
+func (s Decode) Uint64() uint64 {
+	in, _ := s.ParseUint64()
+
+	return in
+}
+
+func (s Decode) Float64() float64 {
+	in, _ := s.ParseFloat64()
+
+	return in
+}
+
+func (s Decode) Bytes() []byte {
+	return []byte(s.String())
+}
+
+func (s Decode) String() string {
+	v, _ := s.ParseString()
+
+	return v
+}
+
+func (s Decode) Bool() bool {
+	in, _ := s.ParseBool()
+
+	return in
+}
+
+func (s Decode) ParseBool() (v bool, err error) {
+	return v, s.Unmarshal(&v)
+}
+
+func (s Decode) Duration() time.Duration {
+	in, _ := s.ParseDuration()
+
+	return in
+}
+
+func (s Decode) Time() time.Time {
+	in, _ := s.ParseTime()
+
+	return in
+}

value/empty.go

@@ -0,0 +1,85 @@
+package value
+
+import (
+	"time"
+)
+
+type Empty struct {
+	Err error
+}
+
+func (e Empty) Unmarshal(val interface{}) error {
+	return e.Err
+}
+
+func (e Empty) ParseString() (string, error) {
+	return "", e.Err
+}
+
+func (e Empty) ParseInt() (int, error) {
+	return 0, e.Err
+}
+
+func (e Empty) ParseInt64() (int64, error) {
+	return 0, e.Err
+}
+
+func (e Empty) ParseUint() (uint, error) {
+	return 0, e.Err
+}
+
+func (e Empty) ParseUint64() (uint64, error) {
+	return 0, e.Err
+}
+
+func (e Empty) ParseFloat64() (float64, error) {
+	return 0, e.Err
+}
+
+func (e Empty) ParseBool() (bool, error) {
+	return false, e.Err
+}
+
+func (e Empty) ParseDuration() (time.Duration, error) {
+	return 0, e.Err
+}
+
+func (e Empty) ParseTime() (time.Time, error) {
+	return time.Time{}, e.Err
+}
+
+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{}
+}

value/helpers.go

@@ -0,0 +1,81 @@
+package value
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"time"
+
+	"gitoa.ru/go-4devs/config"
+)
+
+func ParseDuration(raw string) (time.Duration, error) {
+	d, err := time.ParseDuration(raw)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", config.ErrInvalidValue, err)
+	}
+
+	return d, nil
+}
+
+func ParseInt(s string) (int64, error) {
+	i, err := strconv.ParseInt(s, 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", config.ErrInvalidValue, err)
+	}
+
+	return i, nil
+}
+
+func ParseUint(s string) (uint64, error) {
+	i, err := strconv.ParseUint(s, 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", config.ErrInvalidValue, err)
+	}
+
+	return i, nil
+}
+
+func Atoi(s string) (int, error) {
+	i, err := strconv.Atoi(s)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", config.ErrInvalidValue, err)
+	}
+
+	return i, nil
+}
+
+func ParseTime(s string) (time.Time, error) {
+	i, err := time.Parse(time.RFC3339, s)
+	if err != nil {
+		return time.Time{}, fmt.Errorf("%w: %s", config.ErrInvalidValue, err)
+	}
+
+	return i, nil
+}
+
+func ParseFloat(s string) (float64, error) {
+	f, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", config.ErrInvalidValue, err)
+	}
+
+	return f, nil
+}
+
+func ParseBool(s string) (bool, error) {
+	b, err := strconv.ParseBool(s)
+	if err != nil {
+		return false, fmt.Errorf("%w: %s", config.ErrInvalidValue, err)
+	}
+
+	return b, nil
+}
+
+func JUnmarshal(b []byte, v interface{}) error {
+	if err := json.Unmarshal(b, v); err != nil {
+		return fmt.Errorf("%w: %s", config.ErrInvalidValue, err)
+	}
+
+	return nil
+}

value/jbytes.go

@@ -0,0 +1,112 @@
+package value
+
+import (
+	"time"
+
+	"gitoa.ru/go-4devs/config"
+)
+
+var _ config.Value = (*JBytes)(nil)
+
+type JBytes []byte
+
+func (s JBytes) Unmarshal(v interface{}) error {
+	return JUnmarshal(s.Bytes(), v)
+}
+
+func (s JBytes) ParseString() (string, error) {
+	return s.String(), nil
+}
+
+func (s JBytes) ParseInt() (int, error) {
+	return Atoi(s.String())
+}
+
+func (s JBytes) ParseInt64() (int64, error) {
+	return ParseInt(s.String())
+}
+
+func (s JBytes) ParseUint() (uint, error) {
+	u64, err := ParseUint(s.String())
+	if err != nil {
+		return 0, err
+	}
+
+	return uint(u64), nil
+}
+
+func (s JBytes) ParseUint64() (uint64, error) {
+	return ParseUint(s.String())
+}
+
+func (s JBytes) ParseFloat64() (float64, error) {
+	return ParseFloat(s.String())
+}
+
+func (s JBytes) ParseBool() (bool, error) {
+	return ParseBool(s.String())
+}
+
+func (s JBytes) ParseDuration() (time.Duration, error) {
+	return ParseDuration(s.String())
+}
+
+func (s JBytes) ParseTime() (time.Time, error) {
+	return ParseTime(s.String())
+}
+
+func (s JBytes) Bytes() []byte {
+	return []byte(s)
+}
+
+func (s JBytes) String() string {
+	return string(s)
+}
+
+func (s JBytes) Int() int {
+	in, _ := s.ParseInt()
+
+	return in
+}
+
+func (s JBytes) Int64() int64 {
+	in, _ := s.ParseInt64()
+
+	return in
+}
+
+func (s JBytes) Uint() uint {
+	in, _ := s.ParseUint()
+
+	return in
+}
+
+func (s JBytes) Uint64() uint64 {
+	in, _ := s.ParseUint64()
+
+	return in
+}
+
+func (s JBytes) Float64() float64 {
+	in, _ := s.ParseFloat64()
+
+	return in
+}
+
+func (s JBytes) Bool() bool {
+	in, _ := s.ParseBool()
+
+	return in
+}
+
+func (s JBytes) Duration() time.Duration {
+	in, _ := s.ParseDuration()
+
+	return in
+}
+
+func (s JBytes) Time() time.Time {
+	in, _ := s.ParseTime()
+
+	return in
+}

value/jstring.go

@@ -0,0 +1,112 @@
+package value
+
+import (
+	"time"
+
+	"gitoa.ru/go-4devs/config"
+)
+
+var _ config.Value = (*JString)(nil)
+
+type JString string
+
+func (s JString) Unmarshal(v interface{}) error {
+	return JUnmarshal(s.Bytes(), v)
+}
+
+func (s JString) ParseString() (string, error) {
+	return s.String(), nil
+}
+
+func (s JString) ParseInt() (int, error) {
+	return Atoi(s.String())
+}
+
+func (s JString) ParseInt64() (int64, error) {
+	return ParseInt(s.String())
+}
+
+func (s JString) ParseUint() (uint, error) {
+	u64, err := ParseUint(s.String())
+	if err != nil {
+		return 0, err
+	}
+
+	return uint(u64), nil
+}
+
+func (s JString) ParseUint64() (uint64, error) {
+	return ParseUint(s.String())
+}
+
+func (s JString) ParseFloat64() (float64, error) {
+	return ParseFloat(s.String())
+}
+
+func (s JString) ParseBool() (bool, error) {
+	return ParseBool(s.String())
+}
+
+func (s JString) ParseDuration() (time.Duration, error) {
+	return ParseDuration(s.String())
+}
+
+func (s JString) ParseTime() (time.Time, error) {
+	return ParseTime(s.String())
+}
+
+func (s JString) Bytes() []byte {
+	return []byte(s)
+}
+
+func (s JString) String() string {
+	return string(s)
+}
+
+func (s JString) Int() int {
+	in, _ := s.ParseInt()
+
+	return in
+}
+
+func (s JString) Int64() int64 {
+	in, _ := s.ParseInt64()
+
+	return in
+}
+
+func (s JString) Uint() uint {
+	in, _ := s.ParseUint()
+
+	return in
+}
+
+func (s JString) Uint64() uint64 {
+	in, _ := s.ParseUint64()
+
+	return in
+}
+
+func (s JString) Float64() float64 {
+	in, _ := s.ParseFloat64()
+
+	return in
+}
+
+func (s JString) Bool() bool {
+	in, _ := s.ParseBool()
+
+	return in
+}
+
+func (s JString) Duration() time.Duration {
+	in, _ := s.ParseDuration()
+
+	return in
+}
+
+func (s JString) Time() time.Time {
+	in, _ := s.ParseTime()
+
+	return in
+}

value/jstring_test.go

@@ -0,0 +1,37 @@
+package value_test
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"gitoa.ru/go-4devs/config"
+	"gitoa.ru/go-4devs/config/value"
+)
+
+func TestStringDuration(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]struct {
+		raw value.JString
+		exp time.Duration
+		err error
+	}{
+		"1m": {
+			raw: value.JString("1m"),
+			exp: time.Minute,
+		},
+		"number error": {
+			raw: value.JString("100000000"),
+			err: config.ErrInvalidValue,
+		},
+	}
+
+	for name, data := range tests {
+		require.Equal(t, data.exp, data.raw.Duration(), name)
+		d, err := data.raw.ParseDuration()
+		require.Truef(t, errors.Is(err, data.err), "%[1]s: expect:%#[2]v, got:%#[3]v", name, data.err, err)
+		require.Equal(t, data.exp, d, name)
+	}
+}

value/value.go

@@ -0,0 +1,158 @@
+package value
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"gitoa.ru/go-4devs/config"
+)
+
+var _ config.Value = (*Value)(nil)
+
+type Value struct {
+	Val interface{}
+}
+
+func (s Value) Int() int {
+	v, _ := s.ParseInt()
+
+	return v
+}
+
+func (s Value) Int64() int64 {
+	v, _ := s.ParseInt64()
+
+	return v
+}
+
+func (s Value) Uint() uint {
+	v, _ := s.ParseUint()
+
+	return v
+}
+
+func (s Value) Uint64() uint64 {
+	v, _ := s.ParseUint64()
+
+	return v
+}
+
+func (s Value) Float64() float64 {
+	in, _ := s.ParseFloat64()
+
+	return in
+}
+
+func (s Value) String() string {
+	v, _ := s.ParseString()
+
+	return v
+}
+
+func (s Value) Bool() bool {
+	v, _ := s.ParseBool()
+
+	return v
+}
+
+func (s Value) Duration() time.Duration {
+	v, _ := s.ParseDuration()
+
+	return v
+}
+
+func (s Value) Raw() interface{} {
+	return s.Val
+}
+
+func (s Value) Time() time.Time {
+	v, _ := s.ParseTime()
+
+	return v
+}
+
+func (s Value) Unmarshal(target interface{}) error {
+	if v, ok := s.Raw().([]byte); ok {
+		err := json.Unmarshal(v, target)
+		if err != nil {
+			return fmt.Errorf("%w: %s", config.ErrInvalidValue, err)
+		}
+
+		return nil
+	}
+
+	return config.ErrInvalidValue
+}
+
+func (s Value) ParseInt() (int, error) {
+	if r, ok := s.Raw().(int); ok {
+		return r, nil
+	}
+
+	return 0, config.ErrInvalidValue
+}
+
+func (s Value) ParseInt64() (int64, error) {
+	if r, ok := s.Raw().(int64); ok {
+		return r, nil
+	}
+
+	return 0, config.ErrInvalidValue
+}
+
+func (s Value) ParseUint() (uint, error) {
+	if r, ok := s.Raw().(uint); ok {
+		return r, nil
+	}
+
+	return 0, config.ErrInvalidValue
+}
+
+func (s Value) ParseUint64() (uint64, error) {
+	if r, ok := s.Raw().(uint64); ok {
+		return r, nil
+	}
+
+	return 0, config.ErrInvalidValue
+}
+
+func (s Value) ParseFloat64() (float64, error) {
+	if r, ok := s.Raw().(float64); ok {
+		return r, nil
+	}
+
+	return 0, config.ErrInvalidValue
+}
+
+func (s Value) ParseString() (string, error) {
+	if r, ok := s.Raw().(string); ok {
+		return r, nil
+	}
+
+	return "", config.ErrInvalidValue
+}
+
+func (s Value) ParseBool() (bool, error) {
+	if b, ok := s.Raw().(bool); ok {
+		return b, nil
+	}
+
+	return false, config.ErrInvalidValue
+}
+
+func (s Value) ParseDuration() (time.Duration, error) {
+	if b, ok := s.Raw().(time.Duration); ok {
+		return b, nil
+	}
+
+	return 0, config.ErrInvalidValue
+}
+
+func (s Value) ParseTime() (time.Time, error) {
+	if b, ok := s.Raw().(time.Time); ok {
+		return b, nil
+	}
+
+	return time.Time{}, config.ErrInvalidValue
+}