shin-faraday 0.4.7

data/lib/faraday/adapter/patron.rb

@@ -0,0 +1,33 @@
+module Faraday
+  module Adapter
+    class Patron < Middleware
+      begin
+        require 'patron'
+      rescue LoadError, NameError => 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,117 @@
+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
+
+        # 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
+      end
+
+      class Stub < Struct.new(:path, :body, :block)
+        def matches?(request_path, request_body)
+          request_path == path && (body.to_s.size.zero? || request_body == body)
+        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 request_uri(url)
+        (url.path != "" ? url.path : "/") +
+        (url.query ? "?#{sort_query_params(url.query)}" : "")
+      end
+
+      def sort_query_params(query)
+        query.split('&').sort.join('&')
+      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

data/lib/faraday/adapter/typhoeus.rb

@@ -0,0 +1,65 @@
+module Faraday
+  module Adapter
+    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, NameError => e
+        self.load_error = e
+      end
+
+      def call(env)
+        process_body_for_request(env)
+
+        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],
+          :disable_ssl_peer_verification => (env[:ssl][:verify] == false)
+        
+        env_req = env[:request]
+        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]
+
+        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
+
+        hydra.queue req
+
+        if !env[:parallel_manager]
+          hydra.run
+        end
+
+        @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
+end

data/lib/faraday/builder.rb

@@ -0,0 +1,82 @@
+module Faraday
+  # Possibly going to extend this a bit.
+  #
+  # Faraday::Connection.new(:url => 'http://sushi.com') do |b|
+  #   b.request  :yajl     # Faraday::Request::Yajl
+  #   b.adapter  :logger   # Faraday::Adapter::Logger
+  #   b.response :yajl     # Faraday::Response::Yajl
+  # end
+  class Builder
+    attr_accessor :handlers
+
+    def self.create(&block)
+      Builder.new(&block)
+    end
+
+    def self.inner_app
+      lambda do |env| 
+        env[:parallel_manager] ? env[:response] : env[:response].finish(env)
+      end
+    end
+
+    def initialize(handlers = [], &block)
+      @handlers = handlers
+      build(&block) if block_given?
+    end
+
+    def build(options = {}, &block)
+      inner = @handlers.shift
+      if !options[:keep]
+        @handlers.clear
+      end
+      block.call(self)
+      run(inner || self.class.inner_app)
+    end
+
+    def [](index)
+      # @handlers are stored in reverse order
+      @handlers[-(index+1)]
+    end
+
+    def run(app)
+      @handlers.unshift app
+    end
+
+    def to_app
+      if @handlers.empty?
+        build { |b| b.adapter Faraday.default_adapter }
+      end
+
+      inner_app = @handlers.first
+      @handlers[1..-1].inject(inner_app) { |app, middleware| middleware.call(app) }
+    end
+
+    def use(klass, *args, &block)
+      run(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
+
+    def ==(other)
+      other.is_a?(self.class) && @handlers == other.handlers
+    end
+
+    def dup
+      self.class.new(@handlers.dup)
+    end
+  end
+end

data/lib/faraday/connection.rb

@@ -0,0 +1,263 @@
+require 'addressable/uri'
+require 'set'
+require 'base64'
+
+module Faraday
+  class Connection
+    include Addressable, Rack::Utils
+
+    HEADERS = Hash.new do |h, k|
+      if k.respond_to?(:to_str)
+        k
+      else 
+        k.to_s.split('_').            # :user_agent => %w(user agent)
+          each { |w| w.capitalize! }. # => %w(User Agent)
+          join('-')                   # => "User-Agent"
+      end
+    end
+    HEADERS.update \
+      :etag => "ETag"
+    HEADERS.values.each { |v| v.freeze }
+
+    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, :options, :ssl
+
+    # :url
+    # :params
+    # :headers
+    # :request
+    # :ssl
+    def initialize(url = nil, options = {}, &block)
+      if url.is_a?(Hash)
+        options = url
+        url     = options[:url]
+      end
+      @headers          = HeaderHash.new
+      @params           = {}
+      @options          = options[:request] || {}
+      @ssl              = options[:ssl]     || {}
+      @parallel_manager = options[:parallel]
+      self.url_prefix = url if url
+      proxy(options[:proxy])
+      merge_params  @params,  options[:params]  if options[:params]
+      merge_headers @headers, options[:headers] if options[:headers]
+
+      if block
+        @builder = Builder.new
+        @builder.build { block.call(self) }
+      else
+        @builder = options[:builder] || Builder.new
+      end
+    end
+
+    def use(klass, *args, &block)
+      @builder.use(klass, *args, &block)
+    end
+
+    def request(key, *args, &block)
+      @builder.request(key, *args, &block)
+    end
+
+    def response(key, *args, &block)
+      @builder.response(key, *args, &block)
+    end
+
+    def adapter(key, *args, &block)
+      @builder.adapter(key, *args, &block)
+    end
+
+    def build(options = {}, &block)
+      @builder.build(options, &block)
+    end
+
+    def get(url = nil, headers = nil, &block)
+      run_request(:get, url, nil, headers, &block)
+    end
+
+    def post(url = nil, body = nil, headers = nil, &block)
+      run_request(:post, url, body, headers, &block)
+    end
+
+    def put(url = nil, body = nil, headers = nil, &block)
+      run_request(:put, url, body, headers, &block)
+    end
+
+    def head(url = nil, headers = nil, &block)
+      run_request(:head, url, nil, headers, &block)
+    end
+
+    def delete(url = nil, headers = nil, &block)
+      run_request(:delete, url, nil, headers, &block)
+    end
+
+    def basic_auth(login, pass)
+      @headers['authorization'] = "Basic #{Base64.encode64("#{login}:#{pass}").strip}"
+    end
+
+    def token_auth(token, options = {})
+      values = ["token=#{token.to_s.inspect}"]
+      options.each do |key, value|
+        values << "#{key}=#{value.to_s.inspect}"
+      end
+      # 21 = "Authorization: Token ".size
+      comma = ",\n#{' ' * 21}"
+      @headers['authorization'] = "Token #{values * comma}"
+    end
+
+    def in_parallel?
+      !!@parallel_manager
+    end
+
+    def in_parallel(manager)
+      @parallel_manager = manager
+      yield
+      @parallel_manager && @parallel_manager.run
+    ensure
+      @parallel_manager = nil
+    end
+
+    def proxy(arg = nil)
+      return @proxy if arg.nil?
+
+      @proxy = 
+        case arg
+          when String then {:uri => proxy_arg_to_uri(arg)}
+          when URI    then {:uri => arg}
+          when Hash   then arg
+            if arg[:uri] = proxy_arg_to_uri(arg[:uri])
+              arg
+            else
+              raise ArgumentError, "no :uri option."
+            end
+        end
+    end
+
+    # 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
+      if uri.user && uri.password
+        basic_auth(uri.user, uri.password)
+      end
+    end
+
+    # Ensures that the path prefix always has a leading / and no trailing /
+    def path_prefix=(value)
+      if value
+        value.chomp!  "/"
+        value.replace "/#{value}" if value !~ /^\//
+      end
+      @path_prefix = value
+    end
+
+    # return the assembled Rack application for this instance.
+    def to_app
+      @builder.to_app
+    end
+
+    def run_request(method, url, body, headers)
+      if !METHODS.include?(method)
+        raise ArgumentError, "unknown http method: #{method}"
+      end
+
+      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
+    end
+
+    # 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)
+      if @path_prefix && uri.path !~ /^\//
+        uri.path = "#{@path_prefix.size > 1 ? @path_prefix : nil}/#{uri.path}"
+      end
+      uri.host   ||= @host
+      uri.port   ||= @port
+      uri.scheme ||= @scheme
+      replace_query(uri, params)
+      uri
+    end
+
+    def dup
+      self.class.new(build_url(''), :headers => headers.dup, :params => params.dup, :builder => builder.dup)
+    end
+
+    def replace_query(uri, params)
+      url_params = @params.dup
+      if uri.query && !uri.query.empty?
+        merge_params(url_params, parse_query(uri.query))
+      end
+      if params && !params.empty?
+        merge_params(url_params, params)
+      end
+      uri.query = url_params.empty? ? nil : build_query(url_params)
+      uri
+    end
+
+    # 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
+
+    # 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
+
+    # 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
+
+    def proxy_arg_to_uri(arg)
+      case arg
+        when String then URI.parse(arg)
+        when URI    then arg
+      end
+    end
+  end
+end