def (#12)

Reviewed-on: #12
2025-12-26 14:55:42 +03:00
parent 22dacb741f
commit f9a0411192
129 changed files with 4660 additions and 1456 deletions
--- a/definition/option/errors.go
+++ b/definition/option/errors.go
@@ -0,0 +1,30 @@
+package option
+
+import (
+	"errors"
+	"fmt"
+)
+
+type Error struct {
+	Key []string
+	Err error
+}
+
+func (o Error) Error() string {
+	return fmt.Sprintf("%s: %s", o.Key, o.Err)
+}
+
+func (o Error) Is(err error) bool {
+	return errors.Is(err, o.Err)
+}
+
+func (o Error) Unwrap() error {
+	return o.Err
+}
+
+func Err(err error, key []string) Error {
+	return Error{
+		Key: key,
+		Err: err,
+	}
+}
--- a/definition/option/option.go
+++ b/definition/option/option.go
@@ -1,100 +1,66 @@
 package option

 import (
-	"gitoa.ru/go-4devs/config/definition"
+	"time"
+
+	"gitoa.ru/go-4devs/config"
+	"gitoa.ru/go-4devs/config/param"
 )

-var _ definition.Option = Option{}
+var _ config.Option = New("", "", nil)

-const (
-	Kind = "option"
-)
-
-const (
-	TypeString   = "string"
-	TypeInt      = "int"
-	TypeInt64    = "int64"
-	TypeUint     = "uint"
-	TypeUint64   = "uint64"
-	TypeFloat64  = "float64"
-	TypeBool     = "bool"
-	TypeTime     = "time.Time"
-	TypeDuration = "time.Duration"
-)
-
-func Default(v any) func(*Option) {
-	return func(o *Option) {
-		o.Default = v
-	}
-}
-
-func New(name, desc string, vtype any, opts ...func(*Option)) Option {
-	option := Option{
-		Name:        name,
-		Description: desc,
-		Type:        vtype,
+func New(name, desc string, vtype any, opts ...param.Option) Option {
+	opts = append(opts, Description(desc), WithType(vtype))
+	res := Option{
+		name:   name,
+		Params: param.New(opts...),
 	}

-	for _, opt := range opts {
-		opt(&option)
-	}
-
-	return option
+	return res
 }

 type Option struct {
-	Name        string
-	Description string
-	Type        any
-	Default     any
-	Params      definition.Params
+	param.Params
+
+	name string
 }

-func (o Option) WithParams(params ...definition.Param) Option {
-	return Option{
-		Name:        o.Name,
-		Description: o.Description,
-		Type:        o.Type,
-		Params:      append(params, o.Params...),
-	}
+func (o Option) Name() string {
+	return o.name
 }

-func (o Option) Kind() string {
-	return Kind
+func String(name, description string, opts ...param.Option) Option {
+	return New(name, description, "", opts...)
 }

-func Time(name, desc string, opts ...func(*Option)) Option {
-	return New(name, desc, TypeTime, opts...)
+func Bool(name, description string, opts ...param.Option) Option {
+	return New(name, description, false, opts...)
 }

-func Duration(name, desc string, opts ...func(*Option)) Option {
-	return New(name, desc, TypeDuration, opts...)
+func Duration(name, description string, opts ...param.Option) Option {
+	return New(name, description, time.Duration(0), opts...)
 }

-func String(name, desc string, opts ...func(*Option)) Option {
-	return New(name, desc, TypeString, opts...)
+func Float64(name, description string, opts ...param.Option) Option {
+	return New(name, description, float64(0), opts...)
 }

-func Int(name, desc string, opts ...func(*Option)) Option {
-	return New(name, desc, TypeInt, opts...)
+func Int(name, description string, opts ...param.Option) Option {
+	return New(name, description, int(0), opts...)
 }

-func Int64(name, desc string, opts ...func(*Option)) Option {
-	return New(name, desc, TypeInt64, opts...)
+func Int64(name, description string, opts ...param.Option) Option {
+	return New(name, description, int64(0), opts...)
 }

-func Uint(name, desc string, opts ...func(*Option)) Option {
-	return New(name, desc, TypeUint, opts...)
+func Time(name, description string, opts ...param.Option) Option {
+	return New(name, description, time.Time{}, opts...)
 }

-func Uint64(name, desc string, opts ...func(*Option)) Option {
-	return New(name, desc, TypeUint64, opts...)
+func Uint(name, description string, opts ...param.Option) Option {
+	return New(name, description, uint(0), opts...)
 }

-func Float64(name, desc string, opts ...func(*Option)) Option {
-	return New(name, desc, TypeFloat64, opts...)
-}
-
-func Bool(name, desc string, opts ...func(*Option)) Option {
-	return New(name, desc, TypeBool, opts...)
+func Uint64(name, descriontion string, opts ...param.Option) Option {
+	return New(name, descriontion, uint64(0), opts...)
 }
--- a/definition/option/params.go
+++ b/definition/option/params.go
@@ -0,0 +1,125 @@
+package option
+
+import (
+	"gitoa.ru/go-4devs/config/param"
+)
+
+type key int
+
+const (
+	paramHidden key = iota + 1
+	paramDefault
+	paramDesc
+	paramRequired
+	paramSlice
+	paramBool
+	paramPos
+	paramShort
+)
+
+func Short(in rune) param.Option {
+	return func(v param.Params) param.Params {
+		return param.With(v, paramShort, string(in))
+	}
+}
+
+func ParamShort(fn param.Params) (string, bool) {
+	data, ok := param.String(fn, paramShort)
+
+	return data, ok
+}
+
+func HasShort(short string) param.Has {
+	return func(fn param.Params) bool {
+		data, ok := param.String(fn, paramShort)
+
+		return ok && data == short
+	}
+}
+
+func WithType(in any) param.Option {
+	return func(v param.Params) param.Params {
+		out := param.WithType(in)(v)
+		if _, ok := in.(bool); ok {
+			return param.With(out, paramBool, ok)
+		}
+
+		return out
+	}
+}
+
+func Position(pos uint64) param.Option {
+	return func(p param.Params) param.Params {
+		return param.With(p, paramPos, pos)
+	}
+}
+
+func Hidden(v param.Params) param.Params {
+	return param.With(v, paramHidden, true)
+}
+
+func Required(v param.Params) param.Params {
+	return param.With(v, paramRequired, true)
+}
+
+func Slice(v param.Params) param.Params {
+	return param.With(v, paramSlice, true)
+}
+
+func Default(in any) param.Option {
+	return func(v param.Params) param.Params {
+		return param.With(v, paramDefault, in)
+	}
+}
+
+func Description(in string) param.Option {
+	return func(v param.Params) param.Params {
+		return param.With(v, paramDesc, in)
+	}
+}
+
+func HasDefaut(fn param.Params) bool {
+	_, ok := fn.Param(paramDefault)
+
+	return ok
+}
+
+func DataPosition(fn param.Params) (uint64, bool) {
+	return param.Uint64(paramPos, fn)
+}
+
+func DataDefaut(fn param.Params) (any, bool) {
+	data, ok := fn.Param(paramDefault)
+
+	return data, ok
+}
+
+func IsSlice(fn param.Params) bool {
+	data, ok := param.Bool(paramSlice, fn)
+
+	return ok && data
+}
+
+func IsBool(fn param.Params) bool {
+	data, ok := param.Bool(paramBool, fn)
+
+	return ok && data
+}
+
+func IsHidden(fn param.Params) bool {
+	data, ok := param.Bool(paramHidden, fn)
+
+	return ok && data
+}
+
+func IsRequired(fn param.Params) bool {
+	data, ok := param.Bool(paramRequired, fn)
+
+	return ok && data
+}
+
+func DataDescription(fn param.Params) string {
+	data, _ := param.String(fn, paramDesc)
+
+	return data
+}
--- a/definition/option/tpl/option.tmpl
+++ b/definition/option/tpl/option.tmpl
@@ -1,33 +0,0 @@
-// read{{.FuncName}} {{.Description}}.
-func (i {{.StructName}}) read{{.FuncName}}(ctx context.Context) (v {{.Type}},e error) {
-	val, err := i.Value(ctx, {{ .ParentKeys }}"{{ .Name }}")
-	if err != nil {
-        {{if .HasDefault}}
-        {{$default := .Default}}
-        {{range .DefaultErrors}}
-        if errors.Is(err,{{.}}){
-            return {{$default}}
-		}
-        {{end}}
-        {{end}}
-        return v, fmt.Errorf("read {{.Keys}}:%w",err)
-	}
-
-	{{.Parse "val" "v" .Keys }}
-}
-
-// Read{{.FuncName}} {{.Description}}.
-func (i {{.StructName}}) Read{{.FuncName}}(ctx context.Context) ({{.Type}}, error) {
-    return i.read{{.FuncName}}(ctx)
-}
-
-// {{.FuncName}} {{.Description}}.
-func (i {{.StructName}}) {{.FuncName}}({{if .Context}} ctx context.Context {{end}}) {{.Type}} {
-    {{if not .Context}} ctx := context.Background() {{end}}
-	val, err := i.read{{.FuncName}}(ctx)
-	if err != nil {
-		i.log(ctx, "get {{.Keys}}: %v", err)
-	}
-
-	return val
-}
--- a/definition/option/tpl/parse.tmpl
+++ b/definition/option/tpl/parse.tmpl
@@ -1,3 +0,0 @@
-{{block "Parse" .}}
-return {{.ValName}}.Parse{{ .FuncType}}()
-{{end}}
--- a/definition/option/tpl/unmarshal_json.tmpl
+++ b/definition/option/tpl/unmarshal_json.tmpl
@@ -1,8 +0,0 @@
-{{block "UnmarshalJSON" . }}
-	pval, perr := {{.ValName}}.ParseString()
-	if perr != nil {
-		return {{.Value}}, fmt.Errorf("read {{.Keys}}:%w", perr)
-	}
-
-	return {{.Value}}, {{.Value}}.UnmarshalJSON([]byte(pval))
-{{end}}
--- a/definition/option/tpl/unmarshal_text.tmpl
+++ b/definition/option/tpl/unmarshal_text.tmpl
@@ -1,8 +0,0 @@
-{{block "UnmarshalText" . }}
-	pval, perr := {{.ValName}}.ParseString()
-	if perr != nil {
-		return {{.Value}}, fmt.Errorf("read {{.Keys}}:%w", perr)
-	}
-
-	return {{.Value}}, {{.Value}}.UnmarshalText([]byte(pval))
-{{end}}
--- a/definition/option/view.go
+++ b/definition/option/view.go
@@ -1,235 +0,0 @@
-package option
-
-import (
-	"bytes"
-	"embed"
-	"encoding"
-	"encoding/json"
-	"fmt"
-	"io"
-	"reflect"
-	"strings"
-	"text/template"
-	"time"
-
-	"gitoa.ru/go-4devs/config/definition"
-	"gitoa.ru/go-4devs/config/definition/generate"
-)
-
-//go:embed tpl/*
-var tpls embed.FS
-
-//nolint:gochecknoglobals
-var tpl = template.Must(template.New("tpls").ParseFS(tpls, "tpl/*.tmpl"))
-
-//nolint:gochecknoinits
-func init() {
-	generate.MustAdd(Kind, Handle(tpl.Lookup("option.tmpl")))
-}
-
-func Handle(tpl *template.Template) generate.Handle {
-	return func(w io.Writer, h generate.Handler, o definition.Option) error {
-		opt, _ := o.(Option)
-		if err := tpl.Execute(w, View{Option: opt, Handler: h}); err != nil {
-			return fmt.Errorf("option tpl:%w", err)
-		}
-
-		return nil
-	}
-}
-
-type View struct {
-	Option
-	generate.Handler
-}
-
-func (v View) Context() bool {
-	return v.Options().Context
-}
-
-func (v View) FuncName() string {
-	if funcName, ok := v.Option.Params.Get(ViewParamFunctName); ok {
-		name, _ := funcName.(string)
-
-		return name
-	}
-
-	return generate.FuncName(v.Name)
-}
-
-func (v View) Description() string {
-	if desc, ok := v.Option.Params.Get(ViewParamDescription); ok {
-		description, _ := desc.(string)
-
-		return description
-	}
-
-	return v.Option.Description
-}
-
-func (v View) Default() string {
-	switch data := v.Option.Default.(type) {
-	case time.Time:
-		return fmt.Sprintf("time.Parse(%q,time.RFC3339Nano)", data.Format(time.RFC3339Nano))
-	case time.Duration:
-		return fmt.Sprintf("time.ParseDuration(%q)", data)
-	default:
-		return fmt.Sprintf("%#v, nil", data)
-	}
-}
-
-func (v View) HasDefault() bool {
-	return v.Option.Default != nil
-}
-
-func (v View) ParentKeys() string {
-	if len(v.Handler.Keys()) > 0 {
-		return `"` + strings.Join(v.Handler.Keys(), `","`) + `",`
-	}
-
-	return ""
-}
-
-func (v View) Type() string {
-	slice := ""
-
-	if vtype, ok := v.Option.Type.(string); ok {
-		if strings.Contains(vtype, ".") {
-			if name, err := v.AddType(vtype); err == nil {
-				return slice + name
-			}
-		}
-
-		return vtype
-	}
-
-	rtype := reflect.TypeOf(v.Option.Type)
-
-	if rtype.PkgPath() == "" {
-		return rtype.String()
-	}
-
-	if rtype.Kind() == reflect.Slice {
-		slice = "[]"
-	}
-
-	short, err := v.AddType(rtype.PkgPath() + "." + rtype.Name())
-	if err != nil {
-		return err.Error()
-	}
-
-	return slice + short
-}
-
-func (v View) FuncType() string {
-	return generate.FuncName(v.Type())
-}
-
-func (v View) Parse(valName string, value string, keys []string) string {
-	h := parser(v.Option.Type)
-
-	data, err := h(ParseData{
-		Value:   value,
-		ValName: valName,
-		Keys:    keys,
-		View:    v,
-	})
-	if err != nil {
-		return err.Error()
-	}
-
-	return data
-}
-
-//nolint:gochecknoglobals,unparam
-var parses = map[string]func(data ParseData) (string, error){
-	typesIntreface[0].Name(): func(data ParseData) (string, error) {
-		var b bytes.Buffer
-
-		err := tpl.ExecuteTemplate(&b, "unmarshal_text.tmpl", data)
-		if err != nil {
-			return "", fmt.Errorf("execute unmarshal text:%w", err)
-		}
-
-		return b.String(), nil
-	},
-	typesIntreface[1].Name(): func(data ParseData) (string, error) {
-		var b bytes.Buffer
-
-		err := tpl.ExecuteTemplate(&b, "unmarshal_json.tmpl", data)
-		if err != nil {
-			return "", fmt.Errorf("execute unmarshal json:%w", err)
-		}
-
-		return b.String(), nil
-	},
-	TypeInt:     internal,
-	TypeInt64:   internal,
-	TypeBool:    internal,
-	TypeString:  internal,
-	TypeFloat64: internal,
-	TypeUint:    internal,
-	TypeUint64:  internal,
-	"time.Duration": func(data ParseData) (string, error) {
-		return fmt.Sprintf("return %s.ParseDuration()", data.ValName), nil
-	},
-	"time.Time": func(data ParseData) (string, error) {
-		return fmt.Sprintf("return %s.ParseTime()", data.ValName), nil
-	},
-	"any": func(data ParseData) (string, error) {
-		return fmt.Sprintf("return %[2]s, %[1]s.Unmarshal(&%[2]s)", data.ValName, data.Value), nil
-	},
-}
-
-func internal(data ParseData) (string, error) {
-	var b bytes.Buffer
-
-	err := tpl.ExecuteTemplate(&b, "parse.tmpl", data)
-	if err != nil {
-		return "", fmt.Errorf("execute parse.tmpl:%w", err)
-	}
-
-	return b.String(), nil
-}
-
-//nolint:gochecknoglobals
-var typesIntreface = [...]reflect.Type{
-	reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem(),
-	reflect.TypeOf((*json.Unmarshaler)(nil)).Elem(),
-}
-
-func parser(data any) func(ParseData) (string, error) {
-	vtype := reflect.TypeOf(data)
-	name := vtype.Name()
-
-	if v, ok := data.(string); ok {
-		name = v
-	}
-
-	if vtype.Kind() == reflect.Slice {
-		return parses["any"]
-	}
-
-	if h, ok := parses[name]; ok {
-		return h
-	}
-
-	for _, extypes := range typesIntreface {
-		if vtype.Implements(extypes) {
-			return parses[extypes.Name()]
-		}
-
-		if vtype.Kind() != reflect.Ptr && reflect.PointerTo(vtype).Implements(extypes) {
-			return parses[extypes.Name()]
-		}
-	}
-
-	return parses["any"]
-}
-
-type ParseData struct {
-	Value   string
-	ValName string
-	Keys    []string
-	View
-}
--- a/definition/option/view_params.go
+++ b/definition/option/view_params.go
@@ -1,6 +0,0 @@
-package option
-
-const (
-	ViewParamFunctName   = "view.funcName"
-	ViewParamDescription = "view.description"
-)