dan/nomino
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

🚧 Pass Config to generator

Browse source
This commit is contained in:
Dan Jones 2025-03-13 15:36:30 -05:00
commit 921020d9fd
6 changed files with 31 additions and 31 deletions
Download patch file Download diff file Expand all files Collapse all files

2
config_test.go
View file

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

14
generators.go
View file

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

2
generators_examples_test.go
View file

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

38
generators_test.go
View file

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

2
make.go
View file

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

4
make_test.go
View file

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