jsi 0.0.4 → 0.4.0

data/test/jsi_json_pointer_test.rb

@@ -0,0 +1,102 @@
+require_relative 'test_helper'
+
+describe JSI::JSON::Pointer do
+  # For example, given the document
+  let(:document) do
+    {
+       "foo" => ["bar", "baz"],
+       "" => 0,
+       "a/b" => 1,
+       "c%d" => 2,
+       "e^f" => 3,
+       "g|h" => 4,
+       "i\\j" => 5,
+       "k\"l" => 6,
+       " " => 7,
+       "m~n" => 8,
+    }
+  end
+
+  describe 'initialize from pointer' do
+    it 'parses' do
+      # The following strings evaluate to the accompanying values:
+      evaluations = [
+        ""      ,     document,
+        "/foo"  ,     ["bar", "baz"],
+        "/foo/0",     "bar",
+        "/"     ,     0,
+        "/a~1b" ,     1,
+        "/c%d"  ,     2,
+        "/e^f"  ,     3,
+        "/g|h"  ,     4,
+        "/i\\j" ,     5,
+        "/k\"l" ,     6,
+        "/ "    ,     7,
+        "/m~0n" ,     8,
+      ]
+      evaluations.each_slice(2) do |pointer, value|
+        assert_equal(value, JSI::JSON::Pointer.from_pointer(pointer).evaluate(document))
+      end
+    end
+
+    it 'raises for invalid syntax' do
+      err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
+        JSI::JSON::Pointer.from_pointer("this does not begin with slash").evaluate(document)
+      end
+      assert_equal("Invalid pointer syntax in \"this does not begin with slash\": pointer must begin with /", err.message)
+    end
+  end
+  describe 'initialize from fragment' do
+    # For example, given the document
+    let(:document) do
+      {
+         "foo" => ["bar", "baz"],
+         "" => 0,
+         "a/b" => 1,
+         "c%d" => 2,
+         "e^f" => 3,
+         "g|h" => 4,
+         "i\\j" => 5,
+         "k\"l" => 6,
+         " " => 7,
+         "m~n" => 8,
+      }
+    end
+
+    it 'parses' do
+      # the following URI fragment identifiers evaluate to the accompanying values:
+      evaluations = [
+        '#',            document,
+        '#/foo',        ["bar", "baz"],
+        '#/foo/0',      "bar",
+        '#/',           0,
+        '#/a~1b',       1,
+        '#/c%25d',      2,
+        '#/e%5Ef',      3,
+        '#/g%7Ch',      4,
+        '#/i%5Cj',      5,
+        '#/k%22l',      6,
+        '#/%20',        7,
+        '#/m~0n',       8,
+      ]
+      evaluations.each_slice(2) do |uri, value|
+        assert_equal(value, JSI::JSON::Pointer.from_fragment(Addressable::URI.parse(uri).fragment).evaluate(document))
+      end
+    end
+
+    it 'raises for invalid syntax' do
+      err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
+        JSI::JSON::Pointer.from_fragment("this does not begin with slash").evaluate(document)
+      end
+      assert_equal("Invalid pointer syntax in \"this does not begin with slash\": pointer must begin with /", err.message)
+    end
+  end
+  describe 'initialize' do
+    describe 'invalid reference_tokens' do
+      it 'raises' do
+        err = assert_raises(TypeError) { JSI::JSON::Pointer.new({}) }
+        assert_equal("reference_tokens must be an array. got: {}", err.message)
+      end
+    end
+  end
+end

data/test/jsi_typelike_as_json_test.rb

@@ -0,0 +1,53 @@
+require_relative 'test_helper'
+
+class JSONifiable
+  def initialize(object)
+    @object = object
+  end
+  def as_json
+    @object
+  end
+end
+
+describe JSI::Typelike do
+  describe 'as_json' do
+    it 'expresses as json' do
+      assert_equal({}, JSI::Typelike.as_json({}))
+      assert_equal([], JSI::Typelike.as_json([]))
+
+      # symbols to string
+      assert_equal(['a'], JSI::Typelike.as_json([:a]))
+
+      # set
+      assert_equal(['a'], JSI::Typelike.as_json(Set.new(['a'])))
+
+      # responds to #to_hash / #to_ary but naught else
+      assert_equal({'a' => 'b'}, JSI::Typelike.as_json(SortOfHash.new({'a' => 'b'})))
+      assert_equal(['a'], JSI::Typelike.as_json(SortOfArray.new(['a'])))
+
+      # symbol keys to string
+      assert_equal({'a' => 'b'}, JSI::Typelike.as_json({a: 'b'}))
+      # non string/symbol key
+      err = assert_raises(TypeError) { JSI::Typelike.as_json({nil => 0}) }
+      assert_equal('json object (hash) cannot be keyed with: nil', err.message)
+
+      # schema
+      schema = JSI::Schema.from_object({'type' => 'array'})
+      assert_equal({'type' => 'array'}, JSI::Typelike.as_json(schema))
+
+      # JSI
+      assert_equal(['a'], JSI::Typelike.as_json(schema.new_jsi(['a'])))
+
+      # JSON::Node
+      assert_equal(['a'], JSI::Typelike.as_json(JSI::JSON::Node.new_doc(['a'])))
+
+      # #as_json
+      assert_equal(['a'], JSI::Typelike.as_json(JSONifiable.new(['a'])))
+
+      # not jsonifiable
+      object = Object.new
+      err = assert_raises(TypeError) { JSI::Typelike.as_json(object) }
+      assert_equal("cannot express object as json: #{object.pretty_inspect.chomp}", err.message)
+    end
+  end
+end

data/test/metaschema_node_test.rb

@@ -0,0 +1,19 @@
+require_relative 'test_helper'
+
+describe JSI::MetaschemaNode do
+  let(:node_document) { {'properties' => {'properties' => {'additionalProperties' => {'$ref' => '#'}}}} }
+  let(:node_ptr) { JSI::JSON::Pointer[] }
+  let(:metaschema_root_ptr) { JSI::JSON::Pointer[] }
+  let(:root_schema_ptr) { JSI::JSON::Pointer[] }
+  let(:subject) { JSI::MetaschemaNode.new(node_document, node_ptr: node_ptr, metaschema_root_ptr: node_ptr, root_schema_ptr: node_ptr) }
+  describe 'initialization' do
+    it 'initializes' do
+      subject
+    end
+  end
+  describe 'json schema draft' do
+    it 'type has a schema' do
+      assert(JSI::JSONSchemaOrgDraft06.schema.type.jsi_schemas.any?)
+    end
+  end
+end

data/test/schema_module_test.rb

@@ -0,0 +1,21 @@
+require_relative 'test_helper'
+
+describe 'JSI::SchemaModule' do
+  let(:schema_content) { {'properties' => {'foo' => {'items' => {'type' => 'string'}}}} }
+  let(:schema) { JSI::Schema.new(schema_content) }
+  let(:schema_module) { schema.jsi_schema_module }
+  describe 'accessors and subscripts' do
+    it 'returns schemas using accessors and subscripts' do
+      assert_equal(schema.properties, schema_module.properties.possibly_schema_node)
+      assert_equal(schema.properties['foo'], schema_module.properties['foo'].possibly_schema_node)
+      assert_equal(schema.properties['foo'].jsi_schema_module, schema_module.properties['foo'])
+      assert_equal(schema.properties['foo'].items, schema_module.properties['foo'].items.possibly_schema_node)
+      assert_equal(schema.properties['foo'].items.jsi_schema_module, schema_module.properties['foo'].items)
+      assert_equal('string', schema_module.properties['foo'].items.type)
+    end
+    it 'accessors and subscripts with a metaschema' do
+      assert_equal(JSI::JSONSchemaOrgDraft06.schema.properties, JSI::JSONSchemaOrgDraft06.properties.possibly_schema_node)
+      assert_equal(JSI::JSONSchemaOrgDraft06.schema.properties['properties'].additionalProperties.jsi_schema_module, JSI::JSONSchemaOrgDraft06.properties['properties'].additionalProperties)
+    end
+  end
+end

data/test/schema_test.rb

@@ -1,149 +1,163 @@
 require_relative 'test_helper'
 
-SomeMetaschema = JSI.class_for_schema({id: 'https://schemas.jsi.unth.net/test/somemetaschema', type: 'object'})
-
 describe JSI::Schema do
   describe 'new' do
     it 'initializes from a hash' do
       schema = JSI::Schema.new({'type' => 'object'})
-      assert_equal(JSI::JSON::Node.new_doc({'type' => 'object'}), schema.schema_node)
+      assert_equal({'type' => 'object'}, schema.jsi_instance)
     end
     it 'initializes from a Node' do
       schema_node = JSI::JSON::Node.new_doc({'type' => 'object'})
       schema = JSI::Schema.new(schema_node)
-      assert_equal(schema_node, schema.schema_node)
-      assert_equal(schema_node, schema.schema_object)
-    end
-    it 'initializes from a JSI' do
-      schema_jsi = SomeMetaschema.new('type' => 'object')
-      schema = JSI::Schema.new(schema_jsi)
-      assert_equal(schema_jsi.instance, schema.schema_node)
-      assert_equal(schema_jsi, schema.schema_object)
+      assert_equal(schema_node, schema.jsi_instance)
     end
     it 'cannot instantiate from some unknown object' do
       err = assert_raises(TypeError) { JSI::Schema.new(Object.new) }
       assert_match(/\Acannot instantiate Schema from: #<Object:.*>\z/m, err.message)
     end
-    it 'makes no sense to instantiate schema from schema' do
-      err = assert_raises(TypeError) { JSI::Schema.new(JSI::Schema.new({})) }
-      assert_match(/\Awill not instantiate Schema from another Schema: #<JSI::Schema schema_id=.*>\z/m, err.message)
+    it 'instantiating a schema from schema returns that schema' do
+      # this is kinda dumb, but Schema.new now just aliases Schema.from_object, so this is the behavior
+      assert_equal(JSI::Schema.new({}), JSI::Schema.new(JSI::Schema.new({})))
     end
   end
   describe 'as an instance of metaschema' do
-    let(:default_metaschema) do
-      validator = ::JSON::Validator.default_validator
-      metaschema_file = validator.metaschema
-      JSI::Schema.new(::JSON.parse(File.read(metaschema_file)))
-    end
-    let(:metaschema_jsi_class) { JSI.class_for_schema(default_metaschema) }
-    let(:schema_object) { {'type' => 'array', 'items' => {'description' => 'items!'}} }
-    let(:schema_jsi) { metaschema_jsi_class.new(schema_object) }
-    let(:schema) { JSI::Schema.new(schema_jsi) }
+    let(:metaschema_jsi_module) { JSI::JSONSchemaOrgDraft04 }
+    let(:schema_content) { {'type' => 'array', 'items' => {'description' => 'items!'}} }
+    let(:schema) { metaschema_jsi_module.new_jsi(schema_content) }
     it '#[]' do
       schema_items = schema['items']
-      assert_instance_of(metaschema_jsi_class, schema_items)
+      assert_is_a(metaschema_jsi_module, schema_items)
       assert_equal({'description' => 'items!'}, schema_items.as_json)
     end
   end
   describe '#schema_id' do
-    it 'generates one' do
-      assert_match(/\A[0-9a-f\-]+#\z/, JSI::Schema.new({}).schema_id)
+    it "hasn't got one" do
+      assert_nil(JSI::Schema.new({}).schema_id)
     end
     it 'uses a given id with a fragment' do
-      schema = JSI::Schema.new({id: 'https://schemas.jsi.unth.net/test/given_id#'})
-      assert_equal('https://schemas.jsi.unth.net/test/given_id#', schema.schema_id)
+      schema = JSI::Schema.new({'id' => 'https://schemas.jsi.unth.net/test/given_id_with_fragment#'})
+      assert_equal('https://schemas.jsi.unth.net/test/given_id_with_fragment#', schema.schema_id)
     end
     it 'uses a given id (adding a fragment)' do
       schema = JSI::Schema.new({id: 'https://schemas.jsi.unth.net/test/given_id'})
       assert_equal('https://schemas.jsi.unth.net/test/given_id#', schema.schema_id)
     end
     it 'uses a pointer in the fragment' do
-      schema_node = JSI::JSON::Node.new_doc({
-        'id' => 'https://schemas.jsi.unth.net/test/given_id#',
+      schema = JSI::Schema.new({
+        'id' => 'https://schemas.jsi.unth.net/test/uses_pointer_in_fragment#',
         'properties' => {'foo' => {'type' => 'object'}},
       })
-      schema = JSI::Schema.new(schema_node['properties']['foo'])
-      assert_equal('https://schemas.jsi.unth.net/test/given_id#/properties/foo', schema.schema_id)
+      subschema = schema['properties']['foo']
+      assert_equal('https://schemas.jsi.unth.net/test/uses_pointer_in_fragment#/properties/foo', subschema.schema_id)
     end
     it 'uses a pointer in the fragment relative to the fragment of the root' do
-      schema_node = JSI::JSON::Node.new_doc({
-        'id' => 'https://schemas.jsi.unth.net/test/given_id#/notroot',
+      schema = JSI::Schema.new({
+        'id' => 'https://schemas.jsi.unth.net/test/id_has_pointer#/notroot',
         'properties' => {'foo' => {'type' => 'object'}},
       })
-      schema = JSI::Schema.new(schema_node['properties']['foo'])
-      assert_equal('https://schemas.jsi.unth.net/test/given_id#/notroot/properties/foo', schema.schema_id)
+      subschema = schema['properties']['foo']
+      assert_equal('https://schemas.jsi.unth.net/test/id_has_pointer#/notroot/properties/foo', subschema.schema_id)
     end
   end
-  describe '#schema_class' do
+  describe '#jsi_schema_module' do
+    it 'returns the module for the schema' do
+      schema = JSI::Schema.new({'id' => 'https://schemas.jsi.unth.net/test/jsi_schema_module'})
+      assert_is_a(JSI::SchemaModule, schema.jsi_schema_module)
+      assert_equal(schema, schema.jsi_schema_module.schema)
+    end
+  end
+  describe '#jsi_schema_class' do
     it 'returns the class for the schema' do
-      schema_node = JSI::JSON::Node.new_doc({'id' => 'https://schemas.jsi.unth.net/test/schema_schema_class'})
-      assert_equal(JSI.class_for_schema(schema_node), JSI::Schema.new(schema_node).schema_class)
+      schema = JSI::Schema.new({'id' => 'https://schemas.jsi.unth.net/test/schema_schema_class'})
+      assert_equal(JSI.class_for_schemas([schema]), schema.jsi_schema_class)
     end
   end
-  describe '#subschema_for_property' do
+  describe '#subschemas_for_property_name' do
     let(:schema) do
       JSI::Schema.new({
-        properties: {foo: {description: 'foo'}},
-        patternProperties: {"^ba" => {description: 'ba*'}},
+        properties: {
+          foo: {description: 'foo'},
+          baz: {description: 'baz'},
+        },
+        patternProperties: {
+          "^b" => {description: 'ba*'},
+        },
         additionalProperties: {description: 'whatever'},
       })
     end
-    it 'has no subschema' do
-      assert_equal(nil, JSI::Schema.new({}).subschema_for_property('no'))
+    it 'has no subschemas' do
+      assert_empty(JSI::Schema.new({}).subschemas_for_property_name('no'))
     end
     it 'has a subschema by property' do
-      subschema = schema.subschema_for_property('foo')
-      assert_instance_of(JSI::Schema, subschema)
-      assert_equal('foo', subschema['description'])
-    end
-    it 'has a subschema by pattern property' do
-      subschema = schema.subschema_for_property('bar')
-      assert_instance_of(JSI::Schema, subschema)
-      assert_equal('ba*', subschema['description'])
-    end
-    it 'has a subschema by additional properties' do
-      subschema = schema.subschema_for_property('anything')
-      assert_instance_of(JSI::Schema, subschema)
-      assert_equal('whatever', subschema['description'])
+      subschemas = schema.subschemas_for_property_name('foo').to_a
+      assert_equal(1, subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[0])
+      assert_equal('foo', subschemas[0].description)
+    end
+    it 'has subschemas by patternProperties' do
+      subschemas = schema.subschemas_for_property_name('bar').to_a
+      assert_equal(1, subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[0])
+      assert_equal('ba*', subschemas[0].description)
+    end
+    it 'has subschemas by properties, patternProperties' do
+      subschemas = schema.subschemas_for_property_name('baz').to_a
+      assert_equal(2, subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[0])
+      assert_equal('baz', subschemas[0].description)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[1])
+      assert_equal('ba*', subschemas[1].description)
+    end
+    it 'has subschemas by additional properties' do
+      subschemas = schema.subschemas_for_property_name('anything').to_a
+      assert_equal(1, subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[0])
+      assert_equal('whatever', subschemas[0].description)
     end
   end
-  describe '#subschema_for_index' do
-    it 'has no subschema' do
-      assert_equal(nil, JSI::Schema.new({}).subschema_for_index(0))
+  describe '#subschemas_for_index' do
+    it 'has no subschemas' do
+      assert_empty(JSI::Schema.new({}).subschemas_for_index(0))
     end
     it 'has a subschema for items' do
       schema = JSI::Schema.new({
         items: {description: 'items!'}
       })
-      first_subschema = schema.subschema_for_index(0)
-      assert_instance_of(JSI::Schema, first_subschema)
-      assert_equal('items!', first_subschema['description'])
-      last_subschema = schema.subschema_for_index(1)
-      assert_instance_of(JSI::Schema, last_subschema)
-      assert_equal('items!', last_subschema['description'])
+      first_subschemas = schema.subschemas_for_index(0).to_a
+      assert_equal(1, first_subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschemas[0])
+      assert_equal('items!', first_subschemas[0].description)
+      last_subschemas = schema.subschemas_for_index(1).to_a
+      assert_equal(1, last_subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschemas[0])
+      assert_equal('items!', last_subschemas[0].description)
     end
     it 'has a subschema for each item by index' do
       schema = JSI::Schema.new({
         items: [{description: 'item one'}, {description: 'item two'}]
       })
-      first_subschema = schema.subschema_for_index(0)
-      assert_instance_of(JSI::Schema, first_subschema)
-      assert_equal('item one', first_subschema['description'])
-      last_subschema = schema.subschema_for_index(1)
-      assert_instance_of(JSI::Schema, last_subschema)
-      assert_equal('item two', last_subschema['description'])
+      first_subschemas = schema.subschemas_for_index(0).to_a
+      assert_equal(1, first_subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschemas[0])
+      assert_equal('item one', first_subschemas[0].description)
+      last_subschemas = schema.subschemas_for_index(1).to_a
+      assert_equal(1, last_subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschemas[0])
+      assert_equal('item two', last_subschemas[0].description)
     end
     it 'has a subschema by additional items' do
       schema = JSI::Schema.new({
         items: [{description: 'item one'}],
         additionalItems: {description: "mo' crap"},
       })
-      first_subschema = schema.subschema_for_index(0)
-      assert_instance_of(JSI::Schema, first_subschema)
-      assert_equal('item one', first_subschema['description'])
-      last_subschema = schema.subschema_for_index(1)
-      assert_instance_of(JSI::Schema, last_subschema)
-      assert_equal("mo' crap", last_subschema['description'])
+      first_subschemas = schema.subschemas_for_index(0).to_a
+      assert_equal(1, first_subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschemas[0])
+      assert_equal('item one', first_subschemas[0].description)
+      last_subschemas = schema.subschemas_for_index(1).to_a
+      assert_equal(1, last_subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschemas[0])
+      assert_equal("mo' crap", last_subschemas[0].description)
     end
   end
   describe 'stringification' do
@@ -152,42 +166,40 @@ describe JSI::Schema do
     end
 
     it '#inspect' do
-      assert_equal(%q(#<JSI::Schema schema_id=https://schemas.jsi.unth.net/test/stringification# #{<JSI::JSON::HashNode fragment="#"> "id" => "https://schemas.jsi.unth.net/test/stringification", "type" => "object"}>), schema.inspect)
+      assert_equal("\#{<JSI (JSI::JSONSchemaOrgDraft06) Schema> \"id\" => \"https://schemas.jsi.unth.net/test/stringification\", \"type\" => \"object\"}", schema.inspect)
     end
     it '#pretty_print' do
-      assert_equal(%q(#<JSI::Schema schema_id=https://schemas.jsi.unth.net/test/stringification#
-        #{<JSI::JSON::HashNode fragment="#">
-          "id" => "https://schemas.jsi.unth.net/test/stringification",
-          "type" => "object"
-        }
-      >).gsub(/^      /, ''), schema.pretty_inspect.chomp)
+      assert_equal("\#{<JSI (JSI::JSONSchemaOrgDraft06) Schema>
+        \"id\" => \"https://schemas.jsi.unth.net/test/stringification\",
+        \"type\" => \"object\"
+      }".gsub(/^      /, ''), schema.pretty_inspect.chomp)
     end
   end
   describe 'validation' do
     let(:schema) { JSI::Schema.new({id: 'https://schemas.jsi.unth.net/test/validation', type: 'object'}) }
     describe 'without errors' do
       let(:instance) { {'foo' => 'bar'} }
-      it '#fully_validate' do
-        assert_equal([], schema.fully_validate(instance))
+      it '#fully_validate_instance' do
+        assert_equal([], schema.fully_validate_instance(instance))
       end
-      it '#validate' do
-        assert_equal(true, schema.validate(instance))
+      it '#validate_instance' do
+        assert_equal(true, schema.validate_instance(instance))
       end
-      it '#validate!' do
-        assert_equal(true, schema.validate!(instance))
+      it '#validate_instance!' do
+        assert_equal(true, schema.validate_instance!(instance))
       end
     end
     describe 'with errors' do
       let(:instance) { ['no'] }
-      it '#fully_validate' do
-        assert_equal(["The property '#/' of type array did not match the following type: object in schema https://schemas.jsi.unth.net/test/validation"], schema.fully_validate(instance))
+      it '#fully_validate_instance' do
+        assert_equal(["The property '#/' of type array did not match the following type: object in schema https://schemas.jsi.unth.net/test/validation"], schema.fully_validate_instance(instance))
       end
-      it '#validate' do
-        assert_equal(false, schema.validate(instance))
+      it '#validate_instance' do
+        assert_equal(false, schema.validate_instance(instance))
       end
-      it '#validate!' do
+      it '#validate_instance!' do
         err = assert_raises(JSON::Schema::ValidationError) do
-          schema.validate!(instance)
+          schema.validate_instance!(instance)
         end
         assert_equal("The property '#/' of type array did not match the following type: object", err.message)
       end