scorpio 0.1.0 → 0.2.0

data/lib/scorpio/openapi.rb

@@ -1,79 +1,157 @@
-require 'scorpio/schema_object_base'
+require 'scorpio/schema_instance_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))
+    module V3
+      openapi_schema = Scorpio::Schema.new(::JSON.parse(Scorpio.root.join('documents/openapis.org/v3/schema.json').read))
+      openapi_class = proc do |*key|
+        Scorpio.class_for_schema(key.inject(openapi_schema, &:[]))
+      end
+
+      Document = openapi_class.call()
+
+      # naming these is not strictly necessary, but is nice to have.
+      # generated: puts openapi_schema_doc['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')
+      Server                      = openapi_class.call('definitions', 'server')
+      ServerVariable              = openapi_class.call('definitions', 'serverVariable')
+      Components                  = openapi_class.call('definitions', 'components')
+      Paths                       = openapi_class.call('definitions', 'paths')
+      PathItem                    = openapi_class.call('definitions', 'pathItem')
+      Operation                   = openapi_class.call('definitions', 'operation')
+      ExternalDocs                = openapi_class.call('definitions', 'externalDocs')
+      Parameter                   = openapi_class.call('definitions', 'parameter')
+      RequestBody                 = openapi_class.call('definitions', 'requestBody')
+      MediaType                   = openapi_class.call('definitions', 'mediaType')
+      Encoding                    = openapi_class.call('definitions', 'encoding')
+      Responses                   = openapi_class.call('definitions', 'responses')
+      Response                    = openapi_class.call('definitions', 'response')
+      Callback                    = openapi_class.call('definitions', 'callback')
+      Example                     = openapi_class.call('definitions', 'example')
+      Link                        = openapi_class.call('definitions', 'link')
+      Header                      = openapi_class.call('definitions', 'header')
+      Tag                         = openapi_class.call('definitions', 'tag')
+      Examples                    = openapi_class.call('definitions', 'examples')
+      Reference                   = openapi_class.call('definitions', 'reference')
+      Schema                      = openapi_class.call('definitions', 'schema')
+      Discriminator               = openapi_class.call('definitions', 'discriminator')
+      Xml                         = openapi_class.call('definitions', 'xml')
+      SecurityScheme              = openapi_class.call('definitions', 'securityScheme')
+      OauthFlows                  = openapi_class.call('definitions', 'oauthFlows')
+      OauthFlow                   = openapi_class.call('definitions', 'oauthFlow')
+      SecurityRequirement         = openapi_class.call('definitions', 'securityRequirement')
+      AnyOrExpression             = openapi_class.call('definitions', 'anyOrExpression')
+      CallbackOrReference         = openapi_class.call('definitions', 'callbackOrReference')
+      ExampleOrReference          = openapi_class.call('definitions', 'exampleOrReference')
+      HeaderOrReference           = openapi_class.call('definitions', 'headerOrReference')
+      LinkOrReference             = openapi_class.call('definitions', 'linkOrReference')
+      ParameterOrReference        = openapi_class.call('definitions', 'parameterOrReference')
+      RequestBodyOrReference      = openapi_class.call('definitions', 'requestBodyOrReference')
+      ResponseOrReference         = openapi_class.call('definitions', 'responseOrReference')
+      SchemaOrReference           = openapi_class.call('definitions', 'schemaOrReference')
+      SecuritySchemeOrReference   = openapi_class.call('definitions', 'securitySchemeOrReference')
+      AnysOrExpressions           = openapi_class.call('definitions', 'anysOrExpressions')
+      CallbacksOrReferences       = openapi_class.call('definitions', 'callbacksOrReferences')
+      Encodings                   = openapi_class.call('definitions', 'encodings')
+      ExamplesOrReferences        = openapi_class.call('definitions', 'examplesOrReferences')
+      HeadersOrReferences         = openapi_class.call('definitions', 'headersOrReferences')
+      LinksOrReferences           = openapi_class.call('definitions', 'linksOrReferences')
+      MediaTypes                  = openapi_class.call('definitions', 'mediaTypes')
+      ParametersOrReferences      = openapi_class.call('definitions', 'parametersOrReferences')
+      RequestBodiesOrReferences   = openapi_class.call('definitions', 'requestBodiesOrReferences')
+      ResponsesOrReferences       = openapi_class.call('definitions', 'responsesOrReferences')
+      SchemasOrReferences         = openapi_class.call('definitions', 'schemasOrReferences')
+      SecuritySchemesOrReferences = openapi_class.call('definitions', 'securitySchemesOrReferences')
+      ServerVariables             = openapi_class.call('definitions', 'serverVariables')
+      Strings                     = openapi_class.call('definitions', 'strings')
+      Object                      = openapi_class.call('definitions', 'object')
+      Any                         = openapi_class.call('definitions', 'any')
+      Expression                  = openapi_class.call('definitions', 'expression')
+      SpecificationExtension      = openapi_class.call('definitions', 'specificationExtension')
+      DefaultType                 = openapi_class.call('definitions', 'defaultType')
     end
+    module V2
+      openapi_schema = Scorpio::Schema.new(::JSON.parse(Scorpio.root.join('documents/swagger.io/v2/schema.json').read))
+      openapi_class = proc do |*key|
+        Scorpio.class_for_schema(key.inject(openapi_schema, &:[]))
+      end
+
+      Document = openapi_class.call()
 
-    Document = openapi_class.call()
+      # naming these is not strictly necessary, but is nice to have.
+      # generated: puts Scorpio::OpenAPI::V2::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')
 
-    # 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
 
-    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
 
-      # there should only be one body parameter; this returns it
-      def body_parameter
-        (parameters || []).detect do |parameter|
-          parameter['in'] == 'body'
+        def request_schema
+          if body_parameter && body_parameter['schema']
+            Scorpio::Schema.new(body_parameter['schema'])
+          end
         end
       end
     end

data/lib/scorpio/pickle_adapter.rb

@@ -2,7 +2,7 @@ require 'scorpio'
 require 'pickle'
 
 module Scorpio
-  class Model
+  class ResourceBase
     module PickleAdapter
       include ::Pickle::Adapter::Base
 
@@ -10,12 +10,12 @@ module Scorpio
       #
       # all of the Scorpio models MUST be loaded before this gets called.
       def self.model_classes
-        ObjectSpace.each_object(Class).select { |klass| klass < ::Scorpio::Model }
+        ObjectSpace.each_object(Class).select { |klass| klass < ::Scorpio::ResourceBase }
       end
 
       # get a list of column names for a given class
       def self.column_names(klass)
-        klass.all_schema_properties
+        klass.all_schema_properties.to_a
       end
 
       # Get an instance by id of the model

data/lib/scorpio/{model.rb → resource_base.rb}

@@ -1,5 +1,6 @@
 require 'addressable/template'
-require 'faraday_middleware'
+require 'faraday'
+require 'scorpio/util/faraday/response_media_type'
 
 module Scorpio
   # see also Faraday::Env::MethodsWithBodies
@@ -7,7 +8,7 @@ module Scorpio
   class RequestSchemaFailure < Error
   end
 
-  class Model
+  class ResourceBase
     class << self
       def define_inheritable_accessor(accessor, options = {})
         if options[:default_getter]
@@ -36,9 +37,6 @@ module Scorpio
               klass.instance_exec(&options[:on_set])
             end
           end
-          if options[:update_methods]
-            update_dynamic_methods
-          end
         end
       end
     end
@@ -46,35 +44,88 @@ module Scorpio
     # (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(: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)
+    define_inheritable_accessor(:tag_name, on_set: -> { update_dynamic_methods })
+    define_inheritable_accessor(:represented_schemas, default_value: [], on_set: proc do
+      unless represented_schemas.respond_to?(:to_ary)
+        raise(TypeError, "represented_schemas must be an array. received: #{represented_schemas.pretty_inspect.chomp}")
+      end
+      if represented_schemas.all? { |s| s.is_a?(Scorpio::Schema) }
+        represented_schemas.each do |schema|
+          openapi_document_class.models_by_schema = openapi_document_class.models_by_schema.merge(schema => self)
+        end
+        update_dynamic_methods
+      else
+        self.represented_schemas = self.represented_schemas.map do |schema|
+          unless schema.is_a?(Scorpio::Schema)
+            schema = Scorpio::Schema.new(schema)
+          end
+          unless schema['type'].nil? || schema.describes_hash?
+            raise(TypeError, "given schema for #{self.inspect} not of type object - type must be object for Scorpio ResourceBase to represent this schema. schema is: #{schema.pretty_inspect.chomp}")
+          end
+          schema
+        end
       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, default_value: {})
-    define_inheritable_accessor(:base_url)
+    # the base url to which paths are appended.
+    # by default this looks at the openapi document's schemes, picking https or http first.
+    # it looks at the openapi_document's host and basePath.
+    # a model overriding this MUST include the openapi document's basePath if defined, e.g.
+    # class MyModel
+    #   self.base_url = File.join('https://example.com/', openapi_document.basePath)
+    # end
+    define_inheritable_accessor(:base_url, default_getter: -> {
+      if openapi_document.schemes.nil?
+        scheme = 'https'
+      elsif openapi_document.schemes.respond_to?(:to_ary)
+        # prefer https, then http, then anything else since we probably don't support.
+        scheme = openapi_document.schemes.sort_by { |s| ['https', 'http'].index(s) || (1.0 / 0) }.first
+      end
+      if openapi_document.host && scheme
+        Addressable::URI.new(
+          scheme: scheme,
+          host: openapi_document.host,
+          path: openapi_document.basePath,
+        ).to_s
+      end
+    })
 
+    define_inheritable_accessor(:user_agent, default_getter: -> {
+      "Scorpio/#{Scorpio::VERSION} (https://github.com/notEthan/scorpio) Faraday/#{Faraday::VERSION} Ruby/#{RUBY_VERSION}"
+    })
     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 set_openapi_document(openapi_document)
+      def openapi_document
+        nil
+      end
+
+      def openapi_document=(openapi_document)
+        self.openapi_document_class = self
+
         if openapi_document.is_a?(Hash)
-          openapi_document = OpenAPI::Document.new(openapi_document)
+          openapi_document = OpenAPI::V2::Document.new(openapi_document)
+        end
+
+        begin
+          singleton_class.instance_exec { remove_method(:openapi_document) }
+        rescue NameError
         end
+        define_singleton_method(:openapi_document) { openapi_document }
+        define_singleton_method(:openapi_document=) do
+          if self == openapi_document_class
+            raise(ArgumentError, "openapi_document may only be set once on #{self.inspect}")
+          else
+            raise(ArgumentError, "openapi_document may not be overridden on subclass #{self.inspect} after it was set on #{openapi_document_class.inspect}")
+          end
+        end
+        update_dynamic_methods
+
         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)
+            unless operation.is_a?(Scorpio::OpenAPI::V2::Operation)
               raise("bad operation at #{operation.fragment}: #{operation.pretty_inspect}")
             end
             operation.path = path
@@ -83,18 +134,7 @@ module Scorpio
         end
 
         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
-          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
 
@@ -104,12 +144,7 @@ module Scorpio
       end
 
       def all_schema_properties
-        schemas_by_key.select { |k, _| definition_keys.include?(k) }.map do |schema_key, schema|
-          unless schema['type'] == 'object'
-            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([], &:|)
+        represented_schemas.map(&:described_hash_property_names).inject(Set.new, &:|)
       end
 
       def update_instance_accessors
@@ -128,14 +163,11 @@ module Scorpio
       end
 
       def operation_for_resource_class?(operation)
-        return false unless resource_name
+        return false unless tag_name
 
-        return true if operation['x-resource'] == self.resource_name
+        return true if operation.tags.respond_to?(:to_ary) && operation.tags.include?(tag_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) }
+        if operation.request_schema && represented_schemas.include?(operation.request_schema)
           return true
         end
 
@@ -145,11 +177,8 @@ module Scorpio
       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) }
+        request_resource_is_self = operation.request_schema && represented_schemas.include?(operation.request_schema)
 
         # also define an instance method depending on certain attributes the request description 
         # might have in common with the model's schema attributes
@@ -165,27 +194,21 @@ module Scorpio
         # 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([], &:|)
+        schema_attributes = represented_schemas.map(&:described_hash_property_names).inject(Set.new, &:|)
 
-        return request_resource_is_self || (request_attributes & schema_attributes).any?
+        return request_resource_is_self || (request_attributes & schema_attributes.to_a).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/
+            raise(ArgumentError, operation.pretty_inspect) unless operation.is_a?(Scorpio::OpenAPI::V2::Operation)
+
+            if operation.tags.respond_to?(:to_ary) && operation.tags.include?(tag_name) && operation.operationId =~ /\A#{Regexp.escape(tag_name)}\.(\w+)\z/
               method_name = $1
             else
-              method_name = operation.operationId || raise("no operationId on operation: #{operation.pretty_inspect}")
+              method_name = operation.operationId
             end
-            method_name = '_' + method_name unless method_name[/\A[a-zA-Z_]/]
-            method_name.gsub(/[^\w]/, '_')
           end
         end
       end
@@ -214,36 +237,14 @@ module Scorpio
         end
       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
-
-      MODULES_FOR_JSON_SCHEMA_TYPES = {
-        'object' => [Hash],
-        'array' => [Array, Set],
-        'string' => [String],
-        'integer' => [Integer],
-        'number' => [Numeric],
-        'boolean' => [TrueClass, FalseClass],
-        'null' => [NilClass],
-      }
-
       def connection
-        Faraday.new do |c|
-          unless faraday_request_middleware.any? { |m| [*m].first == :json }
-            c.request :json
-          end
+        Faraday.new(:headers => {'User-Agent' => user_agent}) do |c|
           faraday_request_middleware.each do |m|
             c.request(*m)
           end
           faraday_response_middleware.each do |m|
             c.response(*m)
           end
-          unless faraday_response_middleware.any? { |m| [*m].first == :json }
-            c.response :json, :content_type => /\bjson$/, :preserve_raw => true
-          end
           c.adapter(*faraday_adapter)
         end
       end
@@ -266,7 +267,10 @@ module Scorpio
             "which were empty: #{empty_variables.inspect}")
         end
         path = path_template.expand(template_params)
-        url = Addressable::URI.parse(base_url) + path
+        # we do not use Addressable::URI#join as the paths should just be concatenated, not resolved.
+        # we use File.join just to deal with consecutive slashes.
+        url = File.join(base_url, path)
+        url = Addressable::URI.parse(url)
         # assume that call_params must be included somewhere. model_attributes are a source of required things
         # but not required to be here.
         other_params = call_params
@@ -274,14 +278,13 @@ module Scorpio
           other_params.reject! { |k, _| path_template.variables.include?(k) }
         end
 
-        request_schema = operation.body_parameter && deref_schema(operation.body_parameter['schema'])
-        if request_schema
+        if operation.request_schema
           # TODO deal with model_attributes / call_params better in nested whatever
           if call_params.nil?
-            body = request_body_for_schema(model_attributes, request_schema)
+            body = request_body_for_schema(model_attributes, operation.request_schema)
           elsif call_params.is_a?(Hash)
-            body = request_body_for_schema(model_attributes.merge(call_params), request_schema)
-            body.update(call_params)
+            body = request_body_for_schema(model_attributes.merge(call_params), operation.request_schema)
+            body = body.merge(call_params) # TODO
           else
             body = call_params
           end
@@ -300,7 +303,59 @@ module Scorpio
           end
         end
 
-        response = connection.run_request(http_method, url, body, nil)
+        request_headers = {}
+
+        if METHODS_WITH_BODIES.any? { |m| m.to_s == http_method.downcase.to_s } && body != nil
+          consumes = operation.consumes || openapi_document.consumes || []
+          if consumes.include?("application/json") || (!body.respond_to?(:to_str) && consumes.empty?)
+          # if we have a body that's not a string and no indication of how to serialize it, we guess json.
+            request_headers['Content-Type'] = "application/json"
+            unless body.respond_to?(:to_str)
+              body = ::JSON.pretty_generate(Typelike.as_json(body))
+            end
+          elsif consumes.include?("application/x-www-form-urlencoded")
+            request_headers['Content-Type'] = "application/x-www-form-urlencoded"
+            unless body.respond_to?(:to_str)
+              body = URI.encode_www_form(body)
+            end
+          elsif body.is_a?(String)
+            if consumes.size == 1
+              request_headers['Content-Type'] = consumes.first
+            end
+          else
+            raise("do not know how to serialize for #{consumes.inspect}: #{body.pretty_inspect.chomp}")
+          end
+        end
+
+        response = connection.run_request(http_method, url, body, request_headers)
+
+        if response.media_type == 'application/json'
+          if response.body.empty?
+            response_object = nil
+          else
+            begin
+              response_object = ::JSON.parse(response.body)
+            rescue ::JSON::ParserError
+              # TODO warn
+              response_object = response.body
+            end
+          end
+        else
+          response_object = response.body
+        end
+
+        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
+        if response_schema
+          # not too sure about this, but I don't think it makes sense to instantiate things that are
+          # not hash or array as a SchemaInstanceBase
+          if response_object.respond_to?(:to_hash) || response_object.respond_to?(:to_ary)
+            response_object = Scorpio.class_for_schema(response_schema).new(response_object)
+          end
+        end
 
         error_class = Scorpio.error_classes_by_status[response.status]
         error_class ||= if (400..499).include?(response.status)
@@ -312,27 +367,28 @@ module Scorpio
         end
         if error_class
           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 }
+          raise(error_class.new(message).tap do |e|
+            e.faraday_response = response
+            e.response_object = response_object
+          end)
         end
 
-        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)
+        response_object_to_instances(response_object, initialize_options)
       end
 
       def request_body_for_schema(object, schema)
-        schema = deref_schema(schema)
-        if object.is_a?(Scorpio::Model)
+        if object.is_a?(Scorpio::ResourceBase)
           # TODO request_schema_fail unless schema is for given model type 
-          request_body_for_schema(object.represent_for_schema(schema), schema)
+          request_body_for_schema(object.attributes, schema)
+        elsif object.is_a?(Scorpio::SchemaInstanceBase)
+          request_body_for_schema(object.instance, schema)
+        elsif object.is_a?(Scorpio::JSON::Node)
+          request_body_for_schema(object.content, schema)
         else
           if object.is_a?(Hash)
             object.map do |key, value|
@@ -391,7 +447,7 @@ module Scorpio
               request_body_for_schema(el, subschema)
             end
           else
-            # TODO maybe raise on anything not jsonifiable 
+            # TODO maybe raise on anything not serializable 
             # TODO check conformance to schema, request_schema_fail if not
             object
           end
@@ -402,36 +458,27 @@ module Scorpio
         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 = {})
-        schema = deref_schema(schema)
-        if schema
-          if schema['type'] == 'object' && MODULES_FOR_JSON_SCHEMA_TYPES['object'].any? { |m| object.is_a?(m) }
-            out = object.map do |key, value|
-              schema_for_value = schema['properties'] && schema['properties'][key] ||
-                if schema['patternProperties']
-                  _, pattern_schema = schema['patternProperties'].detect do |pattern, _|
-                    key =~ Regexp.new(pattern)
-                  end
-                  pattern_schema
-                end ||
-                schema['additionalProperties']
-              {key => response_object_to_instances(value, schema_for_value, initialize_options)}
-            end.inject(object.class.new, &:update)
-            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
-              out
-            end
-          elsif schema['type'] == 'array' && MODULES_FOR_JSON_SCHEMA_TYPES['array'].any? { |m| object.is_a?(m) }
+      def response_object_to_instances(object, initialize_options = {})
+        if object.is_a?(SchemaInstanceBase)
+          model = models_by_schema[object.schema]
+        end
+
+        if object.respond_to?(:to_hash)
+          out = Typelike.modified_copy(object) do
+            object.map do |key, value|
+              {key => response_object_to_instances(value, initialize_options)}
+            end.inject({}, &:update)
+          end
+          if model
+            model.new(out, initialize_options)
+          else
+            out
+          end
+        elsif object.respond_to?(:to_ary)
+          Typelike.modified_copy(object) do
             object.map do |element|
-              response_object_to_instances(element, schema['items'], initialize_options)
+              response_object_to_instances(element, initialize_options)
             end
-          else
-            object
           end
         else
           object
@@ -470,17 +517,13 @@ module Scorpio
 
       # 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
-      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'] ? as['id'] == request_schema['id'] : as == request_schema) && self.class.definition_keys.include?(key) }
+      request_resource_is_self = operation.request_schema && self.class.represented_schemas.include?(operation.request_schema)
       if @options['response'] && @options['response'].status && operation.responses
-        _, response_schema = operation.responses.detect { |k, v| k.to_s == @options['response'].status.to_s }
+        _, response_schema_node = 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 &&
-        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'])
+      response_schema = Scorpio::Schema.new(response_schema_node) if response_schema_node
+      response_resource_is_self = response_schema && self.class.represented_schemas.include?(response_schema)
+      if request_resource_is_self && %w(put post).include?(operation.http_method.to_s.downcase)
         @persisted = true
 
         if response_resource_is_self
@@ -491,17 +534,16 @@ module Scorpio
       response
     end
 
-    # TODO
-    def represent_for_schema(schema)
-      @attributes
+    def as_json
+      Typelike.as_json(@attributes)
     end
 
     def inspect
-      "\#<#{self.class.name} #{attributes.inspect}>"
+      "\#<#{self.class.inspect} #{attributes.inspect}>"
     end
     def pretty_print(q)
       q.instance_exec(self) do |obj|
-        text "\#<#{obj.class.name}"
+        text "\#<#{obj.class.inspect}"
         group_sub {
           nest(2) {
             breakable ' '
@@ -514,7 +556,7 @@ module Scorpio
     end
 
     def fingerprint
-      {class: self.class, attributes: @attributes}
+      {class: self.class, attributes: Typelike.as_json(@attributes)}
     end
     include FingerprintHash
   end