jsi 0.0.1

data/test/jsi_test.rb

@@ -0,0 +1,11 @@
+require_relative 'test_helper'
+
+class JSITest < Minitest::Test
+  def test_that_it_has_a_version_number
+    refute_nil ::JSI::VERSION
+  end
+
+  def test_it_does_something_useful
+    assert true
+  end
+end

data/test/schema_instance_json_coder_test.rb

@@ -0,0 +1,122 @@
+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

@@ -0,0 +1,130 @@
+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

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+require 'coveralls'
+if Coveralls.will_run?
+  Coveralls.wear!
+end
+
+require 'simplecov'
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'jsi'
+
+# NO EXPECTATIONS 
+ENV["MT_NO_EXPECTATIONS"] = ''
+
+require 'minitest/autorun'
+require 'minitest/around/spec'
+require 'minitest/reporters'
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+require 'byebug'
+
+class JSISpec < Minitest::Spec
+  def assert_equal exp, act, msg = nil
+    msg = message(msg, E) { diff exp, act }
+    assert exp == act, msg
+  end
+end
+
+# register this to be the base class for specs instead of Minitest::Spec
+Minitest::Spec.register_spec_type(//, JSISpec)

data/test/util_test.rb

@@ -0,0 +1,62 @@
+require_relative 'test_helper'
+
+describe JSI::Util do
+  describe '.stringify_symbol_keys' do
+    it 'stringifies symbol hash keys' do
+      assert_equal({'a' => 'b', 'c' => 'd', nil => 3}, JSI.stringify_symbol_keys({a: 'b', 'c' => 'd', nil => 3}))
+    end
+    it 'stringifies HashNode keys' do
+      actual = JSI.stringify_symbol_keys(JSI::JSON::HashNode.new({a: 'b', 'c' => 'd', nil => 3}, []))
+      expected = JSI::JSON::HashNode.new({'a' => 'b', 'c' => 'd', nil => 3}, [])
+      assert_equal(expected, actual)
+    end
+    it 'stringifies SchemaObjectBase hash keys' do
+      klass = JSI.class_for_schema(type: 'object')
+      expected = JSI.stringify_symbol_keys(klass.new(JSI::JSON::HashNode.new({a: 'b', 'c' => 'd', nil => 3}, [])))
+      actual = klass.new(JSI::JSON::HashNode.new({'a' => 'b', 'c' => 'd', nil => 3}, []))
+      assert_equal(expected, actual)
+    end
+    describe 'non-hash-like argument' do
+      it 'errors' do
+        err = assert_raises(ArgumentError) { JSI.stringify_symbol_keys(nil) }
+        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(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(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)
+      end
+    end
+  end
+  describe '.deep_stringify_symbol_keys' do
+    it 'stringifies symbol hash keys' do
+      actual = JSI.deep_stringify_symbol_keys({
+        a: 'b',
+        'c' => [
+          {d: true},
+          [{'e' => 0}],
+        ],
+        nil => 3,
+      })
+      expected = {
+        'a' => 'b',
+        'c' => [
+          {'d' => true},
+          [{'e' => 0}],
+        ],
+        nil => 3,
+      }
+      assert_equal(expected, actual)
+    end
+    it 'deep stringifies HashNode keys' do
+      actual = JSI.deep_stringify_symbol_keys(JSI::JSON::HashNode.new({a: 'b', 'c' => {d: 0}, nil => 3}, []))
+      expected = JSI::JSON::HashNode.new({'a' => 'b', 'c' => {'d' => 0}, nil => 3}, [])
+      assert_equal(expected, actual)
+    end
+    it 'deep stringifies SchemaObjectBase instance on initialize' do
+      klass = JSI.class_for_schema(type: 'object')
+      expected = klass.new(JSI::JSON::HashNode.new({a: 'b', 'c' => {d: 0}, nil => 3}, []))
+      actual = klass.new(JSI::JSON::HashNode.new({'a' => 'b', 'c' => {'d' => 0}, nil => 3}, []))
+      assert_equal(expected, actual)
+    end
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: jsi
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ethan
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-around
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: JSI represents json-schemas as ruby classes and json-schema instances
+  as instances of those classes
+email:
+- ethan@unth
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".simplecov"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile.rb
+- jsi.gemspec
+- lib/jsi.rb
+- lib/jsi/base.rb
+- lib/jsi/base/to_rb.rb
+- lib/jsi/json-schema-fragments.rb
+- lib/jsi/json.rb
+- lib/jsi/json/node.rb
+- lib/jsi/schema.rb
+- lib/jsi/schema_instance_json_coder.rb
+- lib/jsi/struct_json_coder.rb
+- lib/jsi/typelike_modules.rb
+- lib/jsi/util.rb
+- lib/jsi/version.rb
+- test/base_array_test.rb
+- test/base_hash_test.rb
+- test/base_test.rb
+- test/jsi_json_arraynode_test.rb
+- test/jsi_json_hashnode_test.rb
+- test/jsi_json_node_test.rb
+- test/jsi_test.rb
+- test/schema_instance_json_coder_test.rb
+- test/struct_json_coder_test.rb
+- test/test_helper.rb
+- test/util_test.rb
+homepage: https://github.com/notEthan/jsi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: 'JSI: JSON-Schema instantiation'
+test_files:
+- test/base_array_test.rb
+- test/base_hash_test.rb
+- test/base_test.rb
+- test/jsi_json_arraynode_test.rb
+- test/jsi_json_hashnode_test.rb
+- test/jsi_json_node_test.rb
+- test/jsi_test.rb
+- test/schema_instance_json_coder_test.rb
+- test/struct_json_coder_test.rb
+- test/test_helper.rb
+- test/util_test.rb