Merge remote-tracking branches 'origin/doc' and 'origin/misc' into HEAD

doc #179
misc #182

Rakefile.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|

lib/jsi/schema/ref.rb

@@ -112,9 +112,9 @@ def deref_schema
         if result_schemas.size == 1
           result_schema = result_schemas.first
         elsif result_schemas.size == 0
-          raise(Schema::ReferenceError, "could not find schema by fragment: #{fragment} in schema resource root: #{schema_resource_root.pretty_inspect.chomp}")
+          raise(Schema::ReferenceError, "could not find schema by fragment: #{fragment.inspect} in schema resource root: #{schema_resource_root.pretty_inspect.chomp}")
         else
-          raise(Schema::ReferenceError, "found multiple schemas for plain name fragment #{fragment}:#{result_schemas.map { |s| "\n" + s.pretty_inspect.chomp }.join('')}")
+          raise(Schema::ReferenceError, "found multiple schemas for plain name fragment #{fragment.inspect}:#{result_schemas.map { |s| "\n" + s.pretty_inspect.chomp }.join('')}")
         end
       end
 

lib/jsi/schema/schema_ancestor_node.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSI
   # a node in a document which may contain a schema somewhere within is extended with SchemaAncestorNode, for
   # tracking things necessary for a schema to function correctly
@@ -76,6 +78,7 @@ def jsi_schema_resource_ancestors=(jsi_schema_resource_ancestors)
           elsif !anc.jsi_ptr.contains?(jsi_ptr)
             raise(Bug, "ancestor does not contain self")
           end
+          last_anc_ptr = anc.jsi_ptr
         end
 
         @jsi_schema_resource_ancestors = jsi_schema_resource_ancestors.to_ary.freeze

lib/jsi/schema_classes.rb

@@ -143,7 +143,7 @@ def accessor_module_for_schema(schema, conflicting_modules: , setters: true)
                 # must not contain characters special to ruby syntax
                 do_define &&= name !~ /[\\\s\#;\.,\(\)\[\]\{\}'"`%\+\-\/\*\^\|&=<>\?:!@\$~]/
                 # must not conflict with any method on a conflicting module
-                do_define &&= !conflicting_instance_methods.any? { |m| m.to_s == name }
+                do_define &&= !conflicting_instance_methods.any? { |mn| mn.to_s == name }
 
                 do_define
               end

lib/jsi/simple_wrap.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module JSI
-  SimpleWrap = JSI.new_schema({
+  SimpleWrap = JSI::JSONSchemaOrgDraft06.new_schema({
     "additionalProperties": {"$ref": "#"},
     "items": {"$ref": "#"}
   }).jsi_schema_module

test/base_array_test.rb

@@ -9,8 +9,10 @@
     {'type' => 'array', 'items' => {}},
   ],
 }
-NamedArrayInstance = JSI.new_schema(base).jsi_schema_class
-NamedIdArrayInstance = JSI.new_schema({'$id' => 'https://schemas.jsi.unth.net/test/base/named_array_schema'}.merge(base)).jsi_schema_class
+NAMED_ARY_SCHEMA = JSI.new_schema(base)
+NamedArrayInstance = NAMED_ARY_SCHEMA.jsi_schema_class
+NAMED_ID_ARY_SCHEMA = JSI.new_schema({'$id' => 'https://schemas.jsi.unth.net/test/base/named_array_schema'}.merge(base))
+NamedIdArrayInstance = NAMED_ID_ARY_SCHEMA.jsi_schema_class
 
 describe 'JSI::Base array' do
   let(:instance) { ['foo', {'lamp' => [3]}, ['q', 'r'], {'four' => 4}] }
@@ -137,49 +139,49 @@
       end
     end
     describe '#inspect named' do
-      let(:subject) { NamedArrayInstance.new(instance) }
+      let(:subject) { NAMED_ARY_SCHEMA.new_jsi(instance) }
       it 'inspects' do
         assert_equal("#[<NamedArrayInstance> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
       end
     end
     describe '#pretty_print named' do
-      let(:subject) { NamedArrayInstance.new(instance) }
+      let(:subject) { NAMED_ARY_SCHEMA.new_jsi(instance) }
       it 'inspects' do
         assert_equal("#[<NamedArrayInstance>\n  \"foo\",\n  \#{<JSI> \"lamp\" => [3]},\n  #[<JSI> \"q\", \"r\"],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
       end
     end
     describe '#inspect named SortOfArray' do
-      let(:subject) { NamedArrayInstance.new(SortOfArray.new(instance)) }
+      let(:subject) { NAMED_ARY_SCHEMA.new_jsi(SortOfArray.new(instance)) }
       it 'inspects' do
         assert_equal("#[<NamedArrayInstance SortOfArray> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
       end
     end
     describe '#pretty_print named SortOfArray' do
-      let(:subject) { NamedArrayInstance.new(SortOfArray.new(instance)) }
+      let(:subject) { NAMED_ARY_SCHEMA.new_jsi(SortOfArray.new(instance)) }
       it 'inspects' do
         assert_equal("#[<NamedArrayInstance SortOfArray>\n  \"foo\",\n  \#{<JSI> \"lamp\" => [3]},\n  #[<JSI> \"q\", \"r\"],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
       end
     end
     describe '#inspect named with id' do
-      let(:subject) { NamedIdArrayInstance.new(instance) }
+      let(:subject) { NAMED_ID_ARY_SCHEMA.new_jsi(instance) }
       it 'inspects' do
         assert_equal("#[<NamedIdArrayInstance> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
       end
     end
     describe '#pretty_print named with id' do
-      let(:subject) { NamedIdArrayInstance.new(instance) }
+      let(:subject) { NAMED_ID_ARY_SCHEMA.new_jsi(instance) }
       it 'inspects' do
         assert_equal("#[<NamedIdArrayInstance>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)>\n    \"lamp\" => [3]\n  },\n  #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)>\n    \"q\",\n    \"r\"\n  ],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
       end
     end
     describe '#inspect named with id SortOfArray' do
-      let(:subject) { NamedIdArrayInstance.new(SortOfArray.new(instance)) }
+      let(:subject) { NAMED_ID_ARY_SCHEMA.new_jsi(SortOfArray.new(instance)) }
       it 'inspects' do
         assert_equal("#[<NamedIdArrayInstance SortOfArray> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
       end
     end
     describe '#pretty_print named with id SortOfArray' do
-      let(:subject) { NamedIdArrayInstance.new(SortOfArray.new(instance)) }
+      let(:subject) { NAMED_ID_ARY_SCHEMA.new_jsi(SortOfArray.new(instance)) }
       it 'inspects' do
         assert_equal("#[<NamedIdArrayInstance SortOfArray>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)>\n    \"lamp\" => [3]\n  },\n  #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)>\n    \"q\",\n    \"r\"\n  ],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
       end

test/base_hash_test.rb

@@ -8,8 +8,10 @@
     'bar' => {},
   },
 }
-NamedHashInstance = JSI.new_schema(base).jsi_schema_class
-NamedIdHashInstance = JSI.new_schema({'$id' => 'https://schemas.jsi.unth.net/test/base/named_hash_schema'}.merge(base)).jsi_schema_class
+NAMED_HASH_SCHEMA = JSI.new_schema(base)
+NamedHashInstance = NAMED_HASH_SCHEMA.jsi_schema_class
+NAMED_ID_HASH_SCHEMA = JSI.new_schema({'$id' => 'https://schemas.jsi.unth.net/test/base/named_hash_schema'}.merge(base))
+NamedIdHashInstance = NAMED_ID_HASH_SCHEMA.jsi_schema_class
 
 describe 'JSI::Base hash' do
   let(:instance) { {'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => [true]} }
@@ -181,49 +183,49 @@
       end
     end
     describe '#inspect named' do
-      let(:subject) { NamedHashInstance.new(instance) }
+      let(:subject) { NAMED_HASH_SCHEMA.new_jsi(instance) }
       it 'inspects' do
         assert_equal("\#{<NamedHashInstance> \"foo\" => \#{<JSI> \"x\" => \"y\"}, \"bar\" => #[<JSI> 9], \"baz\" => [true]}", subject.inspect)
       end
     end
     describe '#pretty_print named' do
-      let(:subject) { NamedHashInstance.new(instance) }
+      let(:subject) { NAMED_HASH_SCHEMA.new_jsi(instance) }
       it 'inspects' do
         assert_equal("\#{<NamedHashInstance>\n  \"foo\" => \#{<JSI> \"x\" => \"y\"},\n  \"bar\" => #[<JSI> 9],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
       end
     end
     describe '#inspect named SortOfHash' do
-      let(:subject) { NamedHashInstance.new(SortOfHash.new(instance)) }
+      let(:subject) { NAMED_HASH_SCHEMA.new_jsi(SortOfHash.new(instance)) }
       it 'inspects' do
         assert_equal("\#{<NamedHashInstance SortOfHash> \"foo\" => \#{<JSI> \"x\" => \"y\"}, \"bar\" => #[<JSI> 9], \"baz\" => [true]}", subject.inspect)
       end
     end
     describe '#pretty_print named SortOfHash' do
-      let(:subject) { NamedHashInstance.new(SortOfHash.new(instance)) }
+      let(:subject) { NAMED_HASH_SCHEMA.new_jsi(SortOfHash.new(instance)) }
       it 'inspects' do
         assert_equal("\#{<NamedHashInstance SortOfHash>\n  \"foo\" => \#{<JSI> \"x\" => \"y\"},\n  \"bar\" => #[<JSI> 9],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
       end
     end
     describe '#inspect named with id' do
-      let(:subject) { NamedIdHashInstance.new(instance) }
+      let(:subject) { NAMED_ID_HASH_SCHEMA.new_jsi(instance) }
       it 'inspects' do
         assert_equal("\#{<NamedIdHashInstance> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
       end
     end
     describe '#pretty_print named with id' do
-      let(:subject) { NamedIdHashInstance.new(instance) }
+      let(:subject) { NAMED_ID_HASH_SCHEMA.new_jsi(instance) }
       it 'inspects' do
         assert_equal("\#{<NamedIdHashInstance>\n  \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/foo)>\n    \"x\" => \"y\"\n  },\n  \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/bar)>\n    9\n  ],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
       end
     end
     describe '#inspect named SortOfHash with id' do
-      let(:subject) { NamedIdHashInstance.new(SortOfHash.new(instance)) }
+      let(:subject) { NAMED_ID_HASH_SCHEMA.new_jsi(SortOfHash.new(instance)) }
       it 'inspects' do
         assert_equal("\#{<NamedIdHashInstance SortOfHash> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
       end
     end
     describe '#pretty_print named with id SortOfHash' do
-      let(:subject) { NamedIdHashInstance.new(SortOfHash.new(instance)) }
+      let(:subject) { NAMED_ID_HASH_SCHEMA.new_jsi(SortOfHash.new(instance)) }
       it 'inspects' do
         assert_equal("\#{<NamedIdHashInstance SortOfHash>\n  \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/foo)>\n    \"x\" => \"y\"\n  },\n  \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/bar)>\n    9\n  ],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
       end

test/base_test.rb

@@ -631,9 +631,11 @@
       end
       describe 'properties with names to ignore' do
         class X
+          # :nocov:
           def to_s
             'x'
           end
+          # :nocov:
         end
         let(:schema_content) do
           {

test/json_schema_suite_test.rb

@@ -7,7 +7,8 @@
     path = JSI::TEST_RESOURCES_PATH.join('JSON-Schema-Test-Suite/remotes').join(*subpath)
 
     if path.directory?
-      path.children(with_directory = false).each { |c| rec.call(subpath + [c.to_s]) }
+      with_directory = false
+      path.children(with_directory).each { |c| rec.call(subpath + [c.to_s]) }
     elsif path.file? && path.to_s =~ /\.json\z/
       remote_content = ::JSON.parse(path.read)
       uri = File.join('http://localhost:1234/', *subpath)
@@ -33,7 +34,8 @@
         proc do |subpath|
           path = JSI::TEST_RESOURCES_PATH.join('JSON-Schema-Test-Suite/tests').join(*subpath)
           if path.directory?
-            path.children(with_directory = false).each { |c| rec.call(subpath + [c.to_s]) }
+            with_directory = false
+            path.children(with_directory).each { |c| rec.call(subpath + [c.to_s]) }
           elsif path.file? && path.to_s =~ /\.json\z/
             describe(subpath.join('/')) do
               JSONSchemaTestSchema.new_jsi(::JSON.parse(path.read)).map do |tests_desc|

test/test_helper.rb

@@ -44,6 +44,7 @@ def report
   end
 end
 Minitest::Reporters.use! MiniTest::SpecReporterWithEndSummary.new
+Minitest::Test.make_my_diffs_pretty!
 
 class JSISpec < Minitest::Spec
   if ENV['JSI_TEST_ALPHA']

test/unsupported_test.rb

@@ -86,4 +86,71 @@
       end
     end
   end
+
+  describe 'property names which are not strings' do
+    ARBITRARY_OBJECT = Object.new
+    describe 'arbitrary object property name' do
+      let(:schema_content) do
+        {
+          'properties' => {
+            ARBITRARY_OBJECT => {},
+          },
+        }
+      end
+      let(:instance) do
+        {
+          ARBITRARY_OBJECT => {},
+        }
+      end
+
+      it 'applies properties' do
+        assert_is_a(schema.properties[ARBITRARY_OBJECT].jsi_schema_module, subject[ARBITRARY_OBJECT])
+      end
+    end
+    describe 'property name which is an array, described by propertyNames' do
+      let(:schema_content) do
+        {
+          'properties' => {
+            [1] => {},
+          },
+          'propertyNames' => {
+            'type' => 'array',
+            'items' => {'type' => 'integer'},
+          },
+        }
+      end
+      describe 'valid' do
+        let(:instance) do
+          {
+            [] => {},
+            [1] => {},
+          }
+        end
+        it 'applies properties' do
+          assert_is_a(schema.properties[[1]].jsi_schema_module, subject[[1]])
+          assert_equal({}, subject[[]]) # not a jsi
+
+          assert(subject.jsi_valid?)
+        end
+      end
+      describe 'invalid' do
+        let(:instance) do
+          {
+            [] => {},
+            [1] => {},
+            {} => {},
+          }
+        end
+        it 'applies properties' do
+          assert_is_a(schema.properties[[1]].jsi_schema_module, subject[[1]])
+          assert_equal({}, subject[[]]) # not a jsi
+
+          assert_equal([
+            "instance type does not match `type` value",
+            "instance object property names are not all valid against `propertyNames` schema value",
+          ], subject.jsi_validate.validation_errors.map(&:message))
+        end
+      end
+    end
+  end
 end