avdi-faraday 0.8.1

data/lib/faraday/adapter/patron.rb

@@ -0,0 +1,65 @@
+module Faraday
+  class Adapter
+    class Patron < Faraday::Adapter
+      dependency 'patron'
+
+      def initialize(app, &block)
+        super(app)
+        @block = block if block_given?
+      end
+
+      def call(env)
+        super
+
+        # TODO: support streaming requests
+        env[:body] = env[:body].read if env[:body].respond_to? :read
+
+        session = @session ||= create_session
+
+        if req = env[:request]
+          session.timeout = session.connect_timeout = req[:timeout] if req[:timeout]
+          session.connect_timeout = req[:open_timeout]              if req[:open_timeout]
+                    
+          if proxy = req[:proxy]
+            session.proxy = proxy[:uri].to_s
+            if proxy[:user] && proxy[:password]
+              prepend_proxy_auth_string(proxy, session)
+            end
+          end
+        end
+
+        response = begin
+          data = env[:body] ? env[:body].to_s : nil
+          session.request(env[:method], env[:url].to_s, env[:request_headers], :data => data)
+        rescue Errno::ECONNREFUSED
+          raise Error::ConnectionFailed, $!
+        end
+
+        save_response(env, response.status, response.body, response.headers)
+
+        @app.call env
+      rescue ::Patron::TimeoutError => err
+        raise Faraday::Error::TimeoutError, err
+      end
+
+      if loaded? && defined?(::Patron::Request::VALID_ACTIONS)
+        # HAX: helps but doesn't work completely
+        # https://github.com/toland/patron/issues/34
+        ::Patron::Request::VALID_ACTIONS.tap do |actions|
+          actions << :patch unless actions.include? :patch
+          actions << :options unless actions.include? :options
+        end
+      end
+
+      def create_session
+        session = ::Patron::Session.new
+        @block.call(session) if @block
+        session
+      end
+    end
+    
+    def prepend_proxy_auth_string(proxy, session)
+      session.proxy.insert(7, "#{proxy[:user]}:#{proxy[:password]}@")
+    end
+  end
+end

data/lib/faraday/adapter/rack.rb

@@ -0,0 +1,57 @@
+module Faraday
+  class Adapter
+    # Sends requests to a Rack app.
+    #
+    # Examples
+    #
+    #   class MyRackApp
+    #     def call(env)
+    #       [200, {'Content-Type' => 'text/html'}, ["hello world"]]
+    #     end
+    #   end
+    #
+    #   Faraday.new do |conn|
+    #     conn.adapter :rack, MyRackApp
+    #   end
+    class Rack < Faraday::Adapter
+      dependency 'rack/test'
+
+      # not prefixed with "HTTP_"
+      SPECIAL_HEADERS = %w[ CONTENT_LENGTH CONTENT_TYPE ]
+
+      def initialize(faraday_app, rack_app)
+        super(faraday_app)
+        mock_session = ::Rack::MockSession.new(rack_app)
+        @session     = ::Rack::Test::Session.new(mock_session)
+      end
+
+      def call(env)
+        super
+        rack_env = {
+          :method => env[:method],
+          :input  => env[:body].respond_to?(:read) ? env[:body].read : env[:body]
+        }
+
+        env[:request_headers].each do |name, value|
+          name = name.upcase.tr('-', '_')
+          name = "HTTP_#{name}" unless SPECIAL_HEADERS.include? name
+          rack_env[name] = value
+        end if env[:request_headers]
+
+        timeout  = env[:request][:timeout] || env[:request][:open_timeout]
+        response = if timeout
+          Timer.timeout(timeout, Faraday::Error::TimeoutError) { execute_request(env, rack_env) }
+        else
+          execute_request(env, rack_env)
+        end
+
+        save_response(env, response.status, response.body, response.headers)
+        @app.call env
+      end
+
+      def execute_request(env, rack_env)
+        @session.request(env[:url].to_s, rack_env)
+      end
+    end
+  end
+end

data/lib/faraday/adapter/test.rb

@@ -0,0 +1,162 @@
+module Faraday
+  class 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 < Faraday::Adapter
+      attr_accessor :stubs
+
+      class Stubs
+        class NotFound < StandardError
+        end
+
+        def initialize
+          # {:get => [Stub, Stub]}
+          @stack, @consumed = {}, {}
+          yield self if block_given?
+        end
+
+        def empty?
+          @stack.empty?
+        end
+
+        def match(request_method, path, body)
+          return false if !@stack.key?(request_method)
+          stack = @stack[request_method]
+          consumed = (@consumed[request_method] ||= [])
+          path = normalize_path(path)
+
+          if stub = matches?(stack, path, body)
+            consumed << stack.delete(stub)
+            stub
+          else
+            matches?(consumed, path, body)
+          end
+        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 patch(path, body=nil, &block)
+          new_stub(:patch, path, body, &block)
+        end
+
+        def delete(path, &block)
+          new_stub(:delete, path, &block)
+        end
+
+        def options(path, &block)
+          new_stub(:options, path, &block)
+        end
+
+        # Raises an error if any of the stubbed calls have not been made.
+        def verify_stubbed_calls
+          failed_stubs = []
+          @stack.each do |method, stubs|
+            unless stubs.size == 0
+              failed_stubs.concat(stubs.map {|stub|
+                "Expected #{method} #{stub}."
+              })
+            end
+          end
+          raise failed_stubs.join(" ") unless failed_stubs.size == 0
+        end
+
+        protected
+
+        def new_stub(request_method, path, body=nil, &block)
+          (@stack[request_method] ||= []) << Stub.new(normalize_path(path), body, block)
+        end
+
+        def matches?(stack, path, body)
+          stack.detect { |stub| stub.matches?(path, body) }
+        end
+
+        # ensure leading + trailing slash
+        def normalize_path(path)
+          path = '/' + path if path.index('/') != 0
+          path = path.sub('?', '/?')
+          path = path + '/' unless $&
+          path.gsub('//', '/')
+        end
+      end
+
+      class Stub < Struct.new(:path, :params, :body, :block)
+        def initialize(full, body, block)
+          path, query = full.split('?')
+          params = query ?
+            Faraday::Utils.parse_nested_query(query) :
+            {}
+          super path, params, body, block
+        end
+
+        def matches?(request_uri, request_body)
+          request_path, request_query = request_uri.split('?')
+          request_params = request_query ?
+            Faraday::Utils.parse_nested_query(request_query) :
+            {}
+          request_path == path &&
+            params_match?(request_params) &&
+            (body.to_s.size.zero? || request_body == body)
+        end
+
+        def params_match?(request_params)
+          params.keys.all? do |key|
+            request_params[key] == params[key]
+          end
+        end
+
+        def to_s
+          "#{path} #{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 call(env)
+        super
+        normalized_path = Faraday::Utils.normalize_path(env[:url])
+
+        if stub = stubs.match(env[:method], normalized_path, env[:body])
+          env[:params] = (query = env[:url].query) ?
+            Faraday::Utils.parse_nested_query(query)  :
+            {}
+          status, headers, body = stub.block.call(env)
+          save_response(env, status, body, headers)
+        else
+          raise Stubs::NotFound, "no stubbed request for #{env[:method]} #{normalized_path} #{env[:body]}"
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/faraday/adapter/typhoeus.rb

@@ -0,0 +1,107 @@
+module Faraday
+  class Adapter
+    class Typhoeus < Faraday::Adapter
+      self.supports_parallel = true
+
+      def self.setup_parallel_manager(options = {})
+        options.empty? ? ::Typhoeus::Hydra.hydra : ::Typhoeus::Hydra.new(options)
+      end
+
+      dependency 'typhoeus'
+
+      def call(env)
+        super
+        perform_request env
+        @app.call env
+      end
+
+      def perform_request(env)
+        read_body env
+
+        hydra = env[:parallel_manager] || self.class.setup_parallel_manager
+        hydra.queue request(env)
+        hydra.run unless parallel?(env)
+      rescue Errno::ECONNREFUSED
+        raise Error::ConnectionFailed, $!
+      end
+
+      # TODO: support streaming requests
+      def read_body(env)
+        env[:body] = env[:body].read if env[:body].respond_to? :read
+      end
+
+      def request(env)
+        req = ::Typhoeus::Request.new env[:url].to_s,
+          :method  => env[:method],
+          :body    => env[:body],
+          :headers => env[:request_headers],
+          :disable_ssl_peer_verification => (env[:ssl] && !env[:ssl].fetch(:verify, true))
+
+        configure_ssl     req, env
+        configure_proxy   req, env
+        configure_timeout req, env
+        configure_socket  req, env
+
+        req.on_complete do |resp|
+          if resp.timed_out?
+            if parallel?(env)
+              # TODO: error callback in async mode
+            else
+              raise Faraday::Error::TimeoutError, "request timed out"
+            end
+          end
+
+          save_response(env, resp.code, resp.body) do |response_headers|
+            response_headers.parse resp.headers
+          end
+          # in async mode, :response is initialized at this point
+          env[:response].finish(env) if parallel?(env)
+        end
+
+        req
+      end
+
+      def configure_ssl(req, env)
+        ssl = env[:ssl]
+
+        req.ssl_version = ssl[:version]          if ssl[:version]
+        req.ssl_cert    = ssl[:client_cert_file] if ssl[:client_cert_file]
+        req.ssl_key     = ssl[:client_key_file]  if ssl[:client_key_file]
+        req.ssl_cacert  = ssl[:ca_file]          if ssl[:ca_file]
+        req.ssl_capath  = ssl[:ca_path]          if ssl[:ca_path]
+      end
+
+      def configure_proxy(req, env)
+        proxy = request_options(env)[:proxy]
+        return unless proxy
+
+        req.proxy = "#{proxy[:uri].host}:#{proxy[:uri].port}"
+
+        if proxy[:username] && proxy[:password]
+          req.proxy_username = proxy[:username]
+          req.proxy_password = proxy[:password]
+        end
+      end
+
+      def configure_timeout(req, env)
+        env_req = request_options(env)
+        req.timeout = req.connect_timeout = (env_req[:timeout] * 1000) if env_req[:timeout]
+        req.connect_timeout = (env_req[:open_timeout] * 1000)          if env_req[:open_timeout]
+      end
+      
+      def configure_socket(req, env)
+        if bind = request_options(env)[:bind]
+          req.interface = bind[:host]
+        end
+      end
+
+      def request_options(env)
+        env[:request]
+      end
+
+      def parallel?(env)
+        !!env[:parallel_manager]
+      end
+    end
+  end
+end

data/lib/faraday/builder.rb

@@ -0,0 +1,184 @@
+module Faraday
+  # Possibly going to extend this a bit.
+  #
+  # Faraday::Connection.new(:url => 'http://sushi.com') do |builder|
+  #   builder.request  :url_encoded  # Faraday::Request::UrlEncoded
+  #   builder.adapter  :net_http     # Faraday::Adapter::NetHttp
+  # end
+  class Builder
+    attr_accessor :handlers
+
+    # Error raised when trying to modify the stack after calling `lock!`
+    class StackLocked < RuntimeError; end
+
+    # borrowed from ActiveSupport::Dependencies::Reference &
+    # ActionDispatch::MiddlewareStack::Middleware
+    class Handler
+      @@constants = Hash.new { |h, k|
+        h[k] = k.respond_to?(:constantize) ? k.constantize : Object.const_get(k)
+      }
+
+      attr_reader :name, :args
+
+      def initialize(klass, *args, &block)
+        @name = klass.to_s
+        @@constants[@name] = klass if klass.respond_to?(:name)
+        @args, @block = args, block
+      end
+
+      def klass() @@constants[@name] end
+      def inspect() @name end
+
+      def ==(other)
+        if other.is_a? Handler
+          self.name == other.name
+        elsif other.respond_to? :name
+          klass == other
+        else
+          @name == other.to_s
+        end
+      end
+
+      def build(app)
+        klass.new(app, *@args, &@block)
+      end
+
+      def adapter?
+        klass.respond_to?(:adapter?) && klass.adapter?
+      end
+    end
+
+    def initialize(handlers = [])
+      @handlers = handlers
+      if block_given?
+        build(&Proc.new)
+      elsif @handlers.empty?
+        # default stack, if nothing else is configured
+        self.request :url_encoded
+        self.adapter Faraday.default_adapter
+      end
+    end
+
+    def build(options = {})
+      raise_if_locked
+      clear unless options[:keep]
+      yield self if block_given?
+    end
+
+    def clear
+      @handlers.clear
+    end
+
+    def [](idx)
+      @handlers[idx]
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && @handlers == other.handlers
+    end
+
+    def dup
+      self.class.new(@handlers.dup)
+    end
+
+    def to_app(inner_app)
+      # last added handler is the deepest and thus closest to the inner app
+      @handlers.reverse.inject(inner_app) { |app, handler| handler.build(app) }
+    end
+
+    # Locks the middleware stack to ensure no further modifications are possible.
+    def lock!
+      @handlers.freeze
+    end
+
+    def locked?
+      @handlers.frozen?
+    end
+
+    def use(klass, *args, &block)
+      if klass.is_a? Symbol
+        use_symbol(Faraday::Middleware, klass, *args, &block)
+      else
+        raise_if_locked
+        @handlers << self.class::Handler.new(klass, *args, &block)
+      end
+    end
+
+    def request(key, *args, &block)
+      use_symbol(Faraday::Request, key, *args, &block)
+    end
+
+    def response(key, *args, &block)
+      use_symbol(Faraday::Response, key, *args, &block)
+    end
+
+    def adapter(key=nil, *args, &block)
+      if [key, *args, block].none?
+        find_adapter
+      else
+        use_symbol(Faraday::Adapter, key, *args, &block)
+      end
+    end
+
+    def has_adapter?
+      !!find_adapter
+    end
+
+    ## methods to push onto the various positions in the stack:
+
+    def insert(index, *args, &block)
+      raise_if_locked
+      index = assert_index(index)
+      handler = self.class::Handler.new(*args, &block)
+      @handlers.insert(index, handler)
+    end
+
+    alias_method :insert_before, :insert
+
+    def insert_after(index, *args, &block)
+      index = assert_index(index)
+      insert(index + 1, *args, &block)
+    end
+
+    def swap(index, *args, &block)
+      raise_if_locked
+      index = assert_index(index)
+      @handlers.delete_at(index)
+      insert(index, *args, &block)
+    end
+
+    def delete(handler)
+      raise_if_locked
+      @handlers.delete(handler)
+    end
+
+    def adapter=(adapter_args)
+      clear_adapters
+      adapter(*adapter_args)
+    end
+
+    private
+
+    def raise_if_locked
+      raise StackLocked, "can't modify middleware stack after making a request" if locked?
+    end
+
+    def use_symbol(mod, key, *args, &block)
+      use(mod.lookup_middleware(key), *args, &block)
+    end
+
+    def assert_index(index)
+      idx = index.is_a?(Integer) ? index : @handlers.index(index)
+      raise "No such handler: #{index.inspect}" unless idx
+      idx
+    end
+
+    def find_adapter
+      @handlers.detect{|h| h.adapter?}
+    end
+
+    def clear_adapters
+      @handlers.delete_if{|h| h.adapter?}
+    end
+  end
+end