extend stringy_numbers to enum, const, uniqueItems

Author: karenetheridge

lib/JSON/Schema/Tiny.pm

@@ -1119,6 +1119,13 @@ sub is_equal ($x, $y, $state = {}) {
     ($y, $types[1]) = (0+!!$$y, 'boolean') if $types[1] eq 'reference to SCALAR';
   }
 
+  if ($STRINGY_NUMBERS) {
+    ($x, $types[0]) = (0+$x, int(0+$x) == $x ? 'integer' : 'number')
+      if $types[0] eq 'string' and looks_like_number($x);
+    ($y, $types[1]) = (0+$y, int(0+$y) == $y ? 'integer' : 'number')
+      if $types[1] eq 'string' and looks_like_number($y);
+  }
+
   return 0 if $types[0] ne $types[1];
   return 1 if $types[0] eq 'null';
   return $x eq $y if $types[0] eq 'string';
@@ -1387,11 +1394,13 @@ Defaults to false.
 =head2 C<$STRINGY_NUMBERS>
 
 When true, any value that is expected to be a number or integer B<in the instance data> may also be
-expressed as a string. This does B<not> apply to the C<const> or C<enum> keywords, but only
-the following keywords:
+expressed as a string. This applies only to the following keywords:
 
 =for :list
 * C<type> (where both C<string> and C<number> (and possibly C<integer>) are considered types
+* C<const> and C<enum> (where the string C<"1"> will match with C<"const": 1>)
+* C<uniqueItems> (where strings and numbers are compared numerically to each other, if either or
+  both are numeric)
 * C<multipleOf>
 * C<maximum>
 * C<exclusiveMaximum>

t/equality.t

@@ -122,4 +122,33 @@ subtest 'equality, using scalarref booleans' => sub {
   }
 };
 
+subtest 'equality, using stringy numbers' => sub {
+  local $JSON::Schema::Tiny::STRINGY_NUMBERS = 1;
+
+  foreach my $test (
+    [ 1, 1, true ],
+    [ 1, 1.0, true ],
+    [ 1, '1.0', true ],
+    [ '1.1', 1.1, true ],
+    [ '1', 1, true ],
+    [ '1.1', 1.1, true ],
+    [ '1', '1.00', true ],
+    [ '1.10', '1.1000', true ],
+    [ 'x', 'x', true ],
+    [ 'x', 'y', false ],
+  ) {
+    my ($x, $y, $expected, $diff_path) = @$test;
+    my @types = map JSON::Schema::Tiny::get_type($_), $x, $y;
+    my $result = JSON::Schema::Tiny::is_equal($x, $y, my $state = {});
+
+    ok(!($result xor $expected), json_sprintf('%s == %s is %s', $x, $y, $expected));
+    is($state->{path}, $diff_path // '', 'two instances differ at the expected place') if not $expected;
+
+    ok(JSON::Schema::Tiny::is_type($types[0], $x), 'type of arg 0 was not mutated while making equality check');
+    ok(JSON::Schema::Tiny::is_type($types[1], $y), 'type of arg 1 was not mutated while making equality check');
+
+    note '';
+  }
+};
+
 done_testing;

t/stringy-numbers.t

@@ -184,6 +184,40 @@ foreach my $config (0, 1) {
   ) if $config == 1;
 
   is(JSON::Schema::Tiny::get_type($data), 'string', 'data was not mutated');
+
+
+  $schema = {
+    enum => [11, 12],
+    const => 11,
+  };
+
+  cmp_deeply(
+    evaluate($data, $schema),
+    {
+      valid => false,
+      errors => [
+        {
+          instanceLocation => '',
+          keywordLocation => '/enum',
+          error => 'value does not match',
+        },
+        {
+          instanceLocation => '',
+          keywordLocation => '/const',
+          error => 'value does not match',
+        },
+      ],
+    },
+    'by default, stringy numbers are not the same as numbers using comparison keywords',
+  ) if $config == 0;
+
+  cmp_deeply(
+    evaluate($data, $schema),
+    { valid => true },
+    'with the config enabled, stringy numbers are the same as numbers using comparison keywords',
+  ) if $config == 1;
+
+  is(JSON::Schema::Tiny::get_type($data), 'string', 'data was not mutated');
 }
 
 done_testing;