conf

type BindParam ¶

type BindParam struct {
	Key      string            // full property key
	Path     string            // full property path
	Tag      ParsedTag         // parsed tag
	Validate reflect.StructTag // original struct field tag for validation
}

BindParam holds metadata needed to bind a single configuration value to a Go struct field, slice element, or map entry.

func (param *BindParam) BindTag(tag string, validate reflect.StructTag) error

type Converter ¶

type Converter[T any] func(string) (T, error)

Converter converts a string to a target type T.

type Filter ¶ added in v1.1.2

type Filter interface {
	Do(i any, param BindParam) (bool, error)
}

Filter defines an interface for filtering configuration fields during binding.

type MutableProperties ¶ added in v1.2.0

type MutableProperties struct {
	*barky.Storage
}

MutableProperties stores the data with map[string]string and the keys are case-sensitive, you can get one of them by its key, or bind some of them to a value.

There are too many formats of configuration files, and too many conflicts between them. Each format of configuration file provides its special characteristics, but usually they are not all necessary, and complementary. For example, `conf` disabled Java properties' expansion when reading file, but also provides similar function when getting or binding properties.

A good rule of thumb is that treating application configuration as a tree, but not all formats of configuration files designed as a tree or not ideal, for instance Java properties isn't strictly verified. Although configuration can store as a tree, but it costs more CPU time when getting properties because it reads property node by node. So `conf` uses a tree to strictly verify and a flat map to store.

func Load(file string) (*MutableProperties, error)

func Map(data map[string]any) *MutableProperties

func New() *MutableProperties

func (p *MutableProperties) Bind(i any, tag ...string) error

value:"${key:=default}>>splitter"

func (p *MutableProperties) CopyTo(out *MutableProperties) error

func (p *MutableProperties) Resolve(s string) (string, error)

type ParsedTag ¶

type ParsedTag struct {
	Key      string // short property key
	Def      string // default value string
	HasDef   bool   // indicates whether a default value exists
	Splitter string // optional splitter function name for slice parsing
}

ParsedTag represents a parsed configuration tag that encodes metadata for binding configuration values from property sources.

A tag string generally follows the pattern:

${key:=default}>>splitter

- "key": the property key used to look up a value. - "default": optional fallback value if the key does not exist. - "splitter": optional custom function name to split strings into slices.

Examples:

"${db.host:=localhost}"       -> key=db.host, default=localhost
"${ports:=8080,9090}>>csv"    -> key=ports, default=8080,9090, splitter=csv
"${:=foo}"                    -> empty key, only default value "foo"

The parsing logic is strict; malformed tags will result in ErrInvalidSyntax.

func ParseTag(tag string) (ret ParsedTag, err error)

"${foo}"               -> Key="foo"
"${foo:=bar}"          -> Key="foo", HasDef=true, Def="bar"
"${foo:=bar}>>csv"     -> Key="foo", HasDef=true, Def="bar", Splitter="csv"
"${:=fallback}"        -> Key="", HasDef=true, Def="fallback"

func (tag ParsedTag) String() string

type Properties ¶

type Properties interface {
	// Data returns all key-value pairs as a flat map.
	Data() map[string]string
	// Keys returns all keys.
	Keys() []string
	// SubKeys returns the sorted sub-keys of a given key.
	SubKeys(key string) ([]string, error)
	// Has checks whether a key exists.
	Has(key string) bool
	// Get returns the value for a given key, with an optional default.
	Get(key string, def ...string) string
	// Resolve resolves placeholders inside a string (e.g. ${key:=default}).
	Resolve(s string) (string, error)
	// Bind binds property values into a target object (struct, map, slice, or primitive).
	Bind(i any, tag ...string) error
	// CopyTo copies properties into another instance, overriding existing values.
	CopyTo(out *MutableProperties) error
}

Properties defines the read-only interface for accessing configuration data.

type Reader ¶

type Reader func(b []byte) (map[string]any, error)

Reader parses raw bytes into a nested map[string]any.

type Splitter ¶

type Splitter func(string) ([]string, error)

Splitter splits a string into a slice of strings using custom logic.

type ValidateFunc ¶ added in v1.2.0

type ValidateFunc[T any] func(T) bool

ValidateFunc defines a type for validation functions, which accept a value of type T and return a boolean result.