Fix Infer, rename tests, add benchmark

- `Infer` can now handle numeric values that are not `float64`
- Add tests for `Infer` in addition to `InferStrings`
- Remove test with only one case and move to table
- Rename tests (drop `JTD`)
- Add benchmarking to see effects on new type switch

Fixes #8

Author: bombsimon

inferred_number.go

@@ -134,3 +134,34 @@ func (i *InferredNumber) ContainedBy(nt NumType) bool {
 
 	return minValue <= i.Min && maxValue >= i.Max
 }
+
+func anyAsNumber(value any) (float64, bool) {
+	switch v := value.(type) {
+	case float64:
+		return v, true
+	case float32:
+		return float64(v), true
+	case uint:
+		return float64(v), true
+	case uint8:
+		return float64(v), true
+	case uint16:
+		return float64(v), true
+	case uint32:
+		return float64(v), true
+	case uint64:
+		return float64(v), true
+	case int:
+		return float64(v), true
+	case int8:
+		return float64(v), true
+	case int16:
+		return float64(v), true
+	case int32:
+		return float64(v), true
+	case int64:
+		return float64(v), true
+	default:
+		return 0.0, false
+	}
+}

inferred_schema.go

@@ -83,9 +83,7 @@ func (i *InferredSchema) Infer(value any, hints Hints) *InferredSchema {
 		return &InferredSchema{SchemaType: SchemaTypeBoolean}
 	}
 
-	// In Go all numbers from unmarshalling JSON will be represented as float64
-	// so this is the only type we need.
-	if v, ok := value.(float64); ok && i.SchemaType == SchemaTypeUnknown {
+	if v, ok := anyAsNumber(value); ok && i.SchemaType == SchemaTypeUnknown {
 		return &InferredSchema{
 			SchemaType: SchemaTypeNumber,
 			Number:     NewNumber().Infer(v),
@@ -175,7 +173,7 @@ func (i *InferredSchema) Infer(value any, hints Hints) *InferredSchema {
 		return &InferredSchema{SchemaType: SchemaTypeAny}
 	}
 
-	if v, ok := value.(float64); ok && i.SchemaType == SchemaTypeNumber {
+	if v, ok := anyAsNumber(value); ok && i.SchemaType == SchemaTypeNumber {
 		return &InferredSchema{
 			SchemaType: SchemaTypeNumber,
 			Number:     i.Number.Infer(v),

inferrer_test.go

@@ -12,6 +12,49 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func TestInfer(t *testing.T) {
+	for _, tc := range []struct {
+		value          any
+		expectedSchema Schema
+	}{
+		{
+			value:          "52",
+			expectedSchema: Schema{Type: jtd.TypeString},
+		},
+		{
+			value:          52,
+			expectedSchema: Schema{Type: jtd.TypeUint8},
+		},
+		{
+			value:          nil,
+			expectedSchema: Schema{Nullable: true},
+		},
+		{
+			value: map[string]any{
+				"name": "Joe",
+				"age":  52,
+			},
+			expectedSchema: Schema{
+				Properties: map[string]Schema{
+					"name": {Type: jtd.TypeString},
+					"age":  {Type: jtd.TypeUint8},
+				},
+			},
+		},
+		{
+			value: []int{1, 3, 5},
+			expectedSchema: Schema{
+				Elements: &Schema{Type: jtd.TypeUint8},
+			},
+		},
+	} {
+		t.Run(fmt.Sprintf("infer_%T", tc.value), func(t *testing.T) {
+			gotSchema := NewInferrer(WithoutHints()).Infer(tc.value).IntoSchema()
+			assert.EqualValues(t, tc.expectedSchema, gotSchema)
+		})
+	}
+}
+
 func TestInferString(t *testing.T) {
 	cases := []struct {
 		description    string
@@ -55,6 +98,19 @@ func TestInferString(t *testing.T) {
 				},
 			},
 		},
+		{
+			description: "object with array",
+			values: []string{
+				`{"name": "Joe", "age": 42, "hobbies": ["code", "animals"]}`,
+			},
+			expectedSchema: Schema{
+				Properties: map[string]Schema{
+					"name":    {Type: jtd.TypeString},
+					"age":     {Type: jtd.TypeUint8},
+					"hobbies": {Elements: &Schema{Type: jtd.TypeString}},
+				},
+			},
+		},
 		{
 			description: "array",
 			values:      []string{`[1, 2, 3]`},
@@ -144,24 +200,7 @@ func TestInferString(t *testing.T) {
 	}
 }
 
-func TestJTDInfer(t *testing.T) {
-	rows := []string{
-		`{"name": "Joe", "age": 42, "hobbies": ["code", "animals"]}`,
-	}
-
-	expectedSchema := Schema{
-		Properties: map[string]Schema{
-			"name":    {Type: jtd.TypeString},
-			"age":     {Type: jtd.TypeUint8},
-			"hobbies": {Elements: &Schema{Type: jtd.TypeString}},
-		},
-	}
-	gotSchema := InferStrings(rows, WithoutHints()).IntoSchema()
-
-	assert.EqualValues(t, expectedSchema, gotSchema)
-}
-
-func TestJTDInferrerWithEnumHints(t *testing.T) {
+func TestInferrerWithEnumHints(t *testing.T) {
 	hints := Hints{
 		Enums: NewHintSet().
 			Add([]string{"name"}).
@@ -209,7 +248,7 @@ func TestJTDInferrerWithEnumHints(t *testing.T) {
 	assert.EqualValues(t, expectedSchema, gotSchema)
 }
 
-func TestJTDInferWithValuesHints(t *testing.T) {
+func TestInferWithValuesHints(t *testing.T) {
 	hints := Hints{
 		Values: NewHintSet().Add([]string{}),
 	}
@@ -231,7 +270,7 @@ func TestJTDInferWithValuesHints(t *testing.T) {
 	assert.EqualValues(t, expectedSchema, gotSchema)
 }
 
-func TestJTDInferWithDiscriminatorHints(t *testing.T) {
+func TestInferWithDiscriminatorHints(t *testing.T) {
 	hints := Hints{
 		Discriminator: NewHintSet().Add([]string{"-", "type"}),
 	}
@@ -280,6 +319,14 @@ func BenchmarkInferThousandRowsNoMissingHints(b *testing.B) {
 	}
 }
 
+func BenchmarkInferSimpleString(b *testing.B) {
+	inferrer := NewInferrer(WithoutHints())
+
+	for n := 0; n < b.N; n++ {
+		inferrer.Infer("string")
+	}
+}
+
 func generateRows(n int) []string {
 	row := `{"name":"bench", "speed":100.2}`
 	rows := []string{}