faraday 0.8.11 → 0.9.0.rc1

data/lib/faraday/response.rb

@@ -13,43 +13,37 @@ module Faraday
       # 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
+        env.body = parse(env.body) if respond_to?(:parse) && env.parse_body?
       end
     end
 
     extend Forwardable
-    extend AutoloadHelper
     extend MiddlewareRegistry
 
-    autoload_all 'faraday/response',
-      :RaiseError => 'raise_error',
-      :Logger     => 'logger'
-
-    register_middleware \
-      :raise_error => :RaiseError,
-      :logger      => :Logger
+    register_middleware File.expand_path('../response', __FILE__),
+      :raise_error => [:RaiseError, 'raise_error'],
+      :logger => [:Logger, 'logger']
 
     def initialize(env = nil)
-      @env = env
+      @env = Env.from(env) if env
       @on_complete_callbacks = []
     end
 
     attr_reader :env
-    alias_method :to_hash, :env
+
+    def_delegators :env, :to_hash
 
     def status
-      finished? ? env[:status] : nil
+      finished? ? env.status : nil
     end
 
     def headers
-      finished? ? env[:response_headers] : {}
+      finished? ? env.response_headers : {}
     end
     def_delegator :headers, :[]
 
     def body
-      finished? ? env[:body] : nil
+      finished? ? env.body : nil
     end
 
     def finished?
@@ -67,33 +61,34 @@ module Faraday
 
     def finish(env)
       raise "response already finished" if finished?
-      @env = env
+      @env = Env.from(env)
       @on_complete_callbacks.each { |callback| callback.call(env) }
       return self
     end
 
     def success?
-      (200..299).include?(status)
+      finished? && env.success?
     end
 
     # because @on_complete_callbacks cannot be marshalled
     def marshal_dump
       !finished? ? nil : {
-        :status => @env[:status], :body => @env[:body],
-        :response_headers => @env[:response_headers]
+        :status => @env.status, :body => @env.body,
+        :response_headers => @env.response_headers
       }
     end
 
     def marshal_load(env)
-      @env = env
+      @env = Env.from(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
+      @env = Env.from(request_env).merge(@env)
       return self
     end
   end
 end
+

data/lib/faraday/response/logger.rb

@@ -15,14 +15,14 @@ module Faraday
     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] }
+      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] }
+      info('Status') { env.status.to_s }
+      debug('response') { dump_headers env.response_headers }
     end
 
     private

data/lib/faraday/response/raise_error.rb

@@ -1,19 +1,18 @@
 module Faraday
   class Response::RaiseError < Response::Middleware
+    ClientErrorStatuses = 400...600
+
     def on_complete(env)
       case env[:status]
       when 404
         raise Faraday::Error::ResourceNotFound, response_values(env)
-      when 407
-        # mimic the behavior that we get with proxy requests with HTTPS
-        raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
-      when 400...600
+      when ClientErrorStatuses
         raise Faraday::Error::ClientError, response_values(env)
       end
     end
 
     def response_values(env)
-      {:status => env[:status], :headers => env[:response_headers], :body => env[:body]}
+      {:status => env.status, :headers => env.response_headers, :body => env.body}
     end
   end
 end

data/lib/faraday/utils.rb

@@ -1,4 +1,6 @@
-require 'cgi'
+require 'uri'
+require 'thread'
+Faraday.require_libs 'parameters'
 
 module Faraday
   module Utils
@@ -6,26 +8,28 @@ module Faraday
 
     # Adapted from Rack::Utils::HeaderHash
     class Headers < ::Hash
+      def self.from(value)
+        new(value)
+      end
+
       def initialize(hash={})
         super()
         @names = {}
         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) then 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"
 
@@ -71,7 +75,6 @@ module Faraday
 
       def replace(other)
         clear
-        @names.clear
         self.update other
         self
       end
@@ -90,12 +93,6 @@ module Faraday
             end
           }
       end
-
-      protected
-
-      def names
-        @names
-      end
     end
 
     # hash with stringified keys
@@ -137,15 +134,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,39 +152,19 @@ 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 .~_-]/
 
     def escape(s)
-      s.to_s.gsub(ESCAPE_RE) {|match|
-        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
+      s.to_s.gsub(ESCAPE_RE) {
+        '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase
       }.tr(' ', '+')
     end
 
@@ -196,31 +173,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 +198,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 +226,25 @@ 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)
+        Kernel.URI(url)
+      else
+        raise ArgumentError, "bad argument (expected URI object or URI string)"
+      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/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/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/server

@@ -6,13 +6,15 @@ ensure
   $VERBOSE = old_verbose
 end
 require 'webrick'
+require 'fileutils'
 
 port = 4000
 if found = ARGV.index('-p')
   port = ARGV[found + 1].to_i
 end
 
-log_io = $stdout
+FileUtils.mkdir_p('log')
+log_io = File.open('log/test.log', 'w')
 log_io.sync = true
 
 webrick_opts = {

data/script/test

@@ -24,7 +24,6 @@ if [[ "$RUBYOPT" != *"bundler/setup"* ]]; then
 fi
 
 port=3999
-proxy_port=3998
 scheme=http
 
 if [ "$SSL" = "yes" ]; then
@@ -48,18 +47,12 @@ filter_matching() {
 
 start_server() {
   mkdir -p log
-  script/server -p $port >log/test.log 2>&1 &
-  echo $!
-}
-
-start_proxy() {
-  mkdir -p log
-  script/proxy-server -p $proxy_port -u "faraday@test.local:there is cake" >log/proxy.log 2>&1 &
+  script/server -p $port >log/server.log 2>&1 &
   echo $!
 }
 
 server_started() {
-  lsof -i :${1?} >/dev/null
+  lsof -i :$port >/dev/null
 }
 
 timestamp() {
@@ -69,7 +62,7 @@ timestamp() {
 wait_for_server() {
   timeout=$(( `timestamp` + $1 ))
   while true; do
-    if server_started "$2"; then
+    if server_started; then
       break
     elif [ `timestamp` -gt "$timeout" ]; then
       echo "timed out after $1 seconds" >&2
@@ -116,45 +109,27 @@ fi
 
 # If there are any adapter tests, spin up the HTTP server
 if [ -n "$(filter_matching "adapters" "${test_files[@]}")" ]; then
-  if server_started $port; then
+  if server_started; then
     echo "aborted: another instance of server running on $port" >&2
     exit 1
   fi
   server_pid=$(start_server)
-  proxy_pid=$(start_proxy)
-  wait_for_server 15 $port || {
-    cat log/test.log
+  wait_for_server 15 || {
+    cat log/server.log
     exit 1
   }
-  wait_for_server 5 $proxy_port
   cleanup() {
     if [ $? -ne 0 ] && [ -n "$TRAVIS" ]; then
       cat log/test.log
     fi
     kill "$server_pid"
-    kill "$proxy_pid"
   }
   trap cleanup INT EXIT
   export LIVE="${scheme}://localhost:${port}"
-  export LIVE_PROXY="http://faraday%40test.local:there%20is%20cake@localhost:${proxy_port}"
 fi
 
-warnings="${TMPDIR:-/tmp}/faraday-warnings.$$"
-
 run_test_files() {
-  # Save warnings on stderr to a separate file
-  RUBYOPT="$RUBYOPT -w" ruby -e 'while f=ARGV.shift and f!="--"; load f; end' "${test_files[@]}" -- "$@" \
-    2> >(tee >(grep 'warning:' >"$warnings") | grep -v 'warning:')
-}
-
-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)"
-  rm -f "$warnings"
-  if [ "$num" -gt 0 ]; then
-    echo "FAILED: this test suite doesn't tolerate Ruby syntax warnings!" >&2
-    exit 1
-  fi
+  ruby -e 'while f=ARGV.shift and f!="--"; load f; end' "${test_files[@]}" -- "$@"
 }
 
 if [ -n "$RBENV_VERSIONS" ]; then
@@ -167,4 +142,3 @@ else
   run_test_files "$@"
 fi
 
-check_warnings