jsi 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61dd1e2dc8c145ccf5acdcd6a0d6eaeef0d61dd85e876347af89f7168e838319
-  data.tar.gz: de6f01e5e859f2b3039b7d2c6f734b1e30b97b8c946f2444783581931d5939e9
+  metadata.gz: 12a262c5b9ec6c22d16c8e4f5cb983c92266d165964a120ffcd72f7e0bd877d1
+  data.tar.gz: 3e4671dda156d3d8073e9f7af42e3335af8f3482719a0495d4f57a2dfaaf12c9
 SHA512:
-  metadata.gz: c15c232306814b19a3b84f94c9bd5bacfa261c7124e007ad8961e6e7a28495c23e675963aca024d2abb29613ba9092313cf11b0344feb3e20f38dec6dcf511b1
-  data.tar.gz: c00160e62da570c862b694d516bb157019b1799dcff24f594f494fa695c45fcfaa4a5e34e93b8bf35978c28e9bf13e84ed86b3938eff3b7443c6e4cae81118af
+  metadata.gz: 7f9c9816756bb70c16498d2ba503c7b0148533b37ae065d8426e654a0644066db6108a6a7d79789bb039f4911432b4273ca85d6a08a47783d0e992af06e248c2
+  data.tar.gz: c9859fffe7cffbdde822530c828db5344cefa12e2b94eef5d3732d88dca741db5e93414c2800d681fba4555b6694d5bf873cdee08ccbfbce293f3e159ac2749e

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# v0.0.3
+
+- JSI::Base returns an instance of the default value for the schema if applicable
+- JSI::Base instance method #class_for_schema may be overridden by subclasses
+- bugfixes and internal refactoring
+
 # v0.0.2
 
 - JSI::JSON::Node and other utilities duck-type better with #to_hash and #to_ary

data/lib/jsi/base.rb

@@ -67,14 +67,14 @@ module JSI
     # a Node already).
     #
     # @param instance [Object] the JSON Schema instance being represented
-    # @param origin [JSI::Base] for internal use, specifies a parent
-    #   from which this JSI originated
-    def initialize(instance, origin: nil)
+    # @param ancestor [JSI::Base] for internal use, specifies an ancestor
+    #   from which this JSI originated to calculate #parents
+    def initialize(instance, ancestor: nil)
       unless respond_to?(:schema)
         raise(TypeError, "cannot instantiate #{self.class.inspect} which has no method #schema. please use JSI.class_for_schema")
       end
 
-      @origin = origin || self
+      @ancestor = ancestor || self
       self.instance = instance
 
       if @instance.is_a?(JSI::JSON::HashNode)
@@ -87,6 +87,9 @@ module JSI
     # the instance of the json-schema. this is a JSI::JSON::Node.
     attr_reader :instance
 
+    # a JSI which is an ancestor of this
+    attr_reader :ancestor
+
     # each is overridden by BaseHash or BaseArray when appropriate. the base
     # #each is not actually implemented, along with all the methods of Enumerable.
     def each
@@ -99,8 +102,8 @@ module JSI
     #
     # @return [Array<JSI::Base>]
     def parents
-      parent = @origin
-      (@origin.instance.path.size...self.instance.path.size).map do |i|
+      parent = @ancestor
+      (@ancestor.instance.path.size...self.instance.path.size).map do |i|
         parent.tap do
           parent = parent[self.instance.path[i]]
         end
@@ -123,7 +126,7 @@ module JSI
       if derefed.object_id == instance.object_id
         self
       else
-        self.class.new(derefed, origin: @origin)
+        self.class.new(derefed, ancestor: @ancestor)
       end
     end
 
@@ -136,7 +139,7 @@ module JSI
     # @return [JSI::Base subclass the same as self] the modified copy of self
     def modified_copy(&block)
       modified_instance = instance.modified_copy(&block)
-      self.class.new(modified_instance, origin: @origin)
+      self.class.new(modified_instance, ancestor: @ancestor)
     end
 
     def fragment
@@ -228,6 +231,12 @@ module JSI
         instance[subscript] = value
       end
     end
+
+    # this is an instance method in order to allow subclasses of JSI classes to
+    # override it to point to other subclasses corresponding to other schemas.
+    def class_for_schema(schema)
+      JSI.class_for_schema(schema)
+    end
   end
 
   # this module is just a namespace for schema classes.
@@ -247,13 +256,7 @@ module JSI
 
   # see {JSI.class_for_schema}
   def SchemaClasses.class_for_schema(schema_object)
-    if schema_object.is_a?(JSI::Schema)
-      schema__ = schema_object
-    else
-      schema__ = JSI::Schema.new(schema_object)
-    end
-
-    memoize(:class_for_schema, schema__) do |schema_|
+    memoize(:class_for_schema, JSI::Schema.from_object(schema_object)) do |schema_|
       begin
         begin
           Class.new(Base).instance_exec(schema_) do |schema|
@@ -284,13 +287,7 @@ module JSI
   # class will be defined. users should use #[] and #[]= to access properties
   # whose names conflict with existing methods.
   def SchemaClasses.module_for_schema(schema_object)
-    if schema_object.is_a?(JSI::Schema)
-      schema__ = schema_object
-    else
-      schema__ = JSI::Schema.new(schema_object)
-    end
-
-    memoize(:module_for_schema, schema__) do |schema_|
+    memoize(:module_for_schema, JSI::Schema.from_object(schema_object)) do |schema_|
       Module.new.tap do |m|
         m.instance_exec(schema_) do |schema|
           define_method(:schema) { schema }
@@ -369,8 +366,16 @@ module JSI
           property_schema = schema.subschema_for_property(property_name)
           property_schema = property_schema && property_schema.match_to_instance(instance[property_name])
 
-          if property_schema && instance[property_name].is_a?(JSON::Node)
-            JSI.class_for_schema(property_schema).new(instance[property_name], origin: @origin)
+          if !instance.key?(property_name) && property_schema && property_schema.schema_object.key?('default')
+            # use the default value
+            default = property_schema.schema_object['default']
+            if default.respond_to?(:to_hash) || default.respond_to?(:to_ary)
+              class_for_schema(property_schema).new(default, ancestor: @ancestor)
+            else
+              default
+            end
+          elsif property_schema && (instance[property_name].respond_to?(:to_hash) || instance[property_name].respond_to?(:to_ary))
+            class_for_schema(property_schema).new(instance[property_name], ancestor: @ancestor)
           else
             instance[property_name]
           end
@@ -426,8 +431,16 @@ module JSI
           index_schema = schema.subschema_for_index(i)
           index_schema = index_schema && index_schema.match_to_instance(instance[i])
 
-          if index_schema && instance[i].is_a?(JSON::Node)
-            JSI.class_for_schema(index_schema).new(instance[i], origin: @origin)
+          if !instance.each_index.to_a.include?(i) && index_schema && index_schema.schema_object.key?('default')
+            # use the default value
+            default = index_schema.schema_object['default']
+            if default.respond_to?(:to_hash) || default.respond_to?(:to_ary)
+              class_for_schema(index_schema).new(default, ancestor: @ancestor)
+            else
+              default
+            end
+          elsif index_schema && (instance[i].respond_to?(:to_hash) || instance[i].respond_to?(:to_ary))
+            class_for_schema(index_schema).new(instance[i], ancestor: @ancestor)
           else
             instance[i]
           end

data/lib/jsi/schema.rb

@@ -7,6 +7,16 @@ module JSI
   class Schema
     include Memoize
 
+    class << self
+      def from_object(schema_object)
+        if schema_object.is_a?(Schema)
+          schema_object
+        else
+          new(schema_object)
+        end
+      end
+    end
+
     # initializes a schema from a given JSI::Base, JSI::JSON::Node, or hash.
     # @param schema_object [JSI::Base, #to_hash] the schema
     def initialize(schema_object)
@@ -118,6 +128,7 @@ module JSI
       # matching allOf is questionable. all of the schemas must be matched but we just return the first match.
       #   there isn't really a better answer with the current implementation. merging the schemas together
       #   is a thought but is not practical.
+      instance = instance.deref if instance.is_a?(JSI::JSON::Node)
       %w(oneOf allOf anyOf).select { |k| schema_node[k].respond_to?(:to_ary) }.each do |someof_key|
         schema_node[someof_key].map(&:deref).map do |someof_node|
           someof_schema = self.class.new(someof_node)
@@ -201,6 +212,22 @@ module JSI
       end
     end
 
+    def default_value
+      if schema_node.key?('default')
+        if schema_node['default'].respond_to?(:to_ary) || schema_node['default'].respond_to?(:to_hash)
+          schema_class.new(schema_node['default'])
+        else
+          schema_node['default']
+        end
+      else
+        nil
+      end
+    end
+
+    def default_value?
+      schema_node.key?('default')
+    end
+
     # @return [Array<String>] array of schema validation error messages for
     #   the given instance against this schema
     def fully_validate(instance)

data/lib/jsi/util.rb

@@ -79,6 +79,7 @@ module JSI
     end
     module_function :ycomb
   end
+  public
   extend Util
 
   module FingerprintHash

data/lib/jsi/version.rb

@@ -1,3 +1,3 @@
 module JSI
-  VERSION = "0.0.2".freeze
+  VERSION = "0.0.3".freeze
 end

data/test/base_array_test.rb

@@ -20,6 +20,61 @@ describe JSI::BaseArray do
   let(:class_for_schema) { JSI.class_for_schema(schema) }
   let(:subject) { class_for_schema.new(instance) }
 
+  describe '#[] with a default that is a basic type' do
+    let(:schema_content) do
+      {
+        'type' => 'array',
+        'items' => {'default' => 'foo'},
+      }
+    end
+    describe 'default value' do
+      let(:document) { [1] }
+      it 'returns the default value' do
+        assert_equal('foo', subject[2])
+      end
+    end
+    describe 'nondefault value (basic type)' do
+      let(:document) { ['who'] }
+      it 'returns the nondefault value' do
+        assert_equal('who', subject[0])
+      end
+    end
+    describe 'nondefault value (nonbasic type)' do
+      let(:document) { [[2]] }
+      it 'returns the nondefault value' do
+        assert_instance_of(JSI.class_for_schema(schema['items']), subject[0])
+        assert_equal([2], subject[0].as_json)
+      end
+    end
+  end
+  describe '#[] with a default that is a nonbasic type' do
+    let(:schema_content) do
+      {
+        'type' => 'array',
+        'items' => {'default' => {'foo' => 2}},
+      }
+    end
+    describe 'default value' do
+      let(:document) { [{'bar' => 3}] }
+      it 'returns the default value' do
+        assert_instance_of(JSI.class_for_schema(schema['items']), subject[1])
+        assert_equal({'foo' => 2}, subject[1].as_json)
+      end
+    end
+    describe 'nondefault value (basic type)' do
+      let(:document) { [true, 'who'] }
+      it 'returns the nondefault value' do
+        assert_equal('who', subject[1])
+      end
+    end
+    describe 'nondefault value (nonbasic type)' do
+      let(:document) { [true, [2]] }
+      it 'returns the nondefault value' do
+        assert_instance_of(JSI.class_for_schema(schema['items']), subject[1])
+        assert_equal([2], subject[1].as_json)
+      end
+    end
+  end
   describe 'arraylike []=' do
     it 'sets an index' do
       orig_2 = subject[2]

data/test/base_hash_test.rb

@@ -19,6 +19,65 @@ describe JSI::BaseHash do
   let(:class_for_schema) { JSI.class_for_schema(schema) }
   let(:subject) { class_for_schema.new(instance) }
 
+  describe '#[] with a default that is a basic type' do
+    let(:schema_content) do
+      {
+        'type' => 'object',
+        'properties' => {
+          'foo' => {'default' => 'foo'},
+        },
+      }
+    end
+    describe 'default value' do
+      let(:document) { {'bar' => 3} }
+      it 'returns the default value' do
+        assert_equal('foo', subject.foo)
+      end
+    end
+    describe 'nondefault value (basic type)' do
+      let(:document) { {'foo' => 'who'} }
+      it 'returns the nondefault value' do
+        assert_equal('who', subject.foo)
+      end
+    end
+    describe 'nondefault value (nonbasic type)' do
+      let(:document) { {'foo' => [2]} }
+      it 'returns the nondefault value' do
+        assert_instance_of(JSI.class_for_schema(schema['properties']['foo']), subject.foo)
+        assert_equal([2], subject.foo.as_json)
+      end
+    end
+  end
+  describe '#[] with a default that is a nonbasic type' do
+    let(:schema_content) do
+      {
+        'type' => 'object',
+        'properties' => {
+          'foo' => {'default' => {'foo' => 2}},
+        },
+      }
+    end
+    describe 'default value' do
+      let(:document) { {'bar' => 3} }
+      it 'returns the default value' do
+        assert_instance_of(JSI.class_for_schema(schema['properties']['foo']), subject.foo)
+        assert_equal({'foo' => 2}, subject.foo.as_json)
+      end
+    end
+    describe 'nondefault value (basic type)' do
+      let(:document) { {'foo' => 'who'} }
+      it 'returns the nondefault value' do
+        assert_equal('who', subject.foo)
+      end
+    end
+    describe 'nondefault value (nonbasic type)' do
+      let(:document) { {'foo' => [2]} }
+      it 'returns the nondefault value' do
+        assert_instance_of(JSI.class_for_schema(schema['properties']['foo']), subject.foo)
+        assert_equal([2], subject.foo.as_json)
+      end
+    end
+  end
   describe 'hashlike []=' do
     it 'sets a property' do
       orig_foo = subject['foo']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsi
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Ethan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-27 00:00:00.000000000 Z
+date: 2019-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema