ddy_remote_resource 0.4.2

data/lib/remote_resource/builder.rb

@@ -0,0 +1,53 @@
+module RemoteResource
+  module Builder
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def build_resource_from_response(response)
+        build_resource response.sanitized_response_body, response_hash(response)
+      end
+
+      def build_resource(collection, response_hash = {})
+        if collection.is_a? Hash
+          new collection.merge response_hash
+        end
+      end
+
+      def build_collection_from_response(response)
+        build_collection response.sanitized_response_body, response_hash(response)
+      end
+
+      def build_collection(collection, response_hash = {})
+        if collection.is_a? Array
+          RemoteResource::Collection.new self, collection, response_hash
+        end
+      end
+
+      private
+
+      def response_hash(response_object)
+        { _response: response_object }
+      end
+    end
+
+    def rebuild_resource_from_response(response)
+      rebuild_resource response.sanitized_response_body, response_hash(response)
+    end
+
+    def rebuild_resource(collection, response_hash = {})
+      if collection.is_a? Hash
+        self.attributes = collection.merge(response_hash)
+      else
+        self.attributes = response_hash
+      end and self
+    end
+
+    private
+
+    def response_hash(response_object)
+      self.class.send :response_hash, response_object
+    end
+
+  end
+end

data/lib/remote_resource/collection.rb

@@ -0,0 +1,31 @@
+module RemoteResource
+  class Collection
+    include Enumerable
+
+    delegate :[], :at, :reverse, :size, to: :to_a
+
+    attr_reader :resource_klass, :resources_collection, :_response
+
+    def initialize(resource_klass, resources_collection, response_hash)
+      @resource_klass       = resource_klass
+      @resources_collection = resources_collection
+      @response_hash        = response_hash
+      @_response            = response_hash[:_response]
+    end
+
+    def each
+      if resources_collection.is_a? Array
+        resources_collection.each { |element| yield resource_klass.new element.merge(@response_hash) }
+      end
+    end
+
+    def empty?
+      resources_collection.blank?
+    end
+
+    def success?
+      _response.success?
+    end
+
+  end
+end

data/lib/remote_resource/connection.rb

@@ -0,0 +1,24 @@
+module RemoteResource
+  module Connection
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :content_type, :default_headers, :extra_headers, instance_accessor: false
+
+      self.content_type    = '.json'
+      self.default_headers = { "Accept" => "application/json" }
+    end
+
+    module ClassMethods
+
+      def connection
+        Typhoeus::Request
+      end
+
+      def headers
+        self.default_headers.merge self.extra_headers || {}
+      end
+
+    end
+  end
+end

data/lib/remote_resource/connection_options.rb

@@ -0,0 +1,41 @@
+module RemoteResource
+  class ConnectionOptions
+
+    attr_reader :base_class
+
+    def initialize(base_class)
+      @base_class = base_class
+      self.send :initialize_connection_options
+    end
+
+    def merge(options = {})
+      options.each do |option, value|
+        self.public_send "#{option}=", value
+      end and self
+    end
+
+    def to_hash
+      RemoteResource::Base::OPTIONS.each_with_object(Hash.new) do |option, hash|
+        hash[option] = self.public_send option
+      end
+    end
+
+    def reload
+      initialize_connection_options
+    end
+
+    def reload!
+      reload and self
+    end
+
+    private
+
+    def initialize_connection_options
+      RemoteResource::Base::OPTIONS.each do |option|
+        self.class.send :attr_accessor, option
+        self.public_send "#{option}=", base_class.public_send(option)
+      end
+    end
+
+  end
+end

data/lib/remote_resource/http_errors.rb

@@ -0,0 +1,33 @@
+module RemoteResource
+  module HTTPErrors
+
+    private
+
+    def raise_http_errors(response)
+      case response.response_code
+      when 301, 302, 303, 307 then raise RemoteResource::HTTPRedirectionError, response
+      when 400 then raise RemoteResource::HTTPBadRequest, response
+      when 401 then raise RemoteResource::HTTPUnauthorized, response
+      when 403 then raise RemoteResource::HTTPForbidden, response
+      when 404 then raise RemoteResource::HTTPNotFound, response
+      when 405 then raise RemoteResource::HTTPMethodNotAllowed, response
+      when 406 then raise RemoteResource::HTTPNotAcceptable, response
+      when 408 then raise RemoteResource::HTTPRequestTimeout, response
+      when 409 then raise RemoteResource::HTTPConflict, response
+      when 410 then raise RemoteResource::HTTPGone, response
+      when 418 then raise RemoteResource::HTTPTeapot, response
+      when 444 then raise RemoteResource::HTTPNoResponse, response
+      when 494 then raise RemoteResource::HTTPRequestHeaderTooLarge, response
+      when 495 then raise RemoteResource::HTTPCertError, response
+      when 496 then raise RemoteResource::HTTPNoCert, response
+      when 497 then raise RemoteResource::HTTPToHTTPS, response
+      when 499 then raise RemoteResource::HTTPClientClosedRequest, response
+      when 400..499 then raise RemoteResource::HTTPClientError, response
+      when 500..599 then raise RemoteResource::HTTPServerError, response
+      else
+        raise RemoteResource::HTTPError, response
+      end
+    end
+
+  end
+end

data/lib/remote_resource/querying/finder_methods.rb

@@ -0,0 +1,34 @@
+module RemoteResource
+  module Querying
+    module FinderMethods
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def find(id, connection_options = {})
+          connection_options.merge! no_params: true
+          response = RemoteResource::Request.new(self, :get, { id: id }, connection_options).perform
+          build_resource_from_response response
+        end
+
+        def find_by(params, connection_options = {})
+          response = RemoteResource::Request.new(self, :get, params, connection_options).perform
+          build_resource_from_response response
+        end
+
+        def all(connection_options = {})
+          connection_options.merge! collection: true
+          response = RemoteResource::Request.new(self, :get, {}, connection_options).perform
+          build_collection_from_response response
+        end
+
+        def where(params, connection_options = {})
+          connection_options.merge! collection: true
+          response = RemoteResource::Request.new(self, :get, params, connection_options).perform
+          build_collection_from_response response
+        end
+      end
+
+    end
+  end
+end

data/lib/remote_resource/querying/persistence_methods.rb

@@ -0,0 +1,38 @@
+module RemoteResource
+  module Querying
+    module PersistenceMethods
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def create(attributes = {}, connection_options = {})
+          resource = new attributes
+          response = RemoteResource::Request.new(self, :post, attributes, connection_options).perform
+          resource.handle_response response
+        end
+      end
+
+      def update_attributes(attributes = {}, connection_options = {})
+        rebuild_resource attributes
+        attributes.reverse_merge! id: id
+        create_or_update attributes, connection_options
+        success? ? self : false
+      end
+
+      def save(connection_options = {})
+        create_or_update self.attributes, connection_options
+        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
+
+    end
+  end
+end

data/lib/remote_resource/request.rb

@@ -0,0 +1,106 @@
+module RemoteResource
+  class Request
+    include RemoteResource::HTTPErrors
+
+    attr_reader :resource, :rest_action, :attributes
+
+    def initialize(resource, rest_action, attributes = {}, connection_options = {})
+      @resource           = resource
+      @rest_action        = rest_action.to_sym
+      @attributes         = attributes
+      @connection_options = connection_options
+      @original_connection_options = connection_options.dup
+    end
+
+    def connection
+      resource_klass.connection
+    end
+
+    def connection_options
+      @connection_options.reverse_merge! threaded_connection_options
+      @connection_options.reverse_merge! resource.connection_options.to_hash
+    end
+
+    def original_connection_options
+      @original_connection_options.reverse_merge! threaded_connection_options
+    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
+      else
+        raise RemoteResource::RESTActionUnknown, "for action: '#{rest_action}'"
+      end
+
+      if response.success? || response.response_code == 422
+        RemoteResource::Response.new response, connection_options
+      else
+        raise_http_errors 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)
+      content_type = connection_options[:content_type]
+
+      "#{base_url}#{content_type}"
+    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 || {}
+
+      if no_params
+        nil
+      elsif no_attributes
+        params
+      else
+        attributes.merge! params
+      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
+      end
+    end
+
+    def determined_headers
+      headers = original_connection_options[:headers].presence || {}
+
+      (connection_options[:default_headers].presence ||
+          resource.connection_options.headers.merge(headers)).reverse_merge RemoteResource::Base.global_headers
+    end
+
+    private
+
+    def threaded_connection_options
+      resource.try(:threaded_connection_options) || {}
+    end
+
+    def determined_url_naming
+      RemoteResource::UrlNamingDetermination.new resource_klass, original_connection_options
+    end
+
+    def resource_klass
+      resource.is_a?(Class) ? resource : resource.class
+    end
+
+    def pack_up_attributes(attributes, root_element)
+      Hash[root_element.to_s, attributes]
+    end
+
+  end
+end

data/lib/remote_resource/response.rb

@@ -0,0 +1,69 @@
+module RemoteResource
+  class Response
+
+    attr_reader :original_response, :original_request
+    private :original_response, :original_request
+
+    def initialize(response, connection_options = {})
+      @original_response  = response
+      @original_request   = response.request
+      @connection_options = connection_options
+    end
+
+    def success?
+      original_response.success?
+    end
+
+    def unprocessable_entity?
+      response_code == 422
+    end
+
+    def response_body
+      original_response.body
+    end
+
+    def response_code
+      original_response.response_code
+    end
+
+    def sanitized_response_body
+      return empty_hash if response_body.blank?
+      return empty_hash if parsed_response_body.blank?
+
+      unpacked_parsed_response_body
+    end
+
+    def error_messages_response_body
+      return empty_hash if response_body.blank?
+      return empty_hash if parsed_response_body.blank?
+
+      return parsed_response_body["errors"]          if parsed_response_body.try :has_key?, "errors"
+      return unpacked_parsed_response_body["errors"] if unpacked_parsed_response_body.try :has_key?, "errors"
+
+      empty_hash
+    end
+
+    def parsed_response_body
+      @parsed_response_body ||= JSON.parse response_body
+    rescue JSON::ParserError
+      nil
+    end
+
+    private
+
+    def empty_hash
+      {}
+    end
+
+    def unpacked_parsed_response_body
+      root_element = @connection_options[:root_element].presence
+
+      if root_element
+        parsed_response_body[root_element.to_s]
+      else
+        parsed_response_body
+      end
+    end
+
+  end
+end

data/lib/remote_resource/response_handeling.rb

@@ -0,0 +1,48 @@
+module RemoteResource
+  class ResponseHandeling
+
+    attr_reader :resource, :response, :connection_options
+
+    def initialize(resource, response, connection_options = {})
+      @resource           = resource
+      @response           = response
+      @connection_options = connection_options
+    end
+
+    def perform
+      if response.success?
+        if resource.respond_to? :new
+          resource.build_resource_from_response response
+        else
+          resource
+        end
+      elsif errors?
+        if resource.respond_to? :new
+          #
+        else
+          # assign response
+          resource.assign_errors response.parsed_response_body, root_element
+        end
+      else
+        # nil
+      end
+    end
+
+    def errors?
+      parsed_response_body = response.parsed_response_body
+
+      if parsed_response_body
+        parsed_response_body.has_key?("errors") || parsed_response_body.fetch(root_element.to_s, nil).has_key?("errors")
+      else
+        false
+      end
+    end
+
+    private
+
+    def root_element
+      connection_options[:root_element].presence || resource.connection_options.root_element.presence
+    end
+
+  end
+end