README
¶
Clean APIs for your Go Applications. Inspired by functional options pattern.
Quick view
package main
import (
"fmt"
"github.com/kataras/go-options"
)
type appOptions struct {
Name string
MaxRequests int
DevMode bool
EnableLogs bool
}
type app struct {
options appOptions
}
func newApp(setters ...options.OptionSetter) *app {
opts := appOptions{Name: "My App's Default Name"} // any default options here
options.Struct(&opts, setters...) // convert any dynamic options to the appOptions struct, fills non-default options from the setters
app := &app{options: opts}
return app
}
// Name sets the appOptions.Name field
// pass an (optionall) option via static func
func Name(val string) options.OptionSetter {
return options.Option("Name", val)
}
// Dev sets the appOptions.DevMode & appOptions.EnableLogs field
// pass an (optionall) option via static func
func Dev(val bool) options.OptionSetter {
return options.Options{"DevMode": val, "EnableLogs": val}
}
// and so on...
func passDynamicOptions() {
myApp := newApp(options.Options{"MaxRequests": 17, "DevMode": true})
fmt.Printf("passDynamicOptions: %#v\n", myApp.options)
}
func passDynamicOptionsAlternative() {
myApp := newApp(options.Option("MaxRequests", 17), options.Option("DevMode", true))
fmt.Printf("passDynamicOptionsAlternative: %#v\n", myApp.options)
}
func passFuncsOptions() {
myApp := newApp(Name("My name"), Dev(true))
fmt.Printf("passFuncsOptions: %#v\n", myApp.options)
}
// go run $GOPATH/github.com/kataras/go-options/example/main.go
func main() {
passDynamicOptions()
passDynamicOptionsAlternative()
passFuncsOptions()
}
Installation
The only requirement is the Go Programming Language, at least v1.7.
$ go get -u github.com/kataras/go-options
FAQ
If you'd like to discuss this package, or ask questions about it, feel free to
- Explore these questions.
- Post an issue or idea here.
- Navigate to the Chat.
Versioning
Current: v0.0.1
Read more about Semantic Versioning 2.0.0
- http://semver.org/
- https://en.wikipedia.org/wiki/Software_versioning
- https://wiki.debian.org/UpstreamGuide#Releases_and_Versions
People
The author of go-options is @kataras.
Contributing
If you are interested in contributing to the go-options project, please make a PR.
License
This project is licensed under the MIT License.
License can be found here.
Documentation
¶
Overview ¶
Package options implements the Functional Options pattern which provides clean APIs in Go. Options implemented as a function set the state of that option. Inspired by https://github.com/tmrts/go-patterns/blob/master/idiom/functional-options.md
Index ¶
Constants ¶
const (
// Version current version number
Version = "0.0.1"
)
Variables ¶
This section is empty.
Functions ¶
func Struct ¶
func Struct(defaultOptions interface{}, opt ...OptionSetter) error
Struct receives default options (pointer to struct) and any option setters fills the static pointer to struct (defaultOptions) returns an error if somethinf bad happen, for example if wrong type kind of value is setted
Types ¶
type OptionSetter ¶
type OptionSetter interface {
// Set receives an Options, which itself implements the OptionSetter, and sets any key-based pair values
Set(Options)
}
OptionSetter contains the Set function Is the receiver to set any options
func Option ¶
func Option(key string, val interface{}) OptionSetter
Option sets a single option's value, implements the OptionSetter, so it can be passed to the .New,.Default & .Struct also useful when you 'like' to pass .Default(Option("key","value")) instead of .Default(Options{Key:value}), both do the same thing
type Options ¶
type Options map[string]interface{}
Options is just a map[string]interface{} which implements the OptionSetter too this map can be converted to Struct if call 'options.Struct'
func Default ¶
func Default(opt ...OptionSetter) Options
Default accepts option setters and returns the new filled Options, you can pass multi Options as OptionSetter too
func New ¶
func New(defOptions Options, opt ...OptionSetter) (Options, func(interface{}) error)
New receives default options, which can be empty and any option setters returns two values returns the new, filled from the setters, Options and a function which is optionally called by the caller, which receives an interface and returns this interface(pointer to struct) filled by the Setters(same as .Struct)
Source Files
Directories