api_client 0.5.24-java → 0.5.25-java

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,31 @@
+module ApiClient
+
+  module Errors
+    class ApiClientError < StandardError
+      def initialize(message = nil, request = nil, response = nil)
+        message ||= "Status code: #{response.status}" if response
+        super(message)
+        @request = request
+        @response = response
+      end
+
+      attr_reader :request, :response
+    end
+
+    class ConnectionFailed < ApiClientError; end
+    class Config < ApiClientError; end
+    class Unauthorized < ApiClientError; end
+    class Forbidden < ApiClientError; end
+    class NotFound < ApiClientError; end
+    class Redirect < ApiClientError; end
+    class BadRequest < ApiClientError; end
+    class Unsupported < ApiClientError; end
+    class Conflict < ApiClientError; end
+    class Gone < ApiClientError; end
+    class ServerError < ApiClientError; end
+    class UnprocessableEntity < ApiClientError; end
+    class Locked < ApiClientError; end
+    class TooManyRequests < ApiClientError; 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,29 @@
+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.clone_only_headers
+        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,67 @@
+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 = NameResolver.resolve(subclass.name)
+          subclass.namespace small_name
+          subclass.prefix    self.prefix
+          subclass.always do
+            name    = small_name
+            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
+        get_scope.destroy(self.id)
+      end
+
+      def payload
+        hash = self.to_hash
+        hash.delete('id') # This key is never required
+        hash
+      end
+
+      def remote_update
+        get_scope.update(self.id, payload)
+      end
+
+      def remote_create
+        get_scope.create(payload)
+      end
+
+      def get_scope
+        original_scope || self.class
+      end
+
+    end
+
+  end
+
+end

data/lib/api_client/resource/name_resolver.rb

@@ -0,0 +1,37 @@
+module ApiClient
+  module Resource
+    class NameResolver
+      def self.resolve(ruby_path)
+        new(ruby_path).resolve
+      end
+
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def resolve
+        select_last_item
+        underscorize
+        lowercase
+        name
+      end
+
+      private
+      def select_last_item
+        @name = @name.split('::').last
+      end
+
+      #Inspired by ActiveSupport::Inflector#underscore
+      def underscorize
+        @name.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        @name.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      end
+
+      def lowercase
+        @name.downcase!
+      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)
+        response = get(path)
+        scoped(self) do
+          raw? ? response : @scopeable.build(response)
+        end
+      end
+
+      def find_all(params = {})
+        path     = append_format(@path)
+        response = get(path, params)
+        scoped(self) do
+          raw? ? response : @scopeable.build(response)
+        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
+          raw? ? response : @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
+          raw? ? response : @scopeable.build(response)
+        end
+      end
+
+      def destroy(id)
+        path = [@path, id].join('/')
+        path = append_format(path)
+        delete(path)
+        true
+      end
+
+    end
+
+  end
+
+end

data/lib/api_client/scope.rb

@@ -0,0 +1,125 @@
+module ApiClient
+
+  class Scope
+    extend ApiClient::Mixins::Configuration
+    extend ApiClient::Mixins::Delegation
+
+    delegate     :prefix, :scoped, :to => :scopeable
+
+    dsl_accessor :endpoint, :adapter, :return_self => true
+
+    attr_reader  :scopeable
+
+    def initialize(scopeable)
+      @scopeable  = scopeable
+      @params     = {}
+      @headers    = {}
+      @options    = {}
+      @scopeable.default_scopes.each do |default_scope|
+        self.instance_eval(&default_scope)
+      end
+    end
+
+    def connection
+      klass       = Connection.const_get((@adapter || Connection.default).to_s.capitalize)
+      @connection = klass.new(@endpoint , @options || {})
+      hooks      = @scopeable.connection_hooks || []
+      hooks.each { |hook| hook.call(@connection, self) }
+      @connection
+    end
+
+    def raw
+      @raw = true
+      self
+    end
+
+    def raw?
+      !!@raw
+    end
+
+    # 3 Pillars of scoping
+    # options - passed on the the adapter
+    # params  - converted to query or request body
+    # headers - passed on to the request
+    def options(new_options = nil)
+      return @options if new_options.nil?
+      ApiClient::Utils.deep_merge(@options, new_options)
+      self
+    end
+
+    def params(options = nil)
+      return @params if options.nil?
+      ApiClient::Utils.deep_merge(@params, options)  if options
+      self
+    end
+    alias :scope :params
+
+    def headers(options = nil)
+      return @headers if options.nil?
+      ApiClient::Utils.deep_merge(@headers, options) if options
+      self
+    end
+
+    def raw_body(options = nil)
+      return @raw_body if options.nil?
+      @raw_body = options
+      self
+    end
+
+    def clone_only_headers
+      self.class.new(self.scopeable).headers(self.headers)
+    end
+
+    # Half-level :)
+    # This is a swiss-army knife kind of method, extremely useful
+    def fetch(path, options = {})
+      scoped(self) do
+        @scopeable.build get(path, options)
+      end
+    end
+
+    # Low-level connection methods
+
+    def request(method, path, options = {})
+      options = options.dup
+
+      raw = raw? || options.delete(:raw)
+      params(options)
+      response = connection.send method, path, (@raw_body || @params), @headers
+      raw ? response : @scopeable.parse(response)
+    end
+
+    def get(path, options = {})
+      request(:get, path, options)
+    end
+
+    def post(path, options = {})
+      request(:post, path, options)
+    end
+
+    def patch(path, options = {})
+      request(:patch, path, options)
+    end
+
+    def put(path, options = {})
+      request(:put, path, options)
+    end
+
+    def delete(path, options = {})
+      request(:delete, path, options)
+    end
+
+    # Dynamic delegation of scopeable methods
+    def method_missing(method, *args, &block)
+      if @scopeable.respond_to?(method)
+        @scopeable.scoped(self) do
+          @scopeable.send(method, *args, &block)
+        end
+      else
+        super
+      end
+    end
+
+  end
+
+end