scorpio 0.1.0 → 0.2.0

data/lib/scorpio/schema.rb

@@ -1,33 +1,94 @@
+require 'scorpio/json/node'
+
 module Scorpio
   class Schema
-    def initialize(schema_node)
-      @schema_node = schema_node
+    include Memoize
+
+    def initialize(schema_object)
+      if schema_object.is_a?(Scorpio::Schema)
+        raise(TypeError, "will not instantiate Schema from another Schema: #{schema_object.pretty_inspect.chomp}")
+      elsif schema_object.is_a?(Scorpio::SchemaInstanceBase)
+        @schema_object = Scorpio.deep_stringify_symbol_keys(schema_object.deref)
+        @schema_node = @schema_object.instance
+      elsif schema_object.is_a?(Scorpio::JSON::HashNode)
+        @schema_object = nil
+        @schema_node = Scorpio.deep_stringify_symbol_keys(schema_object.deref)
+      elsif schema_object.respond_to?(:to_hash)
+        @schema_object = nil
+        @schema_node = Scorpio::JSON::Node.new_by_type(Scorpio.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 SchemaInstanceBaseHash
+      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 subschema_for_property(property_name)
-      if schema_node['properties'].respond_to?(:to_hash) && schema_node['properties'][property_name].respond_to?(:to_hash)
-        self.class.new(schema_node['properties'][property_name].deref)
-      else
-        if schema_node['patternProperties'].respond_to?(:to_hash)
-          _, pattern_schema_node = schema_node['patternProperties'].detect do |pattern, _|
-            property_name =~ Regexp.new(pattern) # TODO map pattern to ruby syntax
+    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
-        end
-        if pattern_schema_node
-          self.class.new(pattern_schema_node.deref)
-        else
-          if schema_node['additionalProperties'].is_a?(Scorpio::JSON::Node)
-            self.class.new(schema_node['additionalProperties'].deref)
+
+          if parent_id || node_for_id.path.empty?
+            done = true
           else
-            nil
+            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 match_to_object(object)
-      # matching oneOf is good here. one schema for one object.
+    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.
@@ -36,88 +97,139 @@ module Scorpio
       %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(object)
-            return someof_schema.match_to_object(object)
+          if someof_schema.validate(instance)
+            return someof_schema.match_to_instance(instance)
           end
         end
       end
       return self
     end
 
-    def subschema_for_index(index)
-      if schema_node['items'].is_a?(Scorpio::JSON::ArrayNode)
-        if index < schema_node['items'].size
-          self.class.new(schema_node['items'][index].deref)
-        elsif schema_node['additionalItems'].is_a?(Node)
-          self.class.new(schema_node['additionalItems'].deref)
+    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
-      elsif schema_node['items'].is_a?(Scorpio::JSON::Node)
-        self.class.new(schema_node['items'].deref)
-      else
-        nil
       end
     end
 
     def describes_array?
-      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? }
+      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?
-      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? }
+      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
-      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)
+      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(object)
-      ::JSON::Validator.fully_validate(schema_node.document, object_to_content(object), fragment: schema_node.fragment)
+    def fully_validate(instance)
+      ::JSON::Validator.fully_validate(schema_node.document, object_to_content(instance), fragment: schema_node.fragment)
     end
-    def validate(object)
-      ::JSON::Validator.validate(schema_node.document, object_to_content(object), fragment: schema_node.fragment)
+    def validate(instance)
+      ::JSON::Validator.validate(schema_node.document, object_to_content(instance), fragment: schema_node.fragment)
     end
-    def validate!(object)
-      ::JSON::Validator.validate!(schema_node.document, object_to_content(object), fragment: schema_node.fragment)
+    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
@@ -125,7 +237,7 @@ module Scorpio
 
     private
     def object_to_content(object)
-      object = object.object if object.is_a?(Scorpio::SchemaObjectBase)
+      object = object.instance if object.is_a?(Scorpio::SchemaInstanceBase)
       object = object.content if object.is_a?(Scorpio::JSON::Node)
       object
     end

data/lib/scorpio/schema_instance_base.rb

@@ -0,0 +1,309 @@
+require 'json'
+require 'scorpio/typelike_modules'
+
+module Scorpio
+  # base class for representing an instance of an instance described by a schema
+  class SchemaInstanceBase
+    include Memoize
+
+    class << self
+      def schema_id
+        schema.schema_id
+      end
+
+      def inspect
+        if !respond_to?(:schema)
+          super
+        elsif !name || name =~ /\AScorpio::SchemaClasses::/
+          %Q(#{SchemaClasses.inspect}[#{schema_id.inspect}])
+        else
+          %Q(#{name} (#{schema_id}))
+        end
+      end
+      def to_s
+        if !respond_to?(:schema)
+          super
+        elsif !name || name =~ /\AScorpio::SchemaClasses::/
+          %Q(#{SchemaClasses.inspect}[#{schema_id.inspect}])
+        else
+          name
+        end
+      end
+
+      def schema_classes_const_name
+        name = schema.schema_id.gsub(/[^\w]/, '_')
+        name = 'X' + name unless name[/\A[a-zA-Z_]/]
+        name = name[0].upcase + name[1..-1]
+        name
+      end
+
+      def name
+        unless super
+          SchemaClasses.const_set(schema_classes_const_name, self)
+        end
+        super
+      end
+    end
+
+    def initialize(instance)
+      unless respond_to?(:schema)
+        raise(TypeError, "cannot instantiate #{self.class.inspect} which has no method #schema. please use Scorpio.class_for_schema")
+      end
+
+      self.instance = instance
+
+      if @instance.is_a?(Scorpio::JSON::HashNode)
+        extend SchemaInstanceBaseHash
+      elsif @instance.is_a?(Scorpio::JSON::ArrayNode)
+        extend SchemaInstanceBaseArray
+      end
+      # certain methods need to be redefined after we are extended by Enumerable
+      extend OverrideFromExtensions
+    end
+
+    module OverrideFromExtensions
+      def as_json
+        Typelike.as_json(instance)
+      end
+    end
+
+    attr_reader :instance
+
+    def deref
+      derefed = instance.deref
+      if derefed.object_id == instance.object_id
+        self
+      else
+        self.class.new(derefed)
+      end
+    end
+
+    def modified_copy(&block)
+      modified_instance = instance.modified_copy(&block)
+      self.class.new(modified_instance)
+    end
+
+    def fragment
+      instance.fragment
+    end
+
+    def fully_validate
+      schema.fully_validate(instance)
+    end
+    def validate
+      schema.validate(instance)
+    end
+    def validate!
+      schema.validate!(instance)
+    end
+    def inspect
+      "\#<#{self.class.to_s} #{instance.inspect}>"
+    end
+    def pretty_print(q)
+      q.instance_exec(self) do |obj|
+        text "\#<#{obj.class.to_s}"
+        group_sub {
+          nest(2) {
+            breakable ' '
+            pp obj.instance
+          }
+        }
+        breakable ''
+        text '>'
+      end
+    end
+
+    def object_group_text
+      instance.object_group_text
+    end
+
+    def fingerprint
+      {class: self.class, instance: instance}
+    end
+    include FingerprintHash
+
+    private
+    def instance=(thing)
+      clear_memo(:[])
+      if instance_variable_defined?(:@instance)
+        if @instance.class != thing.class
+          raise(Scorpio::Bug, "will not accept instance of different class #{thing.class} to current instance class #{@instance.class} on #{self.class.inspect}")
+        end
+      end
+      if thing.is_a?(SchemaInstanceBase)
+        warn "assigning instance to a SchemaInstanceBase instance is incorrect. received: #{thing.pretty_inspect.chomp}"
+        @instance = Scorpio.deep_stringify_symbol_keys(thing.instance)
+      elsif thing.is_a?(Scorpio::JSON::Node)
+        @instance = Scorpio.deep_stringify_symbol_keys(thing)
+      else
+        @instance = Scorpio::JSON::Node.new_by_type(Scorpio.deep_stringify_symbol_keys(thing), [])
+      end
+    end
+  end
+
+  # this module is just a namespace for schema classes.
+  module SchemaClasses
+    def self.[](schema_id)
+      @classes_by_id[schema_id]
+    end
+    @classes_by_id = {}
+  end
+
+  def self.class_for_schema(schema_object)
+    if schema_object.is_a?(Scorpio::Schema)
+      schema__ = schema_object
+    else
+      schema__ = Scorpio::Schema.new(schema_object)
+    end
+
+    memoize(:class_for_schema, schema__) do |schema_|
+      begin
+        begin
+          Class.new(SchemaInstanceBase).instance_exec(schema_) do |schema|
+            begin
+              include(Scorpio.module_for_schema(schema))
+
+              SchemaClasses.instance_exec(self) { |klass| @classes_by_id[klass.schema_id] = klass }
+
+              self
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def self.module_for_schema(schema_object)
+    if schema_object.is_a?(Scorpio::Schema)
+      schema__ = schema_object
+    else
+      schema__ = Scorpio::Schema.new(schema_object)
+    end
+
+    memoize(:module_for_schema, schema__) do |schema_|
+      Module.new.tap do |m|
+        m.instance_exec(schema_) do |schema|
+          define_method(:schema) { schema }
+          define_singleton_method(:schema) { schema }
+          define_singleton_method(:included) do |includer|
+            includer.send(:define_singleton_method, :schema) { schema }
+          end
+
+          define_singleton_method(:schema_id) do
+            schema.schema_id
+          end
+          define_singleton_method(:inspect) do
+            %Q(#<Module for Schema: #{schema_id}>)
+          end
+
+          if schema.describes_hash?
+            instance_method_modules = [m, SchemaInstanceBase, SchemaInstanceBaseArray, SchemaInstanceBaseHash, SchemaInstanceBase::OverrideFromExtensions]
+            instance_methods = instance_method_modules.map do |mod|
+              mod.instance_methods + mod.private_instance_methods
+            end.inject(Set.new, &:|)
+            accessors_to_define = schema.described_hash_property_names.map(&:to_s) - instance_methods.map(&:to_s)
+            accessors_to_define.each do |property_name|
+              define_method(property_name) do
+                if respond_to?(:[])
+                  self[property_name]
+                else
+                  raise(NoMethodError, "instance does not respond to []; cannot call reader `#{property_name}' for: #{pretty_inspect.chomp}")
+                end
+              end
+              define_method("#{property_name}=") do |value|
+                if respond_to?(:[]=)
+                  self[property_name] = value
+                else
+                  raise(NoMethodError, "instance does not respond to []=; cannot call writer `#{property_name}=' for: #{pretty_inspect.chomp}")
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  module SchemaInstanceBaseHash
+    # Hash methods
+    def each
+      return to_enum(__method__) { instance.size } unless block_given?
+      instance.each_key { |k| yield(k, self[k]) }
+      self
+    end
+
+    def to_hash
+      inject({}) { |h, (k, v)| h[k] = v; h }
+    end
+
+    include Hashlike
+
+    # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_hash)
+    SAFE_KEY_ONLY_METHODS.each do |method_name|
+      define_method(method_name) { |*a, &b| instance.public_send(method_name, *a, &b) }
+    end
+
+    def [](property_name_)
+      memoize(:[], property_name_) do |property_name|
+        begin
+          property_schema = schema.subschema_for_property(property_name)
+          property_schema = property_schema && property_schema.match_to_instance(instance[property_name])
+
+          if property_schema && instance[property_name].is_a?(JSON::Node)
+            Scorpio.class_for_schema(property_schema).new(instance[property_name])
+          else
+            instance[property_name]
+          end
+        end
+      end
+    end
+
+    def []=(property_name, value)
+      self.instance = instance.modified_copy do |hash|
+        hash.merge(property_name => value)
+      end
+    end
+  end
+
+  module SchemaInstanceBaseArray
+    def each
+      return to_enum(__method__) { instance.size } unless block_given?
+      instance.each_index { |i| yield(self[i]) }
+      self
+    end
+
+    def to_ary
+      to_a
+    end
+
+    include Arraylike
+
+    # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_a).
+    # we override these methods from Arraylike
+    SAFE_INDEX_ONLY_METHODS.each do |method_name|
+      define_method(method_name) { |*a, &b| instance.public_send(method_name, *a, &b) }
+    end
+
+    def [](i_)
+      memoize(:[], i_) do |i|
+        begin
+          index_schema = schema.subschema_for_index(i)
+          index_schema = index_schema && index_schema.match_to_instance(instance[i])
+
+          if index_schema && instance[i].is_a?(JSON::Node)
+            Scorpio.class_for_schema(index_schema).new(instance[i])
+          else
+            instance[i]
+          end
+        end
+      end
+    end
+    def []=(i, value)
+      self.instance = instance.modified_copy do |ary|
+        ary.each_with_index.map do |el, ary_i|
+          ary_i == i ? value : el
+        end
+      end
+    end
+  end
+end