Pass hints, add infer support form strings

Author: bombsimon

hints.go

@@ -9,15 +9,6 @@ type Hints struct {
 	Discriminator  HintSet
 }
 
-func New(defaultNumType NumType, enums, values, discriminator HintSet) Hints {
-	return Hints{
-		DefaultNumType: defaultNumType,
-		Enums:          enums,
-		Values:         values,
-		Discriminator:  discriminator,
-	}
-}
-
 func (h Hints) SubHints(key string) Hints {
 	return Hints{
 		DefaultNumType: h.DefaultNumType,
@@ -43,12 +34,17 @@ type HintSet struct {
 	Values [][]string
 }
 
-func NewHintSet(values [][]string) HintSet {
+func NewHintSet() HintSet {
 	return HintSet{
-		Values: values,
+		Values: [][]string{},
 	}
 }
 
+func (h HintSet) Add(v []string) HintSet {
+	h.Values = append(h.Values, v)
+	return h
+}
+
 func (h HintSet) SubHints(key string) HintSet {
 	filteredValues := [][]string{}
 

inferred_schema.go

@@ -276,7 +276,7 @@ func (i *InferredSchema) Infer(value any, hints Hints) *InferredSchema {
 	if m, ok := value.(map[string]any); ok && i.SchemaType == SchemaTypeValues {
 		subInfer := i.Values
 		for k, v := range m {
-			subInfer = NewInferredSchema().Infer(v, hints.SubHints(k))
+			subInfer = subInfer.Infer(v, hints.SubHints(k))
 		}
 
 		return &InferredSchema{
@@ -314,7 +314,7 @@ func (i *InferredSchema) Infer(value any, hints Hints) *InferredSchema {
 }
 
 // IntoSchema will convert an `InferredSchema` to a final `Schema`.
-func (i *InferredSchema) IntoSchema() Schema {
+func (i *InferredSchema) IntoSchema(hints Hints) Schema {
 	switch i.SchemaType {
 	case SchemaTypeUnknown, SchemaTypeAny:
 		return Schema{}
@@ -323,7 +323,7 @@ func (i *InferredSchema) IntoSchema() Schema {
 		return Schema{Type: jtd.TypeBoolean}
 	case SchemaTypeNumber:
 		return Schema{
-			Type: i.Number.IntoType(NumTypeUint8),
+			Type: i.Number.IntoType(hints.DefaultNumType),
 		}
 	case SchemaTypeString:
 		return Schema{Type: jtd.TypeString}
@@ -337,7 +337,7 @@ func (i *InferredSchema) IntoSchema() Schema {
 
 		return Schema{Enum: enum}
 	case SchemaTypeArray:
-		elements := i.Array.IntoSchema()
+		elements := i.Array.IntoSchema(hints)
 		return Schema{Elements: &elements}
 	case SchemaTypeProperties:
 		var (
@@ -349,15 +349,15 @@ func (i *InferredSchema) IntoSchema() Schema {
 			required = make(map[string]Schema, len(i.Properties.Required))
 
 			for k, v := range i.Properties.Required {
-				required[k] = v.IntoSchema()
+				required[k] = v.IntoSchema(hints)
 			}
 		}
 
 		if i.Properties.Optional != nil {
 			optional = make(map[string]Schema, len(i.Properties.Optional))
 
 			for k, v := range i.Properties.Optional {
-				optional[k] = v.IntoSchema()
+				optional[k] = v.IntoSchema(hints)
 			}
 		}
 
@@ -366,20 +366,20 @@ func (i *InferredSchema) IntoSchema() Schema {
 			OptionalProperties: optional,
 		}
 	case SchemaTypeValues:
-		values := i.Values.IntoSchema()
+		values := i.Values.IntoSchema(hints)
 		return Schema{Values: &values}
 	case SchemaTypeDiscriminator:
 		mappings := map[string]Schema{}
 		for k, v := range i.Discriminator.Mapping {
-			mappings[k] = v.IntoSchema()
+			mappings[k] = v.IntoSchema(hints)
 		}
 
 		return Schema{
 			Discriminator: i.Discriminator.Discriminator,
 			Mapping:       mappings,
 		}
 	case SchemaTypeNullable:
-		schema := i.Nullable.IntoSchema()
+		schema := i.Nullable.IntoSchema(hints)
 		schema.Nullable = true
 
 		return schema

inferrer.go

@@ -1,5 +1,9 @@
 package jtdinfer
 
+import (
+	"encoding/json"
+)
+
 // Inferrer represents the `InferredSchema` with its state combined with the
 // hints used when inferring.
 type Inferrer struct {
@@ -24,6 +28,31 @@ func (i *Inferrer) Infer(value any) *Inferrer {
 }
 
 // IntoSchema will convert the `InferredSchema` into a final `Schema`.
-func (i *Inferrer) IntoSchema() Schema {
-	return i.Inference.IntoSchema()
+func (i *Inferrer) IntoSchema(hints Hints) Schema {
+	return i.Inference.IntoSchema(hints)
+}
+
+// InferStrings accepts a slice of strings and will convert them to either a
+// `map[string]any` or []any` and run inference on all the rows. If any of the
+// rows are not valid JSON object or list, the inference up to that point is
+// returned.
+//
+// If you need to infer simple values like strings or integers they can be
+// passed directly to `Infer`.
+func InferStrings(rows []string, hints Hints) *Inferrer {
+	inferrer := NewInferrer(hints)
+
+	for _, row := range rows {
+		var toInfer any = make(map[string]any, 0)
+		if err := json.Unmarshal([]byte(row), &toInfer); err != nil {
+			toInfer = make([]any, 0)
+			if err := json.Unmarshal([]byte(row), &toInfer); err != nil {
+				return inferrer
+			}
+		}
+
+		inferrer = inferrer.Infer(toInfer)
+	}
+
+	return inferrer
 }

inferrer_test.go

@@ -1,62 +1,41 @@
 package jtdinfer
 
 import (
-	"encoding/json"
 	"testing"
 
 	jtd "github.com/jsontypedef/json-typedef-go"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestJTDInfer(t *testing.T) {
 	rows := []string{
 		`{"name": "Joe", "age": 42, "hobbies": ["code", "animals"]}`,
 	}
 
-	inferrer := NewInferrer(Hints{})
-
-	for _, row := range rows {
-		rowAsJSON := make(map[string]any, 0)
-		require.NoError(t, json.Unmarshal([]byte(row), &rowAsJSON))
-		inferrer = inferrer.Infer(rowAsJSON)
-	}
-
 	expectedSchema := Schema{
 		Properties: map[string]Schema{
 			"name":    {Type: jtd.TypeString},
 			"age":     {Type: jtd.TypeUint8},
 			"hobbies": {Elements: &Schema{Type: jtd.TypeString}},
 		},
 	}
-	gotSchema := inferrer.IntoSchema()
+	gotSchema := InferStrings(rows, Hints{}).IntoSchema(Hints{})
 
 	assert.EqualValues(t, expectedSchema, gotSchema)
 }
 
-func TestJTDInferrerWithHints(t *testing.T) {
+func TestJTDInferrerWithEnumHints(t *testing.T) {
 	hints := Hints{
-		Enums: HintSet{
-			Values: [][]string{
-				{"name"},
-				{"address", "city"},
-			},
-		},
+		Enums: NewHintSet().
+			Add([]string{"name"}).
+			Add([]string{"address", "city"}),
 	}
 
 	rows := []string{
 		`{"address": {"city": "Stockholm"}, "name": "Joe", "age": 42}`,
 		`{"address": {"city": "Umeå"}, "name": "Labero", "age": 42}`,
 	}
 
-	inferrer := NewInferrer(hints)
-
-	for _, row := range rows {
-		rowAsJSON := make(map[string]any, 0)
-		require.NoError(t, json.Unmarshal([]byte(row), &rowAsJSON))
-		inferrer = inferrer.Infer(rowAsJSON)
-	}
-
 	expectedSchema := Schema{
 		Properties: map[string]Schema{
 			"name": {Enum: []string{"Joe", "Labero"}},
@@ -68,30 +47,40 @@ func TestJTDInferrerWithHints(t *testing.T) {
 			},
 		},
 	}
-	gotSchema := inferrer.IntoSchema()
+	gotSchema := InferStrings(rows, hints).IntoSchema(hints)
 
 	assert.EqualValues(t, expectedSchema, gotSchema)
 }
 
-func TestJTDInferWithDiscriminatorHints(t *testing.T) {
+func TestJTDInferWithValuesHints(t *testing.T) {
 	hints := Hints{
-		Discriminator: HintSet{
-			Values: [][]string{
-				{"-", "type"},
-			},
-		},
+		Values: NewHintSet().Add([]string{}),
 	}
 
 	rows := []string{
-		`[{"type": "s", "value": "foo"},{"type": "n", "value": 3.14}]`,
+		`{"x": [1, 2, 3], "y": [4, 5, 6], "z": [7, 8, 9]}`,
+		`{"x": [1, 2, 3], "y": [4, 5, -600], "z": [7, 8, 9]}`,
 	}
 
-	inferrer := NewInferrer(hints)
+	expectedSchema := Schema{
+		Values: &Schema{
+			Elements: &Schema{
+				Type: jtd.TypeInt16,
+			},
+		},
+	}
+	gotSchema := InferStrings(rows, hints).IntoSchema(hints)
+
+	assert.EqualValues(t, expectedSchema, gotSchema)
+}
 
-	for _, row := range rows {
-		rowAsJSON := make([]any, 0)
-		require.NoError(t, json.Unmarshal([]byte(row), &rowAsJSON))
-		inferrer = inferrer.Infer(rowAsJSON)
+func TestJTDInferWithDiscriminatorHints(t *testing.T) {
+	hints := Hints{
+		Discriminator: NewHintSet().Add([]string{"-", "type"}),
+	}
+
+	rows := []string{
+		`[{"type": "s", "value": "foo"},{"type": "n", "value": 3.14}]`,
 	}
 
 	expectedSchema := Schema{
@@ -111,7 +100,7 @@ func TestJTDInferWithDiscriminatorHints(t *testing.T) {
 			},
 		},
 	}
-	gotSchema := inferrer.IntoSchema()
+	gotSchema := InferStrings(rows, hints).IntoSchema(hints)
 
 	assert.EqualValues(t, expectedSchema, gotSchema)
 }