RubyGems - jsi - Versions diffs - 0.0.4 → 0.4.0 - Mend

jsi 0.0.4 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (47) hide show

checksums.yaml +4 -4
data/.simplecov +3 -1
data/CHANGELOG.md +48 -0
data/LICENSE.md +613 -0
data/README.md +84 -45
data/jsi.gemspec +11 -14
data/lib/jsi.rb +31 -12
data/lib/jsi/base.rb +310 -344
data/lib/jsi/base/to_rb.rb +2 -0
data/lib/jsi/jsi_coder.rb +91 -0
data/lib/jsi/json-schema-fragments.rb +3 -135
data/lib/jsi/json.rb +3 -0
data/lib/jsi/json/node.rb +72 -197
data/lib/jsi/json/pointer.rb +419 -0
data/lib/jsi/metaschema.rb +7 -0
data/lib/jsi/metaschema_node.rb +218 -0
data/lib/jsi/pathed_node.rb +118 -0
data/lib/jsi/schema.rb +168 -223
data/lib/jsi/schema_classes.rb +158 -0
data/lib/jsi/simple_wrap.rb +12 -0
data/lib/jsi/typelike_modules.rb +71 -45
data/lib/jsi/util.rb +47 -57
data/lib/jsi/version.rb +1 -1
data/lib/schemas/json-schema.org/draft-04/schema.rb +7 -0
data/lib/schemas/json-schema.org/draft-06/schema.rb +7 -0
data/resources/icons/AGPL-3.0.png +0 -0
data/test/base_array_test.rb +210 -84
data/test/base_hash_test.rb +201 -58
data/test/base_test.rb +212 -121
data/test/jsi_coder_test.rb +85 -0
data/test/jsi_json_arraynode_test.rb +26 -25
data/test/jsi_json_hashnode_test.rb +40 -39
data/test/jsi_json_node_test.rb +95 -126
data/test/jsi_json_pointer_test.rb +102 -0
data/test/jsi_typelike_as_json_test.rb +53 -0
data/test/metaschema_node_test.rb +19 -0
data/test/schema_module_test.rb +21 -0
data/test/schema_test.rb +109 -97
data/test/spreedly_openapi_test.rb +8 -0
data/test/test_helper.rb +42 -8
data/test/util_test.rb +14 -14
metadata +54 -25
data/LICENSE.txt +0 -21
data/lib/jsi/schema_instance_json_coder.rb +0 -83
data/lib/jsi/struct_json_coder.rb +0 -30
data/test/schema_instance_json_coder_test.rb +0 -121
data/test/struct_json_coder_test.rb +0 -130

data/test/schema_instance_json_coder_test.rb DELETED

@@ -1,121 +0,0 @@
-require_relative 'test_helper'
-describe JSI::SchemaInstanceJSONCoder do
-  let(:schema_instance_class) { JSI.class_for_schema(properties: {foo: {}, bar: {}}) }
-  let(:options) { {} }
-  let(:schema_instance_json_coder) { JSI::SchemaInstanceJSONCoder.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
-    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
-    end
-  end
-  describe 'string' do
-    let(:options) { {string: true} }
-    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
-      it 'loads something that is not a json string' do
-        assert_raises(::JSON::ParserError) do
-          schema_instance_json_coder.load('??')
-        end
-      end
-      describe 'array' do
-        let(:options) { {string: true, 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('{}')
-          end
-        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) { {string: true, 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
-    end
-  end
-end

data/test/struct_json_coder_test.rb DELETED

@@ -1,130 +0,0 @@
-require_relative 'test_helper'
-describe JSI::StructJSONCoder do
-  let(:struct) { Struct.new(:foo, :bar) }
-  let(:options) { {} }
-  let(:struct_json_coder) { JSI::StructJSONCoder.new(struct, options) }
-  describe 'json' do
-    describe 'load' do
-      it 'loads nil' do
-        assert_nil(struct_json_coder.load(nil))
-      end
-      it 'loads a hash' do
-        assert_equal(struct.new('bar'), struct_json_coder.load({"foo" => "bar"}))
-      end
-      it 'loads something else' do
-        assert_raises(JSI::StructJSONCoder::LoadError) do
-          struct_json_coder.load([[]])
-        end
-      end
-      it 'loads unrecognized keys' do
-        assert_raises(JSI::StructJSONCoder::LoadError) do
-          struct_json_coder.load({"uhoh" => "spaghettio"})
-        end
-      end
-      describe 'array' do
-        let(:options) { {array: true} }
-        it 'loads an array of hashes' do
-          data = [{"foo" => "bar"}, {"foo" => "baz"}]
-          assert_equal([struct.new('bar'), struct.new('baz')], struct_json_coder.load(data))
-        end
-        it 'loads an empty array' do
-          assert_equal([], struct_json_coder.load([]))
-        end
-      end
-    end
-    describe 'dump' do
-      it 'dumps nil' do
-        assert_nil(struct_json_coder.dump(nil))
-      end
-      it 'dumps a struct' do
-        assert_equal({"foo" => "x", "bar" => "y"}, struct_json_coder.dump(struct.new('x', 'y')))
-      end
-      it 'dumps something else' do
-        assert_raises(TypeError) do
-          struct_json_coder.dump(Object.new)
-        end
-      end
-      it 'dumps all the keys of a struct after loading in a partial one' do
-        struct = struct_json_coder.load({'foo' => 'who'})
-        assert_equal({'foo' => 'who', 'bar' => nil}, struct_json_coder.dump(struct))
-        struct.bar = 'whar'
-        assert_equal({'foo' => 'who', 'bar' => 'whar'}, struct_json_coder.dump(struct))
-      end
-      describe 'array' do
-        let(:options) { {array: true} }
-        it 'dumps an array of structs' do
-          structs = [struct.new('x', 'y'), struct.new('z', 'q')]
-          assert_equal([{"foo" => "x", "bar" => "y"}, {"foo" => "z", "bar" => "q"}], struct_json_coder.dump(structs))
-        end
-      end
-    end
-  end
-  describe 'string' do
-    let(:options) { {string: true} }
-    describe 'load' do
-      it 'loads nil' do
-        assert_nil(struct_json_coder.load(nil))
-      end
-      it 'loads a hash' do
-        assert_equal(struct.new('bar'), struct_json_coder.load('{"foo": "bar"}'))
-      end
-      it 'loads something else' do
-        assert_raises(JSI::StructJSONCoder::LoadError) do
-          struct_json_coder.load('[[]]')
-        end
-      end
-      it 'loads something that is not a json string' do
-        assert_raises(JSON::ParserError) do
-          struct_json_coder.load('??')
-        end
-      end
-      it 'loads unrecognized keys' do
-        assert_raises(JSI::StructJSONCoder::LoadError) do
-          struct_json_coder.load('{"uhoh": "spaghettio"}')
-        end
-      end
-      describe 'array' do
-        let(:options) { {string: true, array: true} }
-        it 'loads an array of hashes' do
-          data = '[{"foo": "bar"}, {"foo": "baz"}]'
-          assert_equal([struct.new('bar'), struct.new('baz')], struct_json_coder.load(data))
-        end
-        it 'loads an empty array' do
-          assert_equal([], struct_json_coder.load('[]'))
-        end
-        it 'loads a not an array' do
-          assert_raises(TypeError) do
-            struct_json_coder.load('{}')
-          end
-        end
-      end
-    end
-    describe 'dump' do
-      it 'dumps nil' do
-        assert_nil(struct_json_coder.dump(nil))
-      end
-      it 'dumps a struct' do
-        assert_equal('{"foo":"x","bar":"y"}', struct_json_coder.dump(struct.new('x', 'y')))
-      end
-      it 'dumps something else' do
-        assert_raises(TypeError) do
-          struct_json_coder.dump(Object.new)
-        end
-      end
-      it 'dumps all the keys of a struct after loading in a partial one' do
-        struct = struct_json_coder.load('{"foo": "who"}')
-        assert_equal("{\"foo\":\"who\",\"bar\":null}", struct_json_coder.dump(struct))
-        struct.bar = 'whar'
-        assert_equal("{\"foo\":\"who\",\"bar\":\"whar\"}", struct_json_coder.dump(struct))
-      end
-      describe 'array' do
-        let(:options) { {string: true, array: true} }
-        it 'dumps an array of structs' do
-          structs = [struct.new('x', 'y'), struct.new('z', 'q')]
-          assert_equal('[{"foo":"x","bar":"y"},{"foo":"z","bar":"q"}]', struct_json_coder.dump(structs))
-        end
-      end
-    end
-  end
-end