api_client 0.1.0

data/lib/api_client/connection/basic.rb

@@ -0,0 +1,105 @@
+# Faraday for making requests
+require 'faraday'
+
+module ApiClient
+
+  module Connection
+
+    class Basic < Abstract
+
+      def create_handler
+        # Create and memoize the connection object
+        @handler = Faraday.new(@endpoint, @options[:faraday] || {})
+        finalize_handler
+      end
+
+      def finalize_handler
+        @handler.use     Middlewares::Request::Logger, ApiClient.logger if ApiClient.logger
+        @handler.use     Faraday::Request::UrlEncoded
+        @handler.adapter Faraday.default_adapter
+      end
+
+      #### ApiClient::Connection::Abstract#get
+      # Performs a GET request
+      # Accepts three parameters:
+      #
+      # * path - the path the request should go to
+      # * data - (optional) the query, passed as a hash and converted into query params
+      # * headers - (optional) headers sent along with the request
+      #
+      def get(path, data = {}, headers = {})
+        query = Faraday::Utils.build_nested_query(data || {})
+        path  = [path, query].join('?') unless query.empty?
+        handle_response @handler.get(path, headers)
+      end
+
+      #### ApiClient::Connection::Abstract#post
+      # Performs a POST request
+      # Accepts three parameters:
+      #
+      # * path - the path request should go to
+      # * data - (optional) data sent in the request
+      # * headers - (optional) headers sent along in the request
+      #
+      # This method automatically adds the application token header
+      def post(path, data = {}, headers = {})
+        handle_response @handler.post(path, data, headers)
+      end
+
+      #### ApiClient::Connection::Abstract#put
+      # Performs a PUT request
+      # Accepts three parameters:
+      #
+      # * path - the path request should go to
+      # * data - (optional) data sent in the request
+      # * headers - (optional) headers sent along in the request
+      #
+      # This method automatically adds the application token header
+      def put(path, data = {}, headers = {})
+        handle_response @handler.put(path, data, headers)
+      end
+
+      #### FS::Connection#delete
+      # Performs a DELETE request
+      # Accepts three parameters:
+      #
+      # * path - the path request should go to
+      # * data - (optional) the query, passed as a hash and converted into query params
+      # * headers - (optional) headers sent along in the request
+      #
+      # This method automatically adds the application token header
+      def delete(path, data = {}, headers = {})
+        query = Faraday::Utils.build_nested_query(data || {})
+        path  = [path, query].join('?') unless query.empty?
+        handle_response @handler.delete(path, headers)
+      end
+
+      private
+
+      def handle_response(response)
+        raise ApiClient::Errors::ConnectionFailed if !response
+        case response.status
+          when 401
+            raise ApiClient::Errors::Unauthorized
+          when 403
+            raise ApiClient::Errors::Forbidden
+          when 404
+            raise ApiClient::Errors::NotFound
+          when 400
+            raise ApiClient::Errors::BadRequest
+          when 406
+            raise ApiClient::Errors::Unsupported
+          when 422
+            raise ApiClient::Errors::UnprocessableEntity.new(response.body)
+          when 300..399
+            raise ApiClient::Errors::Redirect.new(response['Location'])
+          when 500..599
+            raise ApiClient::Errors::ServerError
+          else
+            response
+        end
+      end
+
+    end
+  end
+end

data/lib/api_client/connection/middlewares/request/logger.rb

@@ -0,0 +1,17 @@
+require "logger"
+class ApiClient::Connection::Middlewares::Request::Logger < Faraday::Middleware
+
+  def call(env)
+    time    = Time.now
+    returns = @app.call(env)
+    taken   = Time.now - time
+    @logger.info "#{env[:method].upcase} #{env[:url]}: #{"%.4f" % taken} seconds"
+    returns
+  end
+
+  def initialize(app, logger = nil)
+    @logger = logger || ::Logger.new(STDOUT)
+    @app    = app
+  end
+
+end

data/lib/api_client/connection/middlewares/request/oauth.rb

@@ -0,0 +1,22 @@
+# Borrowed from https://github.com/pengwynn/faraday_middleware/blob/master/lib/faraday/request/oauth.rb
+class ApiClient::Connection::Middlewares::Request::OAuth < Faraday::Middleware
+
+  dependency 'simple_oauth'
+
+  def call(env)
+    params = env[:body] || {}
+    signature_params = params.reject{ |k,v| v.respond_to?(:content_type) }
+
+    header = SimpleOAuth::Header.new(env[:method], env[:url], signature_params, @options || {})
+
+    env[:request_headers]['Authorization'] = header.to_s
+    env[:request_headers]['User-Agent'] = "ApiClient gem v#{ApiClient::VERSION}"
+
+    @app.call(env)
+  end
+
+  def initialize(app, options = {})
+    @app, @options = app, options
+  end
+
+end

data/lib/api_client/connection/oauth.rb

@@ -0,0 +1,18 @@
+module ApiClient
+
+  module Connection
+
+    class Oauth < Basic
+
+      def finalize_handler
+        @handler.use     Middlewares::Request::Logger, ApiClient.logger if ApiClient.logger
+        @handler.use     Middlewares::Request::OAuth,  @options[:oauth]
+        @handler.use     Faraday::Request::UrlEncoded
+        @handler.adapter Faraday.default_adapter
+      end
+
+    end
+
+  end
+
+end

data/lib/api_client/errors.rb

@@ -0,0 +1,16 @@
+module ApiClient
+
+  module Errors
+    class ConnectionFailed < Exception; end
+    class Config < Exception; end
+    class Unauthorized < Exception; end
+    class Forbidden < Exception; end
+    class NotFound < Exception; end
+    class Redirect < Exception; end
+    class BadRequest < Exception; end
+    class Unsupported < Exception; end
+    class ServerError < Exception; end
+    class UnprocessableEntity < Exception; end
+  end
+
+end

data/lib/api_client/mixins/configuration.rb

@@ -0,0 +1,24 @@
+module ApiClient
+
+  module Mixins
+
+    module Configuration
+
+      def dsl_accessor(*names)
+        options = names.last.is_a?(Hash) ? names.pop : {}
+        names.each do |name|
+          returns = options[:return_self] ? "self" : "@#{name}"
+          class_eval <<-STR
+            def #{name}(value = nil)
+              value.nil? ? @#{name} : @#{name} = value
+              #{returns}
+            end
+          STR
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/api_client/mixins/connection_hooks.rb

@@ -0,0 +1,24 @@
+module ApiClient
+
+  module Mixins
+
+    module ConnectionHooks
+
+      attr_accessor :connection_hooks
+
+      def connection(&block)
+        @connection_hooks ||= []
+        @connection_hooks.push(block) if block
+        @connection_hooks
+      end
+
+      def connection_hooks
+        @connection_hooks || []
+      end
+
+    end
+
+  end
+
+end
+

data/lib/api_client/mixins/delegation.rb

@@ -0,0 +1,23 @@
+module ApiClient
+
+  module Mixins
+
+    module Delegation
+
+      def delegate(*methods)
+        hash = methods.pop
+        to = hash[:to]
+        methods.each do |method|
+          class_eval <<-STR
+          def #{method}(*args, &block)
+            #{to}.#{method}(*args, &block)
+          end
+          STR
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/api_client/mixins/inheritance.rb

@@ -0,0 +1,19 @@
+module ApiClient
+
+  module Mixins
+
+    module Inheritance
+
+      def inherited(subclass)
+        subclass.default_scopes   = self.default_scopes.dup
+        subclass.connection_hooks = self.connection_hooks.dup
+
+        subclass.namespace          self.namespace
+        subclass.format             self.format
+      end
+
+    end
+
+  end
+
+end

data/lib/api_client/mixins/instantiation.rb

@@ -0,0 +1,35 @@
+module ApiClient
+
+  module Mixins
+
+    module Instantiation
+
+      def self.extended(base)
+        base.instance_eval do
+          attr_accessor :original_scope
+        end
+      end
+
+      def build_one(hash)
+        instance = self.new self.namespace ? hash[namespace] : hash
+        instance.original_scope = self.scope
+        instance
+      end
+
+      def build_many(array)
+        array.collect { |one| build_one(one) }
+      end
+
+      def build(result_or_array)
+        if result_or_array.is_a?(Array)
+          build_many result_or_array
+        else
+          build_one  result_or_array
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/api_client/mixins/scoping.rb

@@ -0,0 +1,49 @@
+module ApiClient
+
+  module Mixins
+
+    module Scoping
+
+      attr_accessor :default_scopes
+
+      # Default scoping
+      def always(&block)
+        default_scopes.push(block) if block
+      end
+
+      def default_scopes
+        @default_scopes || []
+      end
+
+      # Scoping
+      def scope(options = {})
+        scope_in_thread || Scope.new(self).params(options)
+      end
+
+      # Allow wrapping singleton methods in a scope
+      # Store the handler in a thread-local variable for thread safety
+      def scoped(scope)
+        Thread.current[scope_thread_attribute_name] ||= []
+        Thread.current[scope_thread_attribute_name].push scope
+        begin
+          yield
+        ensure
+          Thread.current[scope_thread_attribute_name] = nil
+        end
+      end
+
+      def scope_thread_attribute_name
+        "#{self.name}_scope"
+      end
+
+      def scope_in_thread
+        if found = Thread.current[scope_thread_attribute_name]
+          found.last
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/api_client/resource/base.rb

@@ -0,0 +1,63 @@
+module ApiClient
+
+  module Resource
+
+    class Base < ApiClient::Base
+
+      class << self
+        extend ApiClient::Mixins::Delegation
+        extend ApiClient::Mixins::Configuration
+
+        delegate :find_all, :find, :create, :update, :destroy, :path, :to => :scope
+
+        dsl_accessor :prefix
+
+        def inherited(subclass)
+          super
+          small_name = subclass.name.split('::').last.downcase
+          subclass.namespace small_name
+          subclass.prefix    self.prefix
+          subclass.always do
+            name    = subclass.name.split('::').last.downcase
+            pre_fix = prefix
+            path ["", prefix, "#{name}s"].compact.join('/')
+          end
+        end
+
+        def scope(options = {})
+          scope_in_thread || ApiClient::Resource::Scope.new(self).params(options)
+        end
+
+      end
+
+      def persisted?
+        !!self.id
+      end
+
+      def save
+        self.persisted? ? remote_update : remote_create
+      end
+
+      def destroy
+        self.class.destroy(self.id)
+      end
+
+      def payload
+        hash = self.to_hash
+        hash.delete('id') # This key is never required
+        hash
+      end
+
+      def remote_update
+        self.class.update(self.id, payload)
+      end
+
+      def remote_create
+        self.class.create(payload)
+      end
+
+    end
+
+  end
+
+end

data/lib/api_client/resource/scope.rb

@@ -0,0 +1,73 @@
+# This class includes methods for calling restful APIs
+module ApiClient
+
+  module Resource
+
+    class Scope < ApiClient::Scope
+
+      dsl_accessor :path, :return_self => true
+
+      def format
+        @scopeable.format
+      end
+
+      def append_format(path)
+        format ? [path, format].join('.') : path
+      end
+
+      def find(id)
+        path = [@path, id].join('/')
+        path = append_format(path)
+        raw  = get(path)
+        scoped(self) do
+          @scopeable.build(raw)
+        end
+      end
+
+      def find_all(params = {})
+        path = append_format(@path)
+        raw  = get(path, params)
+        scoped(self) do
+          @scopeable.build(raw)
+        end
+      end
+
+      def create(params = {})
+        path = append_format(@path)
+        hash = if @scopeable.namespace
+          { @scopeable.namespace => params }
+        else
+          params
+        end
+        response = post(path, hash)
+        scoped(self) do
+          @scopeable.build(response)
+        end
+      end
+
+      def update(id, params = {})
+        path = [@path, id].join('/')
+        path = append_format(path)
+        hash = if @scopeable.namespace
+          { @scopeable.namespace => params }
+        else
+          params
+        end
+        response = put(path, hash)
+        scoped(self) do
+          @scopeable.build(response)
+        end
+      end
+
+      def destroy(id)
+        path = [@path, id].join('/')
+        path = append_format(path)
+        delete(path)
+        true
+      end
+
+    end
+
+  end
+
+end