avdi-faraday 0.8.1

data/lib/faraday/error.rb

@@ -0,0 +1,40 @@
+module Faraday
+  module Error
+    class ClientError < StandardError
+      attr_reader :response
+
+      def initialize(ex, response = nil)
+        @wrapped_exception = nil
+        @response = response
+
+        if ex.respond_to?(:backtrace)
+          super(ex.message)
+          @wrapped_exception = ex
+        elsif ex.respond_to?(:each_key)
+          super("the server responded with status #{ex[:status]}")
+          @response = ex
+        else
+          super(ex.to_s)
+        end
+      end
+
+      def backtrace
+        if @wrapped_exception
+          @wrapped_exception.backtrace
+        else
+          super
+        end
+      end
+
+      def inspect
+        %(#<#{self.class}>)
+      end
+    end
+
+    class ConnectionFailed < ClientError;   end
+    class ResourceNotFound < ClientError;   end
+    class ParsingError     < ClientError;   end
+    class TimeoutError < ClientError; end
+    class MissingDependency < StandardError; end
+  end
+end

data/lib/faraday/middleware.rb

@@ -0,0 +1,41 @@
+module Faraday
+  class Middleware
+    extend MiddlewareRegistry
+
+    class << self
+      attr_accessor :load_error
+      private :load_error=
+    end
+
+    self.load_error = nil
+
+    # Executes a block which should try to require and reference dependent libraries
+    def self.dependency(lib = nil)
+      lib ? require(lib) : yield
+    rescue LoadError, NameError => error
+      self.load_error = error
+    end
+
+    def self.new(*)
+      raise "missing dependency for #{self}: #{load_error.message}" unless loaded?
+      super
+    end
+
+    def self.loaded?
+      load_error.nil?
+    end
+
+    def self.inherited(subclass)
+      super
+      subclass.send(:load_error=, self.load_error)
+    end
+
+    def self.adapter?
+      false
+    end
+
+    def initialize(app = nil)
+      @app = app
+    end
+  end
+end

data/lib/faraday/request.rb

@@ -0,0 +1,101 @@
+module Faraday
+  # Used to setup urls, params, headers, and the request body in a sane manner.
+  #
+  #   @connection.post do |req|
+  #     req.url 'http://localhost', 'a' => '1' # 'http://localhost?a=1'
+  #     req.headers['b'] = '2' # Header
+  #     req.params['c']  = '3' # GET Param
+  #     req['b']         = '2' # also Header
+  #     req.body = 'abc'
+  #   end
+  #
+  class Request < Struct.new(:method, :path, :params, :headers, :body, :options)
+    extend AutoloadHelper
+    extend MiddlewareRegistry
+
+    autoload_all 'faraday/request',
+      :UrlEncoded => 'url_encoded',
+      :Multipart => 'multipart',
+      :Retry => 'retry',
+      :Timeout => 'timeout',
+      :Authorization => 'authorization',
+      :BasicAuthentication => 'basic_authentication',
+      :TokenAuthentication => 'token_authentication'
+
+    register_middleware \
+      :url_encoded => :UrlEncoded,
+      :multipart => :Multipart,
+      :retry => :Retry,
+      :authorization => :Authorization,
+      :basic_auth => :BasicAuthentication,
+      :token_auth => :TokenAuthentication
+
+    def self.create(request_method)
+      new(request_method).tap do |request|
+        yield request if block_given?
+      end
+    end
+
+    # Public: Replace params, preserving the existing hash type
+    def params=(hash)
+      if params then params.replace hash
+      else super
+      end
+    end
+
+    # Public: Replace request headers, preserving the existing hash type
+    def headers=(hash)
+      if headers then headers.replace hash
+      else super
+      end
+    end
+
+    def url(path, params = nil)
+      if path.respond_to? :query
+        if query = path.query
+          path = path.dup
+          path.query = nil
+        end
+      else
+        path, query = path.split('?', 2)
+      end
+      self.path = path
+      self.params.merge_query query
+      self.params.update(params) if params
+    end
+
+    def [](key)
+      headers[key]
+    end
+
+    def []=(key, value)
+      headers[key] = value
+    end
+
+    # ENV Keys
+    # :method - a symbolized request method (:get, :post)
+    # :body   - the request body that will eventually be converted to a string.
+    # :url    - URI instance for the current request.
+    # :status           - HTTP response status code
+    # :request_headers  - hash of HTTP Headers to be sent to the server
+    # :response_headers - Hash of HTTP headers from the server
+    # :parallel_manager - sent if the connection is in parallel mode
+    # :request - Hash of options for configuring the request.
+    #   :timeout      - open/read timeout Integer in seconds
+    #   :open_timeout - read timeout Integer in seconds
+    #   :proxy        - Hash of proxy options
+    #     :uri        - Proxy Server URI
+    #     :user       - Proxy server username
+    #     :password   - Proxy server password
+    # :ssl - Hash of options for configuring SSL requests.
+    def to_env(connection)
+      { :method           => method,
+        :body             => body,
+        :url              => connection.build_exclusive_url(path, params),
+        :request_headers  => headers,
+        :parallel_manager => connection.parallel_manager,
+        :request          => options,
+        :ssl              => connection.ssl}
+    end
+  end
+end

data/lib/faraday/request/authorization.rb

@@ -0,0 +1,40 @@
+module Faraday
+  class Request::Authorization < Faraday::Middleware
+    KEY = "Authorization".freeze
+
+    # Public
+    def self.header(type, token)
+      case token
+      when String, Symbol then "#{type} #{token}"
+      when Hash then build_hash(type.to_s, token)
+      else
+        raise ArgumentError, "Can't build an Authorization #{type} header from #{token.inspect}"
+      end
+    end
+
+    # Internal
+    def self.build_hash(type, hash)
+      offset = KEY.size + type.size + 3
+      comma = ",\n#{' ' * offset}"
+      values = []
+      hash.each do |key, value|
+        values << "#{key}=#{value.to_s.inspect}"
+      end
+      "#{type} #{values * comma}"
+    end
+
+    def initialize(app, type, token)
+      @header_value = self.class.header(type, token)
+      super(app)
+    end
+
+    # Public
+    def call(env)
+      unless env[:request_headers][KEY]
+        env[:request_headers][KEY] = @header_value
+      end
+      @app.call(env)
+    end
+  end
+end
+

data/lib/faraday/request/basic_authentication.rb

@@ -0,0 +1,13 @@
+require 'base64'
+
+module Faraday
+  class Request::BasicAuthentication < Request::Authorization
+    # Public
+    def self.header(login, pass)
+      value = Base64.encode64([login, pass].join(':'))
+      value.gsub!("\n", '')
+      super(:Basic, value)
+    end
+  end
+end
+

data/lib/faraday/request/multipart.rb

@@ -0,0 +1,62 @@
+module Faraday
+  class Request::Multipart < Request::UrlEncoded
+    self.mime_type = 'multipart/form-data'.freeze
+    DEFAULT_BOUNDARY = "-----------RubyMultipartPost".freeze
+
+    def call(env)
+      match_content_type(env) do |params|
+        env[:request] ||= {}
+        env[:request][:boundary] ||= DEFAULT_BOUNDARY
+        env[:request_headers][CONTENT_TYPE] += ";boundary=#{env[:request][:boundary]}"
+        env[:body] = create_multipart(env, params)
+      end
+      @app.call env
+    end
+
+    def process_request?(env)
+      type = request_type(env)
+      env[:body].respond_to?(:each_key) and !env[:body].empty? and (
+        (type.empty? and has_multipart?(env[:body])) or
+        type == self.class.mime_type
+      )
+    end
+
+    def has_multipart?(obj)
+      # string is an enum in 1.8, returning list of itself
+      if obj.respond_to?(:each) && !obj.is_a?(String)
+        (obj.respond_to?(:values) ? obj.values : obj).each do |val|
+          return true if (val.respond_to?(:content_type) || has_multipart?(val))
+        end
+      end
+      false
+    end
+
+    def create_multipart(env, params)
+      boundary = env[:request][:boundary]
+      parts = process_params(params) do |key, value|
+        Faraday::Parts::Part.new(boundary, key, value)
+      end
+      parts << Faraday::Parts::EpiloguePart.new(boundary)
+
+      body = Faraday::CompositeReadIO.new(parts)
+      env[:request_headers]['Content-Length'] = body.length.to_s
+      return body
+    end
+
+    def process_params(params, prefix = nil, pieces = nil, &block)
+      params.inject(pieces || []) do |all, (key, value)|
+        key = "#{prefix}[#{key}]" if prefix
+
+        case value
+        when Array
+          values = value.inject([]) { |a,v| a << [nil, v] }
+          process_params(values, key, all, &block)
+        when Hash
+          process_params(value, key, all, &block)
+        else
+          all << block.call(key, value)
+        end
+      end
+    end
+  end
+end

data/lib/faraday/request/retry.rb

@@ -0,0 +1,67 @@
+module Faraday
+  # Catches exceptions and retries each request a limited number of times.
+  #
+  # By default, it retries 2 times and handles only timeout exceptions. It can
+  # be configured with an arbitrary number of retries, a list of exceptions to
+  # handle an a retry interval.
+  #
+  # Examples
+  #
+  #   Faraday.new do |conn|
+  #     conn.request :retry, max: 2, interval: 0.05,
+  #                          exceptions: [CustomException, 'Timeout::Error']
+  #     conn.adapter ...
+  #   end
+  class Request::Retry < Faraday::Middleware
+    # Public: Initialize middleware
+    #
+    # Options:
+    # max        - Maximum number of retries (default: 2).
+    # interval   - Pause in seconds between retries (default: 0).
+    # exceptions - The list of exceptions to handle. Exceptions can be
+    #              given as Class, Module, or String. (default:
+    #              [Errno::ETIMEDOUT, Timeout::Error, Error::TimeoutError])
+    def initialize(app, options = {})
+      super(app)
+      @retries, options = options, {} if options.is_a? Integer
+      @retries ||= options.fetch(:max, 2).to_i
+      @sleep     = options.fetch(:interval, 0).to_f
+      to_handle  = options.fetch(:exceptions) {
+                     [Errno::ETIMEDOUT, 'Timeout::Error', Error::TimeoutError]
+                   }
+      @errmatch  = build_exception_matcher Array(to_handle)
+    end
+
+    def call(env)
+      retries = @retries
+      begin
+        @app.call(env)
+      rescue @errmatch
+        if retries > 0
+          retries -= 1
+          sleep @sleep if @sleep > 0
+          retry
+        end
+        raise
+      end
+    end
+
+    # Private: construct an exception matcher object.
+    #
+    # An exception matcher for the rescue clause can usually be any object that
+    # responds to `===`, but for Ruby 1.8 it has to be a Class or Module.
+    def build_exception_matcher(exceptions)
+      matcher = Module.new
+      (class << matcher; self; end).class_eval do
+        define_method(:===) do |error|
+          exceptions.any? do |ex|
+            if ex.is_a? Module then error.is_a? ex
+            else error.class.to_s == ex.to_s
+            end
+          end
+        end
+      end
+      matcher
+    end
+  end
+end

data/lib/faraday/request/token_authentication.rb

@@ -0,0 +1,15 @@
+module Faraday
+  class Request::TokenAuthentication < Request::Authorization
+    # Public
+    def self.header(token, options = nil)
+      options ||= {}
+      options[:token] = token
+      super :Token, options
+    end
+
+    def initialize(app, token, options = nil)
+      super(app, token, options)
+    end
+  end
+end
+

data/lib/faraday/request/url_encoded.rb

@@ -0,0 +1,35 @@
+module Faraday
+  class Request::UrlEncoded < Faraday::Middleware
+    CONTENT_TYPE = 'Content-Type'.freeze
+
+    class << self
+      attr_accessor :mime_type
+    end
+    self.mime_type = 'application/x-www-form-urlencoded'.freeze
+
+    def call(env)
+      match_content_type(env) do |data|
+        env[:body] = Faraday::Utils.build_nested_query data
+      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
+end

data/lib/faraday/response.rb

@@ -0,0 +1,99 @@
+require 'forwardable'
+
+module Faraday
+  class Response
+    # Used for simple response middleware.
+    class Middleware < Faraday::Middleware
+      def call(env)
+        @app.call(env).on_complete do |environment|
+          on_complete(environment)
+        end
+      end
+
+      # Override this to modify the environment after the response has finished.
+      # Calls the `parse` method if defined
+      def on_complete(env)
+        if respond_to? :parse
+          env[:body] = parse(env[:body]) unless [204,304].index env[:status]
+        end
+      end
+    end
+
+    extend Forwardable
+    extend AutoloadHelper
+    extend MiddlewareRegistry
+
+    autoload_all 'faraday/response',
+      :RaiseError => 'raise_error',
+      :Logger     => 'logger'
+
+    register_middleware \
+      :raise_error => :RaiseError,
+      :logger      => :Logger
+
+    def initialize(env = nil)
+      @env = env
+      @on_complete_callbacks = []
+    end
+
+    attr_reader :env
+    alias_method :to_hash, :env
+
+    def status
+      finished? ? env[:status] : nil
+    end
+
+    def headers
+      finished? ? env[:response_headers] : {}
+    end
+    def_delegator :headers, :[]
+
+    def body
+      finished? ? env[:body] : nil
+    end
+
+    def finished?
+      !!env
+    end
+
+    def on_complete
+      if not finished?
+        @on_complete_callbacks << Proc.new
+      else
+        yield env
+      end
+      return self
+    end
+
+    def finish(env)
+      raise "response already finished" if finished?
+      @env = env
+      @on_complete_callbacks.each { |callback| callback.call(env) }
+      return self
+    end
+
+    def success?
+      (200..299).include?(status)
+    end
+
+    # because @on_complete_callbacks cannot be marshalled
+    def marshal_dump
+      !finished? ? nil : {
+        :status => @env[:status], :body => @env[:body],
+        :response_headers => @env[:response_headers]
+      }
+    end
+
+    def marshal_load(env)
+      @env = env
+    end
+
+    # Expand the env with more properties, without overriding existing ones.
+    # Useful for applying request params after restoring a marshalled Response.
+    def apply_request(request_env)
+      raise "response didn't finish yet" unless finished?
+      @env = request_env.merge @env
+      return self
+    end
+  end
+end