passit: add RepeatGen

Author: tmthrgd

README.md

@@ -82,17 +82,18 @@ The package also provides a number of generators that produce output based on us
 
 There are also a number of 'helper' generators that interact with the output of other generators:
 
-| Generator         | Description                                                                     |
-| ----------------- | ------------------------------------------------------------------------------- |
-| `Alternate`       | Select a generator at random                                                    |
-| `Join`            | Concatenate the output of multiple generators                                   |
-| `Repeat`          | Invoke a generator multiple times and concatenate the output                    |
-| `RandomRepeat`    | Invoke a generator a random number of times and concatenate the output          |
-| `RejectionSample` | Continually invoke a generator until the output passes a test                   |
-| `Transform`       | Invoke a generator and convert the output according to a user supplied function |
-| `LowerCase`       | Invoke a generator and convert the output to lower case                         |
-| `UpperCase`       | Invoke a generator and convert the output to upper case                         |
-| `TitleCase`       | Invoke a generator and convert the output to language-specific title case       |
+| Generator         | Description                                                                           |
+| ----------------- | ------------------------------------------------------------------------------------- |
+| `Alternate`       | Select a generator at random                                                          |
+| `Join`            | Concatenate the output of multiple generators                                         |
+| `Repeat`          | Invoke a generator multiple times and concatenate the output with a fixed separator   |
+| `RepeatGen`       | Invoke a generator multiple times and concatenate the output with a dynamic separator |
+| `RandomRepeat`    | Invoke a generator a random number of times and concatenate the output                |
+| `RejectionSample` | Continually invoke a generator until the output passes a test                         |
+| `Transform`       | Invoke a generator and convert the output according to a user supplied function       |
+| `LowerCase`       | Invoke a generator and convert the output to lower case                               |
+| `UpperCase`       | Invoke a generator and convert the output to upper case                               |
+| `TitleCase`       | Invoke a generator and convert the output to language-specific title case             |
 
 Most generators only generate a single of something, be it a rune, ASCII character
 or word. For generating longer passwords use `Repeat` or `RandomRepeat`, possibly

helper.go

@@ -45,9 +45,8 @@ type repeatGenerator struct {
 	count int
 }
 
-// Repeat returns a Generator that concatenates the output of invoking the Generator
-// count times to create a single string. The separator string sep is placed between
-// the outputs in the resulting string.
+// Repeat returns a Generator that invokes the Generator count times and
+// concatenates the output with a fixed separator.
 func Repeat(gen Generator, sep string, count int) Generator {
 	switch {
 	case count < 0:
@@ -75,6 +74,51 @@ func (rg *repeatGenerator) Password(r io.Reader) (string, error) {
 	return strings.Join(parts, rg.sep), nil
 }
 
+type repeatGenGenerator struct {
+	gen   Generator
+	sep   Generator
+	count int
+}
+
+// RepeatGen returns a Generator that invokes gen count times and concatenates the
+// output with a dynamic separator produced by sep.
+//
+// For instance, RepeatGen(gen, sep, 4) would be equivalent to
+// Join("", gen, sep, gen, sep, gen, sep, gen).
+func RepeatGen(gen, sep Generator, count int) Generator {
+	switch {
+	case count < 0:
+		panic("passit: count must be positive")
+	case count == 0:
+		return Empty
+	case count == 1:
+		return gen
+	default:
+		return &repeatGenGenerator{gen, sep, count}
+	}
+}
+
+func (rg *repeatGenGenerator) Password(r io.Reader) (string, error) {
+	var b strings.Builder
+	for i := range rg.count {
+		if i > 0 {
+			sep, err := rg.sep.Password(r)
+			if err != nil {
+				return "", err
+			}
+			b.WriteString(sep)
+		}
+
+		part, err := rg.gen.Password(r)
+		if err != nil {
+			return "", err
+		}
+		b.WriteString(part)
+	}
+
+	return b.String(), nil
+}
+
 type randomRepeatGenerator struct {
 	gen Generator
 	sep string

helper_test.go

@@ -11,6 +11,7 @@ import (
 	"strings"
 	"testing"
 	"testing/iotest"
+	"unicode"
 	"unicode/utf8"
 
 	"github.com/stretchr/testify/assert"
@@ -113,6 +114,43 @@ func TestRepeat(t *testing.T) {
 	}
 }
 
+func TestRepeatGen(t *testing.T) {
+	assert.PanicsWithValue(t, "passit: count must be positive", func() {
+		RepeatGen(Hyphen, Space, -1)
+	})
+
+	assert.Equal(t, Empty, RepeatGen(Hyphen, Space, 0),
+		"Repeat with count zero should return Empty")
+
+	assert.Equal(t, Hyphen, RepeatGen(Hyphen, Space, 1),
+		"Repeat with count one should return Generator")
+
+	for _, tc := range []struct {
+		count  int
+		sep    Generator
+		expect string
+	}{
+		{2, Space, "reprint wool"},
+		{2, Digit, "reprint5ultimatum"},
+		{4, Empty, "reprintwoolpantryunworried"},
+		{4, LatinUpper, "reprintXultimatumIunworriedGrecoil"},
+		{4, FromRangeTable(unicode.P), "reprint」pantry𛲟mummify❩securely"},
+		{12, String("-"), "reprint-wool-pantry-unworried-mummify-veneering-securely-munchkin-juiciness-steep-cresting-dastardly"},
+		{12, FromCharset("-~_"), "reprint-ultimatum-unworried~recoil~munchkin~phrase~cubical_haunt-voice-cycle_acetone~grunt"},
+		{12, ASCIINoLettersNumbers, "reprint,ultimatum+unworried)recoil?munchkin]phrase\"cubical|haunt(voice$cycle/acetone$grunt"},
+		{12, ASCIINoLetters, "reprint\\ultimatum-unworried+recoil+munchkin%phrase.cubical>haunt6voice$cycle{acetone`grunt"},
+	} {
+		tr := newTestRand()
+
+		pass, err := RepeatGen(EFFLargeWordlist, tc.sep, tc.count).Password(tr)
+		if !assert.NoErrorf(t, err, "valid range should not error when generating: %v", tc) {
+			continue
+		}
+
+		assert.Equal(t, tc.expect, pass, "valid range expected password: %v", tc)
+	}
+}
+
 func TestRandomRepeat(t *testing.T) {
 	const maxInt = 1<<(bits.UintSize-1) - 1