Broke down setValue function to smaller fuctions

env.go

@@ -30,6 +30,11 @@ type EnvProvider struct {
 	Required bool
 }
 
+var (
+	_ Provider = (*EnvProvider)(nil)
+	_ Filler   = (*EnvProvider)(nil)
+)
+
 // NewEnvProvider creates a new EnvProvider
 func NewEnvProvider() *EnvProvider {
 	return &EnvProvider{
@@ -42,18 +47,6 @@ func NewEnvProvider() *EnvProvider {
 	}
 }
 
-// NewEnvFileProvider creates a new EnvProvider from .env file
-func NewEnvFileProvider(path string) *EnvProvider {
-	return &EnvProvider{
-		EnvPrefix:      "",
-		SnakeCase:      true,
-		UpperCase:      true,
-		FieldSeparator: "_",
-		Source:         path,
-		Required:       false,
-	}
-}
-
 // Name of provider
 func (ep *EnvProvider) Name() string {
 	return "ENV provider"
@@ -76,7 +69,7 @@ func (ep *EnvProvider) Fill(in *Input) error {
 			return err
 		}
 
-		err = in.setValue(f, value)
+		err = in.SetValue(f, value)
 		if err != nil {
 			return err
 		}
@@ -87,8 +80,7 @@ func (ep *EnvProvider) Fill(in *Input) error {
 	return nil
 }
 
-// envMap returns environment variables map from either OS or file specified by source
-// Defaults to operating system env variables
+// envMap joins env vars from OS and optional env file and returns corresponding map
 func (ep *EnvProvider) envMap() (map[string]string, error) {
 	envs := envFromOS()
 	var fileEnvs map[string]string

file.go

@@ -32,6 +32,12 @@ type FileProvider struct {
 	Required bool
 }
 
+var (
+	_ Provider    = (*FileProvider)(nil)
+	_ Unmarshaler = (*FileProvider)(nil)
+	_ Filler      = (*FileProvider)(nil)
+)
+
 // NewFileProvider creates a new FileProvider from specified path
 func NewFileProvider(path string) *FileProvider {
 	return &FileProvider{
@@ -43,7 +49,7 @@ func NewFileProvider(path string) *FileProvider {
 
 // Name of provider
 func (fp *FileProvider) Name() string {
-	return "File provider"
+	return fmt.Sprintf("File provider (%v)", fp.FileExt[1:])
 }
 
 // UnmarshalStruct takes a struct pointer and loads values from provided file into it
@@ -73,8 +79,7 @@ func (fp *FileProvider) Fill(in *Input) error {
 			key = f.Tags.Toml
 		}
 
-		_, err := fp.provide(content, key, f.Path)
-		if err == nil {
+		if _, err := fp.provide(content, key, f.Path); err == nil {
 			f.IsSet = true
 		}
 	}
@@ -90,11 +95,11 @@ func (fp *FileProvider) decode(i interface{}) (err error) {
 			return nil
 		}
 
-		return fmt.Errorf("file provider: %w", err)
+		return err
 	}
 	defer func() {
-		if cerr := f.Close(); cerr != nil && err == nil {
-			err = cerr
+		if cErr := f.Close(); cErr != nil && err == nil {
+			err = cErr
 		}
 	}()
 
@@ -121,7 +126,13 @@ func (fp *FileProvider) decode(i interface{}) (err error) {
 
 // provide find a value from file content based on specified key and path
 func (fp *FileProvider) provide(content map[string]interface{}, key string, path []string) (string, error) {
-	return traverseMap(content, fp.buildPath(key, path))
+	builtPath := fp.buildPath(key, path)
+	value, exists := traverseMap(content, builtPath)
+	if !exists {
+		return "", ErrKeyNotFound
+	}
+
+	return value, nil
 }
 
 // buildPath makes a path from key and path slice

gonfig.go

@@ -16,57 +16,31 @@ type Config struct {
 	ce ConfigErrors
 }
 
-// Provider is used to provide values
-// It can implement either Unmarshaler or Filler interface or both
-// Name method is used for error messages
-type Provider interface {
-	Name() string
-}
-
-// Unmarshaler can be implemented by providers to receive struct pointer and unmarshal values into it
-type Unmarshaler interface {
-	UnmarshalStruct(i interface{}) (err error)
-}
-
-// Filler can be implemented by providers to receive struct fields and set their value
-type Filler interface {
-	Fill(in *Input) (err error)
-}
-
 // Load creates a new Config object
 func Load() *Config {
 	return &Config{}
 }
 
 // FromEnv adds an EnvProvider to Providers list
 func (c *Config) FromEnv() *Config {
-	return c.FromEnvWithConfig(NewEnvProvider())
-}
-
-// FromEnvWithConfig adds an EnvProvider to Providers list with specified config
-func (c *Config) FromEnvWithConfig(ep *EnvProvider) *Config {
-	c.Providers = append(c.Providers, ep)
-	return c
+	return c.AddProvider(NewEnvProvider())
 }
 
 // FromFile adds a FileProvider to Providers list
 // In case of .env file, it adds a EnvProvider to the list
 func (c *Config) FromFile(path string) *Config {
 	if filepath.Ext(path) == ENV {
-		return c.FromEnvWithConfig(NewEnvFileProvider(path))
+		ep := NewEnvProvider()
+		ep.Source = path
+		return c.AddProvider(NewEnvProvider())
 	}
 
-	return c.FromFileWithConfig(NewFileProvider(path))
+	return c.AddProvider(NewFileProvider(path))
 }
 
-// FromRequiredFile adds a FileProvider to Providers list with specified config
-// In case of .env file, it adds a EnvProvider to the list
-func (c *Config) FromFileWithConfig(fp *FileProvider) *Config {
-	if fp.FileExt == ENV || filepath.Ext(fp.FilePath) == ENV {
-		return c.FromEnvWithConfig(NewEnvFileProvider(fp.FilePath))
-	}
-
-	c.Providers = append(c.Providers, fp)
+// AddProvider adds a Provider to Providers list
+func (c *Config) AddProvider(p Provider) *Config {
+	c.Providers = append(c.Providers, p)
 	return c
 }
 
@@ -82,13 +56,13 @@ func (c *Config) Into(i interface{}) error {
 	for _, p := range c.Providers {
 		if u, ok := p.(Unmarshaler); ok {
 			if err := u.UnmarshalStruct(i); err != nil {
-				c.collectError(err)
+				c.collectError(fmt.Errorf("%v: %w", p.Name(), err))
 			}
 		}
 
 		if f, ok := p.(Filler); ok {
 			if err := f.Fill(in); err != nil {
-				c.collectError(err)
+				c.collectError(fmt.Errorf("%v: %w", p.Name(), err))
 			}
 		}
 	}
@@ -98,15 +72,15 @@ func (c *Config) Into(i interface{}) error {
 			if f.Tags.Required {
 				c.collectError(fmt.Errorf(requiredFieldErrFormat, ErrRequiredField, in.getPath(f.Path)))
 			} else if f.Tags.Default != "" {
-				err := in.setValue(f, f.Tags.Default)
+				err := in.SetValue(f, f.Tags.Default)
 				if err != nil {
 					c.collectError(err)
 				}
 			}
 		}
 
 		if f.Tags.Expand && f.Value.Kind() == reflect.String {
-			err := in.setValue(f, f.Value.String())
+			err := in.SetValue(f, f.Value.String())
 			if err != nil {
 				c.collectError(err)
 			}