faraday 0.1.2 → 0.2.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 rick
+Copyright (c) 2009-* rick olson, zack hobson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,79 +1,66 @@
 = faraday
 
-Experiments in a REST API lib
-
-Super alpha!  Don't use it if you mind throwing away all the code when I change
-the API on a whim.
+Modular HTTP client library using middleware heavily inspired by Rack.
 
 This mess is gonna get raw, like sushi. So, haters to the left.
 
 == Usage
 
-    # uses Net/HTTP, no response parsing
-    conn = Faraday::Connection.new("http://sushi.com")
-    conn.extend Faraday::Adapter::NetHttp
-    resp = conn.get("/sake.json")
-    resp.body # => %({"name":"Sake"})
-
-    # uses Net/HTTP, Yajl parsing
-    conn = Faraday::Connection.new("http://sushi.com")
-    conn.extend Faraday::Adapter::NetHttp
-    conn.response_class = Faraday::Response::YajlResponse
-    resp = conn.get("/sake.json")
-    resp.body # => {"name": "Sake"}
-
-    # uses Typhoeus, no response parsing
-    conn = Faraday::Connection.new("http://sushi.com")
-    conn.extend Faraday::Adapter::Typhoeus
-    resp = conn.get("/sake.json")
-    resp.body # => %({"name":"Sake"})
-
-    # uses Typhoeus, Yajl parsing, performs requests in parallel
-    conn = Faraday::Connection.new("http://sushi.com")
-    conn.extend Faraday::Adapter::Typhoeus
-    conn.response_class = Faraday::Response::YajlResponse
-    resp1, resp2 = nil, nil
-    conn.in_parallel do
-      resp1 = conn.get("/sake.json")
-      resp2 = conn.get("/unagi.json")
-
-      # requests have not been made yet
-      resp1.body # => nil
-      resp2.body # => nil
-    end
-    resp1.body # => {"name": "Sake"}
-    resp2.body # => {"name": "Unagi"}
+  conn = Alice::Connection.new(:url => 'http://sushi.com') do |builder|
+    builder.use Alice::Request::Yajl     # convert body to json with Yajl lib
+    builder.use Alice::Adapter::Logger   # log the request somewhere?
+    builder.use Alice::Adapter::Typhoeus # make http request with typhoeus
+    builder.use Alice::Response::Yajl    # # parse body with yajl
+
+    # or use shortcuts
+    builder.request  :yajl     # Alice::Request::Yajl
+    builder.adapter  :logger   # Alice::Adapter::Logger
+    builder.adapter  :typhoeus # Alice::Adapter::Typhoeus
+    builder.response :yajl     # Alice::Response::Yajl
+  end
+
+  resp1 = conn.get '/nigiri/sake.json'
+  resp2 = conn.post do |req|
+    req.url  "/nigiri.json", :page => 2
+    req[:content_type] = 'application/json'
+    req.body = {:name => 'Unagi'}
+  end
 
 == Testing
 
-* Yajl is needed for tests :(
-* Live Sinatra server is required for tests: `ruby test/live_server.rb` to start it.
-
-=== Writing tests based on faraday
+  # It's possible to define stubbed request outside a test adapter block.
+  stubs = Alice::Test::Stubs.new do |stub|
+    stub.get('/tamago') { [200, 'egg', {} }
+  end
 
-Using the MockRequest connection adapter you can implement your own test
-connection class:
-
-    # customize your own TestConnection or just use Faraday::TestConnection
-    class TestConnection < Faraday::Connection
-      include Faraday::Adapter::MockRequest
+  # You can pass stubbed request to the test adapter or define them in a block
+  # or a combination of the two.
+  test = Alice::Connection.new do |builder|
+    builder.adapter :test, stubs do |stub|
+      stub.get('/ebi') {[ 200, 'shrimp', {} ]}
     end
+  end
 
-    conn = TestConnection.new do |stub|
-      # response mimics a rack response
-      stub.get('/hello.json') { [200, {}, 'hi world'] }
-    end
-    resp = conn.get '/hello.json'
-    resp.body                     # => 'hi world'
-    resp = conn.get '/whatever'   # => <not stubbed, raises connection error>
+  # It's also possible to stub additional requests after the connection has
+  # been initialized. This is useful for testing.
+  stubs.get('/uni') {[ 200, 'urchin', {} ]}
+
+  resp = test.get '/tamago'
+  resp.body # => 'egg'
+  resp = test.get '/ebi'
+  resp.body # => 'shrimp'
+  resp = test.get '/uni'
+  resp.body # => 'urchin'
+  resp = test.get '/else' #=> raises "no such stub" error
 
 == TODO
 
-* other HTTP methods besides just GET
-* gracefully skip tests for Yajl and other optional libraries if they don't exist.
-* gracefully skip live http server tests if the sinatra server is not running.
-* use Typhoeus' request mocking facilities in the Typhoeus adapter test
-* lots of other crap
+* Add curb/em-http support
+* Add xml parsing
+* Support timeouts, proxy servers, ssl options
+* Add streaming requests and responses
+* Add default middleware load out for common cases
+* Add symbol => string index for mime types (:json => 'application/json')
 
 == Note on Patches/Pull Requests
  
@@ -87,4 +74,4 @@ connection class:
 
 == Copyright
 
-Copyright (c) 2009 rick. See LICENSE for details.
+Copyright (c) 2009-2010 rick, hobson. See LICENSE for details.

data/Rakefile

@@ -10,6 +10,8 @@ begin
     gem.email = "technoweenie@gmail.com"
     gem.homepage = "http://github.com/technoweenie/faraday"
     gem.authors = ["rick"]
+    gem.add_dependency "rack"
+    gem.add_dependency "addressable"
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -27,7 +29,7 @@ begin
   require 'rcov/rcovtask'
   Rcov::RcovTask.new do |test|
     test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
+    test.pattern = 'test/**/*_test.rb'
     test.verbose = true
   end
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/faraday.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{faraday}
-  s.version = "0.1.2"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["rick"]
-  s.date = %q{2010-01-05}
+  s.date = %q{2010-01-12}
   s.description = %q{HTTP/REST API client library with pluggable components}
   s.email = %q{technoweenie@gmail.com}
   s.extra_rdoc_files = [
@@ -25,23 +25,30 @@ Gem::Specification.new do |s|
      "VERSION",
      "faraday.gemspec",
      "lib/faraday.rb",
-     "lib/faraday/adapter/mock_request.rb",
      "lib/faraday/adapter/net_http.rb",
+     "lib/faraday/adapter/patron.rb",
+     "lib/faraday/adapter/test.rb",
      "lib/faraday/adapter/typhoeus.rb",
+     "lib/faraday/builder.rb",
      "lib/faraday/connection.rb",
      "lib/faraday/error.rb",
-     "lib/faraday/loadable.rb",
-     "lib/faraday/request/post_request.rb",
-     "lib/faraday/request/yajl_request.rb",
+     "lib/faraday/middleware.rb",
+     "lib/faraday/request.rb",
+     "lib/faraday/request/active_support_json.rb",
+     "lib/faraday/request/yajl.rb",
      "lib/faraday/response.rb",
-     "lib/faraday/response/yajl_response.rb",
-     "lib/faraday/test_connection.rb",
-     "test/adapter/typhoeus_test.rb",
-     "test/adapter_test.rb",
+     "lib/faraday/response/active_support_json.rb",
+     "lib/faraday/response/yajl.rb",
+     "test/adapters/live_test.rb",
+     "test/adapters/test_middleware_test.rb",
+     "test/adapters/typhoeus_test.rb",
+     "test/connection_app_test.rb",
      "test/connection_test.rb",
+     "test/env_test.rb",
      "test/helper.rb",
      "test/live_server.rb",
-     "test/response_test.rb"
+     "test/request_middleware_test.rb",
+     "test/response_middleware_test.rb"
   ]
   s.homepage = %q{http://github.com/technoweenie/faraday}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -49,12 +56,16 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{HTTP/REST API client library}
   s.test_files = [
-    "test/adapter/typhoeus_test.rb",
-     "test/adapter_test.rb",
+    "test/adapters/live_test.rb",
+     "test/adapters/test_middleware_test.rb",
+     "test/adapters/typhoeus_test.rb",
+     "test/connection_app_test.rb",
      "test/connection_test.rb",
+     "test/env_test.rb",
      "test/helper.rb",
      "test/live_server.rb",
-     "test/response_test.rb"
+     "test/request_middleware_test.rb",
+     "test/response_middleware_test.rb"
   ]
 
   if s.respond_to? :specification_version then
@@ -62,9 +73,15 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rack>, [">= 0"])
+      s.add_runtime_dependency(%q<addressable>, [">= 0"])
     else
+      s.add_dependency(%q<rack>, [">= 0"])
+      s.add_dependency(%q<addressable>, [">= 0"])
     end
   else
+    s.add_dependency(%q<rack>, [">= 0"])
+    s.add_dependency(%q<addressable>, [">= 0"])
   end
 end
 

data/lib/faraday.rb

@@ -1,5 +1,16 @@
+require 'rack/utils'
+
 module Faraday
   module AutoloadHelper
+    def register_lookup_modules(mods)
+      (@lookup_module_index ||= {}).update(mods)
+    end
+
+    def lookup_module(key)
+      return if !@lookup_module_index
+      const_get @lookup_module_index[key] || key
+    end
+
     def autoload_all(prefix, options)
       options.each do |const_name, path|
         autoload const_name, File.join(prefix, path)
@@ -8,45 +19,41 @@ module Faraday
 
     # Loads each autoloaded constant.  If thread safety is a concern, wrap
     # this in a Mutex.
-    def load
+    def load_autoloaded_constants
       constants.each do |const|
         const_get(const) if autoload?(const)
       end
     end
+
+    def all_loaded_constants
+      constants.map { |c| const_get(c) }.select { |a| a.loaded? }
+    end
   end
 
   extend AutoloadHelper
 
   autoload_all 'faraday', 
-    :Connection     => 'connection',
-    :TestConnection => 'test_connection',
-    :Response       => 'response',
-    :Error          => 'error',
-    :Loadable       => 'loadable'
-
-  module Request
-    extend AutoloadHelper
-    autoload_all 'faraday/request',
-      :YajlRequest => 'yajl_request',
-      :PostRequest => 'post_request'
-  end
+    :Connection => 'connection',
+    :Middleware => 'middleware',
+    :Builder    => 'builder',
+    :Request    => 'request',
+    :Response   => 'response',
+    :Error      => 'error'
 
   module Adapter
     extend AutoloadHelper
-    autoload_all 'faraday/adapter', 
-      :NetHttp     => 'net_http',
-      :Typhoeus    => 'typhoeus',
-      :MockRequest => 'mock_request'
+    autoload_all 'faraday/adapter',
+      :NetHttp  => 'net_http',
+      :Typhoeus => 'typhoeus',
+      :Patron   => 'patron',
+      :Test     => 'test'
 
-    # Names of available adapters.  Should not actually load them.
-    def self.adapters
-      constants
-    end
-
-    # Array of Adapters.  These have been loaded and confirmed to work (right gems, etc).
-    def self.loaded_adapters
-      adapters.map { |c| const_get(c) }.select { |a| a.loaded? }
-    end
+    register_lookup_modules \
+      :test     => :Test,
+      :net_http => :NetHttp,
+      :typhoeus => :Typhoeus,
+      :patron   => :patron,
+      :net_http => :NetHttp
   end
 end
 

data/lib/faraday/adapter/net_http.rb

@@ -1,42 +1,28 @@
 require 'net/http'
-require 'cgi'
 module Faraday
   module Adapter
-    module NetHttp
-      extend Faraday::Connection::Options
+    class NetHttp < Middleware
+      def call(env)
+        process_body_for_request(env)
 
-      def _perform(method, uri, data, request_headers)
-        http = Net::HTTP.new(uri.host, uri.port)
-        response_class.new do |resp|
-          http_resp = http.send_request(method, path_for(uri), data, request_headers)
-          raise Faraday::Error::ResourceNotFound if http_resp.code == '404'
-          resp.process http_resp.body
-          http_resp.each_header do |key, value|
-            resp.headers[key] = value
-          end
-        end
-      rescue Errno::ECONNREFUSED
-        raise Faraday::Error::ConnectionFailed, "connection refused"
-      end
-
-      def _put(uri, data, request_headers)
-        request = request_class.new(data, request_headers)
-        _perform('PUT', uri, request.body, request.headers)
-      end
+        http      = Net::HTTP.new(env[:url].host, env[:url].port)
+        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])
 
-      def _post(uri, data, request_headers)
-        request = request_class.new(data, request_headers)
-        _perform('POST', uri, request.body, request.headers)
-      end
+        resp_headers = {}
+        http_resp.each_header do |key, value|
+          resp_headers[key] = value
+        end
 
-      def _get(uri, request_headers)
-        _perform('GET', uri, uri.query, request_headers)
-      end
+        env.update \
+          :status           => http_resp.code.to_i, 
+          :response_headers => resp_headers, 
+          :body             => http_resp.body
 
-      def _delete(uri, request_headers)
-        _perform('DELETE', uri, uri.query, request_headers)
+        @app.call env
+      rescue Errno::ECONNREFUSED
+        raise Error::ConnectionFailed, "connection refused"
       end
-
     end
   end
 end

data/lib/faraday/adapter/patron.rb

@@ -0,0 +1,33 @@
+module Faraday
+  module Adapter
+    class Patron < Middleware
+      begin
+        require 'patron'
+      rescue LoadError => e
+        self.load_error = e
+      end
+
+      def call(env)
+        process_body_for_request(env)
+
+        sess = ::Patron::Session.new
+        args = [env[:method], env[:url].to_s, env[:request_headers]]
+        if Faraday::Connection::METHODS_WITH_BODIES.include?(env[:method])
+          args.insert(2, env[:body].to_s)
+        end
+        resp = sess.send *args
+
+        env.update \
+          :status           => resp.status,
+          :response_headers => resp.headers.
+            inject({}) { |memo, (k, v)| memo.update(k.downcase => v) },
+          :body             => resp.body
+        env[:response].finish(env)
+
+        @app.call env
+      rescue Errno::ECONNREFUSED
+        raise Error::ConnectionFailed, "connection refused"
+      end
+    end
+  end
+end

data/lib/faraday/adapter/test.rb

@@ -0,0 +1,96 @@
+module Faraday
+  module Adapter
+    # test = Faraday::Connection.new do
+    #   use Faraday::Adapter::Test do |stub|
+    #     stub.get '/nigiri/sake.json' do
+    #       [200, {}, 'hi world']
+    #     end
+    #   end
+    # end
+    # 
+    # resp = test.get '/nigiri/sake.json'
+    # resp.body # => 'hi world'
+    #
+    class Test < Middleware
+      attr_accessor :stubs
+
+      def self.loaded?() false end
+
+      class Stubs
+        def initialize
+          # {:get => [Stub, Stub]}
+          @stack = {}
+          yield self if block_given?
+        end
+
+        def empty?
+          @stack.empty?
+        end
+
+        def match(request_method, path, body)
+          return false if !@stack.key?(request_method)
+          stub = @stack[request_method].detect { |stub| stub.matches?(path, body) }
+          @stack[request_method].delete stub
+        end
+
+        def get(path, &block)
+          new_stub(:get, path, &block)
+        end
+
+        def head(path, &block)
+          new_stub(:head, path, &block)
+        end
+
+        def post(path, body=nil, &block)
+          new_stub(:post, path, body, &block)
+        end
+
+        def put(path, body=nil, &block)
+          new_stub(:put, path, body, &block)
+        end
+
+        def delete(path, &block)
+          new_stub(:delete, path, &block)
+        end
+
+        def new_stub(request_method, path, body=nil, &block)
+          (@stack[request_method] ||= []) << Stub.new(path, body, block)
+        end
+      end
+
+      class Stub < Struct.new(:path, :body, :block)
+        def matches?(request_path, request_body)
+          request_path == path && request_body == body
+        end
+      end
+
+      def initialize app, stubs=nil, &block
+        super(app)
+        @stubs = stubs || Stubs.new
+        configure(&block) if block
+      end
+
+      def configure
+        yield stubs
+      end
+
+      def request_uri url
+        (url.path != "" ? url.path : "/") +
+        (url.query ? "?#{url.query}" : "")
+      end
+
+      def call(env)
+        if stub = stubs.match(env[:method], request_uri(env[:url]), env[:body])
+          status, headers, body = stub.block.call(env)
+          env.update \
+            :status           => status,
+            :response_headers => headers,
+            :body             => body
+        else
+          raise "no stubbed request for #{env[:method]} #{request_uri(env[:url])} #{env[:body]}"
+        end
+        @app.call(env)
+      end
+    end
+  end
+end