api_client 0.5.24-java → 0.5.25-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86de6b224c93faa28969412f7d2121a53a613739959da4d0993b7e3143c2ccb3
-  data.tar.gz: 5e51da700d497e3444e515c166459f4485e180b5705a04af3212750e3d924937
+  metadata.gz: a6aee99219c58bf02f29e11548ea72dd56ad18fba534f326626147053148f81b
+  data.tar.gz: 767a054b03b9ea36501f7dbdd71bc898d65d5db26b09962dbb1d4e4283c60203
 SHA512:
-  metadata.gz: 511be118de39ceefb8cf983e9798fec9de476f82c78e77e2b8924d97a2740f3e1b9daef81a763678407a08cb158de6a77d8b5ee5fdc9398fa363fbc9cd9a1fba
-  data.tar.gz: bb9d276c8ce9c2442acee7b085801e8e728e5898a668678a37725b6ce747f7bd9a6855c46eb210009fa19b272437970ccbda655fec0ea569e47556478033bf88
+  metadata.gz: ae82881334deac2a7d458e4618d6c7502580e4a070202e04836b8166603a42bba48d6abe047efda1eaff153f540993c1ccb0109a275eebffcf35e38a01985abb
+  data.tar.gz: 78193bbf66f1e8c8d961f83b39ed86a23348cca2c56c235e1f896ae8b19ec676aaa0f678602c00b5a239e4c0555814d7b1b3a6b9432a3d3bc3414dda1d5ad834

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 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,129 @@
+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::Error::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 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