rack-client 0.1.1 → 0.3.0

data/lib/rack/client/cookie_jar/context.rb

@@ -0,0 +1,59 @@
+module Rack
+  module Client
+    module CookieJar
+      class Context
+        include Options
+        include DualBand
+
+        def initialize(app, options = {})
+          @app = app
+
+          initialize_options options
+        end
+
+        def sync_call(env)
+          request = Request.new(env)
+          cookies = lookup(request)
+          request.inject(cookies)
+
+          response = Response.new(*@app.call(request.env))
+          cookies = Cookie.merge(cookies, response.cookies)
+          store cookies
+
+          response['rack-client-cookiejar.cookies'] = cookies.map {|c| c.to_header } * ', ' unless cookies.empty?
+          response.finish
+        end
+
+        def async_call(env)
+          request = Request.new(env)
+          cookies = lookup(request)
+          request.inject(cookies)
+
+          @app.call(request.env) do |request_parts|
+            response  = Response.new(*request_parts)
+            cookies   = Cookie.merge(cookies, response.cookies)
+            store cookies
+
+            response['rack-client-cookiejar.cookies'] = cookies.map {|c| c.to_header } * ', ' unless cookies.empty?
+            yield response.finish
+          end
+        end
+
+        def lookup(request)
+          cookiestore.match(request.host, request.path)
+        end
+
+        def store(cookies)
+          cookies.each do |cookie|
+            cookiestore.store(cookie)
+          end
+        end
+
+        def cookiestore
+          uri = options['rack-client-cookiejar.cookiestore']
+          storage.resolve_cookiestore_uri(uri)
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/cookie_jar/cookie.rb

@@ -0,0 +1,59 @@
+module Rack
+  module Client
+    module CookieJar
+      class Cookie < Struct.new(:key, :value, :domain, :path)
+
+        def self.merge(bottom, top)
+          bottom.reject {|a| top.any? {|b| a == b } } | top
+        end
+
+        def self.parse(raw)
+          raw.split(', ').map {|header| from(header) }
+        end
+
+        def self.from(header)
+          data  = header.split('; ')
+          tuple = data.shift.split('=')
+          parts = data.map {|s| s.split('=') }
+
+          new parts.inject('key'=> tuple.first, 'value'=> tuple.last) {|h,(k,v)| h.update(k => v)}
+        end
+
+        def initialize(parts = {})
+          parts.each do |k,v|
+            send(:"#{k}=", v)
+          end
+        end
+
+        def to_key
+          [ key, domain, path ] * ';'
+        end
+
+        def to_header
+          hash = members.zip(values).inject({}) {|h,(k,v)| h.update(k => v) }.reject {|k,v| v.nil?}
+          "#{hash.delete('key')}=#{hash.delete('value')}" << ('; ' + hash.map {|(k,v)| "#{k}=#{v}" } * '; ' unless hash.empty?)
+        end
+
+        def eql?(other)
+          to_key == other.to_key
+        end
+
+        def match?(domain, path)
+          fuzzy_domain_equal(domain) && fuzzy_path_equal(path)
+        end
+
+        def fuzzy_domain_equal(other_domain)
+          if domain =~ /^\./
+            other_domain =~ /#{Regexp.escape(domain)}$/
+          else
+            domain == other_domain
+          end
+        end
+
+        def fuzzy_path_equal(other_path)
+          path == '/' || path == other_path
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/cookie_jar/cookiestore.rb

@@ -0,0 +1,36 @@
+module Rack
+  module Client
+    module CookieJar
+      class CookieStore
+        def store(cookie)
+          write cookie.to_key, cookie.to_header
+        end
+
+        def match(domain, path)
+          cookies = map {|header| Cookie.from(header) }
+          cookies.select {|cookie| cookie.match?(domain, path) }
+        end
+
+        class Heap < CookieStore
+          def initialize
+            @heap = Hash.new {|h,k| h[k] = [] }
+          end
+
+          def write(key, value)
+            @heap[key] << value
+          end
+
+          def map
+            @heap.values.flatten.map {|*a| yield *a }
+          end
+
+          def self.resolve(uri)
+            new
+          end
+        end
+
+        HEAP = Heap
+      end
+    end
+  end
+end

data/lib/rack/client/cookie_jar/options.rb

@@ -0,0 +1,43 @@
+module Rack
+  module Client
+    module CookieJar
+      module Options
+        def self.option_accessor(key)
+          name = option_name(key)
+          define_method(key) { || options[name] }
+          define_method("#{key}=") { |value| options[name] = value }
+          define_method("#{key}?") { || !! options[name] }
+        end
+
+        def options
+          @default_options.merge(@options)
+        end
+
+        def options=(hash = {})
+          @options = hash.each { |key,value| write_option(key, value) }
+        end
+
+        def option_name(key)
+          case key
+          when Symbol ; "rack-client-cookiejar.#{key}"
+          when String ; key
+          else raise ArgumentError
+          end
+        end
+        module_function :option_name
+
+        option_accessor :storage
+        option_accessor :cookiestore
+        option_accessor :cookies
+
+        def initialize_options(options={})
+          @default_options = {
+            'rack-client-cookiejar.storage'     => Storage.new,
+            'rack-client-cookiejar.cookiestore' => 'heap:/',
+          }
+          self.options = options
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/cookie_jar/request.rb

@@ -0,0 +1,15 @@
+module Rack
+  module Client
+    module CookieJar
+      class Request < Rack::Request
+        def inject(cookies)
+          if raw_cookies = env['HTTP_COOKIE']
+            cookies = Cookie.merge(cookies, raw_cookies)
+          end
+
+          env['HTTP_COOKIE'] = cookies.map {|c| c.to_header } * ', ' unless cookies.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/cookie_jar/response.rb

@@ -0,0 +1,16 @@
+module Rack
+  module Client
+    module CookieJar
+      class Response < Client::Response
+        def cookies
+          return [] unless set_cookie
+          Cookie.parse(set_cookie.last)
+        end
+
+        def set_cookie
+          @set_cookie ||= headers.detect {|(k,v)| k =~ /Set-Cookie/i }
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/cookie_jar/storage.rb

@@ -0,0 +1,34 @@
+module Rack
+  module Client
+    module CookieJar
+      class Storage
+        def initialize
+          @cookiestores = {}
+        end
+
+        def resolve_cookiestore_uri(uri)
+          @cookiestores[uri.to_s] ||= create_store(uri)
+        end
+
+        def create_store(uri)
+          if uri.respond_to?(:scheme) || uri.respond_to?(:to_str)
+            uri = URI.parse(uri) unless uri.respond_to?(:scheme)
+            if CookieStore.const_defined?(uri.scheme.upcase)
+              klass = CookieStore.const_get(uri.scheme.upcase)
+              klass.resolve(uri)
+            else
+              fail "Unknown storage provider: #{uri.to_s}"
+            end
+          else
+            fail "Unknown storage provider: #{uri.to_s}"
+          end
+        end
+
+        @@singleton_instance = new
+        def self.instance
+          @@singleton_instance
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/dual_band.rb

@@ -0,0 +1,13 @@
+module Rack
+  module Client
+    module DualBand
+      def call(env, &block)
+        if block_given?
+          async_call(env, &block)
+        else
+          sync_call(env)
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/follow_redirects.rb

@@ -1,27 +1,54 @@
-class Rack::Client::FollowRedirects
-    include Rack::Test::Methods
+module Rack
+  module Client
+    class FollowRedirects
+      include DualBand
 
-    def initialize(app)
-      @app = app
-    end
+      def initialize(app)
+        @app = app
+      end
 
-    def call(env)
-      status, headers, body = @app.call(env)
-      response = Rack::Response.new(body, status, headers)
-      if response.redirect?
-        uri = URI.parse(response["Location"])
-        new_env = {}
-        env.each do |k,v|
-          if %w| HTTP_HOST SERVER_NAME SERVER_PORT |.include?(k)
-            new_env[k] = v
+      def async_call(env, &block)
+        @app.call(env) do |tuple|
+          response = Response.new(*tuple)
+
+          if response.redirect?
+            follow_redirect(response, env, &block)
+          else
+            yield response.finish
           end
         end
-        new_env["REQUEST_METHOD"] = "GET"
-        session = Rack::Test::Session.new(@app)
-        env = session.send(:env_for, uri.to_s, new_env)
-        call(env)
-      else
-        [status, headers, body]
+      end
+
+      def sync_call(env, &block)
+        response = Response.new(*@app.call(env))
+        response.redirect? ? follow_redirect(response, env, &block) : response
+      end
+
+      def follow_redirect(response, env, &block)
+        call(next_env(response, env), &block)
+      end
+
+      def next_env(response, env)
+        env = env.dup
+
+        original    = URI.parse(env['REQUEST_URI'])
+        redirection = URI.parse(response['Location'])
+
+        uri = original.merge(redirection)
+
+        env.update 'REQUEST_METHOD' => 'GET'
+        env.update 'PATH_INFO'      => uri.path.empty? ? '/' : uri.path
+        env.update 'REQUEST_URI'    => uri.to_s
+        env.update 'SERVER_NAME'    => uri.host
+        env.update 'SERVER_PORT'    => uri.port
+        env.update 'SCRIPT_NAME'    => ''
+
+        env.update 'rack.url_scheme'  => uri.scheme
+
+        env.update 'HTTPS'  => env["rack.url_scheme"] == "https" ? "on" : "off"
+
+        env
       end
     end
   end
+end

data/lib/rack/client/handler.rb

@@ -0,0 +1,10 @@
+module Rack
+  module Client
+    module Handler
+      autoload :NetHTTP,  'rack/client/handler/net_http'
+      autoload :Excon,    'rack/client/handler/excon'
+      autoload :EmHttp,   'rack/client/handler/em-http'
+      autoload :Typhoeus, 'rack/client/handler/typhoeus'
+    end
+  end
+end

data/lib/rack/client/handler/em-http.rb

@@ -0,0 +1,66 @@
+require 'em-http'
+
+module Rack
+  module Client
+    module Handler
+      class EmHttp
+        include Rack::Client::DualBand
+
+        def initialize(url)
+          @uri = URI.parse(url)
+        end
+
+        def sync_call(env)
+          raise("Synchronous API is not supported for EmHttp Handler") unless block_given?
+        end
+
+        def async_call(env)
+          request = Rack::Request.new(env)
+
+          EM.schedule do
+            em_http = connection(request.path).send(request.request_method.downcase, request_options(request))
+            em_http.callback do
+              yield parse(em_http).finish
+            end
+
+            em_http.errback do
+              yield parse(em_http).finish
+            end
+          end
+        end
+
+        def connection(path)
+          @connection ||= EventMachine::HttpRequest.new((@uri + path).to_s)
+        end
+
+        def request_options(request)
+          options = {}
+
+          if request.body
+            options[:body] = case request.body
+                             when Array     then request.body.to_s
+                             when StringIO  then request.body.string
+                             when IO        then request.body.read
+                             when String    then request.body
+                             end
+          end
+
+          options
+        end
+
+        def parse(em_http)
+          body = em_http.response.empty? ? [] : StringIO.new(em_http.response)
+          Response.new(em_http.response_header.status, Headers.new(em_http.response_header).to_http, body)
+        end
+
+        def normalize_headers(em_http)
+          headers = em_http.response_header
+
+          headers['LOCATION'] = URI.parse(headers['LOCATION']).path if headers.include?('LOCATION')
+
+          headers
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/handler/excon.rb

@@ -0,0 +1,50 @@
+require 'excon'
+
+module Rack
+  module Client
+    module Handler
+      class Excon
+        include DualBand
+
+        def initialize(url)
+          @uri = URI.parse(url)
+        end
+
+        def async_call(env)
+          raise("Asynchronous API is not supported for EmHttp Handler") unless block_given?
+        end
+
+        def sync_call(env)
+          request = Rack::Request.new(env)
+
+          body = case request.body
+                 when StringIO then request.body.string
+                 when IO       then request.body.read
+                 when Array    then request.body.to_s
+                 when String   then request.body
+                 end
+
+          response = parse connection.request(:method   => request.request_method,
+                                              :path     => request.path,
+                                              :headers  => Headers.from(env).to_http,
+                                              :body     => body)
+
+          response.finish
+        end
+
+        def parse(excon_response)
+          body = excon_response.body.empty? ? [] : StringIO.new(excon_response.body)
+          Response.new(excon_response.status, Headers.new(excon_response.headers).to_http, body)
+        end
+
+        def connection
+          connection_table[self] ||= ::Excon.new(@uri.to_s)
+        end
+
+        def connection_table
+          Thread.current[:_rack_client_excon_connections] ||= {}
+        end
+      end
+    end
+  end
+end