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

jsi 0.0.4 → 0.4.0

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