🚧 Pass Config to generator

config_test.go

@@ -10,7 +10,7 @@ import (
 func TestNewConf(t *testing.T) {
 	c := NewConfig()
 	assert.Equal(t, ".txt", c.extension)
-	st, _ := c.generator()
+	st, _ := c.generator(&c)
 	_, parseErr := uuid.Parse(st)
 	assert.NoError(t, parseErr)
 }

generators.go

@@ -11,7 +11,7 @@ import (
 // Generator is a function that returns the "random" portion of the returned filename.
 // Technically, it doesn't necessarily need to be random, and could be based on time, or a counter,
 // for example.
-type Generator func() (string, error)
+type Generator func(conf *Config) (string, error)
 
 // WithGenerator sets the specified generator
 func WithGenerator(g Generator) Option {
@@ -23,7 +23,7 @@ func WithGenerator(g Generator) Option {
 // ErrMissingGenerators is returned by a multi-generator if no generators are supplied.
 var ErrMissingGenerators = errors.New("no generators supplied")
 
-func missingGen() (string, error) {
+func missingGen(*Config) (string, error) {
 	return "", ErrMissingGenerators
 }
 
@@ -39,14 +39,14 @@ func MultiGeneratorInOrder(gens ...Generator) Generator {
 	}
 
 	var idx int
-	return func() (string, error) {
-		st, err := gens[idx]()
+	return func(c *Config) (string, error) {
+		st, err := gens[idx](c)
 		idx = (idx + 1) % len(gens)
 		return st, err
 	}
 }
 
-func uuidGen() (string, error) {
+func uuidGen(*Config) (string, error) {
 	u, err := uuid.NewRandom()
 	if err != nil {
 		return "", err
@@ -81,7 +81,7 @@ func Time(t time.Time) Generator {
 
 // FormattedTime generates a date and time for the supplied time with the supplied format.
 func FormattedTime(t time.Time, f string) Generator {
-	return func() (string, error) {
+	return func(*Config) (string, error) {
 		return t.Format(f), nil
 	}
 }
@@ -117,7 +117,7 @@ func IncrementalWithStep(step int) Generator {
 // InrementalWithStartAndStep generates a name that is a series of integers, starting at the specified number, and increasing the specified step each time
 func IncrementalWithStartAndStep(start, step int) Generator {
 	next := start
-	return func() (string, error) {
+	return func(*Config) (string, error) {
 		out := strconv.Itoa(next)
 		next += step
 		return out, nil

generators_examples_test.go

@@ -3,7 +3,7 @@ package nomino
 import "fmt"
 
 func ExampleWithGenerator_custom_generator() {
-	gen := func() (string, error) {
+	gen := func(*Config) (string, error) {
 		return "hello", nil
 	}
 	option := WithGenerator(gen)

generators_test.go

@@ -10,10 +10,10 @@ import (
 )
 
 func TestWithGenerator(t *testing.T) {
-	g := func() (string, error) { return "abc", nil }
+	g := func(*Config) (string, error) { return "abc", nil }
 	var c Config
 	WithGenerator(g)(&c)
-	st, err := c.generator()
+	st, err := c.generator(&c)
 	assert.NoError(t, err)
 	assert.Equal(t, "abc", st)
 }
@@ -22,49 +22,49 @@ func TestMultiGeneratorInOrder(t *testing.T) {
 	st1 := "abc"
 	st2 := "def"
 	er1 := errors.New("oops")
-	g1 := func() (string, error) { return st1, nil }
-	g2 := func() (string, error) { return st2, nil }
-	g3 := func() (string, error) { return "", er1 }
+	g1 := func(*Config) (string, error) { return st1, nil }
+	g2 := func(*Config) (string, error) { return st2, nil }
+	g3 := func(*Config) (string, error) { return "", er1 }
 	g := MultiGeneratorInOrder(g1, g2, g3)
-	st, err := g()
+	st, err := g(nil)
 	assert.NoError(t, err)
 	assert.Equal(t, st1, st)
-	st, err = g()
+	st, err = g(nil)
 	assert.NoError(t, err)
 	assert.Equal(t, st2, st)
-	st, err = g()
+	st, err = g(nil)
 	assert.Zero(t, st)
 	assert.ErrorIs(t, err, er1)
-	st, err = g()
+	st, err = g(nil)
 	assert.NoError(t, err)
 	assert.Equal(t, st1, st)
 }
 
 func TestMultiGeneratorInOrderOne(t *testing.T) {
 	st1 := "abc"
-	g1 := func() (string, error) { return st1, nil }
+	g1 := func(*Config) (string, error) { return st1, nil }
 	g := MultiGeneratorInOrder(g1)
 
-	st, err := g()
+	st, err := g(nil)
 	assert.NoError(t, err)
 	assert.Equal(t, st1, st)
-	st, err = g()
+	st, err = g(nil)
 	assert.NoError(t, err)
 	assert.Equal(t, st1, st)
 }
 
 func TestMultiGeneratorInOrderMissing(t *testing.T) {
 	g := MultiGeneratorInOrder()
-	st, err := g()
+	st, err := g(nil)
 	assert.Zero(t, st)
 	assert.ErrorIs(t, err, ErrMissingGenerators)
-	st, err = g()
+	st, err = g(nil)
 	assert.Zero(t, st)
 	assert.ErrorIs(t, err, ErrMissingGenerators)
 }
 
 func TestUUID(t *testing.T) {
-	st, err := UUID()()
+	st, err := UUID()(nil)
 	assert.NoError(t, err)
 	_, parseErr := uuid.Parse(st)
 	assert.NoError(t, parseErr)
@@ -80,13 +80,13 @@ func TestUUIDFail(t *testing.T) {
 	uuid.SetRand(badRead{})
 	defer uuid.SetRand(nil)
 
-	_, err := UUID()()
+	_, err := UUID()(nil)
 	assert.Equal(t, errors.New("sorry"), err)
 }
 
 func TestTimestamp(t *testing.T) {
 	n := time.Now()
-	st, err := Timestamp()()
+	st, err := Timestamp()(nil)
 	assert.NoError(t, err)
 	assert.Equal(t, n.Format(FileTimestamp), st)
 }
@@ -94,14 +94,14 @@ func TestTimestamp(t *testing.T) {
 func TestTime(t *testing.T) {
 	d := time.Date(1986, time.March, 28, 12, 0, 0, 0, time.UTC)
 
-	st, err := Time(d)()
+	st, err := Time(d)(nil)
 	assert.NoError(t, err)
 	assert.Equal(t, d.Format(FileTimestamp), st)
 }
 
 func TestTimestampUTC(t *testing.T) {
 	n := time.Now()
-	st, err := TimestampUTC()()
+	st, err := TimestampUTC()(nil)
 	assert.NoError(t, err)
 	assert.Equal(t, n.UTC().Format(FileTimestampNoTZ), st)
 }

make.go

@@ -6,7 +6,7 @@ import "fmt"
 // In general, the final filename will be [prefix]_[generated_string]_[original_filename]_[suffix].[extension].
 // If the name generator returns an error (generally, it shouldn't), that will be returned instead.
 func Make(conf Config) (string, error) {
-	name, err := conf.generator()
+	name, err := conf.generator(&conf)
 	if err != nil {
 		return "", err
 	}

make_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestMake(t *testing.T) {
-	genOpt := WithGenerator(func() (string, error) { return "abc", nil })
+	genOpt := WithGenerator(func(*Config) (string, error) { return "abc", nil })
 	testcases := []struct {
 		name string
 		opts []Option
@@ -47,7 +47,7 @@ func TestMake(t *testing.T) {
 
 func TestMakeErr(t *testing.T) {
 	retErr := errors.New("oops")
-	conf := NewConfig(WithGenerator(func() (string, error) { return "foobar", retErr }))
+	conf := NewConfig(WithGenerator(func(*Config) (string, error) { return "foobar", retErr }))
 	st, err := Make(conf)
 	assert.Zero(t, st)
 	assert.ErrorIs(t, err, retErr)