api_client 0.5.24-java → 0.6.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86de6b224c93faa28969412f7d2121a53a613739959da4d0993b7e3143c2ccb3
-  data.tar.gz: 5e51da700d497e3444e515c166459f4485e180b5705a04af3212750e3d924937
+  metadata.gz: 861da114f0da9d319e5e08c020e4c07f29299fb111975feeec2b926142f7d1f5
+  data.tar.gz: f4faf72c964e354f05ff9bafe9da81385f749453130c21877081cf3b73dae220
 SHA512:
-  metadata.gz: 511be118de39ceefb8cf983e9798fec9de476f82c78e77e2b8924d97a2740f3e1b9daef81a763678407a08cb158de6a77d8b5ee5fdc9398fa363fbc9cd9a1fba
-  data.tar.gz: bb9d276c8ce9c2442acee7b085801e8e728e5898a668678a37725b6ce747f7bd9a6855c46eb210009fa19b272437970ccbda655fec0ea569e47556478033bf88
+  metadata.gz: c928fcc0591ec30b435c8e135b583228e302282031dcc5c8122f7edcd3987010ddb43b8954b3c169a89e77a43d50ce4e898c0c3ec1ea93b539b85f1bf3c94d39
+  data.tar.gz: 1601de7481ad45bbdce864ec4291197721b222dafbc0b119dd739a26fc38ece6a96a728b40f038809ae886fb89498328a699245b901a798f703a9a2d23a3051c

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# 0.6.0
+
+* Add support for faraday gem version >= 1.0.0 and < 2.0.0
+* Drop support for Ruby < 2.3
+
+# 0.5.26
+
+* Add support for HTTP status code: 412 Precondition Failed
+
+# 0.5.25
+
+* Fix broken gem build (gemspec files)
+
 # 0.5.23
 
 * Add support for HTTP status code: 423 Locked

data/lib/api_client/base.rb

@@ -0,0 +1,77 @@
+module ApiClient
+
+  class Base < Hashie::Mash
+
+    extend ApiClient::Mixins::Inheritance
+    extend ApiClient::Mixins::Instantiation
+    extend ApiClient::Mixins::Scoping
+    extend ApiClient::Mixins::ConnectionHooks
+
+    class << self
+      extend ApiClient::Mixins::Delegation
+      extend ApiClient::Mixins::Configuration
+
+      delegate :fetch, :get, :put, :post, :patch, :delete, :headers, :endpoint, :options, :adapter, :params, :raw, :to => :scope
+
+      dsl_accessor :format, :namespace
+
+      def subkey_class
+        Hashie::Mash
+      end
+
+      def parse(response)
+        if response.is_a?(Faraday::Response)
+          return nil if response.status == 204
+          response = response.body
+        end
+
+        if self.format == :json
+          MultiJson.load(response)
+        elsif self.format == :xml
+          MultiXml.parse(response)
+        else
+          response
+        end
+      end
+
+    end
+
+    # Defaults
+    self.format :json
+
+    def id
+      self['id']
+    end
+
+    def inspect
+      attributes = []
+      attr_keys = self.keys - ['id']
+      attributes.push "id: #{self.id}" if self.id
+      attr_keys.each do |key|
+        attributes.push("#{key}: #{self[key].inspect}")
+      end
+      "#<#{self.class} #{attributes.join(', ')}>"
+    end
+
+    private
+    def method_missing(method_name, *args, &blk)
+      if respond_to?(method_name) || has_special_ending?(method_name)
+        super
+      elsif use_strict_reader?(method_name)
+        fetch(method_name)
+      else
+        super
+      end
+    end
+
+    def use_strict_reader?(method_name)
+      respond_to?(:strict_attr_reader?) &&
+        self.strict_attr_reader? &&
+        method_name != :to_ary
+    end
+
+    def has_special_ending?(name)
+      name.to_s =~ /[?=]$/
+    end
+  end
+end

data/lib/api_client/connection/abstract.rb

@@ -0,0 +1,81 @@
+module ApiClient
+
+  module Connection
+
+    class Abstract
+
+      attr_accessor :endpoint, :handler, :options
+
+      def initialize(endpoint, options = {})
+        raise "Cannot instantiate abstract class" if self.class == ApiClient::Connection::Abstract
+        @endpoint = endpoint
+        @options  = options
+        create_handler
+      end
+
+      def create_handler
+      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 = {})
+      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
+      #
+      def post(path, data = {}, headers = {})
+      end
+
+      #### ApiClient::Connection::Abstract#patch
+      # Performs a PATCH 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
+      #
+      def patch(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
+      #
+      def 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
+      #
+      def delete(path, data = {}, headers = {})
+      end
+
+      def inspect
+        "#<#{self.class} endpoint: \"#{endpoint}\">"
+      end
+      alias :to_s :inspect
+
+    end
+  end
+end

data/lib/api_client/connection/basic.rb

@@ -0,0 +1,131 @@
+module ApiClient
+
+  module Connection
+
+    class Basic < Abstract
+
+      def create_handler
+        # Create and memoize the connection object
+        # The empty block is necessary as we don't want Faraday to
+        # initialize itself, we build our own stack in finalize_handler
+        @handler = Faraday.new(@endpoint, @options[:faraday] || {})  do end
+        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 = {})
+        exec_request(:get, path, data, 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 = {})
+        exec_request(:post, path, data, headers)
+      end
+
+      #### ApiClient::Connection::Abstract#patch
+      # Performs a PATCH 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 patch(path, data = {}, headers = {})
+        exec_request(:patch, 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 = {})
+        exec_request(: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 = {})
+        exec_request(:delete, path, data, headers)
+      end
+
+      private
+
+      def exec_request(method, path, data, headers)
+        response = @handler.send(method, path, data, headers)
+        request = { :method => method, :path => path, :data => data}
+        handle_response(request, response)
+      rescue Faraday::ConnectionFailed => e
+        raise ApiClient::Errors::ConnectionFailed.new(e.message, request, response)
+      end
+
+      def handle_response(request, response)
+        raise ApiClient::Errors::ConnectionFailed.new(nil, request, response) unless response
+        case response.status
+          when 401
+            raise ApiClient::Errors::Unauthorized.new(nil, request, response)
+          when 403
+            raise ApiClient::Errors::Forbidden.new(nil, request, response)
+          when 404
+            raise ApiClient::Errors::NotFound.new(nil, request, response)
+          when 400
+            raise ApiClient::Errors::BadRequest.new(nil, request, response)
+          when 406
+            raise ApiClient::Errors::Unsupported.new(nil, request, response)
+          when 409
+            raise ApiClient::Errors::Conflict.new(nil, request, response)
+          when 410
+            raise ApiClient::Errors::Gone.new(nil, request, response)
+          when 412
+            raise ApiClient::Errors::PreconditionFailed.new(nil, request, response)
+          when 422
+            raise ApiClient::Errors::UnprocessableEntity.new(response.body, request, response)
+          when 423
+            raise ApiClient::Errors::Locked.new(response.body, request, response)
+          when 429
+            raise ApiClient::Errors::TooManyRequests.new(response.body, request, response)
+          when 300..399
+            raise ApiClient::Errors::Redirect.new(response['Location'], request, response)
+          when 500..599
+            raise ApiClient::Errors::ServerError.new(nil, request, response)
+          else
+            response
+        end
+      end
+
+    end
+  end
+end

data/lib/api_client/connection/json.rb

@@ -0,0 +1,14 @@
+# Exactly like Basic, but uses JSON encoding for request body
+# if applicable
+module ApiClient
+  module Connection
+    class Json < Basic
+      def finalize_handler
+        @handler.use     Middlewares::Request::Logger, ApiClient.logger if ApiClient.logger
+        @handler.use     Middlewares::Request::Json
+        @handler.use     Faraday::Request::UrlEncoded
+        @handler.adapter Faraday.default_adapter
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+class ApiClient::Connection::Middlewares::Request::Json < Faraday::Middleware
+  CONTENT_TYPE = "Content-Type".freeze
+
+  class << self
+    attr_accessor :mime_type
+  end
+  self.mime_type = "application/json".freeze
+
+  def call(env)
+    match_content_type(env) do |data|
+      params = Faraday::Utils::ParamsHash[data]
+      env[:body] = MultiJson.dump(params)
+    end
+    @app.call env
+  end
+
+  def match_content_type(env)
+    if process_request?(env)
+      env[:request_headers][CONTENT_TYPE] ||= self.class.mime_type
+      yield env[:body] unless env[:body].respond_to?(:to_str)
+    end
+  end
+
+  def process_request?(env)
+    type = request_type(env)
+    env[:body] and (type.empty? or type == self.class.mime_type)
+  end
+
+  def request_type(env)
+    type = env[:request_headers][CONTENT_TYPE].to_s
+    type = type.split(";", 2).first if type.index(";")
+    type
+  end
+end

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

@@ -0,0 +1,64 @@
+require "logger"
+
+class ApiClient::Connection::Middlewares::Request::Logger < Faraday::Middleware
+  def call(env)
+    debug_lines = []
+    should_log_details = @logger.level <= ::Logger::DEBUG
+
+    gather_request_debug_lines(env, debug_lines) if should_log_details
+
+    start = CurrentTimestamp.milis
+    response = @app.call(env)
+    taken_sec = (CurrentTimestamp.milis - start) / 1000.0
+
+    gather_response_debug_lines(response, taken_sec, debug_lines) if response && should_log_details
+
+    if should_log_details
+      debug_lines.each { |line| line.encode!("UTF-8", invalid: :replace, undef: :replace) }
+      @logger.debug { debug_lines.join("\n") }
+    else
+      @logger.info { "#{env[:method].to_s.upcase} #{env[:url]}: #{"%.4f" % taken_sec} seconds" }
+    end
+
+    response
+  end
+
+  def initialize(app, logger = nil)
+    @logger = logger || ::Logger.new(STDOUT)
+    @app = app
+  end
+
+  private
+
+  def gather_request_debug_lines(env, debug_lines)
+    debug_lines << "> #{env[:method].to_s.upcase} #{env[:url]}"
+    env[:request_headers].each { |k, v| debug_lines << "> #{k}: #{v}" }
+    debug_lines << "> "
+    debug_lines << "> #{env[:body]}\n> " if env[:body] && env[:body] != ""
+    debug_lines
+  end
+
+  def gather_response_debug_lines(response, taken_sec, debug_lines)
+    debug_lines << "< responded in #{"%.4f" % taken_sec} seconds with HTTP #{response.status}"
+    response.headers.each { |k, v| debug_lines << "< #{k}: #{v}" }
+    debug_lines << "< "
+    debug_lines << "< #{response.body}\n> " if response.body && response.body != ""
+    debug_lines
+  end
+
+  class CurrentTimestamp
+    class << self
+      version = RUBY_VERSION.split('.').map(&:to_i)
+
+      if (version[0] < 2) || (version[0] == 2 && version[1] < 2)
+        def milis
+          (Time.now.to_f * 1000).to_i
+        end
+      else
+        def milis
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+        end
+      end
+    end
+  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,32 @@
+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 PreconditionFailed < 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