faraday 0.5.7 → 0.6.0

data/lib/faraday/error.rb

@@ -1,28 +1,33 @@
 module Faraday
   module Error
     class ClientError < StandardError
-      def initialize(exception)
-        @inner_exception = exception
-      end
+      attr_reader :response
 
-      def message
-        @inner_exception.respond_to?(:message) ?
-          @inner_exception.message             :
-          @inner_exception.to_s
-      end
+      def initialize(ex)
+        @wrapped_exception = nil
+        @response = nil
 
-      def backtrace
-        @inner_exception.backtrace
+        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
 
-      alias to_str message
-
-      def to_s
-        @inner_exception.to_s
+      def backtrace
+        if @wrapped_exception
+          @wrapped_exception.backtrace
+        else
+          super
+        end
       end
 
       def inspect
-        @inner_exception.inspect
+        %(#<#{self.class}>)
       end
     end
 

data/lib/faraday/middleware.rb

@@ -1,7 +1,5 @@
 module Faraday
   class Middleware
-    include Rack::Utils
-
     class << self
       attr_accessor :load_error, :supports_parallel_requests
       alias supports_parallel_requests? supports_parallel_requests
@@ -13,6 +11,13 @@ module Faraday
       end
     end
 
+    # 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.loaded?
       @load_error.nil?
     end

data/lib/faraday/request.rb

@@ -11,15 +11,16 @@ module Faraday
   #
   class Request < Struct.new(:path, :params, :headers, :body)
     extend AutoloadHelper
+
     autoload_all 'faraday/request',
-      :Yajl              => 'yajl',
-      :ActiveSupportJson => 'active_support_json'
+      :JSON       => 'json',
+      :UrlEncoded => 'url_encoded',
+      :Multipart  => 'multipart'
 
     register_lookup_modules \
-      :yajl                => :Yajl,
-      :activesupport_json  => :ActiveSupportJson,
-      :rails_json          => :ActiveSupportJson,
-      :active_support_json => :ActiveSupportJson
+      :json        => :JSON,
+      :url_encoded => :UrlEncoded,
+      :multipart   => :Multipart
 
     def self.run(connection, request_method)
       req = create
@@ -54,7 +55,6 @@ module Faraday
     # :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
-    # :response         - the actual response object that stores the rack response
     # :request - Hash of options for configuring the request.
     #   :timeout      - open/read timeout Integer in seconds
     #   :open_timeout - read timeout Integer in seconds
@@ -74,15 +74,18 @@ module Faraday
         :url              => connection.build_url(path, env_params),
         :request_headers  => env_headers,
         :parallel_manager => connection.parallel_manager,
-        :response         => Response.new,
         :request          => connection.options.merge(:proxy => connection.proxy),
         :ssl              => connection.ssl}
     end
 
     def run(connection, request_method)
-      app = connection.to_app
+      app = lambda { |env|
+        response = Response.new
+        response.finish(env) unless env[:parallel_manager]
+        env[:response] = response
+      }
       env = to_env_hash(connection, request_method)
-      app.call(env)
+      connection.builder.to_app(app).call(env)
     end
   end
 end

data/lib/faraday/request/json.rb

@@ -0,0 +1,31 @@
+module Faraday
+  class Request::JSON < Request::UrlEncoded
+    self.mime_type = 'application/json'.freeze
+
+    class << self
+      attr_accessor :adapter
+    end
+
+    # loads the JSON encoder either from yajl-ruby or activesupport
+    dependency do
+      begin
+        require 'yajl'
+        self.adapter = Yajl::Encoder
+      rescue LoadError, NameError
+        require 'active_support/core_ext/module/attribute_accessors' # AS 2.3.11
+        require 'active_support/core_ext/kernel/reporting'           # AS 2.3.11
+        require 'active_support/json/encoding'
+        require 'active_support/ordered_hash' # AS 3.0.4
+        self.adapter = ActiveSupport::JSON
+      end
+    end
+
+    def call(env)
+      match_content_type(env) do |data|
+        # encode with the first successfully loaded adapter
+        env[:body] = self.class.adapter.encode data
+      end
+      @app.call env
+    end
+  end
+end

data/lib/faraday/request/multipart.rb

@@ -0,0 +1,63 @@
+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?(body)
+      body.values.each do |val|
+        if val.respond_to?(:content_type)
+          return true
+        elsif val.respond_to?(:values)
+          return true if 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/url_encoded.rb

@@ -0,0 +1,37 @@
+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)
+      type = request_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

@@ -1,56 +1,98 @@
+require 'forwardable'
+
 module Faraday
   class Response
+    # Used for simple response middleware.
     class Middleware < Faraday::Middleware
-      self.load_error = :abstract
-
-      # Use a response callback in case the request is parallelized.
-      #
-      #   env[:response].on_complete do |finished_env|
-      #     finished_env[:body] = do_stuff_to(finished_env[:body])
-      #   end
-      #
-      def self.register_on_complete(env)
+      def call(env)
+        @app.call(env).on_complete do |env|
+          on_complete(env)
+        end
       end
 
-      def call(env)
-        self.class.register_on_complete(env)
-        @app.call env
+      # 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])
+        end
       end
     end
 
+    extend Forwardable
     extend AutoloadHelper
 
     autoload_all 'faraday/response',
-      :Yajl              => 'yajl',
-      :ActiveSupportJson => 'active_support_json'
+      :RaiseError => 'raise_error',
+      :Logger     => 'logger'
 
     register_lookup_modules \
-      :yajl                => :Yajl,
-      :activesupport_json  => :ActiveSupportJson,
-      :rails_json          => :ActiveSupportJson,
-      :active_support_json => :ActiveSupportJson
-    attr_accessor :status, :headers, :body
-
-    def initialize
-      @status, @headers, @body = nil, nil, nil
+      :raise_error => :RaiseError,
+      :logger      => :Logger
+
+    def initialize(env = nil)
+      @env = env
       @on_complete_callbacks = []
     end
 
-    def on_complete(&block)
-      @on_complete_callbacks << block
+    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)
-      return self if @status
-      env[:body]             ||= ''
-      env[:response_headers] ||= {}
-      @on_complete_callbacks.each { |c| c.call(env) }
-      @status, @headers, @body = env[:status], env[:response_headers], env[:body]
-      self
+      raise "response already finished" if finished?
+      @env = env
+      @on_complete_callbacks.each { |callback| callback.call(env) }
+      return self
     end
 
     def success?
       status == 200
     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

data/lib/faraday/response/logger.rb

@@ -0,0 +1,34 @@
+require 'forwardable'
+
+module Faraday
+  class Response::Logger < Response::Middleware
+    extend Forwardable
+
+    def initialize(app, logger = nil)
+      super(app)
+      @logger = logger || begin
+        require 'logger'
+        ::Logger.new(STDOUT)
+      end
+    end
+
+    def_delegators :@logger, :debug, :info, :warn, :error, :fatal
+
+    def call(env)
+      info "#{env[:method]} #{env[:url].to_s}"
+      debug('request') { dump_headers env[:request_headers] }
+      super
+    end
+
+    def on_complete(env)
+      info('Status') { env[:status].to_s }
+      debug('response') { dump_headers env[:response_headers] }
+    end
+
+    private
+
+    def dump_headers(headers)
+      headers.map { |k, v| "#{k}: #{v.inspect}" }.join("\n")
+    end
+  end
+end

data/lib/faraday/response/raise_error.rb

@@ -0,0 +1,16 @@
+module Faraday
+  class Response::RaiseError < Response::Middleware
+    def on_complete(env)
+      case env[:status]
+      when 404
+        raise Faraday::Error::ResourceNotFound, response_values(env)
+      when 400...600
+        raise Faraday::Error::ClientError, response_values(env)
+      end
+    end
+    
+    def response_values(env)
+      {:status => env[:status], :headers => env[:response_headers], :body => env[:body]}
+    end
+  end
+end

data/lib/faraday/upload_io.rb

@@ -3,13 +3,21 @@ begin
   require 'parts'
   require 'stringio'
 rescue LoadError
-  puts "Install the multipart-post gem."
+  $stderr.puts "Install the multipart-post gem."
   raise
 end
 
-# Auto-load multipart-post gem on first request.
 module Faraday
-  CompositeReadIO = ::CompositeReadIO
-  UploadIO        = ::UploadIO
-  Parts           = ::Parts
-end
+  class CompositeReadIO < ::CompositeReadIO
+    attr_reader :length
+    
+    def initialize(parts)
+      @length = parts.inject(0) { |sum, part| sum + part.length }
+      ios = parts.map{ |part| part.to_io }
+      super(*ios)
+    end
+  end
+
+  UploadIO = ::UploadIO
+  Parts = ::Parts
+end