Support non-string schema and instance keys

This deep stringifies input hashes in order to support symbol (and other
non-string) keys. Symbol keys have been a common issue for people
forever (as evidenced by `InvalidSymbolKey`) and I've been hesitant to
address it because duplicating hashes and stringifying keys hurts
performance, but I think it's probably worth it.

The tricky thing here is that `insert_property_defaults`,
`before_property_validation`, and `after_property_validation` need
access to the actual hashes instead of the stringified version. To work
around that, the original instance is passed around in `Context` and can
be accessed by location using `original_instance`. Values passed in
hooks need to be re-stringified in case the user added non-string keys.

If this becomes a performance bottleneck, it may make sense to add a way
to turn it off for people that know they're using string keys.

Related:

- #91
- #123

Author: davishmcclurg

lib/json_schemer.rb

@@ -68,7 +68,6 @@ class InvalidRefResolution < StandardError; end
   class InvalidRefPointer < StandardError; end
   class InvalidRegexpResolution < StandardError; end
   class InvalidFileURI < StandardError; end
-  class InvalidSymbolKey < StandardError; end
   class InvalidEcmaRegexp < StandardError; end
 
   VOCABULARIES = {

lib/json_schemer/draft202012/vocab/applicator.rb

@@ -230,11 +230,13 @@ def validate(instance, instance_location, keyword_location, context)
             return result(instance, instance_location, keyword_location, true) unless instance.is_a?(Hash)
 
             if root.before_property_validation.any?
+              original_instance = context.original_instance(instance_location)
               root.before_property_validation.each do |hook|
                 parsed.each do |property, subschema|
-                  hook.call(instance, property, subschema.value, schema.value)
+                  hook.call(original_instance, property, subschema.value, schema.value)
                 end
               end
+              instance.replace(deep_stringify_keys(original_instance))
             end
 
             evaluated_keys = []
@@ -248,11 +250,13 @@ def validate(instance, instance_location, keyword_location, context)
             end
 
             if root.after_property_validation.any?
+              original_instance = context.original_instance(instance_location)
               root.after_property_validation.each do |hook|
                 parsed.each do |property, subschema|
-                  hook.call(instance, property, subschema.value, schema.value)
+                  hook.call(original_instance, property, subschema.value, schema.value)
                 end
               end
+              instance.replace(deep_stringify_keys(original_instance))
             end
 
             result(instance, instance_location, keyword_location, nested.all?(&:valid), nested, :annotation => evaluated_keys)

lib/json_schemer/output.rb

@@ -26,5 +26,30 @@ def join_location(location, keyword)
     def fragment_encode(location)
       Format.percent_encode(location, FRAGMENT_ENCODE_REGEX)
     end
+
+    # :nocov:
+    if Symbol.method_defined?(:name)
+      def stringify(key)
+        key.is_a?(Symbol) ? key.name : key.to_s
+      end
+    else
+      def stringify(key)
+        key.to_s
+      end
+    end
+    # :nocov:
+
+    def deep_stringify_keys(obj)
+      case obj
+      when Hash
+        obj.each_with_object({}) do |(key, value), out|
+          out[stringify(key)] = deep_stringify_keys(value)
+        end
+      when Array
+        obj.map { |item| deep_stringify_keys(item) }
+      else
+        obj
+      end
+    end
   end
 end

lib/json_schemer/result.rb

@@ -128,8 +128,8 @@ def classic
       end
     end
 
-    def insert_property_defaults
-      instances = {}
+    def insert_property_defaults(context)
+      instance_locations = {}
 
       results = [[self, true]]
       while (result, valid = results.pop)
@@ -145,18 +145,19 @@ def insert_property_defaults
             instance_location = Location.join(result.instance_location, property)
             keyword_location = Location.join(Location.join(result.keyword_location, property), default.keyword)
             default_result = default.validate(nil, instance_location, keyword_location, nil)
-            instances[result.instance] ||= {}
-            instances[result.instance][property] ||= []
-            instances[result.instance][property] << [default_result, valid]
+            instance_locations[result.instance_location] ||= {}
+            instance_locations[result.instance_location][property] ||= []
+            instance_locations[result.instance_location][property] << [default_result, valid]
           end
         end
       end
 
       inserted = false
 
-      instances.each do |instance, properties|
+      instance_locations.each do |instance_location, properties|
+        original_instance = context.original_instance(instance_location)
         properties.each do |property, results_with_tree_validity|
-          property_inserted = yield(instance, property, results_with_tree_validity)
+          property_inserted = yield(original_instance, property, results_with_tree_validity)
           inserted ||= (property_inserted != false)
         end
       end

lib/json_schemer/schema.rb

@@ -1,7 +1,13 @@
 # frozen_string_literal: true
 module JSONSchemer
   class Schema
-    Context = Struct.new(:dynamic_scope, :adjacent_results, :short_circuit)
+    Context = Struct.new(:instance, :dynamic_scope, :adjacent_results, :short_circuit) do
+      def original_instance(instance_location)
+        Hana::Pointer.parse(Location.resolve(instance_location)).reduce(instance) do |obj, token|
+          obj.fetch(obj.is_a?(Array) ? token.to_i : token)
+        end
+      end
+    end
 
     include Output
     include Format::JSONPointer
@@ -52,7 +58,7 @@ def initialize(
       regexp_resolver: 'ruby',
       output_format: 'classic'
     )
-      @value = value
+      @value = deep_stringify_keys(value)
       @parent = parent
       @root = root
       @keyword = keyword
@@ -79,10 +85,10 @@ def valid?(instance)
 
     def validate(instance, output_format: @output_format)
       instance_location = Location.root
-      context = Context.new([], nil, (!insert_property_defaults && output_format == 'flag'))
-      result = validate_instance(instance, instance_location, root_keyword_location, context)
-      if insert_property_defaults && result.insert_property_defaults(&property_default_resolver)
-        result = validate_instance(instance, instance_location, root_keyword_location, context)
+      context = Context.new(instance, [], nil, (!insert_property_defaults && output_format == 'flag'))
+      result = validate_instance(deep_stringify_keys(instance), instance_location, root_keyword_location, context)
+      if insert_property_defaults && result.insert_property_defaults(context, &property_default_resolver)
+        result = validate_instance(deep_stringify_keys(instance), instance_location, root_keyword_location, context)
       end
       result.output(output_format)
     end
@@ -271,7 +277,6 @@ def parse
           value.sort do |(keyword_a, _value_a), (keyword_b, _value_b)|
             keyword_order.fetch(keyword_a, last) <=> keyword_order.fetch(keyword_b, last)
           end.each do |keyword, value|
-            raise InvalidSymbolKey, 'schemas must use string keys' unless keyword.is_a?(String)
             @parsed[keyword] ||= keywords.fetch(keyword, UNKNOWN_KEYWORD_CLASS).new(value, self, keyword)
           end
         end

test/json_schema_test_suite_test.rb

@@ -56,6 +56,8 @@ def test_json_schema_test_suite
         file_output[file] = JSON.parse(File.read(file)).map do |defn|
           tests, schema = defn.values_at('tests', 'schema')
 
+          schema = JSON.parse(JSON.generate(schema), :symbolize_names => true) if rand < 0.5
+
           schemer = JSONSchemer::Schema.new(
             schema,
             :meta_schema => meta_schema,
@@ -70,6 +72,8 @@ def test_json_schema_test_suite
           tests.map do |test|
             data, valid = test.values_at('data', 'valid')
 
+            data = JSON.parse(JSON.generate(data), :symbolize_names => true) if rand < 0.5
+
             assert_equal(
               valid,
               schemer.valid?(data),

test/json_schemer_test.rb

@@ -86,17 +86,6 @@ def test_it_handles_json_strings
     refute(schema.valid?('1'))
   end
 
-  def test_it_checks_for_symbol_keys
-    assert_raises(JSONSchemer::InvalidSymbolKey) { JSONSchemer.schema({ :type => 'integer' }) }
-    schema = JSONSchemer.schema(
-      { '$ref' => 'http://example.com' },
-      :ref_resolver => proc do |uri|
-        { :type => 'integer' }
-      end
-    )
-    assert_raises(JSONSchemer::InvalidSymbolKey) { schema.valid?(1) }
-  end
-
   def test_it_returns_nested_errors
     root = {
       'type' => 'object',
@@ -345,4 +334,44 @@ def test_it_allows_validating_schemas
     assert_empty(JSONSchemer.validate_schema(valid_detected_draft4_schema).to_a)
     assert_equal([required_error], JSONSchemer.validate_schema(invalid_detected_draft4_schema).to_a)
   end
+
+  def test_non_string_keys
+    schemer = JSONSchemer.schema({
+      properties: {
+        'title' => {
+          type: 'string'
+        },
+        :description => {
+          'type' => 'string'
+        }
+      }
+    })
+    assert(schemer.valid?({ title: 'some title' }))
+    assert(schemer.valid?({ 'title' => 'some title' }))
+    refute(schemer.valid?({ title: :sometitle }))
+    refute(schemer.valid?({ 'title' => :sometitle }))
+    assert(schemer.valid?({ description: 'some description' }))
+    assert(schemer.valid?({ 'description' => 'some description' }))
+    refute(schemer.valid?({ description: :somedescription }))
+    refute(schemer.valid?({ 'description' => :somedescription }))
+
+    schemer = JSONSchemer.schema({
+      'properties' => {
+        '1' => {
+          'const' => 'one'
+        },
+        2 => {
+          :const => 'two'
+        }
+      }
+    })
+    assert(schemer.valid?({ 1 => 'one' }))
+    assert(schemer.valid?({ '1' => 'one' }))
+    refute(schemer.valid?({ 1 => 'neo' }))
+    refute(schemer.valid?({ '1' => 'neo' }))
+    assert(schemer.valid?({ 2 => 'two' }))
+    assert(schemer.valid?({ '2' => 'two' }))
+    refute(schemer.valid?({ 2 => 'tow' }))
+    refute(schemer.valid?({ '2' => 'tow' }))
+  end
 end