faraday 0.8.11 → 0.9.0

data/lib/faraday/utils.rb

@@ -1,4 +1,5 @@
-require 'cgi'
+require 'thread'
+Faraday.require_libs 'parameters'
 
 module Faraday
   module Utils
@@ -6,26 +7,29 @@ module Faraday
 
     # Adapted from Rack::Utils::HeaderHash
     class Headers < ::Hash
-      def initialize(hash={})
+      def self.from(value)
+        new(value)
+      end
+
+      def initialize(hash = nil)
         super()
         @names = {}
-        self.update hash
+        self.update(hash || {})
       end
 
-      # on dup/clone, we need to duplicate @names hash
-      def initialize_copy(other)
-        super
-        @names = other.names.dup
-      end
+      # need to synchronize concurrent writes to the shared KeyMap
+      keymap_mutex = Mutex.new
 
       # symbol -> string mapper + cache
       KeyMap = Hash.new do |map, key|
-        map[key] = if key.respond_to?(:to_str) then key
+        value = if key.respond_to?(:to_str)
+          key
         else
           key.to_s.split('_').            # :user_agent => %w(user agent)
             each { |w| w.capitalize! }.   # => %w(User Agent)
             join('-')                     # => "User-Agent"
         end
+        keymap_mutex.synchronize { map[key] = value }
       end
       KeyMap[:etag] = "ETag"
 
@@ -39,14 +43,20 @@ module Faraday
         k = (@names[k.downcase] ||= k)
         # join multiple values with a comma
         v = v.to_ary.join(', ') if v.respond_to? :to_ary
-        super k, v
+        super(k, v)
+      end
+
+      def fetch(k, *args, &block)
+        k = KeyMap[k]
+        key = @names.fetch(k.downcase, k)
+        super(key, *args, &block)
       end
 
       def delete(k)
         k = KeyMap[k]
         if k = @names[k.downcase]
           @names.delete k.downcase
-          super k
+          super(k)
         end
       end
 
@@ -71,7 +81,6 @@ module Faraday
 
       def replace(other)
         clear
-        @names.clear
         self.update other
         self
       end
@@ -85,17 +94,13 @@ module Faraday
           map  { |h| h.split(/:\s+/, 2) }.reject { |p| p[0].nil? }. # split key and value, ignore blank lines
           each { |key, value|
             # join multiple values with a comma
-            if self[key] then self[key] << ', ' << value
-            else self[key] = value
+            if self[key]
+              self[key] << ', ' << value
+            else
+              self[key] = value
             end
           }
       end
-
-      protected
-
-      def names
-        @names
-      end
     end
 
     # hash with stringified keys
@@ -137,15 +142,15 @@ module Faraday
         update(other)
       end
 
-      def merge_query(query)
+      def merge_query(query, encoder = nil)
         if query && !query.empty?
-          update Utils.parse_nested_query(query)
+          update((encoder || Utils.default_params_encoder).decode(query))
         end
         self
       end
 
-      def to_query
-        Utils.build_nested_query(self)
+      def to_query(encoder = nil)
+        (encoder || Utils.default_params_encoder).encode(self)
       end
 
       private
@@ -155,32 +160,12 @@ module Faraday
       end
     end
 
-    # Copied from Rack
     def build_query(params)
-      params.map { |k, v|
-        if v.class == Array
-          build_query(v.map { |x| [k, x] })
-        else
-          v.nil? ? escape(k) : "#{escape(k)}=#{escape(v)}"
-        end
-      }.join("&")
+      FlatParamsEncoder.encode(params)
     end
 
-    # Rack's version modified to handle non-String values
-    def build_nested_query(value, prefix = nil)
-      case value
-      when Array
-        value.map { |v| build_nested_query(v, "#{prefix}%5B%5D") }.join("&")
-      when Hash
-        value.map { |k, v|
-          build_nested_query(v, prefix ? "#{prefix}%5B#{escape(k)}%5D" : escape(k))
-        }.join("&")
-      when NilClass
-        prefix
-      else
-        raise ArgumentError, "value must be a Hash" if prefix.nil?
-        "#{prefix}=#{escape(value)}"
-      end
+    def build_nested_query(params)
+      NestedParamsEncoder.encode(params)
     end
 
     ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
@@ -196,31 +181,20 @@ module Faraday
     DEFAULT_SEP = /[&;] */n
 
     # Adapted from Rack
-    def parse_query(qs)
-      params = {}
-
-      (qs || '').split(DEFAULT_SEP).each do |p|
-        k, v = p.split('=', 2).map { |x| unescape(x) }
+    def parse_query(query)
+      FlatParamsEncoder.decode(query)
+    end
 
-        if cur = params[k]
-          if cur.class == Array then params[k] << v
-          else params[k] = [cur, v]
-          end
-        else
-          params[k] = v
-        end
-      end
-      params
+    def parse_nested_query(query)
+      NestedParamsEncoder.decode(query)
     end
 
-    def parse_nested_query(qs)
-      params = {}
+    def default_params_encoder
+      @default_params_encoder ||= NestedParamsEncoder
+    end
 
-      (qs || '').split(DEFAULT_SEP).each do |p|
-        k, v = p.split('=', 2).map { |s| unescape(s) }
-        normalize_params(params, k, v)
-      end
-      params
+    class << self
+      attr_writer :default_params_encoder
     end
 
     # Stolen from Rack
@@ -232,7 +206,12 @@ module Faraday
       return if k.empty?
 
       if after == ""
-        params[k] = v
+        if params[k]
+          params[k] = Array[params[k]] unless params[k].kind_of?(Array)
+          params[k] << v
+        else
+          params[k] = v
+        end
       elsif after == "[]"
         params[k] ||= []
         raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
@@ -255,9 +234,40 @@ module Faraday
       return params
     end
 
-    # Receives a URL and returns just the path with the query string sorted.
+    # Normalize URI() behavior across Ruby versions
+    #
+    # url - A String or URI.
+    #
+    # Returns a parsed URI.
+    def URI(url)
+      if url.respond_to?(:host)
+        url
+      elsif url.respond_to?(:to_str)
+        default_uri_parser.call(url)
+      else
+        raise ArgumentError, "bad argument (expected URI object or URI string)"
+      end
+    end
+
+    def default_uri_parser
+      @default_uri_parser ||= begin
+        require 'uri'
+        Kernel.method(:URI)
+      end
+    end
+
+    def default_uri_parser=(parser)
+      @default_uri_parser = if parser.respond_to?(:call) || parser.nil?
+        parser
+      else
+        parser.method(:parse)
+      end
+    end
+
+    # Receives a String or URI and returns just the path with the query string sorted.
     def normalize_path(url)
-      (url.path != "" ? url.path : "/") +
+      url = URI(url)
+      (url.path.start_with?('/') ? url.path : '/' + url.path) +
       (url.query ? "?#{sort_query_params(url.query)}" : "")
     end
 

data/lib/faraday.rb

@@ -1,25 +1,100 @@
+require 'thread'
+require 'cgi'
+require 'set'
+require 'forwardable'
+
+# Public: This is the main namespace for Faraday.  You can either use it to
+# create Faraday::Connection objects, or access it directly.
+#
+# Examples
+#
+#   Faraday.get "http://faraday.com"
+#
+#   conn = Faraday.new "http://faraday.com"
+#   conn.get '/'
+#
 module Faraday
-  VERSION = "0.8.11"
+  VERSION = "0.9.0"
 
   class << self
-    attr_accessor :root_path, :lib_path
-    attr_accessor :default_adapter
-    attr_writer   :default_connection
+    # Public: Gets or sets the root path that Faraday is being loaded from.
+    # This is the root from where the libraries are auto-loaded from.
+    attr_accessor :root_path
+
+    # Public: Gets or sets the path that the Faraday libs are loaded from.
+    attr_accessor :lib_path
 
-    def new(url = nil, options = {})
+    # Public: Gets or sets the Symbol key identifying a default Adapter to use
+    # for the default Faraday::Connection.
+    attr_reader :default_adapter
+
+    # Public: Sets the default Faraday::Connection for simple scripts that
+    # access the Faraday constant directly.
+    #
+    #     Faraday.get "https://faraday.com"
+    attr_writer :default_connection
+
+    # Public: Sets the default options used when calling Faraday#new.
+    attr_writer :default_connection_options
+
+    # Public: Initializes a new Faraday::Connection.
+    #
+    # url     - The optional String base URL to use as a prefix for all
+    #           requests.  Can also be the options Hash.
+    # options - The optional Hash used to configure this Faraday::Connection.
+    #           Any of these values will be set on every request made, unless
+    #           overridden for a specific request.
+    #           :url     - String base URL.
+    #           :params  - Hash of URI query unencoded key/value pairs.
+    #           :headers - Hash of unencoded HTTP header key/value pairs.
+    #           :request - Hash of request options.
+    #           :ssl     - Hash of SSL options.
+    #           :proxy   - Hash of Proxy options.
+    #
+    # Examples
+    #
+    #   Faraday.new 'http://faraday.com'
+    #
+    #   # http://faraday.com?page=1
+    #   Faraday.new 'http://faraday.com', :params => {:page => 1}
+    #
+    #   # same
+    #
+    #   Faraday.new :url => 'http://faraday.com',
+    #     :params => {:page => 1}
+    #
+    # Returns a Faraday::Connection.
+    def new(url = nil, options = nil)
       block = block_given? ? Proc.new : nil
+      options = options ? default_connection_options.merge(options) : default_connection_options.dup
       Faraday::Connection.new(url, options, &block)
     end
 
+    # Internal: Requires internal Faraday libraries.
+    #
+    # *libs - One or more relative String names to Faraday classes.
+    #
+    # Returns nothing.
     def require_libs(*libs)
       libs.each do |lib|
         require "#{lib_path}/#{lib}"
       end
     end
 
+    # Public: Updates default adapter while resetting
+    # #default_connection.
+    #
+    # Returns the new default_adapter.
+    def default_adapter=(adapter)
+      @default_connection = nil
+      @default_adapter = adapter
+    end
+
     alias require_lib require_libs
 
   private
+    # Internal: Proxies method calls on the Faraday constant to
+    # #default_connection.
     def method_missing(name, *args, &block)
       default_connection.send(name, *args, &block)
     end
@@ -29,10 +104,20 @@ module Faraday
   self.lib_path = File.expand_path "../faraday", __FILE__
   self.default_adapter = :net_http
 
+  # Gets the default connection used for simple scripts.
+  #
+  # Returns a Faraday::Connection, configured with the #default_adapter.
   def self.default_connection
     @default_connection ||= Connection.new
   end
 
+  # Gets the default connection options used when calling Faraday#new.
+  #
+  # Returns a Faraday::ConnectionOptions.
+  def self.default_connection_options
+    @default_connection_options ||= ConnectionOptions.new
+  end
+
   if (!defined?(RUBY_ENGINE) || "ruby" == RUBY_ENGINE) && RUBY_VERSION < '1.9'
     begin
       require 'system_timer'
@@ -47,103 +132,137 @@ module Faraday
     Timer = Timeout
   end
 
+  # Public: Adds the ability for other modules to register and lookup
+  # middleware classes.
   module MiddlewareRegistry
-    # Internal: Register middleware class(es) on the current module.
+    # Public: Register middleware class(es) on the current module.
+    #
+    # mapping - A Hash mapping Symbol keys to classes. Classes can be expressed
+    #           as fully qualified constant, or a Proc that will be lazily
+    #           called to return the former.
+    #
+    # Examples
+    #
+    #   module Faraday
+    #     class Whatever
+    #       # Middleware looked up by :foo returns Faraday::Whatever::Foo.
+    #       register_middleware :foo => Foo
+    #
+    #       # Middleware looked up by :bar returns Faraday::Whatever.const_get(:Bar)
+    #       register_middleware :bar => :Bar
     #
-    # mapping - A Hash mapping Symbol keys to classes. See
-    #           Faraday.register_middleware for more details.
-    def register_middleware(mapping)
-      (@registered_middleware ||= {}).update(mapping)
+    #       # Middleware looked up by :baz requires 'baz' and returns Faraday::Whatever.const_get(:Baz)
+    #       register_middleware :baz => [:Baz, 'baz']
+    #     end
+    #   end
+    #
+    # Returns nothing.
+    def register_middleware(autoload_path = nil, mapping = nil)
+      if mapping.nil?
+        mapping = autoload_path
+        autoload_path = nil
+      end
+      middleware_mutex do
+        @middleware_autoload_path = autoload_path if autoload_path
+        (@registered_middleware ||= {}).update(mapping)
+      end
     end
 
-    # Internal: Lookup middleware class with a registered Symbol shortcut.
+    # Public: Lookup middleware class with a registered Symbol shortcut.
+    #
+    # key - The Symbol key for the registered middleware.
+    #
+    # Examples
+    #
+    #   module Faraday
+    #     class Whatever
+    #       register_middleware :foo => Foo
+    #     end
+    #   end
+    #
+    #   Faraday::Whatever.lookup_middleware(:foo)
+    #   # => Faraday::Whatever::Foo
     #
     # Returns a middleware Class.
     def lookup_middleware(key)
-      unless defined? @registered_middleware and found = @registered_middleware[key]
-        raise "#{key.inspect} is not registered on #{self}"
-      end
-      found = @registered_middleware[key] = found.call if found.is_a? Proc
-      found.is_a?(Module) ? found : const_get(found)
+      load_middleware(key) ||
+        raise(Faraday::Error.new("#{key.inspect} is not registered on #{self}"))
     end
-  end
 
-  module AutoloadHelper
-    def autoload_all(prefix, options)
-      if prefix =~ /^faraday(\/|$)/i
-        prefix = File.join(Faraday.root_path, prefix)
-      end
-      options.each do |const_name, path|
-        autoload const_name, File.join(prefix, path)
+    def middleware_mutex(&block)
+      @middleware_mutex ||= begin
+        require 'monitor'
+        Monitor.new
       end
+      @middleware_mutex.synchronize(&block)
     end
 
-    # Loads each autoloaded constant.  If thread safety is a concern, wrap
-    # this in a Mutex.
-    def load_autoloaded_constants
-      constants.each do |const|
-        const_get(const) if autoload?(const)
-      end
+    def fetch_middleware(key)
+      defined?(@registered_middleware) && @registered_middleware[key]
     end
 
-    def all_loaded_constants
-      constants.map { |c| const_get(c) }.
-        select { |a| a.respond_to?(:loaded?) && a.loaded? }
+    def load_middleware(key)
+      value = fetch_middleware(key)
+      case value
+      when Module
+        value
+      when Symbol, String
+        middleware_mutex do
+          @registered_middleware[key] = const_get(value)
+        end
+      when Proc
+        middleware_mutex do
+          @registered_middleware[key] = value.call
+        end
+      when Array
+        middleware_mutex do
+          const, path = value
+          if root = @middleware_autoload_path
+            path = "#{root}/#{path}"
+          end
+          require(path)
+          @registered_middleware[key] = const
+        end
+        load_middleware(key)
+      end
     end
   end
 
-  extend AutoloadHelper
-
-  # Public: register middleware classes under a short name.
-  #
-  # type    - A Symbol specifying the kind of middleware (default: :middleware)
-  # mapping - A Hash mapping Symbol keys to classes. Classes can be expressed
-  #           as fully qualified constant, or a Proc that will be lazily called
-  #           to return the former.
-  #
-  # Examples
-  #
-  #   Faraday.register_middleware :aloha => MyModule::Aloha
-  #   Faraday.register_middleware :response, :boom => MyModule::Boom
-  #
-  #   # shortcuts are now available in Builder:
-  #   builder.use :aloha
-  #   builder.response :boom
-  #
-  # Returns nothing.
-  def self.register_middleware type, mapping = nil
-    type, mapping = :middleware, type if mapping.nil?
-    component = self.const_get(type.to_s.capitalize)
-    component.register_middleware(mapping)
+  def self.const_missing(name)
+    if name.to_sym == :Builder
+      warn "Faraday::Builder is now Faraday::RackBuilder."
+      const_set name, RackBuilder
+    else
+      super
+    end
   end
 
-  autoload_all "faraday",
-    :Middleware      => 'middleware',
-    :Builder         => 'builder',
-    :Request         => 'request',
-    :Response        => 'response',
-    :CompositeReadIO => 'upload_io',
-    :UploadIO        => 'upload_io',
-    :Parts           => 'upload_io'
+  require_libs "utils", "options", "connection", "rack_builder", "parameters",
+    "middleware", "adapter", "request", "response", "upload_io", "error"
 
-  require_libs "utils", "connection", "adapter", "error"
+  if !ENV["FARADAY_NO_AUTOLOAD"]
+    require_lib 'autoload'
+  end
 end
 
-
 # not pulling in active-support JUST for this method.  And I love this method.
 class Object
-  # Yields <code>x</code> to the block, and then returns <code>x</code>.
   # The primary purpose of this method is to "tap into" a method chain,
   # in order to perform operations on intermediate results within the chain.
   #
+  # Examples
+  #
   #   (1..10).tap { |x| puts "original: #{x.inspect}" }.to_a.
   #     tap    { |x| puts "array: #{x.inspect}" }.
   #     select { |x| x%2 == 0 }.
   #     tap    { |x| puts "evens: #{x.inspect}" }.
   #     map    { |x| x*x }.
   #     tap    { |x| puts "squares: #{x.inspect}" }
+  #
+  # Yields self.
+  # Returns self.
   def tap
-    yield self
+    yield(self)
     self
   end unless Object.respond_to?(:tap)
 end

data/script/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Usage: script/console
+# Starts an IRB console with this library loaded.
+
+gemspec="$(ls *.gemspec | head -1)"
+
+exec bundle exec irb -r "${gemspec%.*}"

data/script/proxy-server

@@ -27,6 +27,7 @@ webrick_opts = {
     if username
       type, credentials = req.header['proxy-authorization'].first.to_s.split(/\s+/, 2)
       unless "Basic" == type && match_credentials.call(credentials)
+        res['proxy-authenticate'] = %{Basic realm="testing"}
         raise WEBrick::HTTPStatus::ProxyAuthenticationRequired
       end
     end

data/script/release

@@ -8,7 +8,10 @@ set -e
 version="$(script/package | grep Version: | awk '{print $2}')"
 [ -n "$version" ] || exit 1
 
-git commit -a -m "faraday $version"
-git tag "v${version}"
-git push origin "v${version}" HEAD
+git commit --allow-empty -a -m "Release $version"
+git tag "v$version"
+git push origin
+git push origin "v$version"
+git push legacy
+git push legacy "v$version"
 gem push pkg/*-${version}.gem

data/script/test

@@ -122,8 +122,10 @@ if [ -n "$(filter_matching "adapters" "${test_files[@]}")" ]; then
   fi
   server_pid=$(start_server)
   proxy_pid=$(start_proxy)
-  wait_for_server 15 $port || {
+  wait_for_server 30 $port || {
     cat log/test.log
+    kill "$server_pid"
+    kill "$proxy_pid"
     exit 1
   }
   wait_for_server 5 $proxy_port
@@ -149,7 +151,7 @@ run_test_files() {
 
 check_warnings() {
   # Display Ruby warnings from this project's source files. Abort if any were found.
-  num="$(grep -F "$PWD" "$warnings" | grep -v "${PWD}/vendor/bundle" | sort | uniq -c | sort -rn | tee /dev/stderr | wc -l)"
+  num="$(grep -F "$PWD" "$warnings" | grep -v "${PWD}/bundle" | sort | uniq -c | sort -rn | tee /dev/stderr | wc -l)"
   rm -f "$warnings"
   if [ "$num" -gt 0 ]; then
     echo "FAILED: this test suite doesn't tolerate Ruby syntax warnings!" >&2

data/test/adapters/em_http_test.rb

@@ -8,8 +8,13 @@ module Adapters
     Integration.apply(self, :Parallel) do
       # https://github.com/eventmachine/eventmachine/pull/289
       undef :test_timeout
+
+      def test_binds_local_socket
+        host = '1.2.3.4'
+        conn = create_connection :request => { :bind => { :host => host } }
+        assert_equal host, conn.options[:bind][:host]
+      end
     end unless jruby? and ssl_mode?
     # https://github.com/eventmachine/eventmachine/issues/180
-
   end
 end

data/test/adapters/em_synchrony_test.rb

@@ -8,7 +8,13 @@ module Adapters
     Integration.apply(self, :Parallel) do
       # https://github.com/eventmachine/eventmachine/pull/289
       undef :test_timeout
-    end unless RUBY_VERSION < '1.9' or jruby?
 
+      def test_binds_local_socket
+        host = '1.2.3.4'
+        conn = create_connection :request => { :bind => { :host => host } }
+        #put conn.get('/who-am-i').body
+        assert_equal host, conn.options[:bind][:host]
+      end
+    end unless RUBY_VERSION < '1.9' or jruby?
   end
 end

data/test/adapters/httpclient_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path('../integration', __FILE__)
+
+module Adapters
+  class HttpclientTest < Faraday::TestCase
+
+    def adapter() :httpclient end
+
+    Integration.apply(self, :NonParallel) do
+      def setup
+        require 'httpclient' unless defined?(HTTPClient)
+        HTTPClient::NO_PROXY_HOSTS.delete('localhost')
+      end
+
+      def test_binds_local_socket
+        host = '1.2.3.4'
+        conn = create_connection :request => { :bind => { :host => host } }
+        assert_equal host, conn.options[:bind][:host]
+      end
+    end
+  end
+end