Simplify domain generation

This removes the configurable domain generation in favor of one that
generates domains within the full rnage allowed by the specification.

Author: wfscheper

url.go

@@ -11,51 +11,49 @@ import (
 	"net/url"
 	"path"
 	"reflect"
-	"strings"
 	"unicode"
 )
 
-type domainNameGen struct {
-	maxLength        int
-	maxElementLength int
-}
+const (
+	domainMaxLength        = 255
+	domainMaxElementLength = 63
+)
+
+var (
+	domainType = reflect.TypeOf("")
+	urlType    = reflect.TypeOf(url.URL{})
+)
+
+type domainNameGen struct{}
 
-func (g *domainNameGen) String() string {
-	return fmt.Sprintf("Domain(maxLength=%v, mmaxElementLength%v)", g.maxLength, g.maxElementLength)
+func (*domainNameGen) String() string {
+	return "Domain()"
 }
 
-func (g *domainNameGen) type_() reflect.Type {
-	return stringType
+func (*domainNameGen) type_() reflect.Type {
+	return domainType
 }
 
+var tldGenerator = SampledFrom(tlds)
+
 func (g *domainNameGen) value(t *T) value {
-	domain := SampledFrom(tlds).
-		Filter(func(s string) bool { return len(s)+2 <= g.maxLength }).
+	domain := tldGenerator.
+		Filter(func(s string) bool { return len(s)+2 <= domainMaxLength }).
 		Map(func(s string) string {
 			var n string
 			for _, ch := range s {
-				n += string(SampledFrom([]rune{unicode.ToUpper(ch), unicode.ToLower(ch)}).Draw(t, "").(rune))
+				n += string(SampledFrom([]rune{unicode.ToLower(ch), unicode.ToUpper(ch)}).Draw(t, "").(rune))
 			}
 
 			return n
-		}).Draw(t, "domain").(string)
+		}).
+		Draw(t, "domain").(string)
 
-	var b strings.Builder
+	expr := fmt.Sprintf(`[a-zA-Z]([a-zA-Z0-9\-]{0,%d}[a-zA-Z0-9])?`, domainMaxElementLength-2)
 	elements := newRepeat(1, 126, 1)
-	b.Grow(elements.avg())
-
-	var expr string
-	switch g.maxElementLength {
-	case 1:
-		expr = `[a-zA-Z]`
-	case 2:
-		expr = `[a-zA-Z][a-zA-Z0-9]?`
-	default:
-		expr = fmt.Sprintf(`[a-zA-Z]([a-zA-Z0-9\-]{0,%d}[a-zA-Z0-9])?`, g.maxElementLength-2)
-	}
 	for elements.more(t.s, g.String()) {
 		subDomain := StringMatching(expr).Draw(t, "subdomain").(string)
-		if len(domain)+len(subDomain) >= g.maxLength {
+		if len(domain)+len(subDomain) >= domainMaxLength {
 			break
 		}
 		domain = subDomain + "." + domain
@@ -66,34 +64,19 @@ func (g *domainNameGen) value(t *T) value {
 
 // Domain generates an RFC 1035 compliant domain name.
 func Domain() *Generator {
-	return DomainOf(255, 63)
-}
-
-// DomainOf generates an RFC 1035 compliant domain name,
-// with a maximum overall length of maxLength
-// and a maximum number of elements of maxElements.
-func DomainOf(maxLength, maxElementLength int) *Generator {
-	assertf(4 <= maxLength, "maximum length (%v) should not be less than 4, to generate a two character domain and a one character subdomain", maxLength)
-	assertf(maxLength <= 255, "maximum length (%v) should not be greater than 255 to comply with RFC 1035", maxLength)
-	assertf(1 <= maxElementLength, "maximum element length (%v) should not be less than 1 to comply with RFC 1035", maxElementLength)
-	assertf(maxElementLength <= 63, "maximum element length (%v) should not be greater than 63 to comply with RFC 1035", maxElementLength)
-
-	return newGenerator(&domainNameGen{
-		maxElementLength: maxElementLength,
-		maxLength:        maxLength,
-	})
+	return newGenerator(&domainNameGen{})
 }
 
 type urlGenerator struct {
 	schemes []string
 }
 
 func (g *urlGenerator) String() string {
-	return fmt.Sprintf("URLGenerator(schemes=%v)", g.schemes)
+	return "URL()"
 }
 
 func (g *urlGenerator) type_() reflect.Type {
-	return reflect.TypeOf(url.URL{})
+	return urlType
 }
 
 func (g *urlGenerator) value(t *T) value {

url_example_test.go

@@ -8,6 +8,7 @@ package rapid_test
 
 import (
 	"fmt"
+	"net/url"
 
 	"pgregory.net/rapid"
 )
@@ -20,39 +21,25 @@ func ExampleDomain() {
 	}
 
 	// Output:
-	// MV2zb0-S2j.trAveLcHAnnEL
-	// Z.CU
-	// r.ABBotT
-	// r.AcCoUNTaNT
-	// R.
-}
-
-func ExampleDomainOf() {
-	gen := rapid.DomainOf(6, 5)
-
-	for i := 0; i < 5; i++ {
-		fmt.Println(gen.Example(i))
-	}
-
-	// Output:
-	// Dg5G.
-	// Z.CU
-	// Bs.
-	// AI.HkT
-	// R.
+	// D1C.TRaVElErs
+	// C.cuISiNeLlA
+	// r.abbVIe
+	// MC0zJ.aCcOuntAnTs
+	// T6hFdv10.aaa
 }
 
 func ExampleURL() {
 	gen := rapid.URL()
 
 	for i := 0; i < 5; i++ {
-		fmt.Println(gen.Example(i))
+		e := gen.Example(i).(url.URL)
+		fmt.Println(e.String())
 	}
 
 	// Output:
-	// {https   U.aaA:4 V0%E2%90%9A%226%E0%BC%B0%F0%91%82%B0%F0%97%B3%80%F0%92%91%ADX/1=%22  false   }
-	// {http   C.AarP:11 1%EF%BD%9F/%F0%9F%AA%95%22%D6%93%E0%A9%AD%E1%B3%930%D0%8A/%C2%BC%E0%B4%BE3%F0%9E%8B%B0%F0%91%86%BD%C2%B2%E0%B3%A9%CC%80D/%7C+%F0%9F%81%9D+%5D%CC%81%CB%85/%CC%80/%E1%B0%BF/%CD%82K%E0%A5%A9%CC%81  false   }
-	// {https   Bs.:11   false   }
-	// {http   MC0zJ.aCcOUNtAnT:2 J%E2%9D%87  false   }
-	// {http   t.Xn--RvC1e0am3E:3 %CC%82/%E2%80%A60%CC%80%C3%B7/%CC%81%CC%A2%21%E0%AF%AB%CC%81%C3%A4/%F0%9F%AA%95%EA%99%B4%CC%80%E0%A5%AD/%F0%AD%B9%A9%F0%91%87%AE/%E1%B7%93%CC%8B%E2%87%94%E2%90%8E%EA%A3%A5%E0%B5%9A=%E5%8E%A4%D9%AAB%F0%A5%8F%9A=%C2%A4%C3%AE%F0%91%84%AD%DC%8A%21%E2%82%8D3/%E1%81%8F%23  false   }
+	// https://r125pz05Rz-0j1d-11.AArP:17
+	// http://L2.aBArTh:7/%25F0%259F%25AA%2595%2522%25D6%2593%25E0%25A9%25AD%25E1%25B3%25930%25D0%258A/%25C2%25BC%25E0%25B4%25BE3%25F0%259E%258B%25B0%25F0%2591%2586%25BD%25C2%25B2%25E0%25B3%25A9%25CC%2580D/%257C+%25F0%259F%2581%259D+%255D%25CC%2581%25CB%2585/%25CC%2580/%25E1%25B0%25BF/%25CD%2582K%25E0%25A5%25A9%25CC%2581
+	// https://pH20DR11.aaA
+	// http://h.AcCounTaNtS:4/%25F0%259E%25A5%259F/:%2521J%25E2%259D%2587
+	// http://A.xN--s9bRJ9C:2
 }

url_external_test.go

@@ -9,15 +9,16 @@ package rapid_test
 import (
 	"net/url"
 	"regexp"
-	"strconv"
 	"strings"
 	"testing"
 
 	. "pgregory.net/rapid"
 )
 
+var pathEscapeRegex = regexp.MustCompile(`^[0-9A-Fa-f]{2}`)
+
 func TestURL(t *testing.T) {
-	pathEscapeRegex := regexp.MustCompile(`^[0-9A-Fa-f]{2}`)
+	t.Parallel()
 
 	Check(t, func(t *T) {
 		u := URL().Draw(t, "url").(url.URL)
@@ -43,31 +44,22 @@ func TestURL(t *testing.T) {
 	})
 }
 
-func TestDomainOf(t *testing.T) {
+func TestDomain(t *testing.T) {
 	t.Parallel()
 
-	genFuncs := []func(int, int) *Generator{
-		func(i, j int) *Generator { return DomainOf(i, j) },
-	}
-
-	for i, gf := range genFuncs {
-		t.Run(strconv.Itoa(i), MakeCheck(func(t *T) {
-			maxLength := IntRange(4, 255).Draw(t, "maxLength").(int)
-			maxElementLength := IntRange(1, 63).Draw(t, "maxElementLength").(int)
-
-			d := gf(maxLength, maxElementLength).Draw(t, "d").(string)
-			if got, want := len(d), maxLength; got > want {
-				t.Errorf("got domain of length %d with maxLenght of %d", got, want)
-			}
+	Check(t, func(t *T) {
+		d := Domain().Draw(t, "d").(string)
+		if got, want := len(d), 255; got > want {
+			t.Errorf("got domain of length %d with maxLenght of %d", got, want)
+		}
 
-			elements := strings.Split(d, ".")
+		elements := strings.Split(d, ".")
 
-			// ignore the tld
-			for i, elem := range elements[:len(elements)-1] {
-				if got, want := len(elem), maxElementLength; got > want {
-					t.Errorf("got domain element %d of length %d with maxElementLength %d", i, got, want)
-				}
+		// ignore the tld
+		for i, elem := range elements[:len(elements)-1] {
+			if got, want := len(elem), 63; got > want {
+				t.Errorf("got domain element %d of length %d with maxElementLength %d", i, got, want)
 			}
-		}))
-	}
+		}
+	})
 }