scorpio 0.0.4 → 0.1.0

data/lib/scorpio/openapi.rb

@@ -0,0 +1,81 @@
+require 'scorpio/schema_object_base'
+
+module Scorpio
+  module OpenAPI
+    openapi_schema_doc = ::JSON.parse(Scorpio.root.join('documents/swagger.io/v2/schema.json').read)
+    openapi_class = proc do |*key|
+      Scorpio.class_for_schema(Scorpio::JSON::Node.new_by_type(openapi_schema_doc, key))
+    end
+
+    Document = openapi_class.call()
+
+    # naming these is not strictly necessary, but is nice to have.
+    # generated: puts Scorpio::OpenAPI::Document.schema_document['definitions'].select { |k,v| ['object', nil].include?(v['type']) }.keys.map { |k| "#{k[0].upcase}#{k[1..-1]} = openapi_class.call('definitions', '#{k}')" }
+    Info                        = openapi_class.call('definitions', 'info')
+    Contact                     = openapi_class.call('definitions', 'contact')
+    License                     = openapi_class.call('definitions', 'license')
+    Paths                       = openapi_class.call('definitions', 'paths')
+    Definitions                 = openapi_class.call('definitions', 'definitions')
+    ParameterDefinitions        = openapi_class.call('definitions', 'parameterDefinitions')
+    ResponseDefinitions         = openapi_class.call('definitions', 'responseDefinitions')
+    ExternalDocs                = openapi_class.call('definitions', 'externalDocs')
+    Examples                    = openapi_class.call('definitions', 'examples')
+    Operation                   = openapi_class.call('definitions', 'operation')
+    PathItem                    = openapi_class.call('definitions', 'pathItem')
+    Responses                   = openapi_class.call('definitions', 'responses')
+    ResponseValue               = openapi_class.call('definitions', 'responseValue')
+    Response                    = openapi_class.call('definitions', 'response')
+    Headers                     = openapi_class.call('definitions', 'headers')
+    Header                      = openapi_class.call('definitions', 'header')
+    VendorExtension             = openapi_class.call('definitions', 'vendorExtension')
+    BodyParameter               = openapi_class.call('definitions', 'bodyParameter')
+    HeaderParameterSubSchema    = openapi_class.call('definitions', 'headerParameterSubSchema')
+    QueryParameterSubSchema     = openapi_class.call('definitions', 'queryParameterSubSchema')
+    FormDataParameterSubSchema  = openapi_class.call('definitions', 'formDataParameterSubSchema')
+    PathParameterSubSchema      = openapi_class.call('definitions', 'pathParameterSubSchema')
+    NonBodyParameter            = openapi_class.call('definitions', 'nonBodyParameter')
+    Parameter                   = openapi_class.call('definitions', 'parameter')
+    Schema                      = openapi_class.call('definitions', 'schema')
+    FileSchema                  = openapi_class.call('definitions', 'fileSchema')
+    PrimitivesItems             = openapi_class.call('definitions', 'primitivesItems')
+    SecurityRequirement         = openapi_class.call('definitions', 'securityRequirement')
+    Xml                         = openapi_class.call('definitions', 'xml')
+    Tag                         = openapi_class.call('definitions', 'tag')
+    SecurityDefinitions         = openapi_class.call('definitions', 'securityDefinitions')
+    BasicAuthenticationSecurity = openapi_class.call('definitions', 'basicAuthenticationSecurity')
+    ApiKeySecurity              = openapi_class.call('definitions', 'apiKeySecurity')
+    Oauth2ImplicitSecurity      = openapi_class.call('definitions', 'oauth2ImplicitSecurity')
+    Oauth2PasswordSecurity      = openapi_class.call('definitions', 'oauth2PasswordSecurity')
+    Oauth2ApplicationSecurity   = openapi_class.call('definitions', 'oauth2ApplicationSecurity')
+    Oauth2AccessCodeSecurity    = openapi_class.call('definitions', 'oauth2AccessCodeSecurity')
+    Oauth2Scopes                = openapi_class.call('definitions', 'oauth2Scopes')
+    Title                       = openapi_class.call('definitions', 'title')
+    Description                 = openapi_class.call('definitions', 'description')
+    Default                     = openapi_class.call('definitions', 'default')
+    MultipleOf                  = openapi_class.call('definitions', 'multipleOf')
+    Maximum                     = openapi_class.call('definitions', 'maximum')
+    ExclusiveMaximum            = openapi_class.call('definitions', 'exclusiveMaximum')
+    Minimum                     = openapi_class.call('definitions', 'minimum')
+    ExclusiveMinimum            = openapi_class.call('definitions', 'exclusiveMinimum')
+    MaxLength                   = openapi_class.call('definitions', 'maxLength')
+    MinLength                   = openapi_class.call('definitions', 'minLength')
+    Pattern                     = openapi_class.call('definitions', 'pattern')
+    MaxItems                    = openapi_class.call('definitions', 'maxItems')
+    MinItems                    = openapi_class.call('definitions', 'minItems')
+    UniqueItems                 = openapi_class.call('definitions', 'uniqueItems')
+    Enum                        = openapi_class.call('definitions', 'enum')
+    JsonReference               = openapi_class.call('definitions', 'jsonReference')
+
+    class Operation
+      attr_accessor :path
+      attr_accessor :http_method
+
+      # there should only be one body parameter; this returns it
+      def body_parameter
+        (parameters || []).detect do |parameter|
+          parameter['in'] == 'body'
+        end
+      end
+    end
+  end
+end

data/lib/scorpio/schema.rb

@@ -0,0 +1,133 @@
+module Scorpio
+  class Schema
+    def initialize(schema_node)
+      @schema_node = schema_node
+    end
+    attr_reader :schema_node
+
+    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
+          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)
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    def match_to_object(object)
+      # matching oneOf is good here. one schema for one object.
+      # 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(object)
+            return someof_schema.match_to_object(object)
+          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)
+        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? }
+    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? }
+    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)
+          end
+        end
+      end
+    end
+
+    def fully_validate(object)
+      ::JSON::Validator.fully_validate(schema_node.document, object_to_content(object), fragment: schema_node.fragment)
+    end
+    def validate(object)
+      ::JSON::Validator.validate(schema_node.document, object_to_content(object), fragment: schema_node.fragment)
+    end
+    def validate!(object)
+      ::JSON::Validator.validate!(schema_node.document, object_to_content(object), fragment: schema_node.fragment)
+    end
+
+    def fingerprint
+      {class: self.class, schema_node: schema_node}
+    end
+    include FingerprintHash
+
+    private
+    def object_to_content(object)
+      object = object.object if object.is_a?(Scorpio::SchemaObjectBase)
+      object = object.content if object.is_a?(Scorpio::JSON::Node)
+      object
+    end
+  end
+end

data/lib/scorpio/schema_object_base.rb

@@ -0,0 +1,227 @@
+require 'json'
+require 'scorpio/typelike_modules'
+
+module Scorpio
+  # base class for representing an instance of an object described by a schema
+  class SchemaObjectBase
+    def initialize(object)
+      if object.is_a?(Scorpio::JSON::Node)
+        @object = object
+      else
+        @object = Scorpio::JSON::Node.new_by_type(object, [])
+      end
+    end
+
+    attr_reader :object
+
+    def fragment
+      object.fragment
+    end
+
+    def fully_validate
+      module_schema.fully_validate(object)
+    end
+    def validate
+      module_schema.validate(object)
+    end
+    def validate!
+      module_schema.validate!(object)
+    end
+    def inspect
+      "\#<#{self.class.name} #{object.inspect}>"
+    end
+    def pretty_print(q)
+      q.instance_exec(self) do |obj|
+        text "\#<#{obj.class.name}"
+        group_sub {
+          nest(2) {
+            breakable ' '
+            pp obj.object
+          }
+        }
+        breakable ''
+        text '>'
+      end
+    end
+
+    def fingerprint
+      {class: self.class, object: object}
+    end
+    include FingerprintHash
+  end
+
+  CLASS_FOR_SCHEMA = Hash.new do |h, schema_node_|
+    h[schema_node_] = Class.new(SchemaObjectBase).instance_exec(schema_node_) do |schema_node|
+      prepend(Scorpio.module_for_schema(schema_node))
+    end
+  end
+
+  def self.class_for_schema(schema_node)
+    schema_node = schema_node.object if schema_node.is_a?(Scorpio::SchemaObjectBase)
+    CLASS_FOR_SCHEMA[schema_node.deref]
+  end
+
+  # this invokes methods of type-like modules (Arraylike, Hashlike) but only if the #object
+  # is of the expected class. since the object may be anything - it will just not be a valid
+  # instance of its schema - we can't assume that the methods on the Xlike modules will work
+  # (e.g. trying to call #each_index on an #object that's not array-like)
+  module SchemaObjectMightBeLike
+    def inspect(*a, &b)
+      if object.is_a?(expected_object_class)
+        super
+      else
+        SchemaObjectBase.instance_method(:inspect).bind(self).call(*a, &b)
+      end
+    end
+    def pretty_print(*a, &b)
+      if object.is_a?(expected_object_class)
+        super
+      else
+        SchemaObjectBase.instance_method(:pretty_print).bind(self).call(*a, &b)
+      end
+    end
+  end
+  module SchemaObjectBaseHash
+    def expected_object_class
+      Scorpio::JSON::HashNode
+    end
+
+    # Hash methods
+    def each
+      return to_enum(__method__) { object.size } unless block_given?
+      object.each_key { |k| yield(k, self[k]) }
+      self
+    end
+    include Enumerable
+
+    def to_hash
+      inject({}) { |h, (k, v)| h[k] = v; h }
+    end
+
+    include Hashlike
+    include SchemaObjectMightBeLike
+
+    # hash methods - define only those which do not modify the hash.
+
+    # methods that don't look at the value; can skip the overhead of #[]
+    key_methods = %w(each_key empty? include? has_key? key key? keys length member? size)
+    key_methods.each do |method_name|
+      define_method(method_name) { |*a, &b| object.public_send(method_name, *a, &b) }
+    end
+
+    # methods which use key and value
+    hash_methods = %w(compact each_pair each_value fetch fetch_values has_value? invert
+      rassoc reject select to_h transform_values value? values values_at)
+    hash_methods.each do |method_name|
+      define_method(method_name) { |*a, &b| to_hash.public_send(method_name, *a, &b) }
+    end
+
+    def [](property_name_)
+      @object_mapped ||= Hash.new do |hash, property_name|
+        hash[property_name] = begin
+          property_schema = module_schema.subschema_for_property(property_name)
+          property_schema = property_schema && property_schema.match_to_object(object[property_name])
+
+          if property_schema && object[property_name].is_a?(JSON::Node)
+            Scorpio.class_for_schema(property_schema.schema_node).new(object[property_name])
+          else
+            object[property_name]
+          end
+        end
+      end
+      @object_mapped[property_name_]
+    end
+
+    def merge(other)
+      # we want to strip the containers from this before we merge
+      # this is kind of annoying. wish I had a better way.
+      other_stripped = ycomb do |striprec|
+        proc do |stripobject|
+          stripobject = stripobject.object if stripobject.is_a?(Scorpio::SchemaObjectBase)
+          stripobject = stripobject.content if stripobject.is_a?(Scorpio::JSON::Node)
+          if stripobject.is_a?(Hash)
+            stripobject.map { |k, v| {striprec.call(k) => striprec.call(v)} }.inject({}, &:update)
+          elsif stripobject.is_a?(Array)
+            stripobject.map(&striprec)
+          elsif stripobject.is_a?(Symbol)
+            stripobject.to_s
+          elsif [String, TrueClass, FalseClass, NilClass, Numeric].any? { |c| stripobject.is_a?(c) }
+            stripobject
+          else
+            raise(TypeError, "bad (not jsonifiable) object: #{stripobject.pretty_inspect}")
+          end
+        end
+      end.call(other)
+
+      self.class.new(object.merge(other_stripped))
+    end
+  end
+
+  module SchemaObjectBaseArray
+    def expected_object_class
+      Scorpio::JSON::ArrayNode
+    end
+
+    def each
+      return to_enum(__method__) { object.size } unless block_given?
+      object.each_index { |i| yield(self[i]) }
+      self
+    end
+    include Enumerable
+
+    def to_ary
+      to_a
+    end
+
+    include Arraylike
+    include SchemaObjectMightBeLike
+
+    def [](i_)
+      # it would make more sense for this to be an array here, but but Array doesn't have a nice memoizing
+      # constructor, so it's a hash with integer keys
+      @object_mapped ||= Hash.new do |hash, i|
+        hash[i] = begin
+          index_schema = module_schema.subschema_for_index(i)
+          index_schema = index_schema && index_schema.match_to_object(object[i])
+
+          if index_schema && object[i].is_a?(JSON::Node)
+            Scorpio.class_for_schema(index_schema.schema_node).new(object[i])
+          else
+            object[i]
+          end
+        end
+      end
+      @object_mapped[i_]
+    end
+  end
+
+  def self.module_for_schema(schema_node_)
+    Module.new.tap do |m|
+      m.instance_exec(schema_node_) do |module_schema_node|
+        unless module_schema_node.is_a?(Scorpio::JSON::Node)
+          raise(ArgumentError, "expected instance of Scorpio::JSON::Node; got: #{module_schema_node.pretty_inspect.chomp}")
+        end
+
+        module_schema = Scorpio::Schema.new(module_schema_node)
+
+        define_method(:module_schema) { module_schema }
+        define_singleton_method(:module_schema) { module_schema }
+        define_singleton_method(:included) do |includer|
+          includer.send(:define_singleton_method, :module_schema) { module_schema }
+        end
+
+        if module_schema.describes_hash?
+          include SchemaObjectBaseHash
+
+          module_schema.described_hash_property_names.each do |property_name|
+            define_method(property_name) do
+              self[property_name]
+            end
+          end
+        elsif module_schema.describes_array?
+          include SchemaObjectBaseArray
+        end
+      end
+    end
+  end
+end

data/lib/scorpio/typelike_modules.rb

@@ -0,0 +1,52 @@
+module Scorpio
+  module Hashlike
+    def inspect
+      object_group_text = respond_to?(:object_group_text) ? ' ' + self.object_group_text : ''
+      "\#{<#{self.class.name}#{object_group_text}> #{self.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(', ')}}"
+    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.name}#{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
+    def inspect
+      object_group_text = respond_to?(:object_group_text) ? ' ' + self.object_group_text : ''
+      "\#[<#{self.class.name}#{object_group_text}> #{self.map { |e| e.inspect }.join(', ')}]"
+    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.name}#{object_group_text}>"
+        group_sub {
+          nest(2) {
+            breakable(obj.any? { true } ? ' ' : '')
+            seplist(obj, nil, :each) { |e|
+              pp e
+            }
+          }
+        }
+        breakable ''
+        text ']'
+      end
+    end
+  end
+end