rack-client 0.1.1 → 0.3.0

data/History.txt

@@ -1,5 +1,5 @@
 == 0.1.0 / 2009-06-14
- 
+
 * 1 major enhancement
- 
+
   * Birthday!

data/README.textile

@@ -14,8 +14,8 @@ h2. Rack responses
 
 Rack::Client can be used to make HTTP requests to any type of server, not
 just ones using Rack. However, when a request is made then a proper
-Rack response (specifically a Rack::MockResponse) object is returned. 
-For Rubyists, this means you don't need to learn yet another interface 
+Rack response (specifically a Rack::MockResponse) object is returned.
+For Rubyists, this means you don't need to learn yet another interface
 and can just stick with Rack both on the server, test, and client side of
 things.
 

data/Rakefile

@@ -1,11 +1,14 @@
+require 'rubygems'
 require 'rake'
 require "rake/gempackagetask"
 require "rake/clean"
 require "spec/rake/spectask"
-require File.expand_path("./lib/rack/client")
+
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'rack/client/version'
 
 Spec::Rake::SpecTask.new(:spec) do |t|
-  t.spec_files = FileList['spec/*_spec.rb']
+  t.spec_files = FileList['spec/**/*_spec.rb']
   t.spec_opts = ['-c']
 end
 
@@ -13,7 +16,7 @@ task :default  => :spec
 
 spec = Gem::Specification.new do |s|
   s.name              = "rack-client"
-  s.rubyforge_project = s.name  
+  s.rubyforge_project = s.name
   s.version           = Rack::Client::VERSION
   s.author            = "Tim Carey-Smith"
   s.email             = "tim" + "@" + "spork.in"
@@ -23,8 +26,11 @@ spec = Gem::Specification.new do |s|
   s.files             = %w[History.txt LICENSE README.textile Rakefile] + Dir["lib/**/*"] + Dir["demo/**/*"]
   s.test_files        = Dir["spec/**/*"]
 
-  s.add_dependency 'rack',      '~> 1'  # 1.X.X
-  s.add_dependency 'rack-test', '~> 0'  # 0.X.X
+  require 'bundler'
+  bundle = Bundler::Definition.from_gemfile("Gemfile")
+  bundle.dependencies.
+    select { |d| d.groups.include?(:runtime) }.
+    each   { |d| s.add_dependency(d.name, d.version_requirements.to_s)  }
 end
 
 Rake::GemPackageTask.new(spec) do |package|

data/demo/demo_spec.rb

@@ -12,7 +12,7 @@ describe Demo, "/store resource" do
     Rack::Client.new
     # Demo::App.new
   end
-  before(:all) { delete "http://localhost:9292/store" }  
+  before(:all) { delete "http://localhost:9292/store" }
   after { delete "http://localhost:9292/store" }
 
   it "should return a 404 if a resource does not exist" do
@@ -28,8 +28,8 @@ describe Demo, "/store resource" do
     last_response.status.should == 200
     last_response.body.should == "strawberry"
     get "http://localhost:9292/store/car"
-    last_response.status.should == 200    
-    last_response.body.should == "lotus"        
+    last_response.status.should == 200
+    last_response.body.should == "lotus"
   end
 
   it "should be able to clear the store of all items" do

data/lib/rack/client.rb

@@ -1,37 +1,41 @@
-unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__) + "/.."))
-  $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/.."))
-end
-
-require 'rack'
-require 'rack/test'
 require 'forwardable'
+require 'uri'
+require 'rack'
 
 module Rack
-  class Client < Rack::Builder
-    VERSION = "0.1.1"
-    include Rack::Test::Methods
-    HTTP_METHODS = [:head, :get, :put, :post, :delete]
-    
+  module Client
+    include Forwardable
+
     class << self
       extend Forwardable
-      def_delegators :new, *HTTP_METHODS
-    end
-
-    def run(*args, &block)
-      @ran = true
-      super(*args, &block)
+      def_delegators :new, :head, :get, :put, :post, :delete
     end
 
-    def to_app(*args, &block)
-      run Rack::Client::HTTP unless @ran
-      super(*args, &block)
+    def self.new(*a, &block)
+      block ||= lambda { run Rack::Client::Handler::NetHTTP }
+      Rack::Client::Simple.new(Rack::Builder.app(&block), *a)
     end
-    alias app to_app
   end
 end
 
-$:.unshift File.dirname(__FILE__)
+require 'rack/client/version'
+
+require 'rack/client/handler'
+require 'rack/client/dual_band'
+require 'rack/client/response'
+require 'rack/client/headers'
+
+require 'rack/client/adapter'
+
+require 'rack/client/follow_redirects'
+require 'rack/client/auth/abstract/challenge'
+require 'rack/client/auth/basic'
+require 'rack/client/auth/digest/challenge'
+require 'rack/client/auth/digest/params'
+require 'rack/client/auth/digest/md5'
+
+require 'rack/client/cache'
+
+require 'rack/client/cookie_jar'
 
-require 'client/http'
-require 'client/auth'
-require 'client/follow_redirects'
+require 'rack/client/parser'

data/lib/rack/client/adapter.rb

@@ -0,0 +1,6 @@
+module Rack
+  module Client
+    autoload :Base,   'rack/client/adapter/base'
+    autoload :Simple, 'rack/client/adapter/simple'
+  end
+end

data/lib/rack/client/adapter/base.rb

@@ -0,0 +1,57 @@
+module Rack
+  module Client
+    class Base
+      extend Forwardable
+
+      def_delegator :@app, :call
+
+      def initialize(app)
+        @app = app
+      end
+
+      %w[ options get head post put delete trace connect ].each do |method|
+        eval <<-RUBY, binding, __FILE__, __LINE__ + 1
+          def #{method}(url, headers = {}, body = nil)
+            if block_given?
+              call(build_env('#{method.upcase}', url, headers, body)) {|tuple| yield *tuple }
+            else
+              return *call(build_env('#{method.upcase}', url, headers, body))
+            end
+          end
+        RUBY
+      end
+
+      def build_env(request_method, url,  headers = {}, body = nil)
+        env = Headers.new(headers).to_env
+
+        env.update 'REQUEST_METHOD' => request_method
+
+        env['CONTENT_TYPE'] ||= 'application/x-www-form-urlencoded'
+
+        uri = URI.parse(url)
+
+        path_info = uri.path.empty? ? '/' : uri.path
+        path_info += '?' + uri.query unless uri.query.nil? || uri.query.empty?
+
+        env.update 'PATH_INFO'   => path_info
+        env.update 'REQUEST_URI' => uri.to_s
+        env.update 'SERVER_NAME' => uri.host
+        env.update 'SERVER_PORT' => uri.port
+        env.update 'SCRIPT_NAME' => ''
+
+        input = case body
+                when nil        then StringIO.new
+                when String     then StringIO.new(body)
+                end
+
+        env.update 'rack.input'       => input
+        env.update 'rack.errors'      => StringIO.new
+        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/adapter/simple.rb

@@ -0,0 +1,49 @@
+module Rack
+  module Client
+    class Simple < Base
+
+      def initialize(app, url = nil)
+        super(app)
+        @base_uri = URI.parse(url) unless url.nil?
+      end
+
+      %w[ options get head delete trace ].each do |method|
+        eval <<-RUBY, binding, __FILE__, __LINE__ + 1
+          def #{method}(url, headers = {}, query_or_params = nil)
+            headers, query_or_params = {}, headers if query_or_params.nil?
+            query_hash = Hash === query_or_params ? query_or_params : Utils.build_query(query_or_params)
+
+            uri = URI.parse(url)
+            uri.query = Utils.build_query(Utils.parse_query(uri.query).merge(query_hash))
+
+            if block_given?
+              super(uri.to_s, headers) {|*tuple| yield Response.new(*tuple) }
+            else
+              return Response.new(*super(uri.to_s, headers))
+            end
+          end
+        RUBY
+      end
+
+      %w[ post put ].each do |method|
+        eval <<-RUBY, binding, __FILE__, __LINE__ + 1
+          def #{method}(url, headers = {}, body_or_params = nil)
+            headers, body_or_params = {}, headers if body_or_params.nil?
+            body = Hash === body_or_params ? Utils.build_query(body_or_params) : body_or_params
+
+            if block_given?
+              super(url, headers, body) {|*tuple| yield Response.new(*tuple) }
+            else
+              return Response.new(*super(url, headers, body))
+            end
+          end
+        RUBY
+      end
+
+      def build_env(request_method, url, headers = {}, body = nil)
+        uri = @base_uri.nil? ? URI.parse(url) : @base_uri + url
+        super(request_method, uri.to_s, headers, body)
+      end
+    end
+  end
+end

data/lib/rack/client/auth/abstract/challenge.rb

@@ -0,0 +1,53 @@
+module Rack
+  module Client
+    module Auth
+      module Abstract
+        class Challenge
+          extend Forwardable
+
+          def_delegators :@request, :request_method, :path
+          def_delegators :@response, :status, :headers
+
+          def initialize(request, response)
+            @request, @response = request, response
+          end
+
+          def required?
+            status == 401
+          end
+
+          def unspecified?
+            scheme.nil?
+          end
+
+          def www_authenticate
+            @www_authenticate ||= headers.detect {|h,_| h =~ /^WWW-AUTHENTICATE$/i }
+          end
+
+          def parts
+            @parts ||= www_authenticate if www_authenticate
+          end
+
+          def scheme
+            @scheme ||= www_authenticate.last[/^(\w+)/, 1].downcase.to_sym if www_authenticate
+          end
+
+          def nonce
+            @nonce ||= Rack::Auth::Digest::Nonce.parse(params['nonce'])
+          end
+
+          def params
+            @params ||= Rack::Auth::Digest::Params.parse(parts.last)
+          end
+
+          def method_missing(sym)
+            if params.has_key? key = sym.to_s
+              return params[key]
+            end
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/auth/basic.rb

@@ -0,0 +1,57 @@
+module Rack
+  module Client
+    module Auth
+      class Basic
+        include Rack::Client::DualBand
+
+        def initialize(app, username, password)
+          @app, @username, @password = app, username, password
+        end
+
+        def sync_call(env)
+          request   = Rack::Request.new(env)
+          response  = Response.new(*@app.call(env))
+          challenge = Basic::Challenge.new(request, response)
+
+          if challenge.required? && (challenge.unspecified? || challenge.basic?)
+            return authorized_call(env)
+          end
+
+          response.finish
+        end
+
+        def async_call(env, &b)
+          @app.call(env) do |response_parts|
+            request   = Rack::Request.new(env)
+            response  = Response.new(*response_parts)
+            challenge = Basic::Challenge.new(request, response)
+
+            if challenge.required? && (challenge.unspecified? || challenge.basic?)
+              authorized_call(env, &b)
+            else
+              yield response.finish
+            end
+          end
+        end
+
+        def authorized_call(env, &b)
+          @app.call(env.merge(auth_header), &b)
+        end
+
+        def auth_header
+          {'HTTP_AUTHORIZATION' => "Basic #{encoded_login}"}
+        end
+
+        def encoded_login
+          ["#{@username}:#{@password}"].pack("m*")
+        end
+
+        class Challenge < Abstract::Challenge
+          def basic?
+            :basic == scheme
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/auth/digest/challenge.rb

@@ -0,0 +1,38 @@
+module Rack
+  module Client
+    module Auth
+      module Digest
+        class Challenge < Abstract::Challenge
+          def initialize(request, response, realm, username, password)
+            super(request, response)
+            @realm, @username, @password = realm, username, password
+          end
+
+          def digest?
+            :digest == scheme
+          end
+
+          def cnonce
+            @cnonce ||= Rack::Auth::Digest::Nonce.new.to_s
+          end
+
+          def response(nc)
+            H([ A1(), nonce, nc, cnonce, qop, A2() ] * ':')
+          end
+
+          def A1
+            H([ @username, @realm, @password ] * ':')
+          end
+
+          def A2
+            H([ request_method, path ] * ':')
+          end
+
+          def H(data)
+            ::Digest::MD5.hexdigest(data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/auth/digest/md5.rb

@@ -0,0 +1,78 @@
+module Rack
+  module Client
+    module Auth
+      module Digest
+        class MD5 < Rack::Auth::Digest::MD5
+          include Rack::Client::DualBand
+
+          def initialize(app, realm, username, password, options = {})
+            @app, @realm, @username, @password = app, realm, username, password
+            @nc = 0
+          end
+
+          def sync_call(env)
+            request   = Rack::Request.new(env)
+            response  = Response.new(*@app.call(env))
+            challenge = Digest::Challenge.new(request, response, @realm, @username, @password)
+
+            if challenge.required? && challenge.digest? && valid?(challenge)
+              return @app.call(env.merge(authorization(challenge)))
+            end
+
+            response.finish
+          end
+
+          def async_call(env)
+            @app.call(env) do |response_parts|
+              request   = Rack::Request.new(env)
+              response  = Response.new(*response_parts)
+              challenge = Digest::Challenge.new(request, response, @realm, @username, @password)
+
+              if challenge.required? && challenge.digest? && valid?(challenge)
+                @app.call(env.merge(authorization(challenge))) {|response_parts| yield response_parts }
+              else
+                @app.call(env) {|response_parts| yield response_parts }
+              end
+            end
+          end
+
+          def valid?(challenge)
+            valid_opaque?(challenge) && valid_nonce?(challenge)
+          end
+
+          def valid_opaque?(challenge)
+            !(challenge.opaque.nil? || challenge.opaque.empty?)
+          end
+
+          def valid_nonce?(challenge)
+            challenge.nonce.valid?
+          end
+
+          def authorization(challenge)
+            return 'HTTP_AUTHORIZATION' => "Digest #{params_for(challenge)}"
+          end
+
+          def params_for(challenge)
+            nc = next_nc
+
+            Rack::Auth::Digest::Params.new do |params|
+              params['username']  = @username
+              params['realm']     = @realm
+              params['nonce']     = challenge.nonce.to_s
+              params['uri']       = challenge.path
+              params['qop']       = challenge.qop
+              params['nc']        = nc
+              params['cnonce']    = challenge.cnonce
+              params['response']  = challenge.response(nc)
+              params['opaque']    = challenge.opaque
+            end
+          end
+
+          def next_nc
+            sprintf("%08x", @nc += 1)
+          end
+        end
+      end
+    end
+  end
+end