avdi-faraday 0.8.1

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

@@ -0,0 +1,23 @@
+begin
+  require 'composite_io'
+  require 'parts'
+  require 'stringio'
+rescue LoadError
+  $stderr.puts "Install the multipart-post gem."
+  raise
+end
+
+module Faraday
+  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

data/lib/faraday/utils.rb

@@ -0,0 +1,274 @@
+require 'cgi'
+
+module Faraday
+  module Utils
+    extend self
+
+    # Adapted from Rack::Utils::HeaderHash
+    class Headers < ::Hash
+      def initialize(hash={})
+        super()
+        @names = {}
+        self.update hash
+      end
+
+      # symbol -> string mapper + cache
+      KeyMap = Hash.new do |map, key|
+        map[key] = 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
+      end
+      KeyMap[:etag] = "ETag"
+
+      def [](k)
+        k = KeyMap[k]
+        super(k) || super(@names[k.downcase])
+      end
+
+      def []=(k, v)
+        k = KeyMap[k]
+        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
+      end
+
+      def delete(k)
+        k = KeyMap[k]
+        if k = @names[k.downcase]
+          @names.delete k.downcase
+          super k
+        end
+      end
+
+      def include?(k)
+        @names.include? k.downcase
+      end
+
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+
+      def merge!(other)
+        other.each { |k, v| self[k] = v }
+        self
+      end
+      alias_method :update, :merge!
+
+      def merge(other)
+        hash = dup
+        hash.merge! other
+      end
+
+      def replace(other)
+        clear
+        self.update other
+        self
+      end
+
+      def to_hash() ::Hash.new.update(self) end
+
+      def parse(header_string)
+        return unless header_string && !header_string.empty?
+        header_string.split(/\r\n/).
+          tap  { |a| a.shift if a.first.index('HTTP/') == 0 }. # drop the HTTP status line
+          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
+            end
+          }
+      end
+    end
+
+    # hash with stringified keys
+    class ParamsHash < Hash
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def include?(key)
+        super(convert_key(key))
+      end
+
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+
+      def update(params)
+        params.each do |key, value|
+          self[key] = value
+        end
+        self
+      end
+      alias_method :merge!, :update
+
+      def merge(params)
+        dup.update(params)
+      end
+
+      def replace(other)
+        clear
+        update(other)
+      end
+
+      def merge_query(query)
+        if query && !query.empty?
+          update Utils.parse_query(query)
+        end
+        self
+      end
+
+      def to_query
+        Utils.build_nested_query(self)
+      end
+
+      private
+
+      def convert_key(key)
+        key.to_s
+      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("&")
+    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
+    end
+
+    ESCAPE_RE = /[^\w .~-]+/
+
+    def escape(s)
+      s.to_s.gsub(ESCAPE_RE) {
+        '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase
+      }.tr(' ', '+')
+    end
+
+    def unescape(s) CGI.unescape s.to_s end
+
+    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) }
+
+        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
+    end
+
+    def parse_nested_query(qs)
+      params = {}
+
+      (qs || '').split(DEFAULT_SEP).each do |p|
+        k, v = p.split('=', 2).map { |s| unescape(s) }
+        normalize_params(params, k, v)
+      end
+      params
+    end
+
+    # Stolen from Rack
+    def normalize_params(params, name, v = nil)
+      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
+      k = $1 || ''
+      after = $' || ''
+
+      return if k.empty?
+
+      if after == ""
+        params[k] = v
+      elsif after == "[]"
+        params[k] ||= []
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        params[k] << v
+      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
+        child_key = $1
+        params[k] ||= []
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
+          normalize_params(params[k].last, child_key, v)
+        else
+          params[k] << normalize_params({}, child_key, v)
+        end
+      else
+        params[k] ||= {}
+        raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Hash)
+        params[k] = normalize_params(params[k], after, v)
+      end
+
+      return params
+    end
+
+    # Receives a URL and returns just the path with the query string sorted.
+    def normalize_path(url)
+      (url.path != "" ? url.path : "/") +
+      (url.query ? "?#{sort_query_params(url.query)}" : "")
+    end
+
+    # Recursive hash update
+    def deep_merge!(target, hash)
+      hash.each do |key, value|
+        if Hash === value and Hash === target[key]
+          target[key] = deep_merge(target[key], value)
+        else
+          target[key] = value
+        end
+      end
+      target
+    end
+
+    # Recursive hash merge
+    def deep_merge(source, hash)
+      deep_merge!(source.dup, hash)
+    end
+
+    protected
+
+    def sort_query_params(query)
+      query.split('&').sort.join('&')
+    end
+  end
+end

data/script/test

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+# Runs the test suite against a local server spawned automatically in a
+# thread. After tests are done, the server is shut down.
+#
+# If filename arguments are given, only those files are run. If arguments given
+# are not filenames, they are taken as words that filter the list of files to run.
+#
+# Examples
+#
+#   $ script/test
+#   $ script/test test/env_test.rb
+#   $ script/test excon typhoeus
+
+require 'rubygems'
+
+# Enable warnings
+$VERBOSE = 2
+
+require 'bundler'
+Bundler.setup
+
+host      = '127.0.0.1'
+logfile   = 'log/test.log'
+test_glob = 'test/**/*_test.rb'
+
+require 'fileutils'
+FileUtils.mkdir_p 'log'
+
+# find available port
+require 'socket'
+port = begin
+  server = TCPServer.new(host, 0)
+  server.addr[1]
+ensure
+  server.close if server
+end
+
+server = nil
+
+# start test server in a separate thread
+thread = Thread.new do
+  old_verbose, $VERBOSE = $VERBOSE, nil
+  begin
+    require File.expand_path('../../test/live_server', __FILE__)
+  ensure
+    $VERBOSE = old_verbose
+  end
+  require 'webrick'
+  log_io = File.open logfile, 'w'
+  webrick_opts = {
+    :Port => port, :Logger => WEBrick::Log::new(log_io),
+    :AccessLog => [[log_io, "[%{X-Faraday-Adapter}i] %m  %U  ->  %s %b"]]
+  }
+  Rack::Handler::WEBrick.run(Faraday::LiveServer, webrick_opts) {|serv| server = serv }
+end
+
+# find files to test
+test_files = Dir[test_glob]
+if ARGV.any?
+  all_files, test_files = test_files, []
+  for arg in ARGV
+    re = /(\b|_)#{arg}(\b|_)/
+    test_files.concat all_files.select { |f| f =~ re }
+  end
+end
+
+require 'net/http'
+conn = Net::HTTP.new host, port
+conn.open_timeout = conn.read_timeout = 0.05
+
+# test if test server is accepting requests
+responsive = lambda { |path|
+  begin
+    res = conn.start { conn.get(path) }
+    res.is_a?(Net::HTTPSuccess)
+  rescue Errno::ECONNREFUSED, Errno::EBADF, Timeout::Error
+    false
+  end
+}
+
+require 'timeout'
+Timeout.timeout 20 do
+  # block until test server is ready
+  thread.join 0.05 until responsive.call('/echo')
+end
+
+ENV['LIVE'] = "http://#{host}:#{port}"
+system 'ruby', '-Ilib:test', '-S', 'testrb', *test_files
+
+server.respond_to?(:stop!) ? server.stop! : server.stop
+thread.join

data/test/adapters/default_test.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../integration', __FILE__)
+
+module Adapters
+  class DefaultTest < Faraday::TestCase
+
+    def adapter() :default end
+
+    Integration.apply(self, :NonParallel) do
+      # default stack is not configured with Multipart
+      undef :test_POST_sends_files
+    end
+
+  end
+end