faraday 0.1.2 → 0.2.0

data/lib/faraday/adapter/typhoeus.rb

@@ -1,75 +1,59 @@
 module Faraday
   module Adapter
-    module Typhoeus
-      extend Faraday::Connection::Options
+    class Typhoeus < Middleware
+      self.supports_parallel_requests = true
+
+      def self.setup_parallel_manager(options = {})
+        options.empty? ? ::Typhoeus::Hydra.hydra : ::Typhoeus::Hydra.new(options)
+      end
 
       begin
         require 'typhoeus'
+      rescue LoadError => e
+        self.load_error = e
+      end
 
-        def in_parallel?
-          !!@parallel_manager
-        end
-        
-        def in_parallel(options = {})
-          setup_parallel_manager(options)
-          yield
-          run_parallel_requests
-        end
-        
-        def setup_parallel_manager(options = {})
-          @parallel_manager ||= ::Typhoeus::Hydra.new(options)
-        end
-        
-        def run_parallel_requests
-          @parallel_manager.run
-          @parallel_manager = nil
-        end
-        
-        def _post(uri, data, request_headers)
-          request = request_class.new(data, request_headers)
-          _perform(:post, uri, :headers => request.headers, :body => request.body)
-        end
+      def call(env)
+        process_body_for_request(env)
 
-        def _get(uri, request_headers)
-          _perform(:get, uri, :headers => request_headers)
-        end
+        hydra = env[:parallel_manager] || self.class.setup_parallel_manager
+        req   = ::Typhoeus::Request.new env[:url].to_s, 
+          :method  => env[:method],
+          :body    => env[:body],
+          :headers => env[:request_headers]
 
-        def _put(uri, data, request_headers)
-          request = request_class.new(data, request_headers)
-          _perform(:put, uri, :headers => request.headers, :body => request.body)
+        req.on_complete do |resp|
+          env.update \
+            :status           => resp.code,
+            :response_headers => parse_response_headers(resp.headers),
+            :body             => resp.body
+          env[:response].finish(env)
         end
 
-        def _delete(uri, request_headers)
-          _perform(:delete, uri, :headers => request_headers)
-        end
+        hydra.queue req
 
-        def _perform method, uri, params
-          response_class.new do |resp|
-            is_async = in_parallel?
-            setup_parallel_manager
-            params[:method] = method
-            req      = ::Typhoeus::Request.new(uri.to_s, params)
-            req.on_complete do |response|
-              raise Faraday::Error::ResourceNotFound if response.code == 404
-              resp.process!(response.body)
-              resp.headers = parse_response_headers(response.headers)
-            end
-            @parallel_manager.queue(req)
-            if !is_async then run_parallel_requests end
-          end
-        rescue Errno::ECONNREFUSED
-          raise Faraday::Error::ConnectionFailed, "connection refused"
+        if !env[:parallel_manager]
+          hydra.run
         end
 
-        def parse_response_headers(header_string)
-          return {} unless header_string # XXX
-          Hash[*header_string.split(/\r\n/).
-            tap  { |a|      a.shift           }. # drop the HTTP status line
-            map! { |h|      h.split(/:\s+/,2) }. # split key and value
-            map! { |(k, v)| [k.downcase, v]   }.flatten!]
-        end
-      rescue LoadError => e
-        self.load_error = e
+        @app.call env
+      rescue Errno::ECONNREFUSED
+        raise Error::ConnectionFailed, "connection refused"
+      end
+
+      def in_parallel(options = {})
+        @hydra = ::Typhoeus::Hydra.new(options)
+        yield
+        @hydra.run
+        @hydra = nil
+      end
+
+      def parse_response_headers(header_string)
+        return {} unless header_string && !header_string.empty?
+        Hash[*header_string.split(/\r\n/).
+          tap  { |a|      a.shift           }. # drop the HTTP status line
+          map! { |h|      h.split(/:\s+/,2) }. # split key and value
+          map! { |(k, v)| [k.downcase, v]   }.flatten!]
       end
     end
   end

data/lib/faraday/builder.rb

@@ -0,0 +1,57 @@
+module Faraday
+  # Possibly going to extend this a bit.
+  #
+  # Faraday::Connection.new(:url => 'http://sushi.com') do
+  #   request  :yajl     # Faraday::Request::Yajl
+  #   adapter  :logger   # Faraday::Adapter::Logger
+  #   response :yajl     # Faraday::Response::Yajl
+  # end
+  class Builder
+    attr_accessor :handlers
+
+    def self.create_with_inner_app(&block)
+      inner = lambda do |env| 
+        if !env[:parallel_manager]
+          env[:response].finish(env)
+        else
+          env[:response]
+        end
+      end
+      Builder.new(&block).tap { |builder| builder.run(inner) }
+    end
+
+    def initialize
+      @handlers = []
+      yield self
+    end
+
+    def run app
+      @handlers.unshift app
+    end
+
+    def to_app
+      inner_app = @handlers.first
+      @handlers[1..-1].inject(inner_app) { |app, middleware| middleware.call(app) }
+    end
+
+    def use klass, *args, &block
+      @handlers.unshift(lambda { |app| klass.new(app, *args, &block) })
+    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, *args, &block)
+      use_symbol Faraday::Adapter, key, *args, &block
+    end
+
+    def use_symbol(mod, key, *args, &block)
+      use mod.lookup_module(key), *args, &block
+    end
+  end
+end

data/lib/faraday/connection.rb

@@ -1,119 +1,115 @@
 require 'addressable/uri'
+require 'set'
+
 module Faraday
   class Connection
-    module Options
-      def load_error()       @load_error         end
-      def load_error=(v)     @load_error = v     end
-      def supports_async()   @supports_async     end
-      def supports_async=(v) @supports_async = v end
-      def loaded?()         !@load_error         end
-      alias supports_async? supports_async
-    end
+    include Addressable, Rack::Utils
 
-    include Addressable
+    HEADERS = Hash.new { |h, k| k.respond_to?(:to_str) ? k : k.to_s.capitalize }.update \
+      :content_type    => "Content-Type",
+      :content_length  => "Content-Length",
+      :accept_charset  => "Accept-Charset",
+      :accept_encoding => "Accept-Encoding"
+    HEADERS.values.each { |v| v.freeze }
 
-    attr_accessor :host, :port, :scheme, :params, :headers
-    attr_reader   :path_prefix
+    METHODS = Set.new [:get, :post, :put, :delete, :head]
+    METHODS_WITH_BODIES = Set.new [:post, :put]
+
+    attr_accessor :host, :port, :scheme, :params, :headers, :parallel_manager
+    attr_reader   :path_prefix, :builder
 
     # :url
     # :params
     # :headers
-    # :response
-    def initialize(url = nil, options = {})
+    def initialize(url = nil, options = {}, &block)
       if url.is_a?(Hash)
         options = url
         url     = options[:url]
       end
-      @response_class = options[:response]
-      @params         = options[:params]  || {}
-      @headers        = options[:headers] || {}
+      @headers          = HeaderHash.new
+      @params           = {}
+      @parallel_manager = options[:parallel]
       self.url_prefix = url if url
+      merge_params  @params,  options[:params]  if options[:params]
+      merge_headers @headers, options[:headers] if options[:headers]
+      if block
+        @builder = Builder.create_with_inner_app(&block)
+      end
     end
 
-    def url_prefix=(url)
-      uri              = URI.parse(url)
-      self.scheme      = uri.scheme
-      self.host        = uri.host
-      self.port        = uri.port
-      self.path_prefix = uri.path
-    end
-
-
-    # Override in a subclass, or include an adapter
-    #
-    #   def _post(uri, post_params, headers)
-    #   end
-    #
-    def post(uri, params = {}, headers = {})
-      _post build_uri(uri), build_params(params), build_headers(headers)
-    end
-
-    # Override in a subclass, or include an adapter
-    #
-    #   def _put(uri, post_params, headers)
-    #   end
-    #
-    def put(uri, params = {}, headers = {})
-      _put build_uri(uri), build_params(params), build_headers(headers)
+    def get(url = nil, headers = nil, &block)
+      run_request :get, url, nil, headers, &block
     end
 
-    # Override in a subclass, or include an adapter
-    #
-    #   def _delete(uri, headers)
-    #   end
-    #
-    def delete(uri, params = {}, headers = {})
-      _delete build_uri(uri, build_params(params)), build_headers(headers)
+    def post(url = nil, body = nil, headers = nil, &block)
+      run_request :post, url, body, headers, &block
     end
 
-    # Override in a subclass, or include an adapter
-    #
-    #   def _get(uri, headers)
-    #   end
-    #
-    def get(url, params = nil, headers = nil)
-      uri = build_uri(url, build_params(params))
-      _get(uri, build_headers(headers))
+    def put(url = nil, body = nil, headers = nil, &block)
+      run_request :put, url, body, headers, &block
     end
 
-    def request_class
-      @request_class || Request::PostRequest
+    def head(url = nil, headers = nil, &block)
+      run_request :head, url, nil, headers, &block
     end
 
-    def response_class
-      @response_class || Response
+    def delete(url = nil, headers = nil, &block)
+      run_request :delete, url, nil, headers, &block
     end
 
-    def response_class=(v)
-      if v.respond_to?(:loaded?) && !v.loaded?
-        raise ArgumentError, "The response class: #{v.inspect} does not appear to be loaded."
+    def run_request(method, url, body, headers)
+      if !METHODS.include?(method)
+        raise ArgumentError, "unknown http method: #{method}"
       end
-      @response_class = v
-    end
 
-    def request_class=(v)
-      if v.respond_to?(:loaded?) && !v.loaded?
-        raise ArgumentError, "The request class: #{v.inspect} does not appear to be loaded."
+      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
-      @request_class = v
     end
 
     def in_parallel?
       !!@parallel_manager
     end
 
-    def in_parallel(options = {})
-      @parallel_manager = true
+    def in_parallel(manager)
+      @parallel_manager = manager
       yield
-      @parallel_manager = false
+      @parallel_manager && @parallel_manager.run
+    ensure
+      @parallel_manager = nil
     end
 
-    def setup_parallel_manager(options = {})
+    # return the assembled Rack application for this instance.
+    def to_app
+      @builder.to_app
     end
 
-    def run_parallel_requests
+    # Parses the giving url with Addressable::URI and stores the individual
+    # components in this connection.  These components serve as defaults for 
+    # requests made by this connection.
+    #
+    #   conn = Faraday::Connection.new { ... }
+    #   conn.url_prefix = "https://sushi.com/api"
+    #   conn.scheme      # => https
+    #   conn.path_prefix # => "/api"
+    #
+    #   conn.get("nigiri?page=2") # accesses https://sushi.com/api/nigiri
+    #
+    def url_prefix=(url)
+      uri              = URI.parse(url)
+      self.scheme      = uri.scheme
+      self.host        = uri.host
+      self.port        = uri.port
+      self.path_prefix = uri.path
+      if uri.query && !uri.query.empty?
+        merge_params @params, parse_query(uri.query)
+      end
     end
 
+    # Ensures that the path prefix always has a leading / and no trailing /
     def path_prefix=(value)
       if value
         value.chomp!  "/"
@@ -122,54 +118,65 @@ module Faraday
       @path_prefix = value
     end
 
-    def build_uri(url, params = nil)
-      uri          = URI.parse(url)
+    # Takes a relative url for a request and combines it with the defaults 
+    # set on the connection instance.
+    #
+    #   conn = Faraday::Connection.new { ... }
+    #   conn.url_prefix = "https://sushi.com/api?token=abc"
+    #   conn.scheme      # => https
+    #   conn.path_prefix # => "/api"
+    #
+    #   conn.build_url("nigiri?page=2")      # => https://sushi.com/api/nigiri?token=abc&page=2
+    #   conn.build_url("nigiri", :page => 2) # => https://sushi.com/api/nigiri?token=abc&page=2
+    #
+    def build_url(url, params = nil)
+      uri          = URI.parse(url.to_s)
       uri.scheme ||= @scheme
       uri.host   ||= @host
       uri.port   ||= @port
       if @path_prefix && uri.path !~ /^\//
         uri.path = "#{@path_prefix.size > 1 ? @path_prefix : nil}/#{uri.path}"
       end
-      if params && !params.empty?
-        uri.query = params_to_query(params)
-      end
+      replace_query(uri, params)
       uri
     end
 
-    def path_for(uri)
-      uri.path.tap do |s|
-        s << "?#{uri.query}"    if uri.query
-        s << "##{uri.fragment}" if uri.fragment
+    def replace_query(uri, params)
+      url_params = @params.dup
+      if uri.query && !uri.query.empty?
+        merge_params url_params, parse_query(uri.query)
       end
-    end
-
-    def build_params(existing)
-      build_hash :params, existing
-    end
-
-    def build_headers(existing)
-      build_hash(:headers, existing).tap do |headers|
-        headers.keys.each do |key|
-          headers[key] = headers.delete(key).to_s
-        end
+      if params && !params.empty?
+        merge_params url_params, params
       end
+      uri.query = url_params.empty? ? nil : build_query(url_params)
+      uri
     end
 
-    def build_hash(method, existing)
-      existing ? send(method).merge(existing) : send(method)
+    # turns param keys into strings
+    def merge_params(existing_params, new_params)
+      new_params.each do |key, value|
+        existing_params[key.to_s] = value
+      end
     end
 
-    def params_to_query(params)
-      params.inject([]) do |memo, (key, val)|
-        memo << "#{escape_for_querystring(key)}=#{escape_for_querystring(val)}"
-      end.join("&")
+    # turns headers keys and values into strings.  Look up symbol keys in the 
+    # the HEADERS hash.  
+    #
+    #   h = merge_headers(HeaderHash.new, :content_type => 'text/plain')
+    #   h['Content-Type'] # = 'text/plain'
+    #
+    def merge_headers(existing_headers, new_headers)
+      new_headers.each do |key, value|
+        existing_headers[HEADERS[key]] = value.to_s
+      end
     end
 
-    # Some servers convert +'s in URL query params to spaces.
-    # Go ahead and encode it.
-    def escape_for_querystring(s)
-      URI.encode_component(s.to_s, Addressable::URI::CharacterClasses::QUERY).tap do |escaped|
-        escaped.gsub! /\+/, "%2B"
+    # Be sure to URI escape '+' symbols to %2B.  Otherwise, they get interpreted
+    # as spaces.
+    def escape(s)
+      s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/n) do
+        '%' << $1.unpack('H2'*bytesize($1)).join('%').tap { |c| c.upcase! }
       end
     end
   end