chore: new opts interface

Author: katallaxie

examples/server/simple.go

@@ -10,6 +10,7 @@ import (
 	"github.com/go-chi/chi"
 	"github.com/go-chi/chi/middleware"
 
+	"github.com/andersnormal/pkg/debug"
 	"github.com/andersnormal/pkg/server"
 )
 
@@ -42,9 +43,9 @@ func main() {
 
 	s, _ := server.WithContext(ctx)
 
-	d := server.NewDebugListener(
-		server.WithPprof(),
-		server.WithStatusAddr(":8443"),
+	d := debug.New(
+		debug.WithPprof(),
+		debug.WithStatusAddr(":8443"),
 	)
 	s.Listen(d, false)
 	s.Listen(&srv{}, true)

opts/opts.go

@@ -1,6 +1,8 @@
 package opts
 
 import (
+	"fmt"
+	"sync"
 	"syscall"
 
 	"go.uber.org/zap"
@@ -17,71 +19,151 @@ const (
 	DefaultKillSignal = syscall.SIGINT
 )
 
-// Env is a string that identifies an environment.
-type Env string
+var (
+	// ErrNotFound signals that this option is not set.
+	ErrNotFound = fmt.Errorf("option not found")
+)
+
+// Opt ...
+type Opt int
 
 const (
-	// Development symbolizes a development environment this program runs in.
-	Development Env = "development"
-	// Production symbolizes a production environment this program runs in.
-	Production Env = "production"
+	// Verbose ...
+	Verbose Opt = iota
+	// ReloadSignal ...
+	ReloadSignal
+	// TermSignal ...
+	TermSignal
+	// KillSignal ...
+	KillSignal
+	// Logger ...
+	Logger
 )
 
 // Opts ...
-type Opts struct {
-	// Verbose toggles verbosity
-	Verbose bool
+type Opts interface {
+	// Get ...
+	Get(Opt) (interface{}, error)
+	// Set ...
+	Set(Opt, interface{})
+	// Configure ...
+	Configure(...OptFunc)
+}
+
+// DefaultOpts ...
+type DefaultOpts interface {
+	// Verbose ...
+	Verbose() bool
 	// ReloadSignal ...
-	ReloadSignal syscall.Signal
+	ReloadSignal() syscall.Signal
 	// TermSignal ...
-	TermSignal syscall.Signal
+	TermSignal() syscall.Signal
 	// KillSignal ...
-	KillSignal syscall.Signal
-	// Logger ...
-	Logger *zap.Logger
-	// Env ...
-	Env Env
+	KillSignal() syscall.Signal
+
+	Opts
 }
 
-// Opt is an option
-type Opt func(*Opts)
+// OptFunc is an option
+type OptFunc func(Opts)
+
+// Options is default options structure.
+type Options struct {
+	opts map[Opt]interface{}
+
+	sync.RWMutex
+}
+
+// DefaultOptions are a collection of default options.
+type DefaultOptions struct {
+	Options
+}
 
 // New returns a new instance of the options.
-func New(opts ...Opt) *Opts {
-	o := NewDefaultOpts()
+func New(opts ...OptFunc) Opts {
+	o := new(Options)
 	o.Configure(opts...)
 
 	return o
 }
 
 // NewDefaultOpts returns options with a default configuration.
-func NewDefaultOpts() *Opts {
-	return &Opts{
-		Verbose:      DefaultVerbose,
-		ReloadSignal: DefaultReloadSignal,
-		TermSignal:   DefaultTermSignal,
-		KillSignal:   DefaultKillSignal,
-		Env:          Development,
-	}
+func NewDefaultOpts(opts ...OptFunc) DefaultOpts {
+	o := new(DefaultOptions)
+	o.Configure(opts...)
+
+	o.Set(Verbose, DefaultVerbose)
+	o.Set(ReloadSignal, DefaultReloadSignal)
+	o.Set(TermSignal, DefaultTermSignal)
+	o.Set(KillSignal, DefaultKillSignal)
+
+	return o
 }
 
-// WithLogger is setting a logger for options
-func WithLogger(logger *zap.Logger) Opt {
-	return func(opts *Opts) {
-		opts.Logger = logger
+// Verbose ...
+func (o *DefaultOptions) Verbose() bool {
+	v, _ := o.Get(Verbose)
+
+	return v.(bool)
+}
+
+// ReloadSignal ...
+func (o *DefaultOptions) ReloadSignal() syscall.Signal {
+	v, _ := o.Get(ReloadSignal)
+
+	return v.(syscall.Signal)
+}
+
+// TermSignal ...
+func (o *DefaultOptions) TermSignal() syscall.Signal {
+	v, _ := o.Get(TermSignal)
+
+	return v.(syscall.Signal)
+}
+
+// KillSignal ...
+func (o *DefaultOptions) KillSignal() syscall.Signal {
+	v, _ := o.Get(KillSignal)
+
+	return v.(syscall.Signal)
+}
+
+// WithLogger is setting a logger for options.
+func WithLogger(logger *zap.Logger) OptFunc {
+	return func(opts Opts) {
+		opts.Set(Logger, logger)
 	}
 }
 
-// WithEnv configures a new environment.
-func WithEnv(env Env) Opt {
-	return func(opts *Opts) {
-		opts.Env = env
+// Get ...
+func (o *Options) Get(opt Opt) (interface{}, error) {
+	o.RLock()
+	defer o.RUnlock()
+
+	v, ok := o.opts[opt]
+	if !ok {
+		return nil, ErrNotFound
+
 	}
+
+	return v, nil
+}
+
+// Set ...
+func (o *Options) Set(opt Opt, v interface{}) {
+	o.Lock()
+	defer o.Unlock()
+
+	o.opts[opt] = v
 }
 
 // Configure os configuring the options.
-func (s *Opts) Configure(opts ...Opt) {
-	for _, o := range opts {
-		o(s)
+func (o *Options) Configure(opts ...OptFunc) {
+	if o.opts == nil {
+		o.opts = make(map[Opt]interface{})
+	}
+
+	for _, opt := range opts {
+		opt(o)
 	}
 }

opts/opts_test.go

@@ -1,22 +1,30 @@
 package opts
 
 import (
-	"syscall"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"go.uber.org/zap"
 )
 
-func TestConfig_New(t *testing.T) {
-	o := New()
+func TestConfig_NewDefaultOpts(t *testing.T) {
+	var cond = []struct {
+		desc string
+		in   Opt
+		out  interface{}
+	}{
+		{desc: "", in: Verbose, out: false},
+	}
 
-	assert.Equal(t, o.Verbose, false)
-	assert.Equal(t, o.Env, Development)
-	assert.Equal(t, o.KillSignal, syscall.SIGINT)
-	assert.Equal(t, o.ReloadSignal, syscall.SIGHUP)
-	assert.Equal(t, o.TermSignal, syscall.SIGTERM)
-	assert.Nil(t, o.Logger)
+	for _, tt := range cond {
+		t.Run(tt.desc, func(t *testing.T) {
+			o := NewDefaultOpts()
+
+			v, err := o.Get(tt.in)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.out, v)
+		})
+	}
 }
 
 func TestConfig_WithLogger(t *testing.T) {
@@ -25,10 +33,7 @@ func TestConfig_WithLogger(t *testing.T) {
 	assert.NoError(t, err)
 
 	o := New(WithLogger(logger))
-	assert.NotNil(t, o.Logger)
-}
-
-func TestConfig_WithName(t *testing.T) {
-	o := New(WithEnv(Env("fooBar")))
-	assert.Equal(t, o.Env, Env("fooBar"))
+	v, err := o.Get(Logger)
+	assert.NoError(t, err)
+	assert.NotNil(t, v)
 }

server/debug.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/signal"
 	"sync"
+	"syscall"
 	"time"
 
 	o "github.com/andersnormal/pkg/opts"
@@ -72,11 +73,11 @@ type server struct {
 	ready chan bool
 	sys   chan os.Signal
 
-	opts *o.Opts
+	opts o.Opts
 }
 
 // WithContext ...
-func WithContext(ctx context.Context, opts ...o.Opt) (Server, context.Context) {
+func WithContext(ctx context.Context, opts ...o.OptFunc) (Server, context.Context) {
 	ctx, cancel := context.WithCancel(ctx)
 
 	// new server
@@ -87,8 +88,8 @@ func WithContext(ctx context.Context, opts ...o.Opt) (Server, context.Context) {
 	return s, ctx
 }
 
-func newServer(ctx context.Context, opts ...o.Opt) *server {
-	options := o.New(opts...)
+func newServer(ctx context.Context, opts ...o.OptFunc) *server {
+	options := o.NewDefaultOpts(opts...)
 
 	s := new(server)
 	s.opts = options
@@ -189,5 +190,7 @@ func (s *server) run(f func() error) {
 
 func configureSignals(s *server) {
 	s.sys = make(chan os.Signal, 1)
-	signal.Notify(s.sys, s.opts.TermSignal)
+	term, _ := s.opts.Get(o.TermSignal)
+
+	signal.Notify(s.sys, term.(syscall.Signal))
 }