scorpio 0.2.3 → 0.3.0

data/lib/scorpio/resource_base.rb

@@ -1,6 +1,5 @@
 require 'addressable/template'
 require 'faraday'
-require 'scorpio/util/faraday/response_media_type'
 
 module Scorpio
   # see also Faraday::Env::MethodsWithBodies
@@ -10,6 +9,9 @@ module Scorpio
 
   class ResourceBase
     class << self
+      # a hash of accessor names (Symbol) to default getter methods (UnboundMethod), used to determine
+      # what accessors have been overridden from their defaults.
+      (-> (x) { define_method(:inheritable_accessor_defaults) { x } }).({})
       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
@@ -19,6 +21,7 @@ module Scorpio
           default_value = options[:default_value]
           define_singleton_method(accessor) { default_value }
         end
+        inheritable_accessor_defaults[accessor] = self.singleton_class.instance_method(accessor)
         # 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|
@@ -40,80 +43,76 @@ module Scorpio
         end
       end
     end
-    # 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(: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) }
+      if represented_schemas.all? { |s| s.is_a?(JSI::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}")
+          unless schema.is_a?(JSI::Schema)
+            schema = JSI::Schema.new(schema)
           end
           schema
         end
       end
     end)
     define_inheritable_accessor(:models_by_schema, default_value: {})
-    # 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
+      openapi_document.base_url(server: server, server_variables: server_variables)
+    })
+
+    define_inheritable_accessor(:server_variables, default_value: {}, on_set: -> {
+      if openapi_document && openapi_document.v2?
+        raise(ArgumentError, "server variables are not supported for OpenAPI V2")
       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(:server, on_set: -> {
+      if openapi_document && openapi_document.v2?
+        raise(ArgumentError, "servers are not supported for OpenAPI V2")
+      end
+      unless server.is_a?(Scorpio::OpenAPI::V3::Server)
+        raise(TypeError, "server must be an #{Scorpio::OpenAPI::V3::Server.inspect}. received: #{server.pretty_inspect.chomp}")
+      end
     })
-    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: [])
+
+    define_inheritable_accessor(:user_agent, default_getter: -> { openapi_document.user_agent })
+
+    define_inheritable_accessor(:faraday_builder, default_getter: -> { openapi_document.faraday_builder })
+    define_inheritable_accessor(:faraday_adapter, default_getter: -> { openapi_document.faraday_adapter })
     class << self
+      # the openapi document
       def openapi_document
         nil
       end
+      def openapi_document_class
+        nil
+      end
 
       def openapi_document=(openapi_document)
-        self.openapi_document_class = self
-
-        if openapi_document.is_a?(Hash)
-          openapi_document = OpenAPI::V2::Document.new(openapi_document)
-        end
+        openapi_document = OpenAPI::Document.from_instance(openapi_document)
 
         begin
           singleton_class.instance_exec { remove_method(:openapi_document) }
         rescue NameError
         end
+        begin
+          singleton_class.instance_exec { remove_method(:openapi_document_class) }
+        rescue NameError
+        end
+        openapi_document_class = self
         define_singleton_method(:openapi_document) { openapi_document }
-        define_singleton_method(:openapi_document=) do
+        define_singleton_method(:openapi_document_class) { openapi_document_class }
+        define_singleton_method(:openapi_document=) do |_|
           if self == openapi_document_class
             raise(ArgumentError, "openapi_document may only be set once on #{self.inspect}")
           else
@@ -124,15 +123,36 @@ module Scorpio
 
         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::V2::Operation)
-              raise("bad operation at #{operation.fragment}: #{operation.pretty_inspect}")
+            unless operation.is_a?(Scorpio::OpenAPI::Operation)
+              next
             end
           end
         end
 
-        openapi_document.validate!
+        # TODO blame validate openapi_document
+
+        update_dynamic_methods
+      end
+
+      def tag_name
+        nil
+      end
 
+      def tag_name=(tag_name)
+        unless tag_name.respond_to?(:to_str)
+          raise(TypeError)
+        end
+        set_on_class = self
+        tag_name = tag_name.to_str
+
+        begin
+          singleton_class.instance_exec { remove_method(:tag_name) }
+        rescue NameError
+        end
+        define_singleton_method(:tag_name) { tag_name }
+        define_singleton_method(:tag_name=) do |_|
+          raise(ArgumentError, "tag_name may not be overridden. it is been set to #{tag_name.inspect}")
+        end
         update_dynamic_methods
       end
 
@@ -142,7 +162,7 @@ module Scorpio
       end
 
       def all_schema_properties
-        represented_schemas.map(&:described_hash_property_names).inject(Set.new, &:|)
+        represented_schemas.map(&:described_object_property_names).inject(Set.new, &:|)
       end
 
       def update_instance_accessors
@@ -165,7 +185,7 @@ module Scorpio
 
         return true if operation.tags.respond_to?(:to_ary) && operation.tags.include?(tag_name)
 
-        if operation.request_schema && represented_schemas.include?(operation.request_schema)
+        if (operation.request_schemas || []).any? { |s| represented_schemas.include?(s) }
           return true
         end
 
@@ -192,7 +212,7 @@ module Scorpio
         # should we define an instance method?
         #request_attributes |= method_desc['parameters'] ? method_desc['parameters'].keys : []
 
-        schema_attributes = represented_schemas.map(&:described_hash_property_names).inject(Set.new, &:|)
+        schema_attributes = represented_schemas.map(&:described_object_property_names).inject(Set.new, &:|)
 
         return request_resource_is_self || (request_attributes & schema_attributes.to_a).any?
       end
@@ -200,7 +220,7 @@ module Scorpio
       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::V2::Operation)
+            raise(ArgumentError, operation.pretty_inspect) unless operation.is_a?(Scorpio::OpenAPI::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
@@ -216,82 +236,95 @@ module Scorpio
           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?
             method_name = method_names_by_operation[operation]
-            # class method
-            if operation_for_resource_class?(operation) && !respond_to?(method_name)
-              define_singleton_method(method_name) do |call_params = nil|
-                call_operation(operation, call_params: call_params)
+            if method_name
+              # class method
+              if operation_for_resource_class?(operation) && !respond_to?(method_name)
+                define_singleton_method(method_name) do |call_params = nil|
+                  call_operation(operation, call_params: call_params)
+                end
               end
-            end
 
-            # instance method
-            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)
+              # instance method
+              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
           end
         end
       end
 
-      def connection
-        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
-          c.adapter(*faraday_adapter)
-        end
-      end
-
       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 || {})
-        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 #{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 #{operation.path} for operation #{operation.operationId} requires attributes " +
-            "which were empty: #{empty_variables.inspect}")
+        call_params = JSI.stringify_symbol_keys(call_params) if call_params.is_a?(Hash)
+        model_attributes = JSI.stringify_symbol_keys(model_attributes || {})
+
+        request = Scorpio::Request.new(operation)
+
+        accessor_overridden = -> (accessor) do
+          # an accessor is overridden if the default accessor getter (UnboundMethod) is the same
+          # as the UnboundMethod returned from instance_method on the owner of that instance method.
+          # gotta be the owner since different classes return different UnboundMethod instances for
+          # the same method. for example, referring to models of scorpio/test/blog_scorpio_models.rb
+          # with the server_variables instance method:
+          #    Article.instance_method(:server_variables)
+          #    => #<UnboundMethod: #<Class:Article>#server_variables>
+          # returns a different UnboundMethod than
+          #    Scorpio::ResourceBase.instance_method(:server_variables)
+          #    => #<UnboundMethod: #<Class:Scorpio::ResourceBase>#server_variables>
+          # even though they are really the same method (the #owner for both is Scorpio::ResourceBase)
+          inheritable_accessor_defaults[accessor] != self.singleton_class.instance_method(accessor).owner.instance_method(accessor)
         end
-        path = path_template.expand(template_params)
-        # 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)
+
+        # pretty ugly... may find a better way to do this.
+        request.base_url =        self.base_url        if accessor_overridden.(:base_url)
+        request.server_variables = self.server_variables if accessor_overridden.(:server_variables)
+        request.server =          self.server          if accessor_overridden.(:server)
+        request.user_agent =      self.user_agent      if accessor_overridden.(:user_agent)
+        request.faraday_builder = self.faraday_builder if accessor_overridden.(:faraday_builder)
+        request.faraday_adapter = self.faraday_adapter if accessor_overridden.(:faraday_adapter)
+
+        request.path_params = request.path_template.variables.map do |var|
+          if call_params.respond_to?(:to_hash) && call_params.key?(var)
+            {var => call_params[var]}
+          elsif model_attributes.respond_to?(:to_hash) && model_attributes.key?(var)
+            {var => model_attributes[var]}
+          else
+            {}
+          end
+        end.inject({}, &:update)
+
         # 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
-        if other_params.is_a?(Hash)
-          other_params.reject! { |k, _| path_template.variables.include?(k) }
+        if call_params.respond_to?(:to_hash)
+          unused_call_params = call_params.reject { |k, _| request.path_template.variables.include?(k) }
+          if !unused_call_params.empty?
+            other_params = unused_call_params
+          else
+            other_params = nil
+          end
+        else
+          other_params = call_params
         end
 
         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, operation.request_schema)
+            request.body_object = 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), operation.request_schema)
-            body = body.merge(call_params) # TODO
+            request.body_object = body.merge(call_params) # TODO
           else
-            body = call_params
+            request.body_object = call_params
           end
         else
           if other_params
-            if METHODS_WITH_BODIES.any? { |m| m.to_s == http_method.downcase.to_s }
-              body = other_params
+            if METHODS_WITH_BODIES.any? { |m| m.to_s == operation.http_method.downcase.to_s }
+              request.body_object = other_params
             else
               if other_params.is_a?(Hash)
                 # TODO pay more attention to 'parameters' api method attribute
-                url.query_values = other_params
+                request.query_params = other_params
               else
                 raise
               end
@@ -299,91 +332,25 @@ module Scorpio
           end
         end
 
-        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
+        ur = request.run_ur
 
-        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)
-          ClientError
-        elsif (500..599).include?(response.status)
-          ServerError
-        elsif !response.success?
-          HTTPError
-        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 do |e|
-            e.faraday_response = response
-            e.response_object = response_object
-          end)
-        end
+        ur.raise_on_http_error
 
         initialize_options = {
           'persisted' => true,
-          'source' => {'operationId' => operation.operationId, 'call_params' => call_params, 'url' => url.to_s},
-          'response' => response,
+          'source' => {'operationId' => operation.operationId, 'call_params' => call_params, 'url' => ur.request.uri.to_s},
+          'ur' => ur,
         }
-        response_object_to_instances(response_object, initialize_options)
+        response_object_to_instances(ur.response.body_object, initialize_options)
       end
 
       def request_body_for_schema(object, schema)
         if object.is_a?(Scorpio::ResourceBase)
           # TODO request_schema_fail unless schema is for given model type 
           request_body_for_schema(object.attributes, schema)
-        elsif object.is_a?(Scorpio::SchemaInstanceBase)
+        elsif object.is_a?(JSI::Base)
           request_body_for_schema(object.instance, schema)
-        elsif object.is_a?(Scorpio::JSON::Node)
+        elsif object.is_a?(JSI::JSON::Node)
           request_body_for_schema(object.content, schema)
         else
           if object.is_a?(Hash)
@@ -436,7 +403,7 @@ module Scorpio
                 if schema['type'] == 'array'
                   # TODO index based subschema or whatever else works for array
                   subschema = schema['items']
-                else
+                elsif schema['type']
                   request_schema_fail(object, schema)
                 end
               end
@@ -451,16 +418,16 @@ module Scorpio
       end
 
       def request_schema_fail(object, schema)
-        raise(RequestSchemaFailure, "object does not conform to schema.\nobject = #{object.pretty_inspect}\nschema = #{::JSON.pretty_generate(schema, quirks_mode: true)}")
+        # TODO blame
       end
 
       def response_object_to_instances(object, initialize_options = {})
-        if object.is_a?(SchemaInstanceBase)
+        if object.is_a?(JSI::Base)
           model = models_by_schema[object.schema]
         end
 
         if object.respond_to?(:to_hash)
-          out = Typelike.modified_copy(object) do
+          out = JSI::Typelike.modified_copy(object) do
             object.map do |key, value|
               {key => response_object_to_instances(value, initialize_options)}
             end.inject({}, &:update)
@@ -471,7 +438,7 @@ module Scorpio
             out
           end
         elsif object.respond_to?(:to_ary)
-          Typelike.modified_copy(object) do
+          JSI::Typelike.modified_copy(object) do
             object.map do |element|
               response_object_to_instances(element, initialize_options)
             end
@@ -483,8 +450,8 @@ module Scorpio
     end
 
     def initialize(attributes = {}, options = {})
-      @attributes = Scorpio.stringify_symbol_keys(attributes)
-      @options = Scorpio.stringify_symbol_keys(options)
+      @attributes = JSI.stringify_symbol_keys(attributes)
+      @options = JSI.stringify_symbol_keys(options)
       @persisted = !!@options['persisted']
     end
 
@@ -514,10 +481,9 @@ 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_resource_is_self = operation.request_schema && self.class.represented_schemas.include?(operation.request_schema)
-      if @options['response'] && @options['response'].status && operation.responses
-        _, response_schema_node = operation.responses.detect { |k, v| k.to_s == @options['response'].status.to_s }
+      if @options['ur'].is_a?(Scorpio::Ur)
+        response_schema = @options['ur'].response.response_schema
       end
-      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
@@ -531,7 +497,7 @@ module Scorpio
     end
 
     def as_json(*opt)
-      Typelike.as_json(@attributes, *opt)
+      JSI::Typelike.as_json(@attributes, *opt)
     end
 
     def inspect
@@ -552,8 +518,8 @@ module Scorpio
     end
 
     def fingerprint
-      {class: self.class, attributes: Typelike.as_json(@attributes)}
+      {class: self.class, attributes: JSI::Typelike.as_json(@attributes)}
     end
-    include FingerprintHash
+    include JSI::FingerprintHash
   end
 end