jsi 0.0.1

data/lib/jsi/schema.rb

@@ -0,0 +1,249 @@
+require 'jsi/json/node'
+
+module JSI
+  class Schema
+    include Memoize
+
+    def initialize(schema_object)
+      if schema_object.is_a?(JSI::Schema)
+        raise(TypeError, "will not instantiate Schema from another Schema: #{schema_object.pretty_inspect.chomp}")
+      elsif schema_object.is_a?(JSI::Base)
+        @schema_object = JSI.deep_stringify_symbol_keys(schema_object.deref)
+        @schema_node = @schema_object.instance
+      elsif schema_object.is_a?(JSI::JSON::HashNode)
+        @schema_object = nil
+        @schema_node = JSI.deep_stringify_symbol_keys(schema_object.deref)
+      elsif schema_object.respond_to?(:to_hash)
+        @schema_object = nil
+        @schema_node = JSI::JSON::Node.new_by_type(JSI.deep_stringify_symbol_keys(schema_object), [])
+      else
+        raise(TypeError, "cannot instantiate Schema from: #{schema_object.pretty_inspect.chomp}")
+      end
+      if @schema_object
+        define_singleton_method(:instance) { schema_node } # aka schema_object.instance
+        define_singleton_method(:schema) { schema_object.schema }
+        extend BaseHash
+      else
+        define_singleton_method(:[]) { |*a, &b| schema_node.public_send(:[], *a, &b) }
+      end
+    end
+    attr_reader :schema_node
+    def schema_object
+      @schema_object || @schema_node
+    end
+
+    def schema_id
+      @schema_id ||= begin
+        # start from schema_node and ascend parents looking for an 'id' property.
+        # append a fragment to that id (appending to an existing fragment if there
+        # is one) consisting of the path from that parent to our schema_node.
+        node_for_id = schema_node
+        path_from_id_node = []
+        done = false
+
+        while !done
+          # TODO: track what parents are schemas. somehow.
+          # look at 'id' if node_for_id is a schema, or the document root.
+          # decide whether to look at '$id' for all parent nodes or also just schemas.
+          if node_for_id.respond_to?(:to_hash)
+            if node_for_id.path.empty? || node_for_id.object_id == schema_node.object_id
+              # I'm only looking at 'id' for the document root and the schema node
+              # until I track what parents are schemas.
+              parent_id = node_for_id['$id'] || node_for_id['id']
+            else
+              # will look at '$id' everywhere since it is less likely to show up outside schemas than
+              # 'id', but it will be better to only look at parents that are schemas for this too.
+              parent_id = node_for_id['$id']
+            end
+          end
+
+          if parent_id || node_for_id.path.empty?
+            done = true
+          else
+            path_from_id_node.unshift(node_for_id.path.last)
+            node_for_id = node_for_id.parent_node
+          end
+        end
+        if parent_id
+          parent_auri = Addressable::URI.parse(parent_id)
+        else
+          node_for_id = schema_node.document_node
+          validator = ::JSON::Validator.new(node_for_id.content, nil)
+          # TODO not good instance_exec'ing into another library's ivars
+          parent_auri = validator.instance_exec { @base_schema }.uri
+        end
+        if parent_auri.fragment
+          # add onto the fragment
+          parent_id_path = ::JSON::Schema::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
+        schema_id = parent_auri.to_s + fragment
+
+        schema_id
+      end
+    end
+
+    def schema_class
+      JSI.class_for_schema(self)
+    end
+
+    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.
+      %w(oneOf allOf 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)
+            return someof_schema.match_to_instance(instance)
+          end
+        end
+      end
+      return self
+    end
+
+    def subschema_for_property(property_name_)
+      memoize(:subschema_for_property, property_name_) do |property_name|
+        if schema_object['properties'].respond_to?(:to_hash) && schema_object['properties'][property_name].respond_to?(:to_hash)
+          self.class.new(schema_object['properties'][property_name])
+        else
+          if schema_object['patternProperties'].respond_to?(:to_hash)
+            _, pattern_schema_object = schema_object['patternProperties'].detect do |pattern, _|
+              property_name.to_s =~ Regexp.new(pattern) # TODO map pattern to ruby syntax
+            end
+          end
+          if pattern_schema_object
+            self.class.new(pattern_schema_object)
+          else
+            if schema_object['additionalProperties'].respond_to?(:to_hash)
+              self.class.new(schema_object['additionalProperties'])
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+
+    def subschema_for_index(index_)
+      memoize(:subschema_for_index, index_) do |index|
+        if schema_object['items'].respond_to?(:to_ary)
+          if index < schema_object['items'].size
+            self.class.new(schema_object['items'][index])
+          elsif schema_object['additionalItems'].respond_to?(:to_hash)
+            self.class.new(schema_object['additionalItems'])
+          end
+        elsif schema_object['items'].respond_to?(:to_hash)
+          self.class.new(schema_object['items'])
+        else
+          nil
+        end
+      end
+    end
+
+    def describes_array?
+      memoize(:describes_array?) do
+        schema_node['type'] == 'array' ||
+          schema_node['items'] ||
+          schema_node['additionalItems'] ||
+          schema_node['default'].respond_to?(:to_ary) || # TODO make sure this is right
+          (schema_node['enum'].respond_to?(:to_ary) && schema_node['enum'].all? { |enum| enum.respond_to?(:to_ary) }) ||
+          schema_node['maxItems'] ||
+          schema_node['minItems'] ||
+          schema_node.key?('uniqueItems') ||
+          schema_node['oneOf'].respond_to?(:to_ary) &&
+            schema_node['oneOf'].all? { |someof_node| self.class.new(someof_node).describes_array? } ||
+          schema_node['allOf'].respond_to?(:to_ary) &&
+            schema_node['allOf'].all? { |someof_node| self.class.new(someof_node).describes_array? } ||
+          schema_node['anyOf'].respond_to?(:to_ary) &&
+            schema_node['anyOf'].all? { |someof_node| self.class.new(someof_node).describes_array? }
+      end
+    end
+    def describes_hash?
+      memoize(:describes_hash?) do
+        schema_node['type'] == 'object' ||
+          schema_node['required'].respond_to?(:to_ary) ||
+          schema_node['properties'].respond_to?(:to_hash) ||
+          schema_node['additionalProperties'] ||
+          schema_node['patternProperties'] ||
+          schema_node['default'].respond_to?(:to_hash) ||
+          (schema_node['enum'].respond_to?(:to_ary) && schema_node['enum'].all? { |enum| enum.respond_to?(:to_hash) }) ||
+          schema_node['oneOf'].respond_to?(:to_ary) &&
+            schema_node['oneOf'].all? { |someof_node| self.class.new(someof_node).describes_hash? } ||
+          schema_node['allOf'].respond_to?(:to_ary) &&
+            schema_node['allOf'].all? { |someof_node| self.class.new(someof_node).describes_hash? } ||
+          schema_node['anyOf'].respond_to?(:to_ary) &&
+            schema_node['anyOf'].all? { |someof_node| self.class.new(someof_node).describes_hash? }
+      end
+    end
+
+    def described_hash_property_names
+      memoize(:described_hash_property_names) do
+        Set.new.tap do |property_names|
+          if schema_node['properties'].respond_to?(:to_hash)
+            property_names.merge(schema_node['properties'].keys)
+          end
+          if schema_node['required'].respond_to?(:to_ary)
+            property_names.merge(schema_node['required'].to_ary)
+          end
+          # we _could_ look at the properties of 'default' and each 'enum' but ... nah.
+          # we should look at dependencies (TODO).
+          %w(oneOf allOf anyOf).select { |k| schema_node[k].respond_to?(:to_ary) }.each do |schemas_key|
+            schema_node[schemas_key].map(&:deref).map do |someof_node|
+              property_names.merge(self.class.new(someof_node).described_hash_property_names)
+            end
+          end
+        end
+      end
+    end
+
+    def fully_validate(instance)
+      ::JSON::Validator.fully_validate(schema_node.document, object_to_content(instance), fragment: schema_node.fragment)
+    end
+    def validate(instance)
+      ::JSON::Validator.validate(schema_node.document, object_to_content(instance), fragment: schema_node.fragment)
+    end
+    def validate!(instance)
+      ::JSON::Validator.validate!(schema_node.document, object_to_content(instance), fragment: schema_node.fragment)
+    end
+
+    def object_group_text
+      "schema_id=#{schema_id}"
+    end
+    def inspect
+      "\#<#{self.class.inspect} #{object_group_text} #{schema_object.inspect}>"
+    end
+    alias_method :to_s, :inspect
+    def pretty_print(q)
+      q.instance_exec(self) do |obj|
+        text "\#<#{obj.class.inspect} #{obj.object_group_text}"
+        group_sub {
+          nest(2) {
+            breakable ' '
+            pp obj.schema_object
+          }
+        }
+        breakable ''
+        text '>'
+      end
+    end
+    def fingerprint
+      {class: self.class, schema_node: schema_node}
+    end
+    include FingerprintHash
+
+    private
+    def object_to_content(object)
+      object = object.instance if object.is_a?(JSI::Base)
+      object = object.content if object.is_a?(JSI::JSON::Node)
+      object
+    end
+  end
+end

data/lib/jsi/schema_instance_json_coder.rb

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

@@ -0,0 +1,30 @@
+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/lib/jsi/typelike_modules.rb

@@ -0,0 +1,164 @@
+module JSI
+  module Typelike
+    def self.modified_copy(other, &block)
+      if other.respond_to?(:modified_copy)
+        other.modified_copy(&block)
+      else
+        return yield(other)
+      end
+    end
+
+    # I could require 'json/add/core' and use #as_json but I like this better.
+    def self.as_json(object, *opt)
+      if object.respond_to?(:to_hash)
+        object.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}")
+          end
+          {k.to_s => as_json(v, *opt)}
+        end.inject({}, &:update)
+      elsif object.respond_to?(:to_ary)
+        object.map { |e| as_json(e, *opt) }
+      elsif [String, TrueClass, FalseClass, NilClass, Numeric].any? { |c| object.is_a?(c) }
+        object
+      elsif object.is_a?(Symbol)
+        object.to_s
+      elsif object.is_a?(Set)
+        as_json(object.to_a, *opt)
+      elsif object.respond_to?(:as_json)
+        as_json(object.as_json(*opt), *opt)
+      else
+        raise(TypeError, "cannot express object as json: #{object.pretty_inspect.chomp}")
+      end
+    end
+  end
+  module Hashlike
+    # safe methods which can be delegated to #to_hash (which the includer is assumed to have defined).
+    # 'safe' means, in this context, nondestructive - methods which do not modify the receiver.
+
+    # methods which do not need to access the value.
+    SAFE_KEY_ONLY_METHODS = %w(each_key empty? has_key? include? key? keys length member? size)
+    SAFE_KEY_VALUE_METHODS = %w(< <= > >= any? assoc compact dig each_pair each_value fetch fetch_values has_value? invert key merge rassoc reject select to_h to_proc transform_values value? values values_at)
+    DESTRUCTIVE_METHODS = %w(clear delete delete_if keep_if reject! replace select! shift)
+    # these return a modified copy
+    safe_modified_copy_methods = %w(compact merge)
+    # select and reject will return a modified copy but need the yielded block variable value from #[]
+    safe_kv_block_modified_copy_methods = %w(select reject)
+    SAFE_METHODS = SAFE_KEY_ONLY_METHODS | SAFE_KEY_VALUE_METHODS
+    safe_to_hash_methods = SAFE_METHODS - safe_modified_copy_methods - safe_kv_block_modified_copy_methods
+    safe_to_hash_methods.each do |method_name|
+      define_method(method_name) { |*a, &b| to_hash.public_send(method_name, *a, &b) }
+    end
+    safe_modified_copy_methods.each do |method_name|
+      define_method(method_name) do |*a, &b|
+        JSI::Typelike.modified_copy(self) do |object_to_modify|
+          object_to_modify.public_send(method_name, *a, &b)
+        end
+      end
+    end
+    safe_kv_block_modified_copy_methods.each do |method_name|
+      define_method(method_name) do |*a, &b|
+        JSI::Typelike.modified_copy(self) do |object_to_modify|
+          object_to_modify.public_send(method_name, *a) do |k, _v|
+            b.call(k, self[k])
+          end
+        end
+      end
+    end
+
+    def inspect
+      object_group_text = respond_to?(:object_group_text) ? ' ' + self.object_group_text : ''
+      "\#{<#{self.class.to_s}#{object_group_text}>#{empty? ? '' : ' '}#{self.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(', ')}}"
+    end
+
+    def to_s
+      inspect
+    end
+
+    def pretty_print(q)
+      q.instance_exec(self) do |obj|
+        object_group_text = obj.respond_to?(:object_group_text) ? ' ' + obj.object_group_text : ''
+        text "\#{<#{obj.class.to_s}#{object_group_text}>"
+        group_sub {
+          nest(2) {
+            breakable(obj.any? { true } ? ' ' : '')
+            seplist(obj, nil, :each_pair) { |k, v|
+              group {
+                pp k
+                text ' => '
+                pp v
+              }
+            }
+          }
+        }
+        breakable ''
+        text '}'
+      end
+    end
+  end
+  module Arraylike
+    # safe methods which can be delegated to #to_ary (which the includer is assumed to have defined).
+    # 'safe' means, in this context, nondestructive - methods which do not modify the receiver.
+
+    # methods which do not need to access the element.
+    SAFE_INDEX_ONLY_METHODS = %w(each_index empty? length size)
+    # there are some ambiguous ones that are omitted, like #sort, #map / #collect.
+    SAFE_INDEX_ELEMENT_METHODS = %w(| & * + - <=> abbrev assoc at bsearch bsearch_index combination compact count cycle dig drop drop_while fetch find_index first include? index join last pack permutation product reject repeated_combination repeated_permutation reverse reverse_each rindex rotate sample select shelljoin shuffle slice sort take take_while transpose uniq values_at zip)
+    DESTRUCTIVE_METHODS = %w(<< clear collect! compact! concat delete delete_at delete_if fill flatten! insert keep_if map! pop push reject! replace reverse! rotate! select! shift shuffle! slice! sort! sort_by! uniq! unshift)
+
+    # methods (well, method) that returns a modified copy and doesn't need any handling of block variable(s)
+    safe_modified_copy_methods = %w(compact)
+
+    # methods that return a modified copy and do need handling of block variables
+    safe_el_block_methods = %w(reject select)
+
+    SAFE_METHODS = SAFE_INDEX_ONLY_METHODS | SAFE_INDEX_ELEMENT_METHODS
+    safe_to_ary_methods = SAFE_METHODS - safe_modified_copy_methods - safe_el_block_methods
+    safe_to_ary_methods.each do |method_name|
+      define_method(method_name) { |*a, &b| to_ary.public_send(method_name, *a, &b) }
+    end
+    safe_modified_copy_methods.each do |method_name|
+      define_method(method_name) do |*a, &b|
+        JSI::Typelike.modified_copy(self) do |object_to_modify|
+          object_to_modify.public_send(method_name, *a, &b)
+        end
+      end
+    end
+    safe_el_block_methods.each do |method_name|
+      define_method(method_name) do |*a, &b|
+        JSI::Typelike.modified_copy(self) do |object_to_modify|
+          i = 0
+          object_to_modify.public_send(method_name, *a) do |_e|
+            b.call(self[i]).tap { i += 1 }
+          end
+        end
+      end
+    end
+
+    def inspect
+      object_group_text = respond_to?(:object_group_text) ? ' ' + self.object_group_text : ''
+      "\#[<#{self.class.to_s}#{object_group_text}>#{empty? ? '' : ' '}#{self.map { |e| e.inspect }.join(', ')}]"
+    end
+
+    def to_s
+      inspect
+    end
+
+    def pretty_print(q)
+      q.instance_exec(self) do |obj|
+        object_group_text = obj.respond_to?(:object_group_text) ? ' ' + obj.object_group_text : ''
+        text "\#[<#{obj.class.to_s}#{object_group_text}>"
+        group_sub {
+          nest(2) {
+            breakable(obj.any? { true } ? ' ' : '')
+            seplist(obj, nil, :each) { |e|
+              pp e
+            }
+          }
+        }
+        breakable ''
+        text ']'
+      end
+    end
+  end
+end