ddy_remote_resource 0.4.11 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae92e08ce0a95cfc8253c09f3106087caf9ba636
-  data.tar.gz: 0e675db4069759cb3bf185c616821c78f55b1cad
+  metadata.gz: e3d2576b744b3dafd66aff8fca6d991f709fa10d
+  data.tar.gz: b32d6edb8af70dccdfe2b83cf4da340969b7f8b9
 SHA512:
-  metadata.gz: 2b829236979e4f246503864b810da68b9939e84e2fdab2c288131a20bbde39fed70660b1a708d9390818e4d408579cf94db7508300c5cc1a3d1dc777cc84aeff
-  data.tar.gz: d8ed2d8f09246377321acb6a2a0cd1a889e2090a2504509346d209f52cb6f541b3f7e30e890cbc72e06d778c36bd10c1071c74abf2adf909e48fb737b1f14796
+  metadata.gz: 3934a8a1d740a88e3cae6e8dc726c6af2bbb99bc35c4d8a25faf8ac6993fedcf5cdf67cf9093c9f6cf299b14eba9be50feb89a3527418720b0a8dc5f6e5f264f
+  data.tar.gz: 99b67f28cb4284c6100d69340e3f68020f4e13e3a5abedc99d62242858864b4846e9b207b6c1e79fc0834781e5e04a782cc6372bda5558aa06e29ee7a07d601e

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in remote_resource.gemspec
 gemspec
+
+gem 'webmock', github: 'JanDintel/webmock', branch: ' feature/ignore-json-keys-order'

data/Guardfile

@@ -40,6 +40,9 @@ guard :rspec, cmd: 'bundle exec rspec', notification: true do
   ruby = dsl.ruby
   dsl.watch_spec_files_for(ruby.lib_files)
 
+  # Integration specs
+  watch(ruby.lib_files) { 'spec/integration' }
+
   # Notification (See: https://github.com/Codaisseur/terminal-notifier-guard)
   notification :terminal_notifier, app_name: 'RemoteResource', activate: 'com.googlecode.iTerm2' if `uname` =~ /Darwin/
 end

data/lib/remote_resource.rb

@@ -17,52 +17,95 @@ require 'remote_resource/rest'
 require 'remote_resource/response'
 require 'remote_resource/querying/finder_methods'
 require 'remote_resource/querying/persistence_methods'
-require 'remote_resource/http_errors'
 require 'remote_resource/request'
-
+require 'remote_resource/util'
 
 module RemoteResource
-  RemoteResourceError = Class.new StandardError
+  RemoteResourceError = Class.new(StandardError)
 
   IdMissingError = Class.new(RemoteResourceError)
-  
+
   CollectionOptionKeyError = Class.new(RemoteResourceError)
 
-  RESTActionUnknown = Class.new RemoteResourceError # REST action
+  HTTPMethodUnsupported = Class.new(RemoteResourceError) # REST action
 
   class HTTPError < RemoteResourceError # HTTP errors
 
-    def initialize(response)
-      if response.try(:response_code)
-        super "for url: #{response.try(:effective_url)} with HTTP response status: #{response.response_code} and response: #{response.inspect}"
-      else
-        super "for url: #{response.try(:effective_url)} with HTTP response: #{response.inspect}"
-      end
+    def initialize(request, response)
+      @request  = request
+      @response = response
+    end
+
+    def resource_klass
+      @request.resource_klass
+    end
+
+    def http_action
+      @request.http_action
+    end
+
+    def request_url
+      @request.request_url
+    end
+
+    def request_query
+      @request.query
+    end
+
+    def request_body
+      @request.body # TODO: Filter sensitive information using: RemoteResource::Util.filter_params
+    end
+
+    def request_headers
+      @request.headers
+    end
+
+    def response_code
+      @response.response_code
+    end
+
+    def response_body
+      @response.response_body # TODO: Filter sensitive information using: RemoteResource::Util.filter_params
+    end
+
+    def response_headers
+      @response.response_headers
+    end
+
+    def to_s
+      message = "HTTP request failed for #{resource_klass}"
+      message << " with response_code=#{response_code}" if response_code.present?
+      message << " with http_action=#{http_action}"
+      message << " with request_url=#{request_url}"
+      # message << " with request_query=#{request_query}" if request_query.present? # TODO: Test usability of error message whether to include this
+      # message << " with request_body=#{request_body}" if request_body.present? # TODO: Test usability of error message whether to include this
+      # message << " with response_body=#{response_body}" if response_body.present? # TODO: Test usability of error message whether to include this
+      message
     end
   end
 
-  HTTPRedirectionError = Class.new HTTPError # HTTP 3xx
-  HTTPClientError      = Class.new HTTPError # HTTP 4xx
-  HTTPServerError      = Class.new HTTPError # HTTP 5xx
-
-  HTTPBadRequest        = Class.new HTTPClientError # HTTP 400
-  HTTPUnauthorized      = Class.new HTTPClientError # HTTP 401
-  HTTPForbidden         = Class.new HTTPClientError # HTTP 403
-  HTTPNotFound          = Class.new HTTPClientError # HTTP 404
-  HTTPMethodNotAllowed  = Class.new HTTPClientError # HTTP 405
-  HTTPNotAcceptable     = Class.new HTTPClientError # HTTP 406
-  HTTPRequestTimeout    = Class.new HTTPClientError # HTTP 408
-  HTTPConflict          = Class.new HTTPClientError # HTTP 409
-  HTTPGone              = Class.new HTTPClientError # HTTP 410
-  HTTPTeapot            = Class.new HTTPClientError # HTTP 418
-
-  NginxClientError = Class.new HTTPClientError # HTTP errors used in Nginx
-
-  HTTPNoResponse            = Class.new NginxClientError # HTTP 444
-  HTTPRequestHeaderTooLarge = Class.new NginxClientError # HTTP 494
-  HTTPCertError             = Class.new NginxClientError # HTTP 495
-  HTTPNoCert                = Class.new NginxClientError # HTTP 496
-  HTTPToHTTPS               = Class.new NginxClientError # HTTP 497
-  HTTPClientClosedRequest   = Class.new NginxClientError # HTTP 499
+  HTTPRedirectionError = Class.new(HTTPError) # HTTP 3xx
+  HTTPClientError      = Class.new(HTTPError) # HTTP 4xx
+  HTTPServerError      = Class.new(HTTPError) # HTTP 5xx
+
+  HTTPBadRequest       = Class.new(HTTPClientError) # HTTP 400
+  HTTPUnauthorized     = Class.new(HTTPClientError) # HTTP 401
+  HTTPForbidden        = Class.new(HTTPClientError) # HTTP 403
+  HTTPNotFound         = Class.new(HTTPClientError) # HTTP 404
+  HTTPMethodNotAllowed = Class.new(HTTPClientError) # HTTP 405
+  HTTPNotAcceptable    = Class.new(HTTPClientError) # HTTP 406
+  HTTPRequestTimeout   = Class.new(HTTPClientError) # HTTP 408
+  HTTPConflict         = Class.new(HTTPClientError) # HTTP 409
+  HTTPGone             = Class.new(HTTPClientError) # HTTP 410
+  HTTPTeapot           = Class.new(HTTPClientError) # HTTP 418
+
+  NginxClientError = Class.new(HTTPClientError) # HTTP errors used in Nginx
+
+  HTTPNoResponse            = Class.new(NginxClientError) # HTTP 444
+  HTTPRequestHeaderTooLarge = Class.new(NginxClientError) # HTTP 494
+  HTTPCertError             = Class.new(NginxClientError) # HTTP 495
+  HTTPNoCert                = Class.new(NginxClientError) # HTTP 496
+  HTTPToHTTPS               = Class.new(NginxClientError) # HTTP 497
+  HTTPClientClosedRequest   = Class.new(NginxClientError) # HTTP 499
 
 end

data/lib/remote_resource/base.rb

@@ -2,8 +2,6 @@ module RemoteResource
   module Base
     extend ActiveSupport::Concern
 
-    OPTIONS = [:base_url, :site, :headers, :version, :path_prefix, :path_postfix, :collection_prefix, :content_type, :collection, :collection_name, :root_element]
-
     included do
       include Virtus.model
       extend ActiveModel::Naming
@@ -14,12 +12,15 @@ module RemoteResource
       include RemoteResource::Builder
       include RemoteResource::UrlNaming
       include RemoteResource::Connection
+
+      extend RemoteResource::REST
       include RemoteResource::REST
 
       include RemoteResource::Querying::FinderMethods
       include RemoteResource::Querying::PersistenceMethods
 
       attr_accessor :_response
+      attr_accessor :destroyed
 
       attribute :id
       class_attribute :root_element, instance_accessor: false
@@ -45,8 +46,7 @@ module RemoteResource
 
       def with_connection_options(connection_options = {})
         begin
-          threaded_connection_options
-          Thread.current[threaded_connection_options_thread_name].merge! connection_options
+          Thread.current[threaded_connection_options_thread_name] = threaded_connection_options.merge(connection_options)
           yield
         ensure
           Thread.current[threaded_connection_options_thread_name] = nil
@@ -68,8 +68,16 @@ module RemoteResource
       @connection_options ||= RemoteResource::ConnectionOptions.new(self.class)
     end
 
+    def persistence
+      self if persisted?
+    end
+
     def persisted?
-      id.present?
+      if destroyed
+        false
+      else
+        id.present?
+      end
     end
 
     def new_record?
@@ -105,11 +113,15 @@ module RemoteResource
     private
 
     def assign_errors(error_messages)
-      return unless error_messages.respond_to? :each
+      return unless error_messages.respond_to?(:each)
 
       error_messages.each do |attribute, attribute_errors|
-        attribute_errors.each do |error|
-          self.errors.add attribute, error
+        attribute_errors.each do |attribute_error|
+          if respond_to?(attribute)
+            self.errors.add(attribute, attribute_error)
+          else
+            self.errors.add(:base, attribute_error)
+          end
         end
       end
     end

data/lib/remote_resource/connection.rb

@@ -3,10 +3,9 @@ module RemoteResource
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :content_type, :default_headers, :extra_headers, instance_accessor: false
+      class_attribute :extension, :default_headers, instance_accessor: false
 
-      self.content_type    = '.json'
-      self.default_headers = { "Accept" => "application/json" }
+      self.default_headers = {}
     end
 
     module ClassMethods
@@ -15,10 +14,32 @@ module RemoteResource
         Typhoeus::Request
       end
 
+      def content_type=(content_type)
+        warn '[DEPRECATION] `.content_type=` is deprecated. Please use `.extension=` instead.'
+        self.extension = content_type
+      end
+
+      def content_type
+        warn '[DEPRECATION] `.content_type` is deprecated. Please use `.extension` instead.'
+        self.extension
+      end
+
+      def extra_headers=(_)
+        warn '[DEPRECATION] `.extra_headers=` is deprecated. Please overwrite the .headers method to set custom headers.'
+      end
+
+      def extra_headers
+        warn '[DEPRECATION] `.extra_headers` is deprecated. Please overwrite the .headers method to set custom headers.'
+      end
+
+      def headers=(_)
+        warn '[WARNING] `.headers=` can not be used to set custom headers. Please overwrite the .headers method to set custom headers.'
+      end
+
       def headers
-        self.default_headers.merge self.extra_headers || {}
+        {}
       end
 
     end
   end
-end
+end

data/lib/remote_resource/connection_options.rb

@@ -1,6 +1,8 @@
 module RemoteResource
   class ConnectionOptions
 
+    AVAILABLE_OPTIONS = [:site, :headers, :default_headers, :version, :path_prefix, :path_postfix, :collection_prefix, :extension, :collection, :collection_name, :root_element].freeze
+
     attr_reader :base_class
 
     def initialize(base_class)
@@ -15,7 +17,7 @@ module RemoteResource
     end
 
     def to_hash
-      RemoteResource::Base::OPTIONS.each_with_object(Hash.new) do |option, hash|
+      AVAILABLE_OPTIONS.each_with_object(Hash.new) do |option, hash|
         hash[option] = self.public_send option
       end
     end
@@ -31,11 +33,11 @@ module RemoteResource
     private
 
     def initialize_connection_options
-      RemoteResource::Base::OPTIONS.each do |option|
+      AVAILABLE_OPTIONS.each do |option|
         self.class.send :attr_accessor, option
         self.public_send "#{option}=", base_class.public_send(option)
       end
     end
 
   end
-end
+end

data/lib/remote_resource/querying/finder_methods.rb

@@ -6,12 +6,12 @@ module RemoteResource
       module ClassMethods
 
         def find(id, connection_options = {})
-          response = RemoteResource::Request.new(self, :get, { id: id }, connection_options.merge(no_attributes: true)).perform
+          response = RemoteResource::Request.new(self, :get, {}, connection_options.merge(id: id)).perform
           build_resource_from_response(response)
         end
 
         def find_by(params, connection_options = {})
-          response = RemoteResource::Request.new(self, :get, params, connection_options).perform
+          response = RemoteResource::Request.new(self, :get, {}, connection_options.deep_merge(id: params[:id], params: params.except(:id))).perform
           build_resource_from_response(response)
         end
 
@@ -21,7 +21,7 @@ module RemoteResource
         end
 
         def where(params, connection_options = {})
-          response = RemoteResource::Request.new(self, :get, params, connection_options.merge(collection: true)).perform
+          response = RemoteResource::Request.new(self, :get, {}, connection_options.deep_merge(collection: true, params: params)).perform
           build_collection_from_response(response)
         end
       end

data/lib/remote_resource/querying/persistence_methods.rb

@@ -12,9 +12,11 @@ module RemoteResource
         end
 
         def destroy(id, connection_options = {})
-          resource = new
-          response = RemoteResource::Request.new(self, :delete, { id: id }, connection_options.reverse_merge(no_attributes: true)).perform
+          resource = new(id: id)
+          response = RemoteResource::Request.new(self, :delete, {}, connection_options.merge(id: id)).perform
           resource.handle_response(response)
+          resource.destroyed = resource.success?
+          resource
         end
       end
 
@@ -29,22 +31,25 @@ module RemoteResource
         success? ? self : false
       end
 
-      def create_or_update(attributes = {}, connection_options = {})
-        if attributes.has_key?(:id)
-          response = RemoteResource::Request.new(self, :patch, attributes, connection_options).perform
-        else
-          response = RemoteResource::Request.new(self, :post, attributes, connection_options).perform
-        end
-        handle_response(response)
-      end
-
       def destroy(connection_options = {})
         id.present? || raise(RemoteResource::IdMissingError.new("`id` is missing from resource"))
-        response = RemoteResource::Request.new(self, :delete, { id: id }, connection_options.reverse_merge(no_attributes: true)).perform
+        response = RemoteResource::Request.new(self, :delete, {}, connection_options.merge(id: id)).perform
         handle_response(response)
+        self.destroyed = success?
         success? ? self : false
       end
 
+      private
+
+      def create_or_update(attributes = {}, connection_options = {})
+        if attributes.has_key?(:id) && attributes[:id].present?
+          response = RemoteResource::Request.new(self, :patch, attributes.except(:id), connection_options.merge(id: attributes[:id])).perform
+        else
+          response = RemoteResource::Request.new(self, :post, attributes.except(:id), connection_options).perform
+        end
+        handle_response(response)
+      end
+
     end
   end
 end

data/lib/remote_resource/request.rb

@@ -1,15 +1,27 @@
 module RemoteResource
   class Request
-    include RemoteResource::HTTPErrors
 
-    attr_reader :resource, :rest_action, :attributes
+    SUPPORTED_HTTP_METHODS = [:get, :put, :patch, :post, :delete].freeze
 
-    def initialize(resource, rest_action, attributes = {}, connection_options = {})
+    DEFAULT_HEADERS = {
+      'Accept'     => 'application/json',
+      'User-Agent' => "RemoteResource #{RemoteResource::VERSION}"
+    }.freeze
+
+    DEFAULT_CONTENT_TYPE = {
+      'Content-Type' => 'application/json'
+    }.freeze
+
+    DEFAULT_EXTENSION = '.json'.freeze
+
+    attr_reader :resource, :resource_klass, :http_action, :attributes
+
+    def initialize(resource, http_action, attributes = {}, connection_options = {})
       @resource           = resource
-      @rest_action        = rest_action.to_sym
+      @resource_klass     = resource.is_a?(Class) ? resource : resource.class
+      @http_action        = http_action.to_sym
       @attributes         = attributes
-      @connection_options = connection_options
-      @original_connection_options = connection_options.dup
+      @connection_options = connection_options.dup
     end
 
     def connection
@@ -17,90 +29,112 @@ module RemoteResource
     end
 
     def connection_options
-      @connection_options.reverse_merge(threaded_connection_options).reverse_merge(resource.connection_options.to_hash)
-    end
+      @combined_connection_options ||= begin
+        default = resource.connection_options.to_hash # Defined on the resource (klass).
+        block   = resource.try(:threaded_connection_options) || {} # Given as arguments in the .with_connection_options block.
+        local   = @connection_options # Given as arguments directly.
 
-    def original_connection_options
-      @original_connection_options.reverse_merge(threaded_connection_options)
+        default.deep_merge(block).deep_merge(local)
+      end
     end
 
     def perform
-      case rest_action
-      when :get
-        response = connection.public_send rest_action, determined_request_url, params: determined_params, headers: determined_headers
-      when :put, :patch, :post
-        response = connection.public_send rest_action, determined_request_url, body: determined_attributes, headers: determined_headers
-      when :delete
-        response = connection.public_send rest_action, determined_request_url, params: determined_params, headers: determined_headers
-      else
-        raise RemoteResource::RESTActionUnknown, "for action: '#{rest_action}'"
-      end
+      SUPPORTED_HTTP_METHODS.include?(http_action) || raise(RemoteResource::HTTPMethodUnsupported, "Requested HTTP method=#{http_action.to_s} is NOT supported, the HTTP action MUST be a supported HTTP action=#{SUPPORTED_HTTP_METHODS.join(', ')}")
+
+      connection_response = connection.public_send(http_action, request_url, params: query, body: body, headers: headers)
+      response            = RemoteResource::Response.new(connection_response, connection_options)
 
-      if response.success? || response.response_code == 422
-        RemoteResource::Response.new response, connection_options
+      if response.success? || response.unprocessable_entity?
+        response
       else
-        raise_http_errors response
+        raise_http_error(self, response)
       end
     end
 
-    def determined_request_url
-      id           = attributes[:id].presence
-      base_url     = original_connection_options[:base_url].presence || determined_url_naming.base_url(id, check_collection_options: true)
-      content_type = connection_options[:content_type]
+    def request_url
+      @request_url ||= begin
+        id        = @attributes[:id].presence || connection_options[:id]
+        base_url  = connection_options[:base_url].presence || RemoteResource::UrlNamingDetermination.new(resource_klass, connection_options).base_url(id, check_collection_options: true)
+        extension = connection_options[:extension] || DEFAULT_EXTENSION
 
-      "#{base_url}#{content_type}"
+        "#{base_url}#{extension}"
+      end
     end
 
-    def determined_params
-      no_params     = connection_options[:no_params].eql? true
-      no_attributes = connection_options[:no_attributes].eql? true
-      params        = connection_options[:params].presence || {}
+    def query
+      @query ||= begin
+        params = connection_options[:params]
 
-      if no_params
-        nil
-      elsif no_attributes
-        params
-      else
-        attributes.merge! params
+        if params.present?
+          RemoteResource::Util.encode_params_to_query(params)
+        else
+          nil
+        end
       end
     end
 
-    def determined_attributes
-      no_attributes = connection_options[:no_attributes].eql? true
-      root_element  = connection_options[:root_element].presence
-
-      if no_attributes
-        {}
-      elsif root_element
-        pack_up_attributes attributes, root_element
-      else
-        attributes
+    def body
+      @body ||= begin
+        if [:put, :patch, :post].include?(http_action)
+          JSON.generate(attributes)
+        else
+          nil
+        end
       end
     end
 
-    def determined_headers
-      headers = original_connection_options[:headers].presence || {}
+    def attributes
+      root_element = connection_options[:root_element]
 
-      (connection_options[:default_headers].presence ||
-          resource.connection_options.headers.merge(headers)).reverse_merge RemoteResource::Base.global_headers
+      if root_element.present?
+        { root_element => @attributes }
+      else
+        @attributes || {}
+      end
     end
 
-    private
+    def headers
+      @headers ||= begin
+        default_headers = connection_options[:default_headers].presence || DEFAULT_HEADERS
+        global_headers  = RemoteResource::Base.global_headers.presence || {}
+        headers         = connection_options[:headers].presence || {}
 
-    def threaded_connection_options
-      resource.try(:threaded_connection_options) || {}
+        default_headers.merge(global_headers).merge(headers).merge(conditional_headers)
+      end
     end
 
-    def determined_url_naming
-      RemoteResource::UrlNamingDetermination.new resource_klass, original_connection_options
+    def conditional_headers
+      headers = {}
+      headers = headers.merge(DEFAULT_CONTENT_TYPE) if body.present?
+      headers
     end
 
-    def resource_klass
-      resource.is_a?(Class) ? resource : resource.class
-    end
+    private
 
-    def pack_up_attributes(attributes, root_element)
-      Hash[root_element.to_s, attributes]
+    def raise_http_error(request, response)
+      case response.try(:response_code)
+      when 301, 302, 303, 307 then raise RemoteResource::HTTPRedirectionError.new(request, response)
+      when 400 then raise RemoteResource::HTTPBadRequest.new(request, response)
+      when 401 then raise RemoteResource::HTTPUnauthorized.new(request, response)
+      when 403 then raise RemoteResource::HTTPForbidden.new(request, response)
+      when 404 then raise RemoteResource::HTTPNotFound.new(request, response)
+      when 405 then raise RemoteResource::HTTPMethodNotAllowed.new(request, response)
+      when 406 then raise RemoteResource::HTTPNotAcceptable.new(request, response)
+      when 408 then raise RemoteResource::HTTPRequestTimeout.new(request, response)
+      when 409 then raise RemoteResource::HTTPConflict.new(request, response)
+      when 410 then raise RemoteResource::HTTPGone.new(request, response)
+      when 418 then raise RemoteResource::HTTPTeapot.new(request, response)
+      when 444 then raise RemoteResource::HTTPNoResponse.new(request, response)
+      when 494 then raise RemoteResource::HTTPRequestHeaderTooLarge.new(request, response)
+      when 495 then raise RemoteResource::HTTPCertError.new(request, response)
+      when 496 then raise RemoteResource::HTTPNoCert.new(request, response)
+      when 497 then raise RemoteResource::HTTPToHTTPS.new(request, response)
+      when 499 then raise RemoteResource::HTTPClientClosedRequest.new(request, response)
+      when 400..499 then raise RemoteResource::HTTPClientError.new(request, response)
+      when 500..599 then raise RemoteResource::HTTPServerError.new(request, response)
+      else
+        raise RemoteResource::HTTPError.new(request, response)
+      end
     end
 
   end