scorpio 0.2.3 → 0.3.0

data/lib/scorpio/response.rb

@@ -0,0 +1,34 @@
+module Scorpio
+  class Response < ::Ur::Response
+    def response_schema
+      ur.scorpio_request.operation.response_schema(status: status, media_type: media_type)
+    end
+
+    def body_object
+      # TODO handle media types like `application/schema-instance+json` or vendor things like github's
+      if media_type == 'application/json'
+        if body.empty?
+          # an empty body isn't valid json, of course, but we'll just return nil for it.
+          body_object = nil
+        else
+          begin
+            body_object = ::JSON.parse(body)
+          #rescue ::JSON::ParserError
+            # TODO
+          end
+        end
+
+        if response_schema && (body_object.respond_to?(:to_hash) || body_object.respond_to?(:to_ary))
+          body_object = JSI.class_for_schema(response_schema).new(JSI::JSON::Node.new_doc(body_object))
+        end
+
+        body_object
+      elsif media_type == 'text/plain'
+        body
+      else
+        # we will return the body if we do not have a supported parsing. for now.
+        body
+      end
+    end
+  end
+end

data/lib/scorpio/ur.rb

@@ -0,0 +1,33 @@
+module Scorpio
+  class Ur < ::Ur
+    attr_accessor :scorpio_request
+
+    def class_for_schema(schema)
+      jsi_class_for_schema = super
+      if jsi_class_for_schema == ::Ur::Response
+        Scorpio::Response
+      else
+        jsi_class_for_schema
+      end
+    end
+
+    def raise_on_http_error
+      error_class = Scorpio.error_classes_by_status[response.status]
+      error_class ||= if (400..499).include?(response.status)
+        ClientError
+      elsif (500..599).include?(response.status)
+        ServerError
+      elsif !response.success?
+        HTTPError
+      end
+      if error_class
+        message = "Error calling operation #{scorpio_request.operation.operationId} on #{self}:\n" + response.body
+        raise(error_class.new(message).tap do |e|
+          e.ur = self
+          e.response_object = response.body_object
+        end)
+      end
+      nil
+    end
+  end
+end

data/lib/scorpio/version.rb

@@ -1,3 +1,3 @@
 module Scorpio
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/scorpio.gemspec

@@ -20,11 +20,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "jsi", "~> 0.0.3"
+  spec.add_dependency "ur", "~> 0.0.2"
   spec.add_dependency "faraday"
-  # we are monkey patching json-schema with a fix that has not been merged in a timely fashion.
-  spec.add_dependency "json-schema", "~> 2.8"
-  spec.add_dependency "api_hammer"
-  spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "minitest-around"
@@ -33,6 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rack", "~> 1.0"
   spec.add_development_dependency "rack-accept"
   spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "api_hammer"
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "database_cleaner"

metadata

@@ -1,45 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: scorpio
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Ethan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-19 00:00:00.000000000 Z
+date: 2019-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: jsi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.3
 - !ruby/object:Gem::Dependency
-  name: json-schema
+  name: ur
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: 0.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: 0.0.2
 - !ruby/object:Gem::Dependency
-  name: api_hammer
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -52,20 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.12'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -178,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: api_hammer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -255,20 +255,16 @@ files:
 - documents/www.googleapis.com/discovery/v1/apis/discovery/v1/rest.yml
 - lib/scorpio.rb
 - lib/scorpio/google_api_document.rb
-- lib/scorpio/json-schema-fragments.rb
-- lib/scorpio/json.rb
-- lib/scorpio/json/node.rb
 - lib/scorpio/openapi.rb
+- lib/scorpio/openapi/document.rb
+- lib/scorpio/openapi/operation.rb
+- lib/scorpio/openapi/operations_scope.rb
+- lib/scorpio/openapi/v3/server.rb
 - lib/scorpio/pickle_adapter.rb
+- lib/scorpio/request.rb
 - lib/scorpio/resource_base.rb
-- lib/scorpio/schema.rb
-- lib/scorpio/schema_instance_base.rb
-- lib/scorpio/schema_instance_base/to_rb.rb
-- lib/scorpio/schema_instance_json_coder.rb
-- lib/scorpio/struct_json_coder.rb
-- lib/scorpio/typelike_modules.rb
-- lib/scorpio/util.rb
-- lib/scorpio/util/faraday/response_media_type.rb
+- lib/scorpio/response.rb
+- lib/scorpio/ur.rb
 - lib/scorpio/version.rb
 - scorpio.gemspec
 homepage: https://github.com/notEthan/scorpio

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

@@ -1,191 +0,0 @@
-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)
-        reference_tokens.inject(document) do |value, token|
-          if value.is_a?(Array)
-            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.size).include?(token)
-              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid index of #{value.inspect}")
-            end
-          elsif value.is_a?(Hash)
-            unless value.key?(token)
-              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid key of #{value.inspect}")
-            end
-          else
-            raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} cannot be resolved in #{value.inspect}")
-          end
-          value[token]
-        end
-      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
-  class Validator
-    def initialize(schema_data, data, opts={})
-      @options = @@default_opts.clone.merge(opts)
-      @errors = []
-
-      validator = self.class.validator_for_name(@options[:version])
-      @options[:version] = validator
-      @options[:schema_reader] ||= self.class.schema_reader
-
-      @validation_options = @options[:record_errors] ? {:record_errors => true} : {}
-      @validation_options[:insert_defaults] = true if @options[:insert_defaults]
-      @validation_options[:strict] = true if @options[:strict] == true
-      @validation_options[:clear_cache] = true if !@@cache_schemas || @options[:clear_cache]
-
-      @@mutex.synchronize { @base_schema = initialize_schema(schema_data) }
-      @original_data = data
-      @data = initialize_data(data)
-      @@mutex.synchronize { build_schemas(@base_schema) }
-
-      # If the :fragment option is set, try and validate against the fragment
-      if opts[:fragment]
-        @base_schema = schema_from_fragment(@base_schema, opts[:fragment])
-      end
-
-      # validate the schema, if requested
-      if @options[:validate_schema]
-        if @base_schema.schema["$schema"]
-          base_validator = self.class.validator_for_name(@base_schema.schema["$schema"])
-        end
-        metaschema = base_validator ? base_validator.metaschema : validator.metaschema
-        # Don't clear the cache during metaschema validation!
-        self.class.validate!(metaschema, @base_schema.schema, {:clear_cache => false})
-      end
-    end
-
-    def schema_from_fragment(base_schema, fragment)
-      schema_uri = base_schema.uri
-
-      pointer = JSON::Schema::Pointer.new(:fragment, fragment)
-
-      base_schema = JSON::Schema.new(pointer.evaluate(base_schema.schema), schema_uri, @options[:version])
-
-      if @options[:list]
-        base_schema.to_array_schema
-      elsif base_schema.is_a?(Hash)
-        JSON::Schema.new(base_schema, schema_uri, @options[:version])
-      else
-        base_schema
-      end
-    end
-  end
-end

data/lib/scorpio/json.rb

@@ -1,5 +0,0 @@
-module Scorpio
-  module JSON
-    autoload :Node, 'scorpio/json/node'
-  end
-end

data/lib/scorpio/json/node.rb

@@ -1,256 +0,0 @@
-module Scorpio
-  module JSON
-    # Scorpio::JSON::Node is an abstraction of a node within a JSON document.
-    # it aims to act like the underlying data type of the node's content
-    # (Hash or Array, generally) in most cases, defining methods of Hash
-    # and Array which delegate to the content. However, destructive methods
-    # are not defined, as modifying the content of a node would change it
-    # for any other nodes in the document that contain or refer to it.
-    #
-    # methods that return a modified copy such as #merge are defined, and
-    # return a copy of the document with the content of the node modified.
-    # the original node's document and content are untouched.
-    class Node
-      # if the content of the document at the given path is a Hash, returns
-      # a HashNode; if an Array, returns ArrayNode. otherwise returns a
-      # regular Node, though, for the most part this will be called with Hash
-      # or Array content.
-      def self.new_by_type(document, path)
-        node = Node.new(document, path)
-        content = node.content
-        if content.is_a?(Hash)
-          HashNode.new(document, path)
-        elsif content.is_a?(Array)
-          ArrayNode.new(document, path)
-        else
-          node
-        end
-      end
-
-      # a Node represents the content of a document at a given path.
-      def initialize(document, path)
-        raise(ArgumentError, "path must be an array. got: #{path.pretty_inspect.chomp} (#{path.class})") unless path.is_a?(Array)
-        @document = document
-        @path = path.dup.freeze
-        @pointer = ::JSON::Schema::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
-      attr_reader :pointer
-
-      # the raw content of this Node from the underlying document at this Node's path.
-      def content
-        pointer.evaluate(document)
-      end
-
-      def [](k)
-        node = self
-        content = node.content
-        if content.is_a?(Hash) && !content.key?(k)
-          node = node.deref
-          content = node.content
-        end
-        begin
-          el = content[k]
-        rescue TypeError => e
-          raise(e.class, e.message + "\nsubscripting with #{k.pretty_inspect.chomp} (#{k.class}) from #{content.class.inspect}. self is: #{pretty_inspect.chomp}", e.backtrace)
-        end
-        if el.is_a?(Hash) || el.is_a?(Array)
-          self.class.new_by_type(node.document, node.path + [k])
-        else
-          el
-        end
-      end
-
-      def []=(k, v)
-        if v.is_a?(Node)
-          content[k] = v.content
-        else
-          content[k] = v
-        end
-      end
-
-      def deref
-        content = self.content
-
-        return self unless content.is_a?(Hash) && content['$ref'].is_a?(String)
-
-        if content['$ref'][/\A#/]
-          return self.class.new_by_type(document, ::JSON::Schema::Pointer.parse_fragment(content['$ref'])).deref
-        end
-
-        # HAX for how google does refs and ids
-        if document_node['schemas'].respond_to?(:to_hash)
-          if document_node['schemas'][content['$ref']]
-            return document_node['schemas'][content['$ref']]
-          end
-          _, deref_by_id = document_node['schemas'].detect { |_k, schema| schema['id'] == content['$ref'] }
-          if deref_by_id
-            return deref_by_id
-          end
-        end
-
-        #raise(NotImplementedError, "cannot dereference #{content['$ref']}") # TODO
-        return self
-      end
-
-      # a Node at the root of the document
-      def document_node
-        Node.new_by_type(document, [])
-      end
-
-      # the parent of this node. if this node is the document root (its path is empty), raises
-      # ::JSON::Schema::Pointer::ReferenceError.
-      def parent_node
-        if path.empty?
-          raise(::JSON::Schema::Pointer::ReferenceError, "cannot access parent of root node: #{pretty_inspect.chomp}")
-        else
-          Node.new_by_type(document, path[0...-1])
-        end
-      end
-
-      # the pointer path to this node within the document, per RFC 6901 https://tools.ietf.org/html/rfc6901
-      def pointer_path
-        pointer.pointer
-      end
-      # the pointer fragment to this node within the document, per RFC 6901 https://tools.ietf.org/html/rfc6901
-      def fragment
-        pointer.fragment
-      end
-
-      def as_json(*opt)
-        Typelike.as_json(content, *opt)
-      end
-
-      # takes a block. the block is yielded the content of this node. the block MUST return a modified
-      # copy of that content (and NOT modify the object it is given).
-      def modified_copy
-        # we need to preserve the rest of the document, but modify the content at our path.
-        #
-        # this is actually a bit tricky. we can't modify the original document, obviously.
-        # we could do a deep copy, but that's expensive. instead, we make a copy of each array
-        # or hash in the path above this node. this node's content is modified by the caller, and
-        # that is recursively merged up to the document root. the recursion is done with a
-        # y combinator, for no other reason than that was a fun way to implement it.
-        modified_document = ycomb do |rec|
-          proc do |subdocument, subpath|
-            if subpath == []
-              yield(subdocument)
-            else
-              car = subpath[0]
-              cdr = subpath[1..-1]
-              if subdocument.respond_to?(:to_hash)
-                car_object = rec.call(subdocument[car], cdr)
-                if car_object.object_id == subdocument[car].object_id
-                  subdocument
-                else
-                  subdocument.merge({car => car_object})
-                end
-              elsif subdocument.respond_to?(:to_ary)
-                if car.is_a?(String) && car =~ /\A\d+\z/
-                  car = car.to_i
-                end
-                unless car.is_a?(Integer)
-                  raise(TypeError, "bad subscript #{car.pretty_inspect.chomp} with remaining subpath: #{cdr.inspect} for array: #{subdocument.pretty_inspect.chomp}")
-                end
-                car_object = rec.call(subdocument[car], cdr)
-                if car_object.object_id == subdocument[car].object_id
-                  subdocument
-                else
-                  subdocument.dup.tap do |arr|
-                    arr[car] = car_object
-                  end
-                end
-              else
-                raise(TypeError, "bad subscript: #{car.pretty_inspect.chomp} with remaining subpath: #{cdr.inspect} for content: #{subdocument.pretty_inspect.chomp}")
-              end
-            end
-          end
-        end.call(document, path)
-        Node.new_by_type(modified_document, path)
-      end
-
-      def object_group_text
-        "fragment=#{fragment.inspect}"
-      end
-      def inspect
-        "\#<#{self.class.inspect} #{object_group_text} #{content.inspect}>"
-      end
-      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.content
-            }
-          }
-          breakable ''
-          text '>'
-        end
-      end
-
-      def fingerprint
-        {is_node: self.is_a?(Scorpio::JSON::Node), document: document, path: path}
-      end
-      include FingerprintHash
-    end
-
-    class ArrayNode < Node
-      def each
-        return to_enum(__method__) { content.size } unless block_given?
-        content.each_index { |i| yield self[i] }
-        self
-      end
-
-      def to_ary
-        to_a
-      end
-
-      include Enumerable
-      include Arraylike
-
-      def as_json(*opt) # needs redefined after including Enumerable
-        Typelike.as_json(content, *opt)
-      end
-
-      # 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| content.public_send(method_name, *a, &b) }
-      end
-    end
-
-    class HashNode < Node
-      def each(&block)
-        return to_enum(__method__) { content.size } unless block_given?
-        if block.arity > 1
-          content.each_key { |k| yield k, self[k] }
-        else
-          content.each_key { |k| yield [k, self[k]] }
-        end
-        self
-      end
-
-      def to_hash
-        inject({}) { |h, (k, v)| h[k] = v; h }
-      end
-
-      include Enumerable
-      include Hashlike
-
-      def as_json(*opt) # needs redefined after including Enumerable
-        Typelike.as_json(content, *opt)
-      end
-
-      # 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| content.public_send(method_name, *a, &b) }
-      end
-    end
-  end
-end