shin-faraday 0.4.7

data/lib/faraday/error.rb

@@ -0,0 +1,8 @@
+module Faraday
+  module Error
+    class ClientError      < StandardError; end
+    class ConnectionFailed < ClientError;   end
+    class ResourceNotFound < ClientError;   end
+    class ParsingError     < ClientError;   end
+  end
+end

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,87 @@
+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
+    # :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
+      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.update(headers),
+        :parallel_manager => connection.parallel_manager,
+        :response         => Response.new,
+        :request          => connection.options.merge(:proxy => connection.proxy),
+        :ssl              => connection.ssl}
+    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,21 @@
+module Faraday
+  class Request::ActiveSupportJson < Faraday::Middleware
+    begin
+      if !defined?(ActiveSupport::JSON)
+        require 'active_support'
+        ActiveSupport::JSON
+      end
+
+    rescue LoadError, NameError => 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, NameError => 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

@@ -0,0 +1,56 @@
+module Faraday
+  class Response
+    class Middleware < Faraday::Middleware
+      self.load_error = :abstract
+
+      # 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
+
+      def call(env)
+        self.class.register_on_complete(env)
+        @app.call env
+      end
+    end
+
+    extend AutoloadHelper
+
+    autoload_all 'faraday/response',
+      :Yajl              => 'yajl',
+      :Nokogiri          => 'nokogiri',
+      :ActiveSupportJson => 'active_support_json'
+
+    register_lookup_modules \
+      :yajl                => :Yajl,
+      :nokogiri            => :Nokogiri,
+      :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)
+      env[:body] ||= ''
+      @on_complete_callbacks.each { |c| c.call(env) }
+      @status, @headers, @body = env[:status], env[:response_headers], env[:body]
+      self
+    end
+
+    def success?
+      status == 200
+    end
+  end
+end

data/lib/faraday/response/active_support_json.rb

@@ -0,0 +1,31 @@
+module Faraday
+  class Response::ActiveSupportJson < Response::Middleware
+    begin
+      if !defined?(ActiveSupport::JSON)
+        require 'active_support'
+        ActiveSupport::JSON
+      end
+
+      def self.register_on_complete(env)
+        env[:response].on_complete do |finished_env|
+          finished_env[:body] = parse(finished_env[:body])
+
+        end
+      end
+    rescue LoadError, NameError => e
+      self.load_error = e
+    end
+
+    def initialize(app)
+      super
+      @parser = nil
+    end
+
+    def self.parse(body)
+      ActiveSupport::JSON.decode(body)
+    # TODO:  Maybe rescue Exception can be better ...
+    rescue Yajl::ParseError => e
+      raise Faraday::Error::ParsingError
+    end
+  end
+end

data/lib/faraday/response/nokogiri.rb

@@ -0,0 +1,21 @@
+module Faraday
+  class Response::Nokogiri < Faraday::Response::Middleware
+    begin
+      require 'nokogiri'
+
+      def self.register_on_complete(env)
+        env[:response].on_complete do |finished_env|
+          finished_env[:body] = ::Nokogiri::XML(finished_env[:body])
+        end 
+      end 
+    rescue LoadError, NameError => e
+      self.load_error = e 
+      raise e
+    end 
+
+    def initialize(app)
+      super
+      @parser = nil 
+    end 
+  end 
+end 

data/lib/faraday/response/yajl.rb

@@ -0,0 +1,26 @@
+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] = parse(finished_env[:body])
+        end
+      end
+    rescue LoadError, NameError => e
+      self.load_error = e
+    end
+
+    def initialize(app)
+      super
+      @parser = nil
+    end
+
+    def self.parse(body)
+      Yajl::Parser.parse(body)
+    rescue Yajl::ParseError => e
+      raise Faraday::Error::ParsingError
+    end
+  end
+end

data/test/adapters/live_test.rb

@@ -0,0 +1,141 @@
+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 + [: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
+
+        define_method "test_#{adapter}_GET_send_url_encoded_params" do
+          resp = create_connection(adapter).get do |req|
+            req.url 'hello', 'name' => 'zack'
+          end
+          assert_equal('hello zack', resp.body)
+        end
+
+        define_method "test_#{adapter}_GET_retrieves_the_response_headers" do
+          assert_equal 'text/html', create_connection(adapter).get('hello_world').headers['content-type']
+        end
+
+        define_method "test_#{adapter}_POST_send_url_encoded_params" do
+          resp = create_connection(adapter).post do |req|
+            req.url 'echo_name'
+            req.body = {'name' => 'zack'}
+          end
+          assert_equal %("zack"), resp.body
+        end
+
+        define_method "test_#{adapter}_POST_send_url_encoded_nested_params" do
+          resp = create_connection(adapter).post do |req|
+            req.url 'echo_name'
+            req.body = {'name' => {'first' => 'zack'}}
+          end
+          assert_equal %({"first"=>"zack"}), resp.body
+        end
+
+        define_method "test_#{adapter}_POST_retrieves_the_response_headers" do
+          assert_equal 'text/html', create_connection(adapter).post('echo_name').headers['content-type']
+        end
+
+        # http://github.com/toland/patron/issues/#issue/9
+        if ENV['FORCE'] || adapter != Faraday::Adapter::Patron
+          define_method "test_#{adapter}_PUT_send_url_encoded_params" do
+            resp = create_connection(adapter).put do |req|
+              req.url 'echo_name'
+              req.body = {'name' => 'zack'}
+            end
+            assert_equal %("zack"), resp.body
+          end
+
+          define_method "test_#{adapter}_PUT_send_url_encoded_nested_params" do
+            resp = create_connection(adapter).put do |req|
+              req.url 'echo_name'
+              req.body = {'name' => {'first' => 'zack'}}
+            end
+            assert_equal %({"first"=>"zack"}), resp.body
+          end
+
+          define_method "test_#{adapter}_PUT_retrieves_the_response_headers" do
+            assert_equal 'text/html', create_connection(adapter).put('echo_name').headers['content-type']
+          end
+        end
+
+        # http://github.com/pauldix/typhoeus/issues#issue/7
+        if ENV['FORCE'] || adapter != Faraday::Adapter::Typhoeus
+          define_method "test_#{adapter}_HEAD_send_url_encoded_params" do
+            resp = create_connection(adapter).head do |req|
+              req.url 'hello', 'name' => 'zack'
+            end
+            assert_equal 'text/html', resp.headers['content-type']
+          end
+
+          define_method "test_#{adapter}_HEAD_retrieves_no_response_body" do
+            assert_equal '', create_connection(adapter).head('hello_world').body.to_s
+          end
+
+          define_method "test_#{adapter}_HEAD_retrieves_the_response_headers" do
+            assert_equal 'text/html', create_connection(adapter).head('hello_world').headers['content-type']
+          end
+        end
+
+        define_method "test_#{adapter}_DELETE_retrieves_the_response_headers" do
+          assert_equal 'text/html', create_connection(adapter).delete('delete_with_json').headers['content-type']
+        end
+
+        define_method "test_#{adapter}_DELETE_retrieves_the_body" do
+          assert_match /deleted/, create_connection(adapter).delete('delete_with_json').body
+        end
+
+        define_method "test_#{adapter}_async_requests_clear_parallel_manager_after_running_a_single_request" do
+          connection = create_connection(adapter)
+          assert !connection.in_parallel?
+          resp = connection.get('hello_world')
+          assert !connection.in_parallel?
+          assert_equal 'hello world', connection.get('hello_world').body
+        end
+      
+        define_method "test_#{adapter}_async_requests_uses_parallel_manager_to_run_multiple_json_requests" do
+          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')
+            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
+
+      def create_connection(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
+  end
+end