scorpio 0.0.4 → 0.1.0

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

@@ -0,0 +1,191 @@
+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.name} #{@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

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

data/lib/scorpio/json/node.rb

@@ -0,0 +1,214 @@
+require 'scorpio/typelike_modules'
+
+module Scorpio
+  module JSON
+    class Node
+      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
+
+      def initialize(document, path)
+        raise(ArgumentError, "path must be an array. got: #{path.pretty_inspect} (#{path.class})") unless path.is_a?(Array)
+        define_singleton_method(:document) { document }
+        @path = path.dup.freeze
+        @pointer = ::JSON::Schema::Pointer.new(:reference_tokens, path)
+      end
+
+      attr_reader :path
+      attr_reader :document
+      attr_reader :pointer
+
+      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 from #{content.pretty_inspect} (#{content.class}): #{k.pretty_inspect} (#{k.class})", 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 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
+
+      def document_node
+        Node.new_by_type(document, [])
+      end
+
+      def pointer_path
+        pointer.pointer
+      end
+      def fragment
+        pointer.fragment
+      end
+
+      def object_group_text
+        "fragment=#{fragment.inspect}"
+      end
+      def inspect
+        "\#<#{self.class.name} #{object_group_text} #{content.inspect}>"
+      end
+      def pretty_print(q)
+        q.instance_exec(self) do |obj|
+          text "\#<#{obj.class.name} #{object_group_text}"
+          group_sub {
+            nest(2) {
+              breakable ' '
+              pp obj.content
+            }
+          }
+          breakable ''
+          text '>'
+        end
+      end
+
+      def fingerprint
+        {class: self.class, 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
+      include Enumerable
+
+      def to_ary
+        to_a
+      end
+
+      include Arraylike
+
+      # array methods - define only those which do not modify the array.
+
+      # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_a)
+      index_methods = %w(each_index empty? length size)
+      index_methods.each do |method_name|
+        define_method(method_name) { |*a, &b| content.public_send(method_name, *a, &b) }
+      end
+
+      # methods which use index and value.
+      # flatten is omitted. flatten should not exist.
+      array_methods = %w(& | * + - <=> abbrev assoc at bsearch bsearch_index combination compact count cycle dig fetch index first include? join last pack permutation rassoc repeated_combination reject reverse reverse_each rindex rotate sample select shelljoin shuffle slice sort take take_while transpose uniq values_at zip)
+      array_methods.each do |method_name|
+        define_method(method_name) { |*a, &b| to_a.public_send(method_name, *a, &b) }
+      end
+    end
+
+    class HashNode < Node
+      def each
+        return to_enum(__method__) { content.size } unless block_given?
+        content.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
+
+      # hash methods - define only those which do not modify the hash.
+
+      # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_hash)
+      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| content.public_send(method_name, *a, &b) }
+      end
+
+      # methods which use key and value
+      hash_methods = %w(any? compact dig 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
+
+      # methods that return a modified copy
+      def merge(other)
+        # 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 merged with `other`, 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.
+        merged_document = ycomb do |rec|
+          proc do |subdocument, subpath|
+            if subpath == []
+              subdocument.merge(other.is_a?(JSON::Node) ? other.content : other)
+            else
+              car = subpath[0]
+              cdr = subpath[1..-1]
+              if subdocument.is_a?(Array)
+                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} with remaining subpath: #{cdr.inspect} for array: #{subdocument.pretty_inspect}")
+                end
+              end
+              car_object = rec.call(subdocument[car], cdr)
+              if car_object == subdocument[car]
+                subdocument
+              elsif subdocument.is_a?(Hash)
+                subdocument.merge({car => car_object})
+              elsif subdocument.is_a?(Array)
+                subdocument.dup.tap do |arr|
+                  arr[car] = car_object
+                end
+              else
+                raise(TypeError, "bad subscript: #{car.pretty_inspect} with remaining subpath: #{cdr.inspect} for content: #{subdocument.pretty_inspect}")
+              end
+            end
+          end
+        end.call(document, path)
+        self.class.new(merged_document, path)
+      end
+    end
+  end
+end

data/lib/scorpio/model.rb

@@ -1,5 +1,4 @@
 require 'addressable/template'
-require 'json-schema'
 require 'faraday_middleware'
 
 module Scorpio
@@ -12,18 +11,27 @@ module Scorpio
     class << self
       def define_inheritable_accessor(accessor, options = {})
         if options[:default_getter]
+          # the value before the field is set (overwritten) is the result of the default_getter proc
           define_singleton_method(accessor, &options[:default_getter])
         else
+          # the value before the field is set (overwritten) is the default_value (which is nil if not specified)
           default_value = options[:default_value]
           define_singleton_method(accessor) { default_value }
         end
+        # field setter method. redefines the getter, replacing the method with one that returns the
+        # setter's argument (that being inherited to the scope of the define_method(accessor) block
         define_singleton_method(:"#{accessor}=") do |value|
+          # the setter operates on the singleton class of the receiver (self)
           singleton_class.instance_exec(value, self) do |value_, klass|
+            # remove a previous getter. NameError is raised if a getter is not defined on this class;
+            # this may be ignored.
             begin
               remove_method(accessor)
             rescue NameError
             end
+            # getter method
             define_method(accessor) { value_ }
+            # invoke on_set callback defined on the class
             if options[:on_set]
               klass.instance_exec(&options[:on_set])
             end
@@ -34,46 +42,58 @@ module Scorpio
         end
       end
     end
-    define_inheritable_accessor(:api_description_class)
-    define_inheritable_accessor(:api_description, on_set: proc { self.api_description_class = self })
+    # the class on which the openapi document is defined. subclasses use the openapi document set on this class
+    # (except in the unlikely event it is overwritten by a subclass)
+    define_inheritable_accessor(:openapi_document_class)
+    # the openapi document
+    define_inheritable_accessor(:openapi_document, on_set: proc { self.openapi_document_class = self })
     define_inheritable_accessor(:resource_name, update_methods: true)
-    define_inheritable_accessor(:schema_keys, default_value: [], update_methods: true, on_set: proc do
-      schema_keys.each do |key|
-        api_description_class.models_by_schema_id = api_description_class.models_by_schema_id.merge(schemas_by_key[key]['id'] => self)
-        api_description_class.models_by_schema_key = api_description_class.models_by_schema_key.merge(key => self)
+    define_inheritable_accessor(:definition_keys, default_value: [], update_methods: true, on_set: proc do
+      definition_keys.each do |key|
+        schema_as_key = schemas_by_key[key]
+        schema_as_key = schema_as_key.object if schema_as_key.is_a?(Scorpio::OpenAPI::Schema)
+        schema_as_key = schema_as_key.content if schema_as_key.is_a?(Scorpio::JSON::Node)
+
+        openapi_document_class.models_by_schema = openapi_document_class.models_by_schema.merge(schema_as_key => self)
       end
     end)
     define_inheritable_accessor(:schemas_by_key, default_value: {})
+    define_inheritable_accessor(:schemas_by_path)
     define_inheritable_accessor(:schemas_by_id, default_value: {})
-    define_inheritable_accessor(:models_by_schema_id, default_value: {})
-    define_inheritable_accessor(:models_by_schema_key, default_value: {})
+    define_inheritable_accessor(:models_by_schema, default_value: {})
     define_inheritable_accessor(:base_url)
 
     define_inheritable_accessor(:faraday_request_middleware, default_value: [])
     define_inheritable_accessor(:faraday_adapter, default_getter: proc { Faraday.default_adapter })
     define_inheritable_accessor(:faraday_response_middleware, default_value: [])
     class << self
-      def api_description_schema
-        @api_description_schema ||= begin
-          rest = YAML.load_file(Pathname.new(__FILE__).join('../../../getRest.yml'))
-          rest['schemas'].each do |name, schema_hash|
-            # URI hax because google doesn't put a URI in the id field properly
-            schema = JSON::Schema.new(schema_hash, Addressable::URI.parse(''))
-            JSON::Validator.add_schema(schema)
+      def set_openapi_document(openapi_document)
+        if openapi_document.is_a?(Hash)
+          openapi_document = OpenAPI::Document.new(openapi_document)
+        end
+        openapi_document.paths.each do |path, path_item|
+          path_item.each do |http_method, operation|
+            next if http_method == 'parameters' # parameters is not an operation. TOOD maybe just select the keys that are http methods?
+            unless operation.is_a?(Scorpio::OpenAPI::Operation)
+              raise("bad operation at #{operation.fragment}: #{operation.pretty_inspect}")
+            end
+            operation.path = path
+            operation.http_method = http_method
           end
-          rest['schemas']['RestDescription']
         end
-      end
 
-      def set_api_description(api_description)
-        JSON::Validator.validate!(api_description_schema, api_description)
-        self.api_description = api_description
-        (api_description['schemas'] || {}).each do |schema_key, schema|
-          unless schema['id']
-            raise ArgumentError, "schema #{schema_key} did not contain an id"
+        openapi_document.validate!
+        self.schemas_by_path = {}
+        self.schemas_by_key = {}
+        self.schemas_by_id = {}
+        self.openapi_document = openapi_document
+        (openapi_document.definitions || {}).each do |schema_key, schema|
+          if schema['id']
+            # this isn't actually allowed by openapi's definition. whatever.
+            self.schemas_by_id = self.schemas_by_id.merge(schema['id'] => schema)
           end
-          schemas_by_id[schema['id']] = schema
-          schemas_by_key[schema_key] = schema
+          self.schemas_by_path = self.schemas_by_path.merge(schema.object.fragment => schema)
+          self.schemas_by_key = self.schemas_by_key.merge(schema_key => schema)
         end
         update_dynamic_methods
       end
@@ -84,9 +104,9 @@ module Scorpio
       end
 
       def all_schema_properties
-        schemas_by_key.select { |k, _| schema_keys.include?(k) }.map do |schema_key, schema|
+        schemas_by_key.select { |k, _| definition_keys.include?(k) }.map do |schema_key, schema|
           unless schema['type'] == 'object'
-            raise "schema key #{schema_key} for #{self} is not of type object - type must be object for Scorpio Model to represent this schema" # TODO class
+            raise "definition key #{schema_key} for #{self} is not of type object - type must be object for Scorpio Model to represent this schema" # TODO class
           end
           schema['properties'].keys
         end.inject([], &:|)
@@ -107,49 +127,87 @@ module Scorpio
         end
       end
 
+      def operation_for_resource_class?(operation)
+        return false unless resource_name
+
+        return true if operation['x-resource'] == self.resource_name
+
+        return true if operation.operationId =~ /\A#{Regexp.escape(resource_name)}\.(\w+)\z/
+
+        request_schema = operation.body_parameter['schema'] if operation.body_parameter
+        if request_schema && schemas_by_key.any? { |key, as| as == request_schema && definition_keys.include?(key) }
+          return true
+        end
+
+        return false
+      end
+
+      def operation_for_resource_instance?(operation)
+        return false unless operation_for_resource_class?(operation)
+
+        request_schema = operation.body_parameter['schema'] if operation.body_parameter
+
+        # define an instance method if the request schema is for this model 
+        request_resource_is_self = request_schema &&
+          schemas_by_key.any? { |key, as| as == request_schema && definition_keys.include?(key) }
+
+        # also define an instance method depending on certain attributes the request description 
+        # might have in common with the model's schema attributes
+        request_attributes = []
+        # if the path has attributes in common with model schema attributes, we'll define on 
+        # instance method
+        request_attributes |= Addressable::Template.new(operation.path).variables
+        # TODO if the method request schema has attributes in common with the model schema attributes,
+        # should we define an instance method?
+        #request_attributes |= request_schema && request_schema['type'] == 'object' && request_schema['properties'] ?
+        #  request_schema['properties'].keys : []
+        # TODO if the method parameters have attributes in common with the model schema attributes,
+        # should we define an instance method?
+        #request_attributes |= method_desc['parameters'] ? method_desc['parameters'].keys : []
+
+        schema_attributes = definition_keys.map do |schema_key|
+          schema = schemas_by_key[schema_key]
+          schema['type'] == 'object' && schema['properties'] ? schema['properties'].keys : []
+        end.inject([], &:|)
+
+        return request_resource_is_self || (request_attributes & schema_attributes).any?
+      end
+
+      def method_names_by_operation
+        @method_names_by_operation ||= Hash.new do |h, operation|
+          h[operation] = begin
+            raise(ArgumentError, operation.pretty_inspect) unless operation.is_a?(Scorpio::OpenAPI::Operation)
+            if operation['x-resource-method']
+              method_name = operation['x-resource-method']
+            elsif resource_name && operation.operationId =~ /\A#{Regexp.escape(resource_name)}\.(\w+)\z/
+              method_name = $1
+            else
+              method_name = operation.operationId || raise("no operationId on operation: #{operation.pretty_inspect}")
+            end
+            method_name = '_' + method_name unless method_name[/\A[a-zA-Z_]/]
+            method_name.gsub(/[^\w]/, '_')
+          end
+        end
+      end
+
       def update_class_and_instance_api_methods
-        if self.resource_name && api_description
-          resource_api_methods = ((api_description['resources'] || {})[resource_name] || {})['methods'] || {}
-          resource_api_methods.each do |method_name, method_desc|
+        openapi_document.paths.each do |path, path_item|
+          path_item.each do |http_method, operation|
+            next if http_method == 'parameters' # parameters is not an operation. TOOD maybe just select the keys that are http methods?
+            operation.path = path
+            operation.http_method = http_method
+            method_name = method_names_by_operation[operation]
             # class method
-            unless respond_to?(method_name)
+            if operation_for_resource_class?(operation) && !respond_to?(method_name)
               define_singleton_method(method_name) do |call_params = nil|
-                call_api_method(method_name, call_params: call_params)
+                call_operation(operation, call_params: call_params)
               end
             end
 
             # instance method
-            unless method_defined?(method_name)
-              request_schema = deref_schema(method_desc['request'])
-
-              # define an instance method if the request schema is for this model 
-              request_resource_is_self = request_schema &&
-                request_schema['id'] &&
-                schemas_by_key.any? { |key, as| as['id'] == request_schema['id'] && schema_keys.include?(key) }
-
-              # also define an instance method depending on certain attributes the request description 
-              # might have in common with the model's schema attributes
-              request_attributes = []
-              # if the path has attributes in common with model schema attributes, we'll define on 
-              # instance method
-              request_attributes |= Addressable::Template.new(method_desc['path']).variables
-              # TODO if the method request schema has attributes in common with the model schema attributes,
-              # should we define an instance method?
-              #request_attributes |= request_schema && request_schema['type'] == 'object' && request_schema['properties'] ?
-              #  request_schema['properties'].keys : []
-              # TODO if the method parameters have attributes in common with the model schema attributes,
-              # should we define an instance method?
-              #request_attributes |= method_desc['parameters'] ? method_desc['parameters'].keys : []
-
-              schema_attributes = schema_keys.map do |schema_key|
-                schema = schemas_by_key[schema_key]
-                schema['type'] == 'object' && schema['properties'] ? schema['properties'].keys : []
-              end.inject([], &:|)
-
-              if request_resource_is_self || (request_attributes & schema_attributes).any?
-                define_method(method_name) do |call_params = nil|
-                  call_api_method(method_name, call_params: call_params)
-                end
+            if operation_for_resource_instance?(operation) && !method_defined?(method_name)
+              define_method(method_name) do |call_params = nil|
+                call_operation(operation, call_params: call_params)
               end
             end
           end
@@ -157,6 +215,8 @@ module Scorpio
       end
 
       def deref_schema(schema)
+        schema = schema.object if schema.is_a?(Scorpio::SchemaObjectBase)
+        schema = schema.deref if schema.is_a?(Scorpio::JSON::Node)
         schema && schemas_by_id[schema['$ref']] || schema
       end
 
@@ -188,22 +248,21 @@ module Scorpio
         end
       end
 
-      def call_api_method(method_name, call_params: nil, model_attributes: nil)
+      def call_operation(operation, call_params: nil, model_attributes: nil)
         call_params = Scorpio.stringify_symbol_keys(call_params) if call_params.is_a?(Hash)
         model_attributes = Scorpio.stringify_symbol_keys(model_attributes || {})
-        method_desc = api_description['resources'][self.resource_name]['methods'][method_name]
-        http_method = method_desc['httpMethod'].downcase.to_sym
-        path_template = Addressable::Template.new(method_desc['path'])
+        http_method = operation.http_method.downcase.to_sym
+        path_template = Addressable::Template.new(operation.path)
         template_params = model_attributes
         template_params = template_params.merge(call_params) if call_params.is_a?(Hash)
         missing_variables = path_template.variables - template_params.keys
         if missing_variables.any?
-          raise(ArgumentError, "path #{method_desc['path']} for method #{method_name} requires attributes " +
+          raise(ArgumentError, "path #{operation.path} for operation #{operation.operationId} requires attributes " +
             "which were missing: #{missing_variables.inspect}")
         end
         empty_variables = path_template.variables.select { |v| template_params[v].to_s.empty? }
         if empty_variables.any?
-          raise(ArgumentError, "path #{method_desc['path']} for method #{method_name} requires attributes " +
+          raise(ArgumentError, "path #{operation.path} for operation #{operation.operationId} requires attributes " +
             "which were empty: #{empty_variables.inspect}")
         end
         path = path_template.expand(template_params)
@@ -215,8 +274,7 @@ module Scorpio
           other_params.reject! { |k, _| path_template.variables.include?(k) }
         end
 
-        method_desc = (((api_description['resources'] || {})[resource_name] || {})['methods'] || {})[method_name]
-        request_schema = deref_schema(method_desc['request'])
+        request_schema = operation.body_parameter && deref_schema(operation.body_parameter['schema'])
         if request_schema
           # TODO deal with model_attributes / call_params better in nested whatever
           if call_params.nil?
@@ -253,13 +311,21 @@ module Scorpio
           HTTPError
         end
         if error_class
-          message = "Error calling #{method_name} on #{self}:\n" + (response.env[:raw_body] || response.env.body)
+          message = "Error calling operation #{operation.operationId} on #{self}:\n" + (response.env[:raw_body] || response.env.body)
           raise error_class.new(message).tap { |e| e.response = response }
         end
 
-        response_schema = method_desc['response']
-        source = {'method_name' => method_name, 'call_params' => call_params, 'url' => url.to_s}
-        response_object_to_instances(response.body, response_schema, 'persisted' => true, 'source' => source)
+        if operation.responses
+          _, operation_response = operation.responses.detect { |k, v| k.to_s == response.status.to_s }
+          operation_response ||= operation.responses['default']
+          response_schema = operation_response.schema if operation_response
+        end
+        initialize_options = {
+          'persisted' => true,
+          'source' => {'operationId' => operation.operationId, 'call_params' => call_params, 'url' => url.to_s},
+          'response' => response,
+        }
+        response_object_to_instances(response.body, response_schema, initialize_options)
       end
 
       def request_body_for_schema(object, schema)
@@ -333,7 +399,7 @@ module Scorpio
       end
 
       def request_schema_fail(object, schema)
-        raise(RequestSchemaFailure, "object does not conform to schema.\nobject = #{object.inspect}\nschema = #{JSON.pretty_generate(schema, quirks_mode: true)}")
+        raise(RequestSchemaFailure, "object does not conform to schema.\nobject = #{object.pretty_inspect}\nschema = #{::JSON.pretty_generate(schema, quirks_mode: true)}")
       end
 
       def response_object_to_instances(object, schema, initialize_options = {})
@@ -351,7 +417,10 @@ module Scorpio
                 schema['additionalProperties']
               {key => response_object_to_instances(value, schema_for_value, initialize_options)}
             end.inject(object.class.new, &:update)
-            model = models_by_schema_id[schema['id']]
+            schema_as_key = schema
+            schema_as_key = schema_as_key.object if schema_as_key.is_a?(Scorpio::OpenAPI::Schema)
+            schema_as_key = schema_as_key.content if schema_as_key.is_a?(Scorpio::JSON::Node)
+            model = models_by_schema[schema_as_key]
             if model
               model.new(out, initialize_options)
             else
@@ -391,24 +460,26 @@ module Scorpio
       @attributes[key] = value
     end
 
-    def ==(other)
-      @attributes == other.instance_eval { @attributes }
+    def call_api_method(method_name, call_params: nil)
+      operation = self.class.method_names_by_operation.invert[method_name] || raise(ArgumentError)
+      call_operation(operation, call_params: call_params)
     end
 
-    def call_api_method(method_name, call_params: nil)
-      response = self.class.call_api_method(method_name, call_params: call_params, model_attributes: self.attributes)
+    def call_operation(operation, call_params: nil)
+      response = self.class.call_operation(operation, call_params: call_params, model_attributes: self.attributes)
 
       # if we're making a POST or PUT and the request schema is this resource, we'll assume that
       # the request is persisting this resource
-      api_method = self.class.api_description['resources'][self.class.resource_name]['methods'][method_name]
-      request_schema = self.class.deref_schema(api_method['request'])
+      request_schema = operation.body_parameter && self.class.deref_schema(operation.body_parameter['schema'])
       request_resource_is_self = request_schema &&
         request_schema['id'] &&
-        self.class.schemas_by_key.any? { |key, as| as['id'] == request_schema['id'] && self.class.schema_keys.include?(key) }
-      response_schema = self.class.deref_schema(api_method['response'])
+        self.class.schemas_by_key.any? { |key, as| (as['id'] ? as['id'] == request_schema['id'] : as == request_schema) && self.class.definition_keys.include?(key) }
+      if @options['response'] && @options['response'].status && operation.responses
+        _, response_schema = operation.responses.detect { |k, v| k.to_s == @options['response'].status.to_s }
+      end
+      response_schema = self.class.deref_schema(response_schema)
       response_resource_is_self = response_schema &&
-        response_schema['id'] &&
-        self.class.schemas_by_key.any? { |key, as| as['id'] == response_schema['id'] && self.class.schema_keys.include?(key) }
+        self.class.schemas_by_key.any? { |key, as| (as['id'] ? as['id'] == response_schema['id'] : as == response_schema) && self.class.definition_keys.include?(key) }
       if request_resource_is_self && %w(PUT POST).include?(api_method['httpMethod'])
         @persisted = true
 
@@ -425,10 +496,26 @@ module Scorpio
       @attributes
     end
 
-    alias eql? ==
+    def inspect
+      "\#<#{self.class.name} #{attributes.inspect}>"
+    end
+    def pretty_print(q)
+      q.instance_exec(self) do |obj|
+        text "\#<#{obj.class.name}"
+        group_sub {
+          nest(2) {
+            breakable ' '
+            pp obj.attributes
+          }
+        }
+        breakable ''
+        text '>'
+      end
+    end
 
-    def hash
-      @attributes.hash
+    def fingerprint
+      {class: self.class, attributes: @attributes}
     end
+    include FingerprintHash
   end
 end