jsi 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 898a2aae157baa1fc01f6e3e28286f4b6fc9be61b7e47689529acdfdbc8c9c17
-  data.tar.gz: 9328c06ac1cc07993f27644b3c94b87b1667be06b6404af2ce5753fb7dc3da1a
+  metadata.gz: e9899a9ae6a661558974001eba14223c9e497849d3bf3d8e3c6ee9fffd4fcc6d
+  data.tar.gz: 8cfcc01a0167bc251235d7376e793e50bdba92e39f706edbb7bd05386a035352
 SHA512:
-  metadata.gz: 874021cfce6aa05353a897d8519cf319ce0de3fc1a2176cefcc7505eddd8960a2525bbb484a0a3fcaa81ac030768a0d64337f1a3f86e6fbb13403ffbdb13eadc
-  data.tar.gz: e67feab1a13a2a23ed51ad75d7622ab9f7093b3dbf0cb79d896f1bd56e6f1f0deb322151b8b7529226a111124de01dceeb4f9981759b358ab78d50b337e2cbef
+  metadata.gz: e4ed68443ce9a25db4ddeb18c80f4aea51b4dbb819600afc98c30ab6453ddf8dbc7589079cb7e6743802a31cc4ec53bc32b1da6796a10334e8cc2b6182d37cd4
+  data.tar.gz: 64e8c93a243bc54e0226b8020e20b475c151d349d0b2769bf745b0ba6019f31cf6de63c4edaa36baea89da790814654e92c68154c5a63ade881bef4a18fac133

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# v0.1.0
+
+- JSI::JSON::Pointer replaces monkey-patched-in ::JSON::Schema::Pointer
+- JSI::JSICoder replaces JSI::SchemaInstanceJSONCoder / ObjectJSONCoder
+- remove JSI::StructJSONCoder
+- misc improvements to code, doc, tests
+
 # v0.0.4
 
 - minor bugfixes / improvements

data/README.md

@@ -48,7 +48,7 @@ bill = Contact.new('name' => 'bill', 'phone' => [{'location' => 'home', 'number'
 
 Note that the keys are strings. JSI, being designed with JSON in mind, is geared toward string keys. Symbol keys will not match to schema properties, and so act the same as any other key not recognized from the schema.
 
-The nested classes can be seen as `JSI::SchemaClasses[schema_id]` where schema_id is a generated value.
+The nested classes can be seen in the #inspect output as `JSI::SchemaClasses[schema_id]` where schema_id is a generated value.
 
 We get accessors for the Contact:
 
@@ -169,16 +169,18 @@ Let's say you're sticking to json types in the database - you have to do so if y
 
 But if your database contains json, then your deserialized objects in ruby are likewise Hash / Array / basic types. You have to use subscripts instead of accessors, and you don't have any way to add methods to your data types.
 
-JSI gives you the best of both with SchemaInstanceJSONCoder. The objects in your database are simple json types, and your ruby classes are extensible and have the accessors you get from a JSI class hierarchy. Here's an example:
+JSI gives you the best of both with JSICoder. This coder dumps objects which are simple json types, and loads instances of a specified JSI class. Here's an example:
 
 ```ruby
 class User < ActiveRecord::Base
-  serialize :contacts, JSI::SchemaInstanceJSONCoder.new(Contact, array: true)
+  serialize :contact_info, JSI::JSICoder.new(Contact)
 end
 ```
 
 Now `user.contacts` will return an array of Contact instances, from the json type in the database, with Contact's accessors, validations, and user-defined instance methods.
 
+See the gem [`arms`](https://github.com/notEthan/arms) if you wish to serialize the dumped JSON-compatible objects further as text.
+
 ## Keying Hashes (JSON Objects)
 
 Unlike Ruby, JSON only supports string keys. It is recommended to use strings as hash keys for all JSI instances, but JSI does not enforce this, nor does it do any key conversion. It should be possible to use ActiveSupport::HashWithIndifferentAccess as the instance of a JSI in order to gain the benefits that offers over a plain hash. This is not tested behavior, but JSI should behave correctly with any instance that responds to #to_hash.

data/lib/jsi.rb

@@ -18,9 +18,7 @@ module JSI
   autoload :BaseArray, 'jsi/base'
   autoload :BaseHash, 'jsi/base'
   autoload :SchemaClasses, 'jsi/base'
-  autoload :ObjectJSONCoder, 'jsi/schema_instance_json_coder'
-  autoload :StructJSONCoder, 'jsi/struct_json_coder'
-  autoload :SchemaInstanceJSONCoder, 'jsi/schema_instance_json_coder'
+  autoload :JSICoder, 'jsi/jsi_coder'
 
   # @return [Class subclassing JSI::Base] a JSI class which represents the
   #   given schema. instances of the class represent JSON Schema instances

data/lib/jsi/base.rb

@@ -15,6 +15,8 @@ module JSI
     include Enumerable
 
     class << self
+      attr_accessor :in_schema_classes
+
       # @return [String] absolute schema_id of the schema this class represents.
       #   see {Schema#schema_id}.
       def schema_id
@@ -23,10 +25,13 @@ module JSI
 
       # @return [String] a string representing the class, with schema_id
       def inspect
+        name # see #name for side effects
         if !respond_to?(:schema)
           super
-        elsif !name || name =~ /\AJSI::SchemaClasses::/
+        elsif in_schema_classes
           %Q(#{SchemaClasses.inspect}[#{schema_id.inspect}])
+        elsif !name
+          %Q(#<Class for Schema: #{schema_id}>)
         else
           %Q(#{name} (#{schema_id}))
         end
@@ -57,6 +62,7 @@ module JSI
       def name
         unless super || SchemaClasses.const_defined?(schema_classes_const_name)
           SchemaClasses.const_set(schema_classes_const_name, self)
+          self.in_schema_classes = true
         end
         super
       end

data/lib/jsi/jsi_coder.rb

@@ -0,0 +1,86 @@
+module JSI
+  # this is an ActiveRecord serialization coder intended to serialize between
+  # JSON-compatible objects on the database side, and a JSI instance loaded on
+  # the model attribute.
+  #
+  # on its own this coder is useful with a JSON database column. in order to
+  # serialize further to a string of JSON, or to YAML, the gem `arms` allows
+  # coders to be chained together. for example, for a table `foos` and a column
+  # `preferences_json` which is an actual json column, and `preferences_txt`
+  # which is a string:
+  #
+  #     Preferences = JSI.class_for_schema(preferences_json_schema)
+  #     class Foo < ActiveRecord::Base
+  #       # as a single serializer, loads a Preferences instance from a json column
+  #       serialize 'preferences', JSI::JSICoder.new(Preferences)
+  #
+  #       # for a text column, arms_serialize will go from JSI to JSON-compatible
+  #       # objects to a string. the symbol `:jsi` is a shortcut for JSI::JSICoder.
+  #       arms_serialize 'preferences', [:jsi, Preferences], :json
+  #     end
+  #
+  # the column data may be either a single instance of the loaded class
+  # (represented as one json object) or an array of them (represented as a json
+  # array of json objects), indicated by the keyword argument `array`.
+  class JSICoder
+    # @param loaded_class [Class] the JSI::Base subclass which #load will instantiate
+    # @param array [Boolean] whether the dumped data represent one instance of loaded_class,
+    #   or an array of them. note that it may be preferable to have loaded_class simply be
+    #   an array schema class.
+    def initialize(loaded_class, array: false)
+      @loaded_class = loaded_class
+      @array = array
+    end
+
+    # loads the database column to instances of #loaded_class
+    #
+    # @param data [Object, Array, nil] the dumped schema instance(s) of the JSI(s)
+    # @return [loaded_class instance, Array<loaded_class instance>, nil] the JSI or JSIs
+    #   containing the schema instance(s), or nil if data is nil
+    def load(data)
+      return nil if data.nil?
+      object = if @array
+        unless data.respond_to?(:to_ary)
+          raise TypeError, "expected array-like column data; got: #{data.class}: #{data.inspect}"
+        end
+        data.map { |el| load_object(el) }
+      else
+        load_object(data)
+      end
+      object
+    end
+
+    # @param object [loaded_class instance, Array<loaded_class instance>, nil] the JSI or array
+    #   of JSIs containing the schema instance(s)
+    # @return [Object, Array, nil] the schema instance(s) of the JSI(s), or nil if object is nil
+    def dump(object)
+      return nil if object.nil?
+      jsonifiable = begin
+        if @array
+          unless object.respond_to?(:to_ary)
+            raise(TypeError, "expected array-like attribute; got: #{object.class}: #{object.inspect}")
+          end
+          object.map do |el|
+            dump_object(el)
+          end
+        else
+          dump_object(object)
+        end
+      end
+      jsonifiable
+    end
+
+    private
+    # @param data [Object]
+    # @return [loaded_class]
+    def load_object(data)
+      @loaded_class.new(data)
+    end
+
+    # @param object [loaded_class]
+    # @return [Object]
+    def dump_object(object)
+      JSI::Typelike.as_json(object)
+    end
+  end
+end

data/lib/jsi/json-schema-fragments.rb

@@ -2,140 +2,6 @@ require "json-schema"
 
 # apply the changes from https://github.com/ruby-json-schema/json-schema/pull/382 
 
-# json-schema/pointer.rb
-require 'addressable/uri'
-
-module JSON
-  class Schema
-    # a JSON Pointer, as described by RFC 6901 https://tools.ietf.org/html/rfc6901
-    class Pointer
-      class Error < JSON::Schema::SchemaError
-      end
-      class PointerSyntaxError < Error
-      end
-      class ReferenceError < Error
-      end
-
-      # parse a fragment to an array of reference tokens
-      #
-      # #/foo/bar
-      #
-      # => ['foo', 'bar']
-      #
-      # #/foo%20bar
-      #
-      # => ['foo bar']
-      def self.parse_fragment(fragment)
-        fragment = Addressable::URI.unescape(fragment)
-        match = fragment.match(/\A#/)
-        if match
-          parse_pointer(match.post_match)
-        else
-          raise(PointerSyntaxError, "Invalid fragment syntax in #{fragment.inspect}: fragment must begin with #")
-        end
-      end
-
-      # parse a pointer to an array of reference tokens
-      #
-      # /foo
-      #
-      # => ['foo']
-      #
-      # /foo~0bar/baz~1qux
-      #
-      # => ['foo~bar', 'baz/qux']
-      def self.parse_pointer(pointer_string)
-        tokens = pointer_string.split('/', -1).map! do |piece|
-          piece.gsub('~1', '/').gsub('~0', '~')
-        end
-        if tokens[0] == ''
-          tokens[1..-1]
-        elsif tokens.empty?
-          tokens
-        else
-          raise(PointerSyntaxError, "Invalid pointer syntax in #{pointer_string.inspect}: pointer must begin with /")
-        end
-      end
-
-      # initializes a JSON::Schema::Pointer from the given representation.
-      #
-      # type may be one of:
-      #
-      # - :fragment - the representation is a fragment containing a pointer (starting with #)
-      # - :pointer - the representation is a pointer (starting with /)
-      # - :reference_tokens - the representation is an array of tokens referencing a path in a document
-      def initialize(type, representation)
-        @type = type
-        if type == :reference_tokens
-          reference_tokens = representation
-        elsif type == :fragment
-          reference_tokens = self.class.parse_fragment(representation)
-        elsif type == :pointer
-          reference_tokens = self.class.parse_pointer(representation)
-        else
-          raise ArgumentError, "invalid initialization type: #{type.inspect} with representation #{representation.inspect}"
-        end
-        @reference_tokens = reference_tokens.map(&:freeze).freeze
-      end
-
-      attr_reader :reference_tokens
-
-      # takes a root json document and evaluates this pointer through the document, returning the value
-      # pointed to by this pointer.
-      def evaluate(document)
-        res = reference_tokens.inject(document) do |value, token|
-          if value.respond_to?(:to_ary)
-            if token.is_a?(String) && token =~ /\A\d|[1-9]\d+\z/
-              token = token.to_i
-            end
-            unless token.is_a?(Integer)
-              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not an integer and cannot be resolved in array #{value.inspect}")
-            end
-            unless (0...(value.respond_to?(:size) ? value : value.to_ary).size).include?(token)
-              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid index of #{value.inspect}")
-            end
-            (value.respond_to?(:[]) ? value : value.to_ary)[token]
-          elsif value.respond_to?(:to_hash)
-            unless (value.respond_to?(:key?) ? value : value.to_hash).key?(token)
-              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid key of #{value.inspect}")
-            end
-            (value.respond_to?(:[]) ? value : value.to_hash)[token]
-          else
-            raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} cannot be resolved in #{value.inspect}")
-          end
-        end
-        res
-      end
-
-      # the pointer string representation of this Pointer
-      def pointer
-        reference_tokens.map { |t| '/' + t.to_s.gsub('~', '~0').gsub('/', '~1') }.join('')
-      end
-
-      # the fragment string representation of this Pointer
-      def fragment
-        '#' + Addressable::URI.escape(pointer)
-      end
-
-      def to_s
-        "#<#{self.class.inspect} #{@type} = #{representation_s}>"
-      end
-
-      private
-
-      def representation_s
-        if @type == :fragment
-          fragment
-        elsif @type == :pointer
-          pointer
-        else
-          reference_tokens.inspect
-        end
-      end
-    end
-  end
-end
-
 # json-schema/validator.rb
 
 module JSON
@@ -177,7 +43,7 @@ module JSON
     def schema_from_fragment(base_schema, fragment)
       schema_uri = base_schema.uri
 
-      pointer = JSON::Schema::Pointer.new(:fragment, fragment)
+      pointer = JSI::JSON::Pointer.new(:fragment, fragment)
 
       base_schema = JSON::Schema.new(pointer.evaluate(base_schema.schema), schema_uri, @options[:version])
 

data/lib/jsi/json.rb

@@ -3,5 +3,6 @@ module JSI
     autoload :Node, 'jsi/json/node'
     autoload :ArrayNode, 'jsi/json/node'
     autoload :HashNode, 'jsi/json/node'
+    autoload :Pointer, 'jsi/json/pointer'
   end
 end

data/lib/jsi/json/node.rb

@@ -52,14 +52,14 @@ module JSI
         end
         @document = document
         @path = path.to_ary.dup.freeze
-        @pointer = ::JSON::Schema::Pointer.new(:reference_tokens, path)
+        @pointer = JSI::JSON::Pointer.new(:reference_tokens, path)
       end
 
       # the path of this Node within its document
       attr_reader :path
       # the document containing this Node at is path
       attr_reader :document
-      # ::JSON::Schema::Pointer representing the path to this node within its document
+      # JSI::JSON::Pointer representing the path to this node within its document
       attr_reader :pointer
 
       # the raw content of this Node from the underlying document at this Node's path.
@@ -129,7 +129,7 @@ module JSI
         return self unless ref.is_a?(String)
 
         if ref[/\A#/]
-          return self.class.new_by_type(document, ::JSON::Schema::Pointer.parse_fragment(ref)).deref
+          return self.class.new_by_type(document, JSI::JSON::Pointer.parse_fragment(ref)).deref
         end
 
         # HAX for how google does refs and ids
@@ -153,10 +153,10 @@ module JSI
       end
 
       # the parent of this node. if this node is the document root (its path is empty), raises
-      # ::JSON::Schema::Pointer::ReferenceError.
+      # JSI::JSON::Pointer::ReferenceError.
       def parent_node
         if path.empty?
-          raise(::JSON::Schema::Pointer::ReferenceError, "cannot access parent of root node: #{pretty_inspect.chomp}")
+          raise(JSI::JSON::Pointer::ReferenceError, "cannot access parent of root node: #{pretty_inspect.chomp}")
         else
           Node.new_by_type(document, path[0...-1])
         end

data/lib/jsi/json/pointer.rb

@@ -0,0 +1,136 @@
+require 'addressable/uri'
+
+module JSI
+  module JSON
+    # a JSON Pointer, as described by RFC 6901 https://tools.ietf.org/html/rfc6901
+    class Pointer
+      class Error < StandardError
+      end
+      class PointerSyntaxError < Error
+      end
+      class ReferenceError < Error
+      end
+
+      # parse a fragment to an array of reference tokens
+      #
+      # #/foo/bar
+      #
+      # => ['foo', 'bar']
+      #
+      # #/foo%20bar
+      #
+      # => ['foo bar']
+      def self.parse_fragment(fragment)
+        fragment = Addressable::URI.unescape(fragment)
+        match = fragment.match(/\A#/)
+        if match
+          parse_pointer(match.post_match)
+        else
+          raise(PointerSyntaxError, "Invalid fragment syntax in #{fragment.inspect}: fragment must begin with #")
+        end
+      end
+
+      # parse a pointer to an array of reference tokens
+      #
+      # /foo
+      #
+      # => ['foo']
+      #
+      # /foo~0bar/baz~1qux
+      #
+      # => ['foo~bar', 'baz/qux']
+      def self.parse_pointer(pointer_string)
+        tokens = pointer_string.split('/', -1).map! do |piece|
+          piece.gsub('~1', '/').gsub('~0', '~')
+        end
+        if tokens[0] == ''
+          tokens[1..-1]
+        elsif tokens.empty?
+          tokens
+        else
+          raise(PointerSyntaxError, "Invalid pointer syntax in #{pointer_string.inspect}: pointer must begin with /")
+        end
+      end
+
+      # initializes a JSI::JSON::Pointer from the given representation.
+      #
+      # type may be one of:
+      #
+      # - :fragment - the representation is a fragment containing a pointer (starting with #)
+      # - :pointer - the representation is a pointer (starting with /)
+      # - :reference_tokens - the representation is an array of tokens referencing a path in a document
+      def initialize(type, representation)
+        @type = type
+        if type == :reference_tokens
+          reference_tokens = representation
+        elsif type == :fragment
+          reference_tokens = self.class.parse_fragment(representation)
+        elsif type == :pointer
+          reference_tokens = self.class.parse_pointer(representation)
+        else
+          raise ArgumentError, "invalid initialization type: #{type.inspect} with representation #{representation.inspect}"
+        end
+        @reference_tokens = reference_tokens.map(&:freeze).freeze
+      end
+
+      attr_reader :reference_tokens
+
+      # takes a root json document and evaluates this pointer through the document, returning the value
+      # pointed to by this pointer.
+      #
+      # @param document [#to_ary, #to_hash] the document against which we will evaluate this pointer
+      # @return [Object] the content of the document pointed to by this pointer
+      # @raise [JSI::JSON::Pointer::ReferenceError] the document does not contain the path this pointer references
+      def evaluate(document)
+        res = reference_tokens.inject(document) do |value, token|
+          if value.respond_to?(:to_ary)
+            if token.is_a?(String) && token =~ /\A\d|[1-9]\d+\z/
+              token = token.to_i
+            end
+            unless token.is_a?(Integer)
+              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not an integer and cannot be resolved in array #{value.inspect}")
+            end
+            unless (0...(value.respond_to?(:size) ? value : value.to_ary).size).include?(token)
+              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid index of #{value.inspect}")
+            end
+            (value.respond_to?(:[]) ? value : value.to_ary)[token]
+          elsif value.respond_to?(:to_hash)
+            unless (value.respond_to?(:key?) ? value : value.to_hash).key?(token)
+              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid key of #{value.inspect}")
+            end
+            (value.respond_to?(:[]) ? value : value.to_hash)[token]
+          else
+            raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} cannot be resolved in #{value.inspect}")
+          end
+        end
+        res
+      end
+
+      # the pointer string representation of this Pointer
+      def pointer
+        reference_tokens.map { |t| '/' + t.to_s.gsub('~', '~0').gsub('/', '~1') }.join('')
+      end
+
+      # the fragment string representation of this Pointer
+      def fragment
+        '#' + Addressable::URI.escape(pointer)
+      end
+
+      def to_s
+        "#<#{self.class.inspect} #{@type} = #{representation_s}>"
+      end
+
+      private
+
+      def representation_s
+        if @type == :fragment
+          fragment
+        elsif @type == :pointer
+          pointer
+        else
+          reference_tokens.inspect
+        end
+      end
+    end
+  end
+end

data/lib/jsi/schema.rb

@@ -97,13 +97,13 @@ module JSI
         end
         if parent_auri.fragment
           # add onto the fragment
-          parent_id_path = ::JSON::Schema::Pointer.new(:fragment, '#' + parent_auri.fragment).reference_tokens
+          parent_id_path = JSI::JSON::Pointer.new(:fragment, '#' + parent_auri.fragment).reference_tokens
           path_from_id_node = parent_id_path + path_from_id_node
           parent_auri.fragment = nil
         #else: no fragment so parent_id good as is
         end
 
-        fragment = ::JSON::Schema::Pointer.new(:reference_tokens, path_from_id_node).fragment
+        fragment = JSI::JSON::Pointer.new(:reference_tokens, path_from_id_node).fragment
         schema_id = parent_auri.to_s + fragment
 
         schema_id
@@ -124,12 +124,9 @@ module JSI
     def match_to_instance(instance)
       # matching oneOf is good here. one schema for one instance.
       # matching anyOf is okay. there could be more than one schema matched. it's often just one. if more
-      #   than one is a match, the problems of allOf occur.
-      # 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.
+      #   than one is a match, you just get the first one.
       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|
+      %w(oneOf 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)
           if someof_schema.validate(instance)

data/lib/jsi/typelike_modules.rb

@@ -36,7 +36,13 @@ module JSI
     # @raise [TypeError] when the object (or an object nested with a hash or
     #   array of object) cannot be expressed as json
     def self.as_json(object, *opt)
-      if object.respond_to?(:to_hash)
+      if object.is_a?(JSI::Schema)
+        as_json(object.schema_object, *opt)
+      elsif object.is_a?(JSI::Base)
+        as_json(object.instance, *opt)
+      elsif object.is_a?(JSI::JSON::Node)
+        as_json(object.content, *opt)
+      elsif object.respond_to?(:to_hash)
         (object.respond_to?(:map) ? object : object.to_hash).map do |k, v|
           unless k.is_a?(Symbol) || k.respond_to?(:to_str)
             raise(TypeError, "json object (hash) cannot be keyed with: #{k.pretty_inspect.chomp}")

data/lib/jsi/version.rb

@@ -1,3 +1,3 @@
 module JSI
-  VERSION = "0.0.4".freeze
+  VERSION = "0.1.0".freeze
 end

data/test/jsi_coder_test.rb

@@ -0,0 +1,85 @@
+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_node_test.rb

@@ -30,8 +30,8 @@ describe JSI::JSON::Node do
     end
   end
   describe '#pointer' do
-    it 'is a ::JSON::Schema::Pointer' do
-      assert_instance_of(::JSON::Schema::Pointer, JSI::JSON::Node.new({}, []).pointer)
+    it 'is a JSI::JSON::Pointer' do
+      assert_instance_of(JSI::JSON::Pointer, JSI::JSON::Node.new({}, []).pointer)
     end
   end
   describe '#content' do
@@ -170,7 +170,7 @@ describe JSI::JSON::Node do
       assert_equal([], root_from_sub.path)
       assert_equal({'a' => {'b' => []}}, root_from_sub.content)
       assert_equal(node, root_from_sub)
-      err = assert_raises(::JSON::Schema::Pointer::ReferenceError) do
+      err = assert_raises(JSI::JSON::Pointer::ReferenceError) do
         root_from_sub.parent_node
       end
       assert_match(/\Acannot access parent of root node: #\{<JSI::JSON::HashNode/, err.message)

data/test/jsi_json_pointer_test.rb

@@ -0,0 +1,98 @@
+require_relative 'test_helper'
+
+describe JSI::JSON::Pointer do
+  # For example, given the document
+  let(:document) do
+    {
+       "foo" => ["bar", "baz"],
+       "" => 0,
+       "a/b" => 1,
+       "c%d" => 2,
+       "e^f" => 3,
+       "g|h" => 4,
+       "i\\j" => 5,
+       "k\"l" => 6,
+       " " => 7,
+       "m~n" => 8,
+    }
+  end
+
+  describe 'initialize from pointer' do
+    it 'parses' do
+      # The following strings evaluate to the accompanying values:
+      evaluations = [
+        ""      ,     document,
+        "/foo"  ,     ["bar", "baz"],
+        "/foo/0",     "bar",
+        "/"     ,     0,
+        "/a~1b" ,     1,
+        "/c%d"  ,     2,
+        "/e^f"  ,     3,
+        "/g|h"  ,     4,
+        "/i\\j" ,     5,
+        "/k\"l" ,     6,
+        "/ "    ,     7,
+        "/m~0n" ,     8,
+      ]
+      evaluations.each_slice(2) do |pointer, value|
+        assert_equal(value, JSI::JSON::Pointer.new(:pointer, pointer).evaluate(document))
+      end
+    end
+
+    it 'raises for invalid syntax' do
+      err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
+        JSI::JSON::Pointer.new(:pointer, "this does not begin with slash").evaluate(document)
+      end
+      assert_equal("Invalid pointer syntax in \"this does not begin with slash\": pointer must begin with /", err.message)
+    end
+  end
+  describe 'initialize from fragment' do
+    # For example, given the document
+    let(:document) do
+      {
+         "foo" => ["bar", "baz"],
+         "" => 0,
+         "a/b" => 1,
+         "c%d" => 2,
+         "e^f" => 3,
+         "g|h" => 4,
+         "i\\j" => 5,
+         "k\"l" => 6,
+         " " => 7,
+         "m~n" => 8,
+      }
+    end
+
+    it 'parses' do
+      # the following URI fragment identifiers evaluate to the accompanying values:
+      evaluations = [
+        '#',            document,
+        '#/foo',        ["bar", "baz"],
+        '#/foo/0',      "bar",
+        '#/',           0,
+        '#/a~1b',       1,
+        '#/c%25d',      2,
+        '#/e%5Ef',      3,
+        '#/g%7Ch',      4,
+        '#/i%5Cj',      5,
+        '#/k%22l',      6,
+        '#/%20',        7,
+        '#/m~0n',       8,
+      ]
+      evaluations.each_slice(2) do |fragment, value|
+        assert_equal(value, JSI::JSON::Pointer.new(:fragment, fragment).evaluate(document))
+      end
+    end
+
+    it 'raises for invalid syntax' do
+      err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
+        JSI::JSON::Pointer.new(:fragment, "this does not begin with #").evaluate(document)
+      end
+      assert_equal("Invalid fragment syntax in \"this does not begin with #\": fragment must begin with #", err.message)
+      err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
+        JSI::JSON::Pointer.new(:fragment, "#this does not begin with slash").evaluate(document)
+      end
+      assert_equal("Invalid pointer syntax in \"this does not begin with slash\": pointer must begin with /", err.message)
+    end
+  end
+end

data/test/jsi_typelike_as_json_test.rb

@@ -0,0 +1,53 @@
+require_relative 'test_helper'
+
+class JSONifiable
+  def initialize(object)
+    @object = object
+  end
+  def as_json
+    @object
+  end
+end
+
+describe JSI::Typelike do
+  describe 'as_json' do
+    it 'expresses as json' do
+      assert_equal({}, JSI::Typelike.as_json({}))
+      assert_equal([], JSI::Typelike.as_json([]))
+
+      # symbols to string
+      assert_equal(['a'], JSI::Typelike.as_json([:a]))
+
+      # set
+      assert_equal(['a'], JSI::Typelike.as_json(Set.new(['a'])))
+
+      # responds to #to_hash / #to_ary but naught else
+      assert_equal({'a' => 'b'}, JSI::Typelike.as_json(SortOfHash.new({'a' => 'b'})))
+      assert_equal(['a'], JSI::Typelike.as_json(SortOfArray.new(['a'])))
+
+      # symbol keys to string
+      assert_equal({'a' => 'b'}, JSI::Typelike.as_json({a: 'b'}))
+      # non string/symbol key
+      err = assert_raises(TypeError) { JSI::Typelike.as_json({nil => 0}) }
+      assert_equal('json object (hash) cannot be keyed with: nil', err.message)
+
+      # schema
+      schema = JSI::Schema.from_object({'type' => 'array'})
+      assert_equal({'type' => 'array'}, JSI::Typelike.as_json(schema))
+
+      # JSI
+      assert_equal(['a'], JSI::Typelike.as_json(JSI.class_for_schema(schema).new(['a'])))
+
+      # JSON::Node
+      assert_equal(['a'], JSI::Typelike.as_json(JSI::JSON::Node.new_doc(['a'])))
+
+      # #as_json
+      assert_equal(['a'], JSI::Typelike.as_json(JSONifiable.new(['a'])))
+
+      # not jsonifiable
+      object = Object.new
+      err = assert_raises(TypeError) { JSI::Typelike.as_json(object) }
+      assert_equal("cannot express object as json: #{object.pretty_inspect.chomp}", err.message)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsi
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Ethan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-27 00:00:00.000000000 Z
+date: 2019-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -98,25 +98,26 @@ files:
 - lib/jsi.rb
 - lib/jsi/base.rb
 - lib/jsi/base/to_rb.rb
+- lib/jsi/jsi_coder.rb
 - lib/jsi/json-schema-fragments.rb
 - lib/jsi/json.rb
 - lib/jsi/json/node.rb
+- lib/jsi/json/pointer.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_coder_test.rb
 - test/jsi_json_arraynode_test.rb
 - test/jsi_json_hashnode_test.rb
 - test/jsi_json_node_test.rb
+- test/jsi_json_pointer_test.rb
 - test/jsi_test.rb
-- test/schema_instance_json_coder_test.rb
+- test/jsi_typelike_as_json_test.rb
 - test/schema_test.rb
-- test/struct_json_coder_test.rb
 - test/test_helper.rb
 - test/util_test.rb
 homepage: https://github.com/notEthan/jsi
@@ -147,12 +148,13 @@ test_files:
 - test/base_array_test.rb
 - test/base_hash_test.rb
 - test/base_test.rb
+- test/jsi_coder_test.rb
 - test/jsi_json_arraynode_test.rb
 - test/jsi_json_hashnode_test.rb
 - test/jsi_json_node_test.rb
+- test/jsi_json_pointer_test.rb
 - test/jsi_test.rb
-- test/schema_instance_json_coder_test.rb
+- test/jsi_typelike_as_json_test.rb
 - test/schema_test.rb
-- test/struct_json_coder_test.rb
 - test/test_helper.rb
 - test/util_test.rb

data/lib/jsi/schema_instance_json_coder.rb

@@ -1,83 +0,0 @@
-module JSI
-  # this is a ActiveRecord serialization class intended to store JSON in the
-  # database column and expose a ruby class once loaded on a model instance.
-  # this allows for better ruby idioms to access to properties, and definition
-  # of related methods on the loaded class.
-  #
-  # the first argument, `loaded_class`, is the class which will be used to
-  # instantiate the column data. properties of the loaded class will correspond
-  # to keys of the json object in the database.
-  #
-  # the column data may be either a single instance of the loaded class
-  # (represented as one json object) or an array of them (represented as a json
-  # array of json objects), indicated by the keyword argument `array`.
-  #
-  # the column behind the attribute may be an actual JSON column (postgres json
-  # or jsonb - hstore should work too if you only have string attributes) or a
-  # serialized string, indicated by the keyword argument `string`.
-  class ObjectJSONCoder
-    class Error < StandardError
-    end
-    class LoadError < Error
-    end
-    class DumpError < Error
-    end
-
-    def initialize(loaded_class, string: false, array: false, next_coder: nil)
-      @loaded_class = loaded_class
-      # this notes the order of the keys as they were in the json, used by dump_object to generate
-      # json that is equivalent to the json/jsonifiable that came in, so that AR's #changed_attributes
-      # can tell whether the attribute has been changed.
-      @loaded_class.send(:attr_accessor, :object_json_coder_keys_order)
-      @string = string
-      @array = array
-      @next_coder = next_coder
-    end
-
-    def load(column_data)
-      return nil if column_data.nil?
-      data = @string ? ::JSON.parse(column_data) : column_data
-      object = if @array
-        unless data.respond_to?(:to_ary)
-          raise TypeError, "expected array-like column data; got: #{data.class}: #{data.inspect}"
-        end
-        data.map { |el| load_object(el) }
-      else
-        load_object(data)
-      end
-      object = @next_coder.load(object) if @next_coder
-      object
-    end
-
-    def dump(object)
-      object = @next_coder.dump(object) if @next_coder
-      return nil if object.nil?
-      jsonifiable = begin
-        if @array
-          unless object.respond_to?(:to_ary)
-            raise DumpError, "expected array-like attribute; got: #{object.class}: #{object.inspect}"
-          end
-          object.map do |el|
-            dump_object(el)
-          end
-        else
-          dump_object(object)
-        end
-      end
-      @string ? ::JSON.generate(jsonifiable) : jsonifiable
-    end
-  end
-  # this is a ActiveRecord serialization class intended to store JSON in the
-  # database column and expose a given JSI::Base subclass once loaded
-  # on a model instance.
-  class SchemaInstanceJSONCoder < ObjectJSONCoder
-    private
-    def load_object(data)
-      @loaded_class.new(data)
-    end
-
-    def dump_object(object)
-      JSI::Typelike.as_json(object)
-    end
-  end
-end

data/lib/jsi/struct_json_coder.rb

@@ -1,30 +0,0 @@
-module JSI
-  # this is a ActiveRecord serialization class intended to store JSON in the
-  # database column and expose a Struct subclass once loaded on a model instance.
-  class StructJSONCoder < ObjectJSONCoder
-    private
-    def load_object(data)
-      if data.is_a?(Hash)
-        good_keys = @loaded_class.members.map(&:to_s)
-        bad_keys = data.keys - good_keys
-        unless bad_keys.empty?
-          raise LoadError, "expected keys #{good_keys}; got unrecognized keys: #{bad_keys}"
-        end
-        instance = @loaded_class.new(*@loaded_class.members.map { |m| data[m.to_s] })
-        instance.object_json_coder_keys_order = data.keys
-        instance
-      else
-        raise LoadError, "expected instance(s) of #{Hash}; got: #{data.class}: #{data.inspect}"
-      end
-    end
-
-    def dump_object(object)
-      if object.is_a?(@loaded_class)
-        keys = (object.object_json_coder_keys_order || []) | @loaded_class.members.map(&:to_s)
-        keys.map { |member| {member => object[member]} }.inject({}, &:update)
-      else
-        raise TypeError, "expected instance(s) of #{@loaded_class}; got: #{object.class}: #{object.inspect}"
-      end
-    end
-  end
-end

data/test/schema_instance_json_coder_test.rb

@@ -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

@@ -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