Address pb33f/openapi-changes#207

Author: daveshanley

datamodel/low/extraction_functions.go

@@ -13,6 +13,7 @@ import (
 	"github.com/pb33f/libopenapi/utils"
 	"go.yaml.in/yaml/v4"
 	"hash/maphash"
+	"math/big"
 	"net/url"
 	"os"
 	"path/filepath"
@@ -1265,10 +1266,12 @@ func hashNodeTree(h *maphash.Hash, n *yaml.Node, visited map[*yaml.Node]bool) {
 	}
 	visited[n] = true
 
-	// Hash node metadata
+	// Hash node metadata. Numeric scalars are normalized so semantically equivalent
+	// values like `1e-08` and `1e-8` compare equal.
+	tag, value := comparableScalarTagAndValue(n)
 	h.Write([]byte{byte(n.Kind)})
-	h.Write([]byte(n.Tag))
-	h.Write([]byte(n.Value))
+	h.Write([]byte(tag))
+	h.Write([]byte(value))
 	if n.Anchor != "" {
 		h.Write([]byte(n.Anchor))
 	}
@@ -1354,6 +1357,23 @@ func hashNodeTree(h *maphash.Hash, n *yaml.Node, visited map[*yaml.Node]bool) {
 	}
 }
 
+func comparableScalarTagAndValue(n *yaml.Node) (string, string) {
+	if n == nil {
+		return "", ""
+	}
+	if n.Kind != yaml.ScalarNode {
+		return n.Tag, n.Value
+	}
+	if n.Tag != "!!int" && n.Tag != "!!float" {
+		return n.Tag, n.Value
+	}
+	rat, ok := new(big.Rat).SetString(n.Value)
+	if !ok {
+		return n.Tag, n.Value
+	}
+	return "!!number", rat.RatString()
+}
+
 // CompareYAMLNodes compares two YAML nodes for equality without marshaling to YAML.
 // This reuses the hashNodeTree logic to generate consistent hashes for comparison,
 // avoiding the expensive yaml.Marshal operations that cause massive allocations.

datamodel/low/extraction_functions_test.go

@@ -2861,6 +2861,118 @@ func TestCompareYAMLNodes_ComplexNodes(t *testing.T) {
 	assert.False(t, result2)
 }
 
+func TestComparableScalarTagAndValue(t *testing.T) {
+	t.Run("nil node", func(t *testing.T) {
+		tag, value := comparableScalarTagAndValue(nil)
+		assert.Empty(t, tag)
+		assert.Empty(t, value)
+	})
+
+	t.Run("non scalar node", func(t *testing.T) {
+		node := utils.CreateEmptyMapNode()
+		tag, value := comparableScalarTagAndValue(node)
+		assert.Equal(t, node.Tag, tag)
+		assert.Equal(t, node.Value, value)
+	})
+
+	t.Run("non numeric scalar", func(t *testing.T) {
+		node := utils.CreateStringNode("pizza")
+		tag, value := comparableScalarTagAndValue(node)
+		assert.Equal(t, "!!str", tag)
+		assert.Equal(t, "pizza", value)
+	})
+
+	t.Run("numeric scalar normalizes", func(t *testing.T) {
+		node := &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!float", Value: "1e-08"}
+		tag, value := comparableScalarTagAndValue(node)
+		assert.Equal(t, "!!number", tag)
+		assert.Equal(t, "1/100000000", value)
+	})
+
+	t.Run("numeric scalar fallback", func(t *testing.T) {
+		node := &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!float", Value: ".inf"}
+		tag, value := comparableScalarTagAndValue(node)
+		assert.Equal(t, "!!float", tag)
+		assert.Equal(t, ".inf", value)
+	})
+}
+
+func TestCompareYAMLNodes_NumericScalarEquivalence(t *testing.T) {
+	tests := []struct {
+		name  string
+		left  *yaml.Node
+		right *yaml.Node
+		equal bool
+	}{
+		{
+			name:  "equivalent exponent formatting",
+			left:  &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!float", Value: "1e-08"},
+			right: &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!float", Value: "1e-8"},
+			equal: true,
+		},
+		{
+			name:  "equivalent int and float formatting",
+			left:  &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!int", Value: "1"},
+			right: &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!float", Value: "1.0"},
+			equal: true,
+		},
+		{
+			name:  "different numeric values",
+			left:  &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!float", Value: "1e-08"},
+			right: &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!float", Value: "2e-08"},
+			equal: false,
+		},
+		{
+			name:  "string and numeric stay different",
+			left:  &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!str", Value: "1.0"},
+			right: &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!float", Value: "1.0"},
+			equal: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.equal, CompareYAMLNodes(tt.left, tt.right))
+		})
+	}
+}
+
+func TestCompareYAMLNodes_ComplexNodesNumericEquivalence(t *testing.T) {
+	left := &yaml.Node{
+		Kind: yaml.MappingNode,
+		Content: []*yaml.Node{
+			{Kind: yaml.ScalarNode, Tag: "!!str", Value: "default"},
+			{Kind: yaml.ScalarNode, Tag: "!!float", Value: "0.10"},
+			{Kind: yaml.ScalarNode, Tag: "!!str", Value: "items"},
+			{
+				Kind: yaml.SequenceNode,
+				Content: []*yaml.Node{
+					{Kind: yaml.ScalarNode, Tag: "!!int", Value: "1"},
+					{Kind: yaml.ScalarNode, Tag: "!!float", Value: "1e-08"},
+				},
+			},
+		},
+	}
+
+	right := &yaml.Node{
+		Kind: yaml.MappingNode,
+		Content: []*yaml.Node{
+			{Kind: yaml.ScalarNode, Tag: "!!str", Value: "items"},
+			{
+				Kind: yaml.SequenceNode,
+				Content: []*yaml.Node{
+					{Kind: yaml.ScalarNode, Tag: "!!float", Value: "1.0"},
+					{Kind: yaml.ScalarNode, Tag: "!!float", Value: "1e-8"},
+				},
+			},
+			{Kind: yaml.ScalarNode, Tag: "!!str", Value: "default"},
+			{Kind: yaml.ScalarNode, Tag: "!!float", Value: "0.1"},
+		},
+	}
+
+	assert.True(t, CompareYAMLNodes(left, right))
+}
+
 func TestGenerateHashString_SchemaProxyNoCache(t *testing.T) {
 	// Test that SchemaProxy types don't get cached (shouldCache = false)
 	// We can't easily test this without creating actual SchemaProxy objects

datamodel/low/v3/paths_test.go

@@ -523,6 +523,8 @@ func TestPaths_Build_BrokenOp(t *testing.T) {
 }
 
 func TestPaths_Hash(t *testing.T) {
+	low.ClearHashCache()
+
 	yml := `/french/toast:
   description: toast
 /french/hen:

document_examples_test.go

@@ -315,7 +315,7 @@ func TestExampleCompareDocuments_openAPI(t *testing.T) {
 	schemaChanges := documentChanges.ComponentsChanges.SchemaChanges
 
 	// Print out some interesting stats about the OpenAPI document changes.
-	assert.Equal(t, `There are 77 changes, of which 19 are breaking. 6 schemas have changes.`, fmt.Sprintf("There are %d changes, of which %d are breaking. %v schemas have changes.",
+	assert.Equal(t, `There are 77 changes, of which 20 are breaking. 6 schemas have changes.`, fmt.Sprintf("There are %d changes, of which %d are breaking. %v schemas have changes.",
 		documentChanges.TotalChanges(), documentChanges.TotalBreakingChanges(), len(schemaChanges)))
 }
 

what-changed/model/comparison_functions.go

@@ -386,8 +386,10 @@ func checkForModificationInternal[T any](l, r *yaml.Node, label string, changes
 	if withEncoding {
 		createFn = CreateChangeWithEncoding
 	}
-	if l != nil && l.Value != EMPTY_STR && r != nil && r.Value != EMPTY_STR && (r.Value != l.Value || r.Tag != l.Tag) {
-		createFn(changes, Modified, label, l, r, breaking, orig, new)
+	if l != nil && l.Value != EMPTY_STR && r != nil && r.Value != EMPTY_STR {
+		if !low.CompareYAMLNodes(l, r) {
+			createFn(changes, Modified, label, l, r, breaking, orig, new)
+		}
 		return
 	}
 	if l != nil && utils.IsNodeArray(l) && r != nil && !utils.IsNodeArray(r) {

what-changed/model/comparison_functions_test.go

@@ -24,6 +24,9 @@ func Test_CheckForModification(t *testing.T) {
 		{"Same string quoted", `value`, `"value"`, false},
 		{"Same string", `value`, `value`, false},
 		{"Same boolean", `true`, `true`, false},
+		{"Equivalent exponent formatting", `1e-08`, `1e-8`, false},
+		{"Equivalent integer and float formatting", `1`, `1.0`, false},
+		{"Equivalent decimal formatting", `0.10`, `0.1`, false},
 		{"Different boolean", `true`, `false`, true},
 		{"Different string", `value_a`, `value_b`, true},
 		{"Different int", `123`, `"123"`, true},
@@ -576,6 +579,17 @@ func TestCheckForModificationWithEncoding(t *testing.T) {
 	}
 }
 
+func TestCheckForModificationWithEncoding_NumericScalarEquivalence(t *testing.T) {
+	var lNode, rNode yaml.Node
+	_ = yaml.Unmarshal([]byte(`1e-08`), &lNode)
+	_ = yaml.Unmarshal([]byte(`1e-8`), &rNode)
+
+	changes := []*Change{}
+	CheckForModificationWithEncoding(lNode.Content[0], rNode.Content[0], "numeric", &changes, false, "old", "new")
+
+	assert.Empty(t, changes)
+}
+
 // TestCheckMapForChangesWithComp tests the deprecated CheckMapForChangesWithComp function
 func TestCheckMapForChangesWithComp(t *testing.T) {
 	t.Run("detects removal", func(t *testing.T) {

what-changed/model/schema_test.go

@@ -3911,6 +3911,44 @@ components:
 	changes.PropertiesOnly() // this does nothing in this lib.
 }
 
+// https://github.com/pb33f/openapi-changes/issues/207
+func TestCompareSchemas_DefaultNumericFormattingIsSemanticallyEqual(t *testing.T) {
+	low.ClearHashCache()
+	left := `openapi: 3.0.0
+components:
+  schemas:
+    Config:
+      type: object
+      properties:
+        angle_threshold:
+          type: number
+          exclusiveMinimum: 0.0
+          title: Angle Threshold
+          default: 1e-08
+`
+
+	right := `openapi: 3.0.0
+components:
+  schemas:
+    Config:
+      type: object
+      properties:
+        angle_threshold:
+          type: number
+          exclusiveMinimum: 0.0
+          title: Angle Threshold
+          default: 1e-8
+`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("Config").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("Config").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.Nil(t, changes)
+}
+
 func TestCompareSchemas_ExclusiveMaximumNodeSwap(t *testing.T) {
 	// Clear hash cache to ensure deterministic results in concurrent test environments
 	low.ClearHashCache()