faraday 0.3.1 → 0.4.0

data/README.rdoc

@@ -26,6 +26,9 @@ This mess is gonna get raw, like sushi. So, haters to the left.
     req.body = {:name => 'Unagi'}
   end
 
+  # If you're ready to roll with just the bare minimum (net/http):
+  resp1 = Faraday.get 'http://sushi.com/nigiri/sake.json'
+
 == Testing
 
   # It's possible to define stubbed request outside a test adapter block.
@@ -63,7 +66,7 @@ This mess is gonna get raw, like sushi. So, haters to the left.
 
 * Add curb/em-http support
 * Add xml parsing
-* Support timeouts, proxy servers, ssl options
+* Support timeouts, proxy servers, ssl options on Typhoeus/Patron
 * Add streaming requests and responses
 * Add default middleware load out for common cases
 * Add symbol => string index for mime types (:json => 'application/json')

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/faraday.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{faraday}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["rick"]
-  s.date = %q{2010-04-22}
+  s.date = %q{2010-04-27}
   s.description = %q{HTTP/REST API client library with pluggable components}
   s.email = %q{technoweenie@gmail.com}
   s.extra_rdoc_files = [

data/lib/faraday.rb

@@ -1,6 +1,62 @@
 require 'rack/utils'
 
 module Faraday
+  class << self
+    attr_accessor :default_adapter
+    attr_writer   :default_connection
+  end
+
+  self.default_adapter = :net_http
+
+  def self.default_connection
+    @default_connection ||= Connection.new
+  end
+
+  # use the method signature from Faraday::Connection
+  def self.build(options = {}, &block)
+    default_connection.build(options, &block)
+  end
+
+  def self.get(url = nil, headers = nil, &block)
+    default_connection.get(url, headers, &block)
+  end
+
+  def self.post(url = nil, body = nil, headers = nil, &block)
+    default_connection.post(url, body, headers, &block)
+  end
+
+  def self.put(url = nil, body = nil, headers = nil, &block)
+    default_connection.put(url, body, headers, &block)
+  end
+
+  def self.head(url = nil, headers = nil, &block)
+    default_connection.head(url, headers, &block)
+  end
+
+  def self.delete(url = nil, headers = nil, &block)
+    default_connection.delete(url, headers, &block)
+  end
+
+  def self.in_parallel?
+    default_connection.in_parallel?
+  end
+
+  def self.in_parallel(manager)
+    default_connection.in_parallel(manager)
+  end
+
+  def self.proxy(arg = nil)
+    default_connection.proxy(arg)
+  end
+
+  def self.url_prefix=(url)
+    default_connection.url_prefix = url
+  end
+
+  def self.path_prefix=(value)
+    default_connection.path_prefix = value
+  end
+
   module AutoloadHelper
     def register_lookup_modules(mods)
       (@lookup_module_index ||= {}).update(mods)

data/lib/faraday/adapter/net_http.rb

@@ -1,11 +1,34 @@
-require 'net/http'
+begin
+  require 'net/https'
+rescue LoadError
+  puts "no such file to load -- net/https. Make sure openssl is installed if you want ssl support"
+  require 'net/http'
+end
+
 module Faraday
   module Adapter
     class NetHttp < Middleware
       def call(env)
         process_body_for_request(env)
 
-        http      = Net::HTTP.new(env[:url].host, env[:url].port)
+        is_ssl = env[:url].scheme == 'https'
+
+        http = net_http_class(env).new(env[:url].host, env[:url].port || (is_ssl ? 443 : 80))
+        if http.use_ssl = is_ssl
+          ssl = env[:ssl]
+          if ssl[:verify] == false
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          else
+            http.verify_mode = ssl[:verify]
+          end
+          http.cert    = ssl[:client_cert] if ssl[:client_cert]
+          http.key     = ssl[:client_key]  if ssl[:client_key]
+          http.ca_file = ssl[:ca_file]     if ssl[:ca_file]
+        end
+        req = env[:request]
+        http.read_timeout = net.open_timeout = req[:timeout] if req[:timeout]
+        http.open_timeout = req[:open_timeout]               if req[:open_timeout]
+        
         full_path = full_path_for(env[:url].path, env[:url].query, env[:url].fragment)
         http_resp = http.send_request(env[:method].to_s.upcase, full_path, env[:body], env[:request_headers])
 
@@ -23,6 +46,14 @@ module Faraday
       rescue Errno::ECONNREFUSED
         raise Error::ConnectionFailed, "connection refused"
       end
+
+      def net_http_class(env)
+        if proxy = env[:request][:proxy]
+          Net::HTTP::Proxy(proxy[:uri].host, proxy[:uri].port, proxy[:user], proxy[:password])
+        else
+          Net::HTTP
+        end
+      end
     end
   end
 end

data/lib/faraday/adapter/typhoeus.rb

@@ -20,7 +20,8 @@ module Faraday
         req   = ::Typhoeus::Request.new env[:url].to_s, 
           :method  => env[:method],
           :body    => env[:body],
-          :headers => env[:request_headers]
+          :headers => env[:request_headers],
+          :disable_ssl_peer_verification => (env[:ssl][:verify] == false)
 
         req.on_complete do |resp|
           env.update \

data/lib/faraday/builder.rb

@@ -24,9 +24,13 @@ module Faraday
       build(&block) if block_given?
     end
 
-    def build(&block)
+    def build(options = {}, &block)
+      inner = @handlers.shift
+      if !options[:keep]
+        @handlers.clear
+      end
       block.call(self)
-      run(self.class.inner_app)
+      run(inner || self.class.inner_app)
     end
 
     def [](index)
@@ -39,6 +43,10 @@ module Faraday
     end
 
     def to_app
+      if @handlers.empty?
+        build { |b| b.adapter Faraday.default_adapter }
+      end
+
       inner_app = @handlers.first
       @handlers[1..-1].inject(inner_app) { |app, middleware| middleware.call(app) }
     end

data/lib/faraday/connection.rb

@@ -16,11 +16,13 @@ module Faraday
     METHODS_WITH_BODIES = Set.new [:post, :put]
 
     attr_accessor :host, :port, :scheme, :params, :headers, :parallel_manager
-    attr_reader   :path_prefix, :builder
+    attr_reader   :path_prefix, :builder, :options, :ssl
 
     # :url
     # :params
     # :headers
+    # :request
+    # :ssl
     def initialize(url = nil, options = {}, &block)
       if url.is_a?(Hash)
         options = url
@@ -28,8 +30,11 @@ module Faraday
       end
       @headers          = HeaderHash.new
       @params           = {}
+      @options          = options[:request] || {}
+      @ssl              = options[:ssl]     || {}
       @parallel_manager = options[:parallel]
       self.url_prefix = url if url
+      proxy(options[:proxy])
       merge_params  @params,  options[:params]  if options[:params]
       merge_headers @headers, options[:headers] if options[:headers]
       if block
@@ -39,8 +44,8 @@ module Faraday
       end
     end
 
-    def build(&block)
-      @builder.build(&block)
+    def build(options = {}, &block)
+      @builder.build(options, &block)
     end
 
     def get(url = nil, headers = nil, &block)
@@ -63,19 +68,6 @@ module Faraday
       run_request :delete, url, nil, headers, &block
     end
 
-    def run_request(method, url, body, headers)
-      if !METHODS.include?(method)
-        raise ArgumentError, "unknown http method: #{method}"
-      end
-
-      Request.run(self, method) do |req|
-        req.url(url)                if url
-        req.headers.update(headers) if headers
-        req.body = body             if body
-        yield req if block_given?
-      end
-    end
-
     def in_parallel?
       !!@parallel_manager
     end
@@ -88,9 +80,20 @@ module Faraday
       @parallel_manager = nil
     end
 
-    # return the assembled Rack application for this instance.
-    def to_app
-      @builder.to_app
+    def proxy(arg = nil)
+      return @proxy if arg.nil?
+
+      @proxy = 
+        case arg
+          when String then {:uri => proxy_arg_to_uri(arg)}
+          when URI    then {:uri => arg}
+          when Hash   then arg
+            if arg[:uri] = proxy_arg_to_uri(arg[:uri])
+              arg
+            else
+              raise ArgumentError, "no :uri option."
+            end
+        end
     end
 
     # Parses the giving url with Addressable::URI and stores the individual
@@ -124,6 +127,24 @@ module Faraday
       @path_prefix = value
     end
 
+    # return the assembled Rack application for this instance.
+    def to_app
+      @builder.to_app
+    end
+
+    def run_request(method, url, body, headers)
+      if !METHODS.include?(method)
+        raise ArgumentError, "unknown http method: #{method}"
+      end
+
+      Request.run(self, method) do |req|
+        req.url(url)                if url
+        req.headers.update(headers) if headers
+        req.body = body             if body
+        yield req if block_given?
+      end
+    end
+
     # Takes a relative url for a request and combines it with the defaults 
     # set on the connection instance.
     #
@@ -137,9 +158,9 @@ module Faraday
     #
     def build_url(url, params = nil)
       uri          = URI.parse(url.to_s)
-      uri.scheme ||= @scheme
       uri.host   ||= @host
       uri.port   ||= @port
+      uri.scheme ||= @scheme
       if @path_prefix && uri.path !~ /^\//
         uri.path = "#{@path_prefix.size > 1 ? @path_prefix : nil}/#{uri.path}"
       end
@@ -189,5 +210,12 @@ module Faraday
         '%' << $1.unpack('H2'*bytesize($1)).join('%').tap { |c| c.upcase! }
       end
     end
+
+    def proxy_arg_to_uri(arg)
+      case arg
+        when String then URI.parse(arg)
+        when URI    then arg
+      end
+    end
   end
 end

data/lib/faraday/request.rb

@@ -54,6 +54,14 @@ module Faraday
     # :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
+    #   :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_hash(connection, request_method)
       env_headers = connection.headers.dup
       env_params  = connection.params.dup
@@ -65,7 +73,9 @@ module Faraday
         :url              => connection.build_url(path, env_params),
         :request_headers  => env_headers.update(headers),
         :parallel_manager => connection.parallel_manager,
-        :response         => Response.new}
+        :response         => Response.new,
+        :request          => connection.options.merge(:proxy => connection.proxy),
+        :ssl              => connection.ssl}
     end
 
     def run(connection, request_method)

data/test/adapters/live_test.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'helper'))
 if Faraday::TestCase::LIVE_SERVER
   module Adapters
     class LiveTest < Faraday::TestCase
-      Faraday::Adapter.all_loaded_constants.each do |adapter|
+      (Faraday::Adapter.all_loaded_constants + [:default]).each do |adapter|
         define_method "test_#{adapter}_GET_retrieves_the_response_body" do
           assert_equal 'hello world', create_connection(adapter).get('hello_world').body
         end
@@ -100,6 +100,7 @@ if Faraday::TestCase::LIVE_SERVER
           resp1, resp2 = nil, nil
 
           connection = create_connection(adapter)
+          adapter    = real_adapter_for(adapter)
 
           connection.in_parallel(adapter.setup_parallel_manager) do
             resp1 = connection.get('json')
@@ -117,8 +118,22 @@ if Faraday::TestCase::LIVE_SERVER
       end
 
       def create_connection(adapter)
-        Faraday::Connection.new LIVE_SERVER do |b|
-          b.use adapter
+        if adapter == :default
+          conn = Faraday.default_connection
+          conn.url_prefix = LIVE_SERVER
+          conn
+        else
+          Faraday::Connection.new LIVE_SERVER do |b|
+            b.use adapter
+          end
+        end
+      end
+
+      def real_adapter_for(adapter)
+        if adapter == :default
+          Faraday::Adapter.lookup_module(Faraday.default_adapter)
+        else
+          adapter
         end
       end
     end

data/test/connection_test.rb

@@ -139,16 +139,61 @@ class TestConnection < Faraday::TestCase
     assert_no_match /token=abc/,   url.query
   end
 
-  def test_build_url_parses_url_into_host
+  def test_build_url_parses_url
     conn = Faraday::Connection.new
     uri = conn.build_url("http://sushi.com/sake.html")
-    assert_equal "sushi.com", uri.host
+    assert_equal "http",             uri.scheme
+    assert_equal "sushi.com",        uri.host
+    assert_equal '/sake.html', uri.path
+    assert_nil uri.port
+  end
+
+  def test_build_url_parses_url_and_changes_scheme
+    conn = Faraday::Connection.new :url => "http://sushi.com/sushi"
+    conn.scheme = 'https'
+    uri = conn.build_url("sake.html")
+    assert_equal 'https://sushi.com/sushi/sake.html', uri.to_s
   end
 
-  def test_build_url_parses_url_into_port
+  def test_proxy_accepts_string
     conn = Faraday::Connection.new
-    uri = conn.build_url("http://sushi.com/sake.html")
-    assert_nil uri.port
+    conn.proxy 'http://proxy.com'
+    assert_equal 'proxy.com', conn.proxy.host
+  end
+
+  def test_proxy_accepts_string
+    conn = Faraday::Connection.new
+    conn.proxy 'http://proxy.com'
+    assert_equal 'proxy.com', conn.proxy[:uri].host
+    assert_equal [:uri],      conn.proxy.keys
+  end
+
+  def test_proxy_accepts_uri
+    conn = Faraday::Connection.new
+    conn.proxy Addressable::URI.parse('http://proxy.com')
+    assert_equal 'proxy.com', conn.proxy[:uri].host
+    assert_equal [:uri],      conn.proxy.keys
+  end
+
+  def test_proxy_accepts_hash_with_string_uri
+    conn = Faraday::Connection.new
+    conn.proxy :uri => 'http://proxy.com', :user => 'rick'
+    assert_equal 'proxy.com', conn.proxy[:uri].host
+    assert_equal 'rick',      conn.proxy[:user]
+  end
+
+  def test_proxy_accepts_hash
+    conn = Faraday::Connection.new
+    conn.proxy :uri => Addressable::URI.parse('http://proxy.com'), :user => 'rick'
+    assert_equal 'proxy.com', conn.proxy[:uri].host
+    assert_equal 'rick',      conn.proxy[:user]
+  end
+
+  def test_proxy_requires_uri
+    conn = Faraday::Connection.new
+    assert_raises ArgumentError do
+      conn.proxy :uri => :bad_uri, :user => 'rick'
+    end
   end
 
   def test_params_to_query_converts_hash_of_params_to_uri_escaped_query_string
@@ -173,4 +218,43 @@ class TestConnection < Faraday::TestCase
       assert_not_equal conn.send(attr).object_id, duped.send(attr).object_id
     end
   end
-end
+
+  def test_allows_rebuilding_of_connection_handlers
+    conn  = Faraday::Connection.new
+    conn.to_app
+    inner = conn.builder.handlers[0]
+    mware = conn.builder.handlers[1].call({})
+    assert_kind_of Faraday::Adapter::NetHttp, mware
+
+    conn.build do |b|
+      b.adapter :test
+    end
+    mware = conn.builder.handlers[1].call({})
+    assert_kind_of Faraday::Adapter::Test, mware
+    assert_equal   inner,                  conn.builder.handlers[0]
+  end
+
+  def test_allows_extending_of_existing_connection_handlers
+    conn  = Faraday::Connection.new
+    conn.to_app
+    mware = conn.builder.handlers[1].call({})
+    assert_kind_of Faraday::Adapter::NetHttp, mware
+    assert_equal   2,                         conn.builder.handlers.size
+
+    conn.build :keep => true do |b|
+      b.adapter :test
+    end
+    mware = conn.builder.handlers[1].call({})
+    assert_kind_of Faraday::Adapter::Test, mware
+    assert_equal   3,                      conn.builder.handlers.size
+  end
+
+  def test_sets_default_adapter_if_none_set
+    conn  = Faraday::Connection.new
+    assert_equal 0, conn.builder.handlers.size
+
+    app   = conn.to_app
+    mware = conn.builder.handlers[1].call({})
+    assert_kind_of Faraday::Adapter::NetHttp, mware
+  end
+end

data/test/env_test.rb

@@ -3,15 +3,18 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 class TestEnv < Faraday::TestCase
   def setup
     @conn = Faraday::Connection.new :url => 'http://sushi.com/api', :headers => {'Mime-Version' => '1.0'}
+    @conn.options[:timeout]      = 3
+    @conn.options[:open_timeout] = 5
+    @conn.ssl[:verify]           = false
+    @conn.proxy 'http://proxy.com'
     @input = {
       :body    => 'abc',
       :headers => {'Server' => 'Faraday'}}
-    @env_setup = Faraday::Request.create do |req|
+    @env = env_for @conn do |req|
       req.url 'foo.json', 'a' => 1
       req['Server'] = 'Faraday'
       req.body = @input[:body]
     end
-    @env  = @env_setup.to_env_hash(@conn, :get)
   end
 
   def test_request_create_stores_method
@@ -30,4 +33,24 @@ class TestEnv < Faraday::TestCase
   def test_request_create_stores_body
     assert_equal @input[:body], @env[:body]
   end
+
+  def test_request_create_stores_ssl_options
+    assert_equal 3, @env[:request][:timeout]
+    assert_equal 5, @env[:request][:open_timeout]
+  end
+
+  def test_request_create_stores_ssl_options
+    assert_equal false, @env[:ssl][:verify]
+  end
+
+  def test_request_create_stores_proxy_options
+    assert_equal 'proxy.com', @env[:request][:proxy][:uri].host
+  end
+
+  def env_for(connection)
+    env_setup = Faraday::Request.create do |req|
+      yield req
+    end
+    env_setup.to_env_hash(connection, :get)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: faraday
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors: 
 - rick
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-22 00:00:00 -04:00
+date: 2010-04-27 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency