golang/mikael/madonctl: comparison vendor/github.com/spf13/viper/README.md

equal deleted inserted replaced

-:db4911b0c721
+:445e01aede7e
 [![run on repl.it](https://repl.it/badge/github/sagikazarmark/Viper-example)](https://repl.it/@sagikazarmark/Viper-example#main.go)
 [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/spf13/viper/CI?style=flat-square)](https://github.com/spf13/viper/actions?query=workflow%3ACI)
 [![Join the chat at https://gitter.im/spf13/viper](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/spf13/viper?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Go Report Card](https://goreportcard.com/badge/github.com/spf13/viper?style=flat-square)](https://goreportcard.com/report/github.com/spf13/viper)
-![Go Version](https://img.shields.io/badge/go%20version-%3E=1.14-61CFDD.svg?style=flat-square)
+![Go Version](https://img.shields.io/badge/go%20version-%3E=1.15-61CFDD.svg?style=flat-square)
 [![PkgGoDev](https://pkg.go.dev/badge/mod/github.com/spf13/viper)](https://pkg.go.dev/mod/github.com/spf13/viper)
 **Go configuration with fangs!**
 Many Go projects are built using Viper including:
 You can handle the specific case where no config file is found like this:
 ```go
 if err := viper.ReadInConfig(); err != nil {
-if _, ok := err.(viper.ConfigFileNotFoundError); ok {
+	if _, ok := err.(viper.ConfigFileNotFoundError); ok {
-// Config file not found; ignore error if desired
+		// Config file not found; ignore error if desired
-} else {
+	} else {
-// Config file was found but another error was produced
+		// Config file was found but another error was produced
-}
+	}
 }
 // Config file found and successfully parsed
 ```
 Optionally you can provide a function for Viper to run each time a change occurs.
 **Make sure you add all of the configPaths prior to calling `WatchConfig()`**
 ```go
-viper.WatchConfig()
 viper.OnConfigChange(func(e fsnotify.Event) {
 	fmt.Println("Config file changed:", e.Name)
 })
+viper.WatchConfig()
 ```
 ### Reading Config from io.Reader
 Viper predefines many configuration sources such as files, environment
 	pflag.Parse()
 	viper.BindPFlags(pflag.CommandLine)
 	i := viper.GetInt("flagname") // retrieve value from viper
-	...
+	// ...
 }
 ```
 #### Flag interfaces
 runtime_viper.Unmarshal(&runtime_conf)
 // open a goroutine to watch remote changes forever
 go func(){
 	for {
-	    time.Sleep(time.Second * 5) // delay after each request
+		time.Sleep(time.Second * 5) // delay after each request
-	    // currently, only tested with etcd support
+		// currently, only tested with etcd support
-	    err := runtime_viper.WatchRemoteConfig()
+		err := runtime_viper.WatchRemoteConfig()
-	    if err != nil {
+		if err != nil {
-	        log.Errorf("unable to read remote config: %v", err)
+			log.Errorf("unable to read remote config: %v", err)
-	        continue
+			continue
-	    }
+		}
-	    // unmarshal new config into our runtime config struct. you can also use channel
+		// unmarshal new config into our runtime config struct. you can also use channel
-	    // to implement a signal to notify the system of the changes
+		// to implement a signal to notify the system of the changes
-	    runtime_viper.Unmarshal(&runtime_conf)
+		runtime_viper.Unmarshal(&runtime_conf)
 	}
 }()
 ```
 ## Getting Values From Viper
 Example:
 ```go
 viper.GetString("logfile") // case-insensitive Setting & Getting
 if viper.GetBool("verbose") {
-fmt.Println("verbose enabled")
+	fmt.Println("verbose enabled")
 }
 ```
 ### Accessing nested keys
 The accessor methods also accept formatted paths to deeply nested keys. For
 So instead of doing that let's pass a Viper instance to the constructor that represents a subset of the configuration:
 ```go
 cache1Config := viper.Sub("cache.cache1")
 if cache1Config == nil { // Sub returns nil if the key cannot be found
-panic("cache configuration not found")
+	panic("cache configuration not found")
 }
 cache1 := NewCache(cache1Config)
 ```
 Internally, the `NewCache` function can address `max-items` and `item-size` keys directly:
 ```go
 func NewCache(v *Viper) *Cache {
-return &Cache{
+	return &Cache{
-MaxItems: v.GetInt("max-items"),
+		MaxItems: v.GetInt("max-items"),
-ItemSize: v.GetInt("item-size"),
+		ItemSize: v.GetInt("item-size"),
-}
+	}
 }
 ```
 The resulting code is easy to test, since it's decoupled from the main config structure,
 and easier to reuse (for the same reason).
 ```go
 v := viper.NewWithOptions(viper.KeyDelimiter("::"))
 v.SetDefault("chart::values", map[string]interface{}{
-"ingress": map[string]interface{}{
+	"ingress": map[string]interface{}{
-"annotations": map[string]interface{}{
+		"annotations": map[string]interface{}{
-"traefik.frontend.rule.type":                 "PathPrefix",
+			"traefik.frontend.rule.type":                 "PathPrefix",
-"traefik.ingress.kubernetes.io/ssl-redirect": "true",
+			"traefik.ingress.kubernetes.io/ssl-redirect": "true",
-},
+		},
-},
+	},
 })
 type config struct {
 	Chart struct{
-Values map[string]interface{}
+		Values map[string]interface{}
-}
+	}
 }
 var C config
 v.Unmarshal(&C)
 }
 ```
 Viper uses [github.com/mitchellh/mapstructure](https://github.com/mitchellh/mapstructure) under the hood for unmarshaling values which uses `mapstructure` tags by default.
+### Decoding custom formats
+A frequently requested feature for Viper is adding more value formats and decoders.
+For example, parsing character (dot, comma, semicolon, etc) separated strings into slices.
+This is already available in Viper using mapstructure decode hooks.
+Read more about the details in [this blog post](https://sagikazarmark.hu/blog/decoding-custom-formats-with-viper/).
 ### Marshalling to string
 You may need to marshal all the settings held in viper into a string rather than write them to a file.
 You can use your favorite format's marshaller with the config returned by `AllSettings()`.
 ```go
 import (
-yaml "gopkg.in/yaml.v2"
+	yaml "gopkg.in/yaml.v2"
-// ...
+	// ...
 )
 func yamlStringSettings() string {
-c := viper.AllSettings()
+	c := viper.AllSettings()
-bs, err := yaml.Marshal(c)
+	bs, err := yaml.Marshal(c)
-if err != nil {
+	if err != nil {
-log.Fatalf("unable to marshal config to YAML: %v", err)
+		log.Fatalf("unable to marshal config to YAML: %v", err)
-}
+	}
-return string(bs)
+	return string(bs)
 }
 ```
 ## Viper or Vipers?

changeset 260	445e01aede7e
parent 256	6d9efbef00a9
child 262	8d3354485fc3