faraday 0.1.2 → 0.2.0

data/lib/faraday/middleware.rb

@@ -0,0 +1,54 @@
+module Faraday
+  class Middleware
+    include Rack::Utils
+
+    class << self
+      attr_accessor :load_error, :supports_parallel_requests
+      alias supports_parallel_requests? supports_parallel_requests
+
+      # valid parallel managers should respond to #run with no parameters.
+      # otherwise, return a short wrapper around it.
+      def setup_parallel_manager(options = {})
+        nil
+      end
+    end
+
+    def self.loaded?
+      @load_error.nil?
+    end
+
+    def initialize(app = nil)
+      @app = app
+    end
+
+    # assume that query and fragment are already encoded properly
+    def full_path_for(path, query = nil, fragment = nil)
+      full_path = path.dup
+      if query && !query.empty?
+        full_path << "?#{query}"
+      end
+      if fragment && !fragment.empty?
+        full_path << "##{fragment}"
+      end
+      full_path
+    end
+
+    def process_body_for_request(env)
+      # if it's a string, pass it through
+      return if env[:body].nil? || env[:body].empty? || !env[:body].respond_to?(:each_key)
+      env[:request_headers]['Content-Type'] ||= 'application/x-www-form-urlencoded'
+      env[:body] = create_form_params(env[:body])
+    end
+
+    def create_form_params(params, base = nil)
+      [].tap do |result|
+        params.each_key do |key|
+          key_str = base ? "#{base}[#{key}]" : key
+          value   = params[key]
+          wee = (value.kind_of?(Hash) ? create_form_params(value, key_str) : "#{key_str}=#{escape(value.to_s)}")
+          result << wee
+        end
+      end.join("&")
+    end
+  end
+end

data/lib/faraday/request.rb

@@ -0,0 +1,77 @@
+module Faraday
+  # Used to setup urls, params, headers, and the request body in a sane manner.
+  #
+  #   @connection.post do |req|
+  #     req.url 'http://localhost', 'a' => '1' # 'http://localhost?a=1'
+  #     req.headers['b'] = '2' # header
+  #     req['b']         = '2' # header
+  #     req.body = 'abc'
+  #   end
+  #
+  class Request < Struct.new(:path, :params, :headers, :body)
+    extend AutoloadHelper
+    autoload_all 'faraday/request',
+      :Yajl              => 'yajl',
+      :ActiveSupportJson => 'active_support_json'
+
+    register_lookup_modules \
+      :yajl                => :Yajl,
+      :activesupport_json  => :ActiveSupportJson,
+      :rails_json          => :ActiveSupportJson,
+      :active_support_json => :ActiveSupportJson
+
+    def self.run(connection, request_method)
+      req = create
+      yield req if block_given?
+      req.run(connection, request_method)
+    end
+
+    def self.create
+      req = new(nil, {}, {}, nil)
+      yield req if block_given?
+      req
+    end
+
+    def url(path, params = {})
+      self.path   = path
+      self.params = params
+    end
+
+    def [](key)
+      headers[key]
+    end
+
+    def []=(key, value)
+      headers[key] = value
+    end
+
+    # ENV Keys
+    # :method - a symbolized request method (:get, :post)
+    # :body   - the request body that will eventually be converted to a string.
+    # :url    - Addressable::URI instance of the URI for the current request.
+    # :status           - HTTP response status code
+    # :request_headers  - hash of HTTP Headers to be sent to the server
+    # :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
+    def to_env_hash(connection, request_method)
+      env_headers = connection.headers.dup
+      env_params  = connection.params.dup
+      connection.merge_headers env_headers, headers
+      connection.merge_params  env_params,  params
+
+      { :method           => request_method, 
+        :body             => body, 
+        :url              => connection.build_url(path, env_params),
+        :request_headers  => env_headers,
+        :parallel_manager => connection.parallel_manager,
+        :response         => Response.new}
+    end
+
+    def run(connection, request_method)
+      app = connection.to_app
+      env = to_env_hash(connection, request_method)
+      app.call(env)
+    end
+  end
+end

data/lib/faraday/request/active_support_json.rb

@@ -0,0 +1,20 @@
+module Faraday
+  class Request::ActiveSupportJson < Faraday::Middleware
+    begin
+      if !defined?(ActiveSupport::JSON)
+        require 'active_support'
+      end
+
+    rescue LoadError => e
+      self.load_error = e
+    end
+
+    def call(env)
+      env[:request_headers]['Content-Type'] = 'application/json'
+      if env[:body] && !env[:body].respond_to?(:to_str)
+        env[:body] = ActiveSupport::JSON.encode env[:body]
+      end
+      @app.call env
+    end
+  end
+end

data/lib/faraday/request/yajl.rb

@@ -0,0 +1,18 @@
+module Faraday
+  class Request::Yajl < Faraday::Middleware
+    begin
+      require 'yajl'
+
+    rescue LoadError => e
+      self.load_error = e
+    end
+
+    def call(env)
+      env[:request_headers]['Content-Type'] = 'application/json'
+      if env[:body] && !env[:body].respond_to?(:to_str)
+        env[:body] = Yajl::Encoder.encode env[:body]
+      end
+      @app.call env
+    end
+  end
+end

data/lib/faraday/response.rb

@@ -1,38 +1,53 @@
 module Faraday
-  class Response < Struct.new(:headers, :body)
-    extend Loadable
+  class Response
+    class Middleware < Faraday::Middleware
+      self.load_error = :abstract
 
-    extend AutoloadHelper
-    autoload_all 'faraday/response', 
-      :YajlResponse => 'yajl_response'
-
-    def initialize(headers = nil, body = nil)
-      super(headers || {}, body)
-      if block_given?
-        yield self
-        processed!
+      # Use a response callback in case the request is parallelized.
+      #
+      #   env[:response].on_complete do |finished_env|
+      #     finished_env[:body] = do_stuff_to(finished_env[:body])
+      #   end
+      #
+      def self.register_on_complete(env)
       end
-    end
 
-    # TODO: process is a funky name.  change it
-    # processes a chunk of the streamed body.
-    def process(chunk)
-      if !body
-        self.body = []
+      def call(env)
+        self.class.register_on_complete(env)
+        @app.call env
       end
-      body << chunk
     end
 
-    # Assume the given content is the full body, and not streamed.  
-    def process!(full_body)
-      process(full_body)
-      processed!
+    extend AutoloadHelper
+
+    autoload_all 'faraday/response',
+      :Yajl              => 'yajl',
+      :ActiveSupportJson => 'active_support_json'
+
+    register_lookup_modules \
+      :yajl                => :Yajl,
+      :activesupport_json  => :ActiveSupportJson,
+      :rails_json          => :ActiveSupportJson,
+      :active_support_json => :ActiveSupportJson
+    attr_accessor :status, :headers, :body
+
+    def initialize
+      @status, @headers, @body = nil, nil, nil
+      @on_complete_callbacks = []
+    end
+
+    def on_complete(&block)
+      @on_complete_callbacks << block
+    end
+
+    def finish(env)
+      @on_complete_callbacks.each { |c| c.call(env) }
+      @status, @headers, @body = env[:status], env[:response_headers], env[:body]
+      self
     end
 
-    # Signals the end of streamed content.  Do whatever you need to clean up
-    # the streamed body.
-    def processed!
-      self.body = body.join if body.respond_to?(:join)
+    def success?
+      status == 200
     end
   end
 end

data/lib/faraday/response/active_support_json.rb

@@ -0,0 +1,22 @@
+module Faraday
+  class Response::ActiveSupportJson < Response::Middleware
+    begin
+      if !defined?(ActiveSupport::JSON)
+        require 'active_support'
+      end
+
+      def self.register_on_complete(env)
+        env[:response].on_complete do |finished_env|
+          finished_env[:body] = ActiveSupport::JSON.decode(finished_env[:body])
+        end
+      end
+    rescue LoadError => e
+      self.load_error = e
+    end
+    
+    def initialize(app)
+      super
+      @parser = nil
+    end
+  end
+end

data/lib/faraday/response/yajl.rb

@@ -0,0 +1,20 @@
+module Faraday
+  class Response::Yajl < Response::Middleware
+    begin
+      require 'yajl'
+
+      def self.register_on_complete(env)
+        env[:response].on_complete do |finished_env|
+          finished_env[:body] = Yajl::Parser.parse(finished_env[:body])
+        end
+      end
+    rescue LoadError => e
+      self.load_error = e
+    end
+    
+    def initialize(app)
+      super
+      @parser = nil
+    end
+  end
+end

data/test/adapters/live_test.rb

@@ -0,0 +1,157 @@
+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|
+        describe "with #{adapter} adapter" do
+          before do
+            @connection = Faraday::Connection.new LIVE_SERVER do
+              use adapter
+            end
+          end
+
+          describe "#get" do
+            it "raises on 404" do
+              assert_raise(Faraday::Error::ResourceNotFound) { @connection.get('/nothing') }
+            end
+
+            it "retrieves the response body" do
+              assert_equal 'hello world', @connection.get('hello_world').body
+            end
+
+            it "send url-encoded params" do
+              resp = @connection.get do |req|
+                req.url 'hello', 'name' => 'zack'
+              end
+              assert_equal('hello zack', resp.body)
+            end
+
+            it "retrieves the response headers" do
+              assert_equal 'text/html', @connection.get('hello_world').headers['content-type']
+            end
+          end
+
+          describe "#post" do
+            it "raises on 404" do
+              assert_raise(Faraday::Error::ResourceNotFound) { @connection.post('/nothing') }
+            end
+
+            it "send url-encoded params" do
+              resp = @connection.post do |req|
+                req.url 'echo_name'
+                req.body = {'name' => 'zack'}
+              end
+              assert_equal %("zack"), resp.body
+            end
+
+            it "send url-encoded nested params" do
+              resp = @connection.post do |req|
+                req.url 'echo_name'
+                req.body = {'name' => {'first' => 'zack'}}
+              end
+              assert_equal %({"first"=>"zack"}), resp.body
+            end
+
+            it "retrieves the response headers" do
+              assert_equal 'text/html', @connection.post('echo_name').headers['content-type']
+            end
+          end
+
+          # http://github.com/toland/patron/issues/#issue/9
+          if ENV['FORCE'] || adapter != Faraday::Adapter::Patron
+            describe "#put" do
+              it "raises on 404" do
+                assert_raise(Faraday::Error::ResourceNotFound) { @connection.put('/nothing') }
+              end
+
+              it "send url-encoded params" do
+                resp = @connection.put do |req|
+                  req.url 'echo_name'
+                  req.body = {'name' => 'zack'}
+                end
+                assert_equal %("zack"), resp.body
+              end
+
+              it "send url-encoded nested params" do
+                resp = @connection.put do |req|
+                  req.url 'echo_name'
+                  req.body = {'name' => {'first' => 'zack'}}
+                end
+                assert_equal %({"first"=>"zack"}), resp.body
+              end
+
+              it "retrieves the response headers" do
+                assert_equal 'text/html', @connection.put('echo_name').headers['content-type']
+              end
+            end
+          end
+
+          # http://github.com/pauldix/typhoeus/issues#issue/7
+          if ENV['FORCE'] || adapter != Faraday::Adapter::Typhoeus
+            describe "#head" do
+              it "raises on 404" do
+                assert_raise(Faraday::Error::ResourceNotFound) { @connection.head('/nothing') }
+              end
+
+              it "send url-encoded params" do
+                resp = @connection.head do |req|
+                  req.url 'hello', 'name' => 'zack'
+                end
+                assert_equal 'text/html', resp.headers['content-type']
+              end
+
+              it "retrieves no response body" do
+                assert_equal '', @connection.head('hello_world').body.to_s
+              end
+
+              it "retrieves the response headers" do
+                assert_equal 'text/html', @connection.head('hello_world').headers['content-type']
+              end
+            end
+          end
+
+          describe "#delete" do
+            it "raises on 404" do
+              assert_raise(Faraday::Error::ResourceNotFound) { @connection.delete('/nothing') }
+            end
+
+            it "retrieves the response headers" do
+              assert_equal 'text/html', @connection.delete('delete_with_json').headers['content-type']
+            end
+
+            it "retrieves the body" do
+              assert_match /deleted/, @connection.delete('delete_with_json').body
+            end
+          end
+
+          describe "async requests" do
+            it "clears parallel manager after running a single request" do
+              assert !@connection.in_parallel?
+              resp = @connection.get('hello_world')
+              assert !@connection.in_parallel?
+              assert_equal 'hello world', @connection.get('hello_world').body
+            end
+
+            it "uses parallel manager to run multiple json requests" do
+              resp1, resp2 = nil, nil
+
+              @connection.in_parallel(adapter.setup_parallel_manager) do
+                resp1 = @connection.get('json')
+                resp2 = @connection.get('json')
+                if adapter.supports_parallel_requests?
+                  assert @connection.in_parallel?
+                  assert_nil resp1.body
+                  assert_nil resp2.body
+                end
+              end
+              assert !@connection.in_parallel?
+              assert_equal '[1,2,3]', resp1.body
+              assert_equal '[1,2,3]', resp2.body
+            end
+          end
+        end
+      end
+    end
+  end
+end