jsi 0.2.1 → 0.3.0

data/test/jsi_typelike_as_json_test.rb

@@ -36,7 +36,7 @@ describe JSI::Typelike do
       assert_equal({'type' => 'array'}, JSI::Typelike.as_json(schema))
 
       # JSI
-      assert_equal(['a'], JSI::Typelike.as_json(JSI.class_for_schema(schema).new(['a'])))
+      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'])))

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.schema)
+    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,53 +1,38 @@
 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, 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(:metaschema_jsi_module) { JSI::JSONSchemaOrgDraft04 }
     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(:schema) { metaschema_jsi_module.new_jsi(schema_object) }
     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#'})
@@ -58,26 +43,33 @@ describe JSI::Schema do
       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({
+      schema = JSI::Schema.new({
         'id' => 'https://schemas.jsi.unth.net/test/given_id#',
         '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/given_id#/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({
+      schema = JSI::Schema.new({
         'id' => 'https://schemas.jsi.unth.net/test/given_id#/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/given_id#/notroot/properties/foo', subschema.schema_id)
+    end
+  end
+  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 '#schema_class' do
+  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_schema(schema), schema.jsi_schema_class)
     end
   end
   describe '#subschema_for_property' do
@@ -93,17 +85,17 @@ describe JSI::Schema do
     end
     it 'has a subschema by property' do
       subschema = schema.subschema_for_property('foo')
-      assert_instance_of(JSI::Schema, subschema)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, 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_is_a(JSI::Schema.default_metaschema.jsi_schema_module, 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_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschema)
       assert_equal('whatever', subschema['description'])
     end
   end
@@ -116,10 +108,10 @@ describe JSI::Schema do
         items: {description: 'items!'}
       })
       first_subschema = schema.subschema_for_index(0)
-      assert_instance_of(JSI::Schema, first_subschema)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschema)
       assert_equal('items!', first_subschema['description'])
       last_subschema = schema.subschema_for_index(1)
-      assert_instance_of(JSI::Schema, last_subschema)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschema)
       assert_equal('items!', last_subschema['description'])
     end
     it 'has a subschema for each item by index' do
@@ -127,10 +119,10 @@ describe JSI::Schema do
         items: [{description: 'item one'}, {description: 'item two'}]
       })
       first_subschema = schema.subschema_for_index(0)
-      assert_instance_of(JSI::Schema, first_subschema)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschema)
       assert_equal('item one', first_subschema['description'])
       last_subschema = schema.subschema_for_index(1)
-      assert_instance_of(JSI::Schema, last_subschema)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschema)
       assert_equal('item two', last_subschema['description'])
     end
     it 'has a subschema by additional items' do
@@ -139,10 +131,10 @@ describe JSI::Schema do
         additionalItems: {description: "mo' crap"},
       })
       first_subschema = schema.subschema_for_index(0)
-      assert_instance_of(JSI::Schema, first_subschema)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschema)
       assert_equal('item one', first_subschema['description'])
       last_subschema = schema.subschema_for_index(1)
-      assert_instance_of(JSI::Schema, last_subschema)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschema)
       assert_equal("mo' crap", last_subschema['description'])
     end
   end
@@ -152,15 +144,13 @@ 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

data/test/test_helper.rb

@@ -28,9 +28,41 @@ class JSISpec < Minitest::Spec
   end
 
   def assert_equal exp, act, msg = nil
-    msg = message(msg, E) { diff exp, act }
+    msg = message(msg, E) do
+      [].tap do |ms|
+        ms << diff(exp, act)
+        ms << "#{ANSI.red   { 'expected' }}: #{exp.inspect}"
+        ms << "#{ANSI.green { 'actual' }}:   #{act.inspect}"
+        if exp.respond_to?(:to_str) && act.respond_to?(:to_str)
+          ms << "#{ANSI.red { 'expected (str)' }}:"
+          ms << exp
+          ms << "#{ANSI.green { 'actual (str)' }}:"
+          ms << act
+        end
+      end.join("\n")
+    end
     assert exp == act, msg
   end
+
+  def assert_match matcher, obj, msg = nil
+    msg = message(msg) do
+      [].tap do |ms|
+        ms << "Expected match."
+        ms << "#{ANSI.red   { 'matcher' }}: #{mu_pp matcher}"
+        ms << "#{ANSI.green { 'object' }}:  #{mu_pp obj}"
+        ms << "#{ANSI.yellow { 'escaped' }}: #{Regexp.new(Regexp.escape(obj)).inspect}" if obj.is_a?(String)
+      end.join("\n")
+    end
+    assert_respond_to matcher, :"=~"
+    matcher = Regexp.new Regexp.escape matcher if String === matcher
+    assert matcher =~ obj, msg
+  end
+
+  def assert_is_a mod, obj, msg = nil
+    msg = message(msg) { "Expected instance of #{mod}. received #{obj.class}: #{mu_pp(obj)}" }
+
+    assert obj.is_a?(mod), msg
+  end
 end
 
 # register this to be the base class for specs instead of Minitest::Spec
@@ -45,7 +77,7 @@ class SortOfHash
     @hash
   end
   include JSI::FingerprintHash
-  def fingerprint
+  def jsi_fingerprint
     {class: self.class, hash: @hash}
   end
 end
@@ -59,7 +91,7 @@ class SortOfArray
     @ary
   end
   include JSI::FingerprintHash
-  def fingerprint
+  def jsi_fingerprint
     {class: self.class, ary: @ary}
   end
 end

data/test/util_test.rb

@@ -11,9 +11,9 @@ describe JSI::Util do
       assert_equal(expected, actual)
     end
     it 'stringifies JSI hash keys' do
-      klass = JSI.class_for_schema(type: 'object')
-      expected = JSI.stringify_symbol_keys(klass.new(JSI::JSON::Node.new_doc({a: 'b', 'c' => 'd', nil => 3})))
-      actual = klass.new(JSI::JSON::Node.new_doc({'a' => 'b', 'c' => 'd', nil => 3}))
+      schema = JSI::Schema.new({type: 'object'})
+      expected = JSI.stringify_symbol_keys(schema.new_jsi({a: 'b', 'c' => 'd', nil => 3}))
+      actual = schema.new_jsi({'a' => 'b', 'c' => 'd', nil => 3})
       assert_equal(expected, actual)
     end
     describe 'non-hash-like argument' do
@@ -22,8 +22,8 @@ describe JSI::Util do
         assert_equal("expected argument to be a hash; got NilClass: nil", err.message)
         err = assert_raises(ArgumentError) { JSI.stringify_symbol_keys(JSI::JSON::Node.new_doc(3)) }
         assert_equal("expected argument to be a hash; got JSI::JSON::Node: #<JSI::JSON::Node fragment=\"#\" 3>", err.message)
-        err = assert_raises(ArgumentError) { JSI.stringify_symbol_keys(JSI.class_for_schema({}).new(JSI::JSON::Node.new_doc(3))) }
-        assert_match(%r(\Aexpected argument to be a hash; got JSI::SchemaClasses\["[^"]+#"\]: #<JSI::SchemaClasses\["[^"]+#"\]\n  #<JSI::JSON::Node fragment="#" 3>\n>\z)m, err.message)
+        err = assert_raises(ArgumentError) { JSI.stringify_symbol_keys(JSI::Schema.new({}).new_jsi(3)) }
+        assert_equal("expected argument to be a hash; got (JSI Schema Class: #): #<JSI 3>", err.message)
       end
     end
   end
@@ -53,9 +53,9 @@ describe JSI::Util do
       assert_equal(expected, actual)
     end
     it 'deep stringifies JSI instance' do
-      klass = JSI.class_for_schema(type: 'object')
-      actual = JSI.deep_stringify_symbol_keys(klass.new(JSI::JSON::Node.new_doc({a: 'b', 'c' => {d: 0}, nil => 3})))
-      expected = klass.new(JSI::JSON::Node.new_doc({'a' => 'b', 'c' => {'d' => 0}, nil => 3}))
+      schema = JSI::Schema.new(type: 'object')
+      actual = JSI.deep_stringify_symbol_keys(schema.new_jsi(JSI::JSON::Node.new_doc({a: 'b', 'c' => {d: 0}, nil => 3})))
+      expected = schema.new_jsi(JSI::JSON::Node.new_doc({'a' => 'b', 'c' => {'d' => 0}, nil => 3}))
       assert_equal(expected, actual)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsi
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Ethan
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2019-11-30 00:00:00.000000000 Z
+date: 2020-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -28,30 +28,30 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest-around
   requirement: !ruby/object:Gem::Requirement
@@ -97,7 +97,7 @@ dependencies:
 description: JSI offers an Object-Oriented representation for JSON data using JSON
   Schemas
 email:
-- ethan@unth.net
+- ethan.jsi@unth.net
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -105,7 +105,7 @@ files:
 - ".simplecov"
 - ".yardopts"
 - CHANGELOG.md
-- LICENSE.txt
+- LICENSE.md
 - README.md
 - Rakefile.rb
 - jsi.gemspec
@@ -117,6 +117,8 @@ files:
 - lib/jsi/json.rb
 - lib/jsi/json/node.rb
 - lib/jsi/json/pointer.rb
+- lib/jsi/metaschema.rb
+- lib/jsi/metaschema_node.rb
 - lib/jsi/pathed_node.rb
 - lib/jsi/schema.rb
 - lib/jsi/schema_classes.rb
@@ -124,6 +126,9 @@ files:
 - lib/jsi/typelike_modules.rb
 - lib/jsi/util.rb
 - lib/jsi/version.rb
+- lib/schemas/json-schema.org/draft-04/schema.rb
+- lib/schemas/json-schema.org/draft-06/schema.rb
+- resources/icons/AGPL-3.0.png
 - test/base_array_test.rb
 - test/base_hash_test.rb
 - test/base_test.rb
@@ -134,13 +139,15 @@ files:
 - test/jsi_json_pointer_test.rb
 - test/jsi_test.rb
 - test/jsi_typelike_as_json_test.rb
+- test/metaschema_node_test.rb
+- test/schema_module_test.rb
 - test/schema_test.rb
 - test/spreedly_openapi_test.rb
 - test/test_helper.rb
 - test/util_test.rb
 homepage: https://github.com/notEthan/jsi
 licenses:
-- MIT
+- AGPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -157,8 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: 'JSI: JSON Schema Instantiation'
@@ -173,6 +179,8 @@ test_files:
 - test/jsi_json_pointer_test.rb
 - test/jsi_test.rb
 - test/jsi_typelike_as_json_test.rb
+- test/metaschema_node_test.rb
+- test/schema_module_test.rb
 - test/schema_test.rb
 - test/spreedly_openapi_test.rb
 - test/test_helper.rb