jsi 0.2.0 → 0.6.0

data/test/jsi_coder_test.rb

@@ -1,85 +0,0 @@
-require_relative 'test_helper'
-
-describe JSI::JSICoder do
-  let(:schema) do
-    {properties: {foo: {}, bar: {}}}
-  end
-  let(:schema_instance_class) { JSI.class_for_schema(schema) }
-  let(:options) { {} }
-  let(:schema_instance_json_coder) { JSI::JSICoder.new(schema_instance_class, options) }
-  describe 'json' do
-    describe 'load' do
-      it 'loads nil' do
-        assert_nil(schema_instance_json_coder.load(nil))
-      end
-      it 'loads a hash' do
-        assert_equal(schema_instance_class.new('foo' => 'bar'), schema_instance_json_coder.load({"foo" => "bar"}))
-      end
-      it 'loads something else' do
-        assert_equal(schema_instance_class.new([[]]), schema_instance_json_coder.load([[]]))
-      end
-      describe 'array' do
-        let(:options) { {array: true} }
-        it 'loads an array of hashes' do
-          data = [{"foo" => "bar"}, {"foo" => "baz"}]
-          assert_equal([schema_instance_class.new('foo' => 'bar'), schema_instance_class.new('foo' => 'baz')], schema_instance_json_coder.load(data))
-        end
-        it 'loads an empty array' do
-          assert_equal([], schema_instance_json_coder.load([]))
-        end
-        it 'loads a not an array' do
-          assert_raises(TypeError) do
-            schema_instance_json_coder.load(Object.new)
-          end
-        end
-      end
-      describe 'array schema' do
-        let(:schema) { {items: {properties: {foo: {}, bar: {}}}} }
-        it 'loads an array of hashes' do
-          data = [{"foo" => "bar"}, {"foo" => "baz"}]
-          assert_equal(schema_instance_class.new([{'foo' => 'bar'}, {'foo' => 'baz'}]), schema_instance_json_coder.load(data))
-        end
-        it 'loads an empty array' do
-          assert_equal(schema_instance_class.new([]), schema_instance_json_coder.load([]))
-        end
-        it 'loads a not an array' do
-          instance = Object.new
-          assert_equal(schema_instance_class.new(instance), schema_instance_json_coder.load(instance))
-        end
-      end
-    end
-    describe 'dump' do
-      it 'dumps nil' do
-        assert_nil(schema_instance_json_coder.dump(nil))
-      end
-      it 'dumps a schema_instance_class' do
-        assert_equal({"foo" => "x", "bar" => "y"}, schema_instance_json_coder.dump(schema_instance_class.new(foo: 'x', bar: 'y')))
-      end
-      it 'dumps something else' do
-        assert_raises(TypeError) do
-          schema_instance_json_coder.dump(Object.new)
-        end
-      end
-      it 'dumps some of the keys of a schema_instance_class after loading in a partial one' do
-        schema_instance_class = schema_instance_json_coder.load({'foo' => 'who'})
-        assert_equal({'foo' => 'who'}, schema_instance_json_coder.dump(schema_instance_class))
-        schema_instance_class.bar = 'whar'
-        assert_equal({'foo' => 'who', 'bar' => 'whar'}, schema_instance_json_coder.dump(schema_instance_class))
-      end
-      describe 'array' do
-        let(:options) { {array: true} }
-        it 'dumps an array of schema_instances' do
-          schema_instances = [schema_instance_class.new(foo: 'x', bar: 'y'), schema_instance_class.new(foo: 'z', bar: 'q')]
-          assert_equal([{"foo" => "x", "bar" => "y"}, {"foo" => "z", "bar" => "q"}], schema_instance_json_coder.dump(schema_instances))
-        end
-      end
-      describe 'array schema' do
-        let(:schema) { {items: {properties: {foo: {}, bar: {}}}} }
-        it 'dumps a schema_instance array' do
-          schema_instances = schema_instance_class.new([{foo: 'x', bar: 'y'}, {foo: 'z', bar: 'q'}])
-          assert_equal([{"foo" => "x", "bar" => "y"}, {"foo" => "z", "bar" => "q"}], schema_instance_json_coder.dump(schema_instances))
-        end
-      end
-    end
-  end
-end

data/test/jsi_json_arraynode_test.rb

@@ -1,150 +0,0 @@
-require_relative 'test_helper'
-
-document_types = [
-  {
-    make_document: -> (d) { d },
-    document: ['a', ['b', 'q'], {'c' => {'d' => 'e'}}],
-    type_desc: 'Array',
-  },
-  {
-    make_document: -> (d) { SortOfArray.new(d) },
-    document: SortOfArray.new(['a', SortOfArray.new(['b', 'q']), SortOfHash.new({'c' => SortOfHash.new({'d' => 'e'})})]),
-    type_desc: 'sort of Array-like',
-  },
-]
-document_types.each do |document_type|
-  describe "JSI::JSON::ArrayNode with #{document_type[:type_desc]}" do
-    # document of the node being tested
-    let(:document) { document_type[:document] }
-    # by default the node is the whole document
-    let(:path) { [] }
-    let(:pointer) { JSI::JSON::Pointer.new(path) }
-    # the node being tested
-    let(:node) { JSI::JSON::Node.new_by_type(document, pointer) }
-
-    describe '#[] bad index' do
-      it 'improves TypeError for Array subsript' do
-        err = assert_raises(TypeError) do
-          node[:x]
-        end
-        assert_match(/^subscripting with :x \(Symbol\) from Array. content is: \[.*\]\z/m, err.message)
-      end
-    end
-    describe '#each' do
-      it 'iterates, one argument' do
-        out = []
-        node.each do |arg|
-          out << arg
-        end
-        assert_instance_of(JSI::JSON::ArrayNode, node[1])
-        assert_instance_of(JSI::JSON::HashNode, node[2])
-        assert_equal(['a', node[1], node[2]], out)
-      end
-      it 'returns self' do
-        assert_equal(node.each { }.object_id, node.object_id)
-      end
-      it 'returns an enumerator when called with no block' do
-        enum = node.each
-        assert_instance_of(Enumerator, enum)
-        assert_equal(['a', node[1], node[2]], enum.to_a)
-      end
-    end
-    describe '#to_ary' do
-      it 'returns a Array with Nodes in' do
-        assert_instance_of(Array, node.to_ary)
-        assert_equal(['a', node[1], node[2]], node.to_ary)
-      end
-    end
-    describe '#as_json' do
-      let(:document) { document_type[:make_document].call(['a', 'b']) }
-      it '#as_json' do
-        assert_equal(['a', 'b'], node.as_json)
-        assert_equal(['a', 'b'], node.as_json(some_option: false))
-      end
-    end
-    # these methods just delegate to Array so not going to test excessively
-    describe 'index only methods' do
-      it('#each_index') { assert_equal([0, 1, 2], node.each_index.to_a) }
-      it('#empty?')     { assert_equal(false, node.empty?) }
-      it('#length')     { assert_equal(3, node.length) }
-      it('#size')       { assert_equal(3, node.size) }
-    end
-    describe 'index + element methods' do
-      it('#|')                    { assert_equal(['a', node[1], node[2], 0], node | [0]) }
-      it('#&')                    { assert_equal(['a'], node & ['a']) }
-      it('#*')                    { assert_equal(node.to_a, node * 1) }
-      it('#+')                    { assert_equal(node.to_a, node + []) }
-      it('#-')                    { assert_equal([node[1], node[2]], node - ['a']) }
-      it('#<=>')                  { assert_equal(1, node <=> []) }
-      it('#<=>')                  { assert_equal(-1, [] <=> node) }
-      require 'abbrev'
-      it('#abbrev')               { assert_equal({'a' => 'a'}, JSI::JSON::Node.new_doc(['a']).abbrev) }
-      it('#assoc')                { assert_equal(['b', 'q'], node.assoc('b')) }
-      it('#at')                   { assert_equal('a', node.at(0)) }
-      it('#bsearch')              { assert_equal(nil, node.bsearch { false }) }
-      it('#bsearch_index')        { assert_equal(nil, node.bsearch_index { false }) } if [].respond_to?(:bsearch_index)
-      it('#combination')          { assert_equal([['a'], [node[1]], [node[2]]], node.combination(1).to_a) }
-      it('#count')                { assert_equal(1, node.count('a')) }
-      it('#cycle')                { assert_equal(node.to_a, node.cycle(1).to_a) }
-      it('#dig')                  { assert_equal('e', node.dig(2, 'c', 'd')) } if [].respond_to?(:dig)
-      it('#drop')                 { assert_equal([node[2]], node.drop(2)) }
-      it('#drop_while')           { assert_equal([node[1], node[2]], node.drop_while { |e| e == 'a' }) }
-      it('#fetch')                { assert_equal('a', node.fetch(0)) }
-      it('#find_index')           { assert_equal(0, node.find_index { true }) }
-      it('#first')                { assert_equal('a', node.first) }
-      it('#include?')             { assert_equal(true, node.include?('a')) }
-      it('#index')                { assert_equal(0, node.index('a')) }
-      it('#join')                 { assert_equal('a b', JSI::JSON::Node.new_doc(['a', 'b']).join(' ')) }
-      it('#last')                 { assert_equal(node[2], node.last) }
-      it('#pack')                 { assert_equal(' ', JSI::JSON::Node.new_doc([32]).pack('c')) }
-      it('#permutation')          { assert_equal([['a'], [node[1]], [node[2]]], node.permutation(1).to_a) }
-      it('#product')              { assert_equal([], node.product([])) }
-      # due to differences in implementation between #assoc and #rassoc, the reason for which
-      # I cannot begin to fathom, assoc works but rassoc does not because rassoc has different
-      # type checking than assoc for the array(like) array elements.
-      # compare:
-      # assoc:  https://github.com/ruby/ruby/blob/v2_5_0/array.c#L3780-L3813
-      # rassoc: https://github.com/ruby/ruby/blob/v2_5_0/array.c#L3815-L3847
-      # for this reason, rassoc is NOT defined on Arraylike. it's here with as_json.
-      #
-      # I've never even seen anybody use rassoc. of all the methods to put into the standard library ...
-      it('#rassoc')              { assert_equal(['b', 'q'], node.as_json.rassoc('q')) }
-      it('#repeated_combination') { assert_equal([[]], node.repeated_combination(0).to_a) }
-      it('#repeated_permutation') { assert_equal([[]], node.repeated_permutation(0).to_a) }
-      it('#reverse')             { assert_equal([node[2], node[1], 'a'], node.reverse) }
-      it('#reverse_each')       { assert_equal([node[2], node[1], 'a'], node.reverse_each.to_a) }
-      it('#rindex')            { assert_equal(0, node.rindex('a')) }
-      it('#rotate')           { assert_equal([node[1], node[2], 'a'], node.rotate) }
-      it('#sample')          { assert_equal('a', JSI::JSON::Node.new_doc(['a']).sample) }
-      it('#shelljoin')      { assert_equal('a', JSI::JSON::Node.new_doc(['a']).shelljoin) } if [].respond_to?(:shelljoin)
-      it('#shuffle')       { assert_equal(3, node.shuffle.size) }
-      it('#slice')        { assert_equal(['a'], node.slice(0, 1)) }
-      it('#sort')        { assert_equal(['a'], JSI::JSON::Node.new_doc(['a']).sort) }
-      it('#take')       { assert_equal(['a'], node.take(1)) }
-      it('#take_while') { assert_equal([], node.take_while { false }) }
-      it('#transpose') { assert_equal([], JSI::JSON::Node.new_doc([]).transpose) }
-      it('#uniq')     { assert_equal(node.to_a, node.uniq) }
-      it('#values_at') { assert_equal(['a'], node.values_at(0)) }
-      it('#zip')      { assert_equal([['a', 'a'], [node[1], node[1]], [node[2], node[2]]], node.zip(node)) }
-    end
-    describe 'modified copy methods' do
-      it('#reject')  { assert_equal(JSI::JSON::Node.new_doc(['a']), node.reject { |e| e != 'a' }) }
-      it('#select')  { assert_equal(JSI::JSON::Node.new_doc(['a']), node.select { |e| e == 'a' }) }
-      it('#compact') { assert_equal(JSI::JSON::Node.new_doc(node.content.to_ary), node.compact) }
-      describe 'at a depth' do
-        let(:document) { document_type[:make_document].call([['b', 'q'], {'c' => ['d', 'e']}]) }
-        let(:path) { ['1', 'c'] }
-        it('#select') do
-          selected = node.select { |e| e == 'd' }
-          equivalent = JSI::JSON::Node.new_by_type([['b', 'q'], {'c' => ['d']}], pointer)
-          assert_equal(equivalent, selected)
-        end
-      end
-    end
-    JSI::Arraylike::DESTRUCTIVE_METHODS.each do |destructive_method_name|
-      it("does not respond to destructive method #{destructive_method_name}") do
-        assert(!node.respond_to?(destructive_method_name))
-      end
-    end
-  end
-end

data/test/jsi_json_hashnode_test.rb

@@ -1,132 +0,0 @@
-require_relative 'test_helper'
-
-document_types = [
-  {
-    make_document: -> (d) { d },
-    document: {'a' => 'b', 'c' => {'d' => 'e'}},
-    type_desc: 'Hash',
-  },
-  {
-    make_document: -> (d) { SortOfHash.new(d) },
-    document: SortOfHash.new({'a' => 'b', 'c' => SortOfHash.new({'d' => 'e'})}),
-    type_desc: 'sort of Hash-like',
-  },
-]
-document_types.each do |document_type|
-  describe "JSI::JSON::HashNode with #{document_type[:type_desc]}" do
-    # document of the node being tested
-    let(:document) { document_type[:document] }
-    # by default the node is the whole document
-    let(:path) { [] }
-    let(:pointer) { JSI::JSON::Pointer.new(path) }
-    # the node being tested
-    let(:node) { JSI::JSON::Node.new_by_type(document, pointer) }
-
-    describe '#each' do
-      it 'iterates, one argument' do
-        out = []
-        node.each do |arg|
-          out << arg
-        end
-        assert_instance_of(JSI::JSON::HashNode, node['c'])
-        assert_equal([['a', 'b'], ['c', node['c']]], out)
-      end
-      it 'iterates, two arguments' do
-        out = []
-        node.each do |k, v|
-          out << [k, v]
-        end
-        assert_instance_of(JSI::JSON::HashNode, node['c'])
-        assert_equal([['a', 'b'], ['c', node['c']]], out)
-      end
-      it 'returns self' do
-        assert_equal(node.each { }.object_id, node.object_id)
-      end
-      it 'returns an enumerator when called with no block' do
-        enum = node.each
-        assert_instance_of(Enumerator, enum)
-        assert_equal([['a', 'b'], ['c', node['c']]], enum.to_a)
-      end
-    end
-    describe '#to_hash' do
-      it 'returns a Hash with Nodes in' do
-        assert_instance_of(Hash, node.to_hash)
-        assert_equal({'a' => 'b', 'c' => node['c']}, node.to_hash)
-      end
-    end
-    describe '#merge' do
-      let(:document) { document_type[:make_document].call({'a' => {'b' => 0}, 'c' => {'d' => 'e'}}) }
-      # testing the node at 'c' here, merging a hash at a path within a document.
-      let(:path) { ['c'] }
-      it 'merges' do
-        merged = node.merge('x' => 'y')
-        # check the content at 'c' was merged with the remainder of the document intact (at 'a')
-        assert_equal({'a' => {'b' => 0}, 'c' => {'d' => 'e', 'x' => 'y'}}, merged.document)
-        # check the original node retains its original document
-        assert_equal(document_type[:make_document].call({'a' => {'b' => 0}, 'c' => {'d' => 'e'}}), node.document)
-        # check that unnecessary copies of unaffected parts of the document were not made
-        assert_equal(node.document.to_hash['a'].object_id, merged.document['a'].object_id)
-      end
-    end
-    describe '#as_json' do
-      let(:document) { document_type[:make_document].call({'a' => 'b'}) }
-      it '#as_json' do
-        assert_equal({'a' => 'b'}, node.as_json)
-        assert_equal({'a' => 'b'}, node.as_json(this_option: 'what?'))
-      end
-    end
-    # these methods just delegate to Hash so not going to test excessively
-    describe 'key only methods' do
-      it('#each_key') { assert_equal(['a', 'c'], node.each_key.to_a) }
-      it('#empty?')   { assert_equal(false, node.empty?) }
-      it('#has_key?') { assert_equal(true, node.has_key?('a')) }
-      it('#include?') { assert_equal(false, node.include?('q')) }
-      it('#key?')    { assert_equal(true, node.key?('c')) }
-      it('#keys')   { assert_equal(['a', 'c'], node.keys) }
-      it('#length') { assert_equal(2, node.length) }
-      it('#member?') { assert_equal(false, node.member?(0)) }
-      it('#size')   { assert_equal(2, node.size) }
-    end
-    describe 'key + value methods' do
-      it('#<')  { assert_equal(true, node < {'a' => 'b', 'c' => node['c'], 'x' => 'y'}) } if {}.respond_to?(:<)
-      it('#<=')  { assert_equal(true, node <= node) } if {}.respond_to?(:<=)
-      it('#>')    { assert_equal(true, node > {}) } if {}.respond_to?(:>)
-      it('#>=')    { assert_equal(false, node >= {'foo' => 'bar'}) } if {}.respond_to?(:>=)
-      it('#any?')   { assert_equal(false, node.any? { |k, v| v == 3 }) }
-      it('#assoc')   { assert_equal(['a', 'b'], node.assoc('a')) }
-      it('#dig')      { assert_equal('e', node.dig('c', 'd')) } if {}.respond_to?(:dig)
-      it('#each_pair') { assert_equal([['a', 'b'], ['c', node['c']]], node.each_pair.to_a) }
-      it('#each_value') { assert_equal(['b', node['c']], node.each_value.to_a) }
-      it('#fetch')       { assert_equal('b', node.fetch('a')) }
-      it('#fetch_values') { assert_equal(['b'], node.fetch_values('a')) } if {}.respond_to?(:fetch_values)
-      it('#has_value?')  { assert_equal(true, node.has_value?('b')) }
-      it('#invert')     { assert_equal({'b' => 'a', node['c'] => 'c'}, node.invert) }
-      it('#key')       { assert_equal('a', node.key('b')) }
-      it('#rassoc')   { assert_equal(['a', 'b'], node.rassoc('b')) }
-      it('#to_h')    { assert_equal({'a' => 'b', 'c' => node['c']}, node.to_h) }
-      it('#to_proc') { assert_equal('b', node.to_proc.call('a')) } if {}.respond_to?(:to_proc)
-      if {}.respond_to?(:transform_values)
-        it('#transform_values') { assert_equal({'a' => nil, 'c' => nil}, node.transform_values { |_| nil }) }
-      end
-      it('#value?')  { assert_equal(false, node.value?('0')) }
-      it('#values')   { assert_equal(['b', node['c']], node.values) }
-      it('#values_at') { assert_equal(['b'], node.values_at('a')) }
-    end
-    describe 'modified copy methods' do
-      # I'm going to rely on the #merge test above to test the modified copy functionality and just do basic
-      # tests of all the modified copy methods here
-      it('#merge') { assert_equal(JSI::JSON::Node.new_doc(node.content), node.merge({})) }
-      it('#reject') { assert_equal(JSI::JSON::Node.new_doc({}), node.reject { true }) }
-      it('#select') { assert_equal(JSI::JSON::Node.new_doc({}), node.select { false }) }
-      # Hash#compact only available as of ruby 2.5.0
-      if {}.respond_to?(:compact)
-        it('#compact') { assert_equal(JSI::JSON::Node.new_doc({"a" => "b", "c" => node.content.to_hash["c"]}), node.compact) }
-      end
-    end
-    JSI::Hashlike::DESTRUCTIVE_METHODS.each do |destructive_method_name|
-      it("does not respond to destructive method #{destructive_method_name}") do
-        assert(!node.respond_to?(destructive_method_name))
-      end
-    end
-  end
-end