scorpio 0.2.3 → 0.3.0

data/lib/scorpio/schema.rb

@@ -1,249 +0,0 @@
-require 'scorpio/json/node'
-
-module Scorpio
-  class Schema
-    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 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
-      Scorpio.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?(Scorpio::SchemaInstanceBase)
-      object = object.content if object.is_a?(Scorpio::JSON::Node)
-      object
-    end
-  end
-end

data/lib/scorpio/schema_instance_base.rb

@@ -1,325 +0,0 @@
-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
-    include Enumerable
-
-    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, origin: nil)
-      unless respond_to?(:schema)
-        raise(TypeError, "cannot instantiate #{self.class.inspect} which has no method #schema. please use Scorpio.class_for_schema")
-      end
-
-      @origin = origin || self
-      self.instance = instance
-
-      if @instance.is_a?(Scorpio::JSON::HashNode)
-        extend SchemaInstanceBaseHash
-      elsif @instance.is_a?(Scorpio::JSON::ArrayNode)
-        extend SchemaInstanceBaseArray
-      end
-    end
-
-    attr_reader :instance
-
-    # each is overridden by SchemaInstanceBaseHash or SchemaInstanceBaseArray when appropriate. the base
-    # #each is not actually implemented, along with all the methods of Enumerable.
-    def each
-      raise NoMethodError, "Enumerable methods and #each not implemented for instance that is not like a hash or array: #{instance.pretty_inspect.chomp}"
-    end
-
-    def parents
-      parent = @origin
-      (@origin.instance.path.size...self.instance.path.size).map do |i|
-        parent.tap do
-          parent = parent[self.instance.path[i]]
-        end
-      end.reverse
-    end
-    def parent
-      parents.first
-    end
-
-    def deref
-      derefed = instance.deref
-      if derefed.object_id == instance.object_id
-        self
-      else
-        self.class.new(derefed, origin: @origin)
-      end
-    end
-
-    def modified_copy(&block)
-      modified_instance = instance.modified_copy(&block)
-      self.class.new(modified_instance, origin: @origin)
-    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 as_json(*opt)
-      Typelike.as_json(instance, *opt)
-    end
-
-    def fingerprint
-      {class: self.class, instance: instance}
-    end
-    include FingerprintHash
-
-    private
-    def instance=(thing)
-      if instance_variable_defined?(:@instance)
-        raise(Scorpio::Bug, "overwriting instance is not supported")
-      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
-
-    def subscript_assign(subscript, value)
-      clear_memo(:[], subscript)
-      if value.is_a?(SchemaInstanceBase)
-        instance[subscript] = value.instance
-      else
-        instance[subscript] = value
-      end
-    end
-  end
-
-  # this module is just a namespace for schema classes.
-  module SchemaClasses
-    extend Memoize
-    def self.[](schema_id)
-      @classes_by_id[schema_id]
-    end
-    @classes_by_id = {}
-  end
-
-  def SchemaClasses.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]
-            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], origin: @origin)
-          else
-            instance[property_name]
-          end
-        end
-      end
-    end
-    def []=(property_name, value)
-      subscript_assign(property_name, value)
-    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], origin: @origin)
-          else
-            instance[i]
-          end
-        end
-      end
-    end
-    def []=(i, value)
-      subscript_assign(i, value)
-    end
-  end
-end