paul-resourceful 0.2.3 → 0.3.0

data/README.markdown

@@ -37,8 +37,8 @@ Simplest example
 Get a page requiring HTTP Authentication
 ----------------------------------------
 
-    basic_handler = Resourceful::BasicAuthenticator.new('My Realm', 'admin', 'secret')
-    http.auth_manager.add_auth_hander(basic_handler)
+    my_realm_authenticator = Resourceful::BasicAuthenticator.new('My Realm', 'admin', 'secret')
+    http = Resourceful::HttpAccessor.new(:authenticator => my_realm_authenticator)
     resp = http.resource('http://example.com/').get
     puts resp.body
 
@@ -53,8 +53,6 @@ callback. If the callback evaluates to true, it will follow the redirect.
     resource.on_redirect { |req, resp| resp.header['Location'] =~ /example.com/ }
     resource.get  # Will only follow the redirect if the new location is example.com
 
-
-
 Post a URL encoded form
 -----------------------
 
@@ -82,5 +80,5 @@ Delete a resource
 Copyright
 ---------
 
-Copyright (c) 2008 Absolute Performance, Inc, Peter Williams; released under the MIT License.
+Copyright (c) 2008 Absolute Performance, Inc, Peter Williams.  Released under the MIT License.
 

data/Rakefile

@@ -1,14 +1,41 @@
-# -*- ruby -*-
-
 require 'rubygems'
-require 'hoe'
-require './lib/resourceful.rb'
+require 'rake'
+require 'echoe'
+
+Echoe.new('resourceful', '0.3.0') do |p|
+  p.description     = "An HTTP library for Ruby that takes advantage of everything HTTP has to offer."
+  p.url             = "http://github.com/paul/resourceful"
+  p.author          = "Paul Sadauskas"
+  p.email           = "psadauskas@gmail.com"
+
+  p.ignore_pattern  = ["pkg/*", "tmp/*"]
+  p.dependencies    = ['addressable', 'httpauth', 'rspec', 'facets', 'andand']
+  p.development_dependencies = ['thin', 'yard']
+end
+
+require 'spec/rake/spectask'
 
-Hoe.new('resourceful', Resourceful::VERSION) do |p|
-  p.rubyforge_name = 'resourceful' # if different than lowercase project name
-  p.developer('Paul Sadauskas', 'psadauskas@gmail.com')
-  p.developer('Peter Williams', 'pezra@barelyenough.org')
-  p.summary = "An HTTP library for Ruby that takes advantage of everything HTTP has to offer."
+desc 'Run all specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+  t.libs << 'lib'
+  t.spec_files = FileList['spec/**/*_spec.rb']
 end
 
-# vim: syntax=Ruby
+desc 'Default: Run Specs'
+task :default => :spec
+
+desc 'Run all tests'
+task :test => :spec
+
+require 'yard'
+
+desc "Generate Yardoc"
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb', 'README.markdown']
+end
+
+desc "Update rubyforge documentation"
+task :update_docs => :yardoc do
+  puts %x{rsync -aPz doc/* psadauskas@resourceful.rubyforge.org:/var/www/gforge-projects/resourceful/}
+end

data/lib/resourceful/cache_manager.rb

@@ -1,20 +1,24 @@
 require 'resourceful/header'
+require 'andand'
 
 module Resourceful
 
-  class CacheManager
+  class AbstractCacheManager
     def initialize
       raise NotImplementedError,
         "Use one of CacheManager's child classes instead. Try NullCacheManager if you don't want any caching at all."
     end
 
-    # Search for a cached representation that can be used to fulfill the
-    # the given request. If none are found, returns nil.
+    # Finds a previously cached response to the provided request.  The
+    # response returned may be stale.
     #
-    # @param request<Resourceful::Request>
-    #   The request to use for searching.
+    # @param [Resourceful::Request] request 
+    #   The request for which we are looking for a response.
+    #
+    # @return [Resourceful::Response] 
+    #   A (possibly stale) response for the request provided.
     def lookup(request); end
-
+    
     # Store a response in the cache. 
     #
     # This method is smart enough to not store responses that cannot be 
@@ -35,29 +39,11 @@ module Resourceful
     # @param uri<String>
     #   The uri of the resource to be invalidated
     def invalidate(uri); end
-
-    # Selects the headers from the request named by the response's Vary header
-    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.5.6
-    #
-    # @param request<Resourceful::Request>
-    #   The request used to obtain the response.
-    # @param response<Resourceful::Response>
-    #   The response obtained from the request.
-    def select_request_headers(request, response)
-      header = Resourceful::Header.new
-
-      response.header['Vary'].first.split(',').each do |name|
-        name.strip!
-        header[name] = request.header[name]
-      end if response.header['Vary']
-
-      header
-    end
   end
 
   # This is the default cache, and does not do any caching. All lookups
   # result in nil, and all attempts to store a response are a no-op.
-  class NullCacheManager < CacheManager
+  class NullCacheManager < AbstractCacheManager
     def initialize; end
 
     def lookup(request)
@@ -70,105 +56,128 @@ module Resourceful
   # This is a nieve implementation of caching. Unused entries are never
   # removed, and this may eventually eat up all your memory and cause your
   # machine to explode.
-  class InMemoryCacheManager < CacheManager
+  class InMemoryCacheManager < AbstractCacheManager
 
     def initialize
       @collection = Hash.new{ |h,k| h[k] = CacheEntryCollection.new}
     end
 
     def lookup(request)
-      entry = @collection[request.uri.to_s][request]
-      response = entry.response if entry
-      response.authoritative = false if response
-
-      response      
+      returning(@collection[request.uri.to_s][request]) do |response|
+        response.authoritative = false if response
+      end
     end
 
     def store(request, response)
       return unless response.cachable?
 
-      entry = CacheEntry.new(request.request_time, 
-                             select_request_headers(request, response), 
-                             response)
-      
-      @collection[request.uri.to_s][request] = entry
+      @collection[request.uri.to_s][request] = response
     end
 
     def invalidate(uri)
       @collection.delete(uri)
     end
+  end  # class InMemoryCacheManager
+
+  # The collection of cached entries.  Nominally all the entry in a
+  # collection of this sort will be for the same resource but that is
+  # not required to be true.
+  class CacheEntryCollection
+    include Enumerable
+    
+    def initialize
+      @entries = []
+    end
+    
+    # Iterates over the entries. Needed for Enumerable
+    def each(&block)
+      @entries.each(&block)
+    end
+    
+    # Looks of a Entry that could fullfil the request. Returns nil if none
+    # was found.
+    #
+    # @param [Resourceful::Request] request
+    #   The request to use for the lookup.
+    #
+    # @return [Resourceful::Response] 
+    #   The cached response for the specified request if one is available.
+    def [](request)
+      find { |an_entry| an_entry.valid_for?(request) }.andand.response 
+    end
+    
+    # Saves an entry into the collection. Replaces any existing ones that could 
+    # be used with the updated response.
+    #
+    # @param [Resourceful::Request] request
+    #   The request that was used to obtain the response
+    # @param [Resourceful::Response] response
+    #   The cache_entry generated from response that was obtained.
+    def []=(request, response)
+      @entries.delete_if { |e| e.valid_for?(request) }
+      @entries << CacheEntry.new(request, response)
+
+      response
+    end
+  end # class CacheEntryCollection
+
+  # Represents a previous request and cached response with enough
+  # detail to determine construct a cached response to a matching
+  # request in the future.  It also understands what a matching
+  # request means.
+  class CacheEntry
+    # request_vary_headers is a HttpHeader with keys from the Vary
+    # header of the response, plus the values from the matching fields
+    # in the request
+    attr_reader :request_vary_headers
+    
+    # The time at which the client believes the request was made.
+    attr_reader :request_time
+
+    # The URI of the request
+    attr_reader :request_uri
+
+    # The response to that we are caching
+    attr_reader :response
+
+    # @param [Resourceful::Request] request
+    #   The request whose response we are storing in the cache.
+    # @param response<Resourceful::Response>
+    #   The Response obhect to be stored.
+    def initialize(request, response)
+      @request_uri = request.uri
+      @request_time = request.request_time
+      @request_vary_headers = select_request_headers(request, response)
+      @response = response
+    end
 
-    # The collection of all cached entries for a single resource (uri). 
-    class CacheEntryCollection
-      include Enumerable
-
-      def initialize
-        @entries = []
-      end
-
-      # Iterates over the entries. Needed for Enumerable
-      def each(&block)
-        @entries.each(&block)
-      end
-
-      # Looks of a Entry that could fullfil the request. Returns nil if none
-      # was found.
-      #
-      # @param request<Resourceful::Request>
-      #   The request to use for the lookup.
-      def [](request)
-        self.each do |entry|
-          return entry if entry.valid_for?(request)
-        end
-        return nil
-      end
-
-      # Saves an entry into the collection. Replaces any existing ones that could 
-      # be used with the updated response.
-      #
-      # @param request<Resourceful::Request>
-      #   The request that was used to obtain the response
-      # @param cache_entry<CacheEntry>
-      #   The cache_entry generated from response that was obtained.
-      def []=(request, cache_entry)
-        @entries.delete_if { |e| e.valid_for?(request) }
-        @entries.unshift cache_entry
-      end
+    # Returns true if this entry may be used to fullfil the given request, 
+    # according to the vary headers.
+    #
+    # @param request<Resourceful::Request>
+    #   The request to do the lookup on. 
+    def valid_for?(request)
+      request.uri == @request_uri and 
+        @request_vary_headers.all? {|key, value| request.header[key] == value}
+    end
 
-    end # class CacheEntryCollection
-
-    # Contains everything we need to know to build a response for a request using the
-    # stored request.
-    class CacheEntry
-      # request_vary_headers is a HttpHeader with keys from the 
-      # Vary header of the response, plus the values from the matching
-      # fields in the request
-      attr_accessor :request_time, :request_vary_headers, :response
-
-      # @param request_time<Time>
-      #   Client-generated timestamp for when the request was made
-      # @param request_vary_headers<Resourceful::HttpHeader>
-      #   A HttpHeader constructed from the keys listed in the vary headers
-      #   of the response, and values obtained from those headers in the request
-      # @param response<Resourceful::Response>
-      #   The Response obhect to be stored.
-      def initialize(request_time, request_vary_headers, response)
-        @request_time, @request_vary_headers, @response = request_time, request_vary_headers, response
-      end
+    # Selects the headers from the request named by the response's Vary header
+    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.5.6
+    #
+    # @param [Resourceful::Request] request
+    #   The request used to obtain the response.
+    # @param [Resourceful::Response] response
+    #   The response obtained from the request.
+    def select_request_headers(request, response)
+      header = Resourceful::Header.new
 
-      # Returns true if this entry may be used to fullfil the given request, 
-      # according to the vary headers.
-      #
-      # @param request<Resourceful::Request>
-      #   The request to do the lookup on. 
-      def valid_for?(request)
-        @request_vary_headers.all? do |key, value|
-          request.header[key] == value
-        end
-      end
+      response.header['Vary'].each do |name|
+        header[name] = request.header[name]
+      end if response.header['Vary']
 
-    end # class CacheEntry
+      header
+    end
 
-  end # class InMemoryCacheManager
+  end # class CacheEntry
 
 end

data/lib/resourceful/http_accessor.rb

@@ -40,13 +40,14 @@ module Resourceful
     attr_accessor :logger, :cache_manager
     
     attr_reader :auth_manager
-    
     attr_reader :user_agent_tokens  
     
     INIT_OPTIONS = OptionsInterpreter.new do 
       option(:logger, :default => Resourceful::BitBucketLogger.new)
       option(:user_agent, :default => []) {|ua| [ua].flatten}
       option(:cache_manager, :default => NullCacheManager.new)
+      option(:authenticator)
+      option(:authenticators, :default => [])
     end
     
     # Initializes a new HttpAccessor.  Valid options:
@@ -56,6 +57,13 @@ module Resourceful
     #
     #  +:user_agent+:: One or more additional user agent tokens to
     #    added to the user agent string.
+    #
+    #  +:cache_manager+:: The cache manager this accessor should use.
+    #
+    #  +:authenticator+:: Add a single authenticator for this accessor.
+    #
+    #  +:authenticators+:: Enumerable of the authenticators for this
+    #    accessor.
     def initialize(options = {})
       @user_agent_tokens = [RESOURCEFUL_USER_AGENT_TOKEN]
       
@@ -64,6 +72,9 @@ module Resourceful
         self.logger = opts[:logger]
         @auth_manager = AuthenticationManager.new()
         @cache_manager = opts[:cache_manager]
+        
+        add_authenticator(opts[:authenticator]) if opts[:authenticator]
+        opts[:authenticators].each { |a| add_authenticator(a) }
       end     
     end
     
@@ -81,5 +92,9 @@ module Resourceful
     end
     alias [] resource
 
+    # Adds an Authenticator to the set used by the accessor.
+    def add_authenticator(an_authenticator)
+      auth_manager.add_auth_handler(an_authenticator)
+    end
   end
 end

data/lib/resourceful/memcache_cache_manager.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + "/cache_manager"
+
+require 'memcache'
+require 'facets/kernel/returning'
+
+module Resourceful
+  class MemcacheCacheManager < AbstractCacheManager
+  
+    # Create a new Memcached backed cache manager
+    #
+    # @param [*String] memcache_servers  
+    #   list of all Memcached servers this cache manager should use.
+    def initialize(*memcache_servers)
+      @memcache = MemCache.new(memcache_servers, :multithread => true)
+    end
+
+    # Finds a previously cached response to the provided request.  The
+    # response returned may be stale.
+    #
+    # @param [Resourceful::Request] request
+    #   The request for which we are looking for a response.
+    #
+    # @return [Resourceful::Response, nil] 
+    #   A (possibly stale) response for the request provided or nil if 
+    #   no matching response is found.
+    def lookup(request)
+      resp = cache_entries_for(request)[request]
+      return if resp.nil?
+
+      resp.authoritative = false
+
+      resp
+    end
+
+    # Store a response in the cache. 
+    #
+    # This method is smart enough to not store responses that cannot be 
+    # cached (Vary: * or Cache-Control: no-cache, private, ...)
+    #
+    # @param [Resourceful::Request] request
+    #   The request used to obtain the response. This is needed so the 
+    #   values from the response's Vary header can be stored.
+    # @param [Resourceful::Response] response
+    #   The response to be stored.
+    def store(request, response)
+      return unless response.cachable?
+
+      @memcache[request.to_mc_key] = returning(cache_entries_for(request)) do |entries|
+        entries[request] = response
+      end
+    end
+
+    # Invalidates a all cached entries for a uri. 
+    #
+    # This is used, for example, to invalidate the cache for a resource 
+    # that gets POSTed to.
+    #
+    # @param [String] uri
+    #   The uri of the resource to be invalidated
+    def invalidate(uri)
+      @memcache.delete(Digest::MD5.hexdigest(uri))
+    end
+
+
+    private 
+
+    ##
+    # The memcache proxy.
+    attr_reader :memcache
+
+    def cache_entries_for(a_request)
+      @memcache.get(a_request.to_mc_key) || Resourceful::CacheEntryCollection.new
+    end
+  end
+  
+  module MemCacheKey
+    def to_mc_key
+      Digest::MD5.hexdigest(uri)
+    end
+  end
+
+  class Request
+    include MemCacheKey
+  end
+end

data/lib/resourceful/request.rb

@@ -12,6 +12,11 @@ module Resourceful
     attr_accessor :method, :resource, :body, :header
     attr_reader   :request_time
 
+    # @param [Symbol] http_method
+    #   :get, :put, :post, :delete or :head
+    # @param [Resourceful::Resource] resource
+    # @param [String] body
+    # @param [Resourceful::Header, Hash] header
     def initialize(http_method, resource, body = nil, header = nil)
       @method, @resource, @body = http_method, resource, body
       @header = header.is_a?(Resourceful::Header) ? header : Resourceful::Header.new(header || {})
@@ -50,6 +55,7 @@ module Resourceful
       @header['Cache-Control'] = 'max-age=0' if response.header.has_key?('Cache-Control') and response.header['Cache-Control'].include?('must-revalidate')
     end
 
+    # @return [String]   The URI against which this request will be, or was, made.
     def uri
       resource.uri
     end

data/lib/resourceful.rb

@@ -4,7 +4,6 @@ require 'resourceful/util'
 
 # Resourceful is a library that provides a high level HTTP interface.
 module Resourceful
-  VERSION = "0.2.3"
 
   HOP_BY_HOP_HEADERS = %w{
     Connection

data/resourceful.gemspec

@@ -1,15 +1,19 @@
+# -*- encoding: utf-8 -*-
+
 Gem::Specification.new do |s|
   s.name = %q{resourceful}
-  s.version = "0.2.3"
+  s.version = "0.3.0"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Paul Sadauskas", "Peter Williams"]
-  s.date = %q{2008-11-22}
-  s.email = ["psadauskas@gmail.com", "pezra@barelyenough.org"]
-  s.extra_rdoc_files = ["Manifest.txt"]
-  s.files = ["MIT-LICENSE", "Manifest.txt", "README.markdown", "Rakefile", "lib/resourceful.rb", "lib/resourceful/authentication_manager.rb", "lib/resourceful/cache_manager.rb", "lib/resourceful/header.rb", "lib/resourceful/http_accessor.rb", "lib/resourceful/net_http_adapter.rb", "lib/resourceful/options_interpreter.rb", "lib/resourceful/request.rb", "lib/resourceful/resource.rb", "lib/resourceful/response.rb", "lib/resourceful/stubbed_resource_proxy.rb", "lib/resourceful/util.rb", "lib/resourceful/version.rb", "resourceful.gemspec", "spec/acceptance_shared_specs.rb", "spec/acceptance_spec.rb", "spec/resourceful/authentication_manager_spec.rb", "spec/resourceful/cache_manager_spec.rb", "spec/resourceful/header_spec.rb", "spec/resourceful/http_accessor_spec.rb", "spec/resourceful/net_http_adapter_spec.rb", "spec/resourceful/options_interpreter_spec.rb", "spec/resourceful/request_spec.rb", "spec/resourceful/resource_spec.rb", "spec/resourceful/response_spec.rb", "spec/resourceful/stubbed_resource_proxy_spec.rb", "spec/simple_http_server_shared_spec.rb", "spec/simple_http_server_shared_spec_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Paul Sadauskas"]
+  s.date = %q{2008-12-05}
+  s.description = %q{An HTTP library for Ruby that takes advantage of everything HTTP has to offer.}
+  s.email = %q{psadauskas@gmail.com}
+  s.extra_rdoc_files = ["lib/resourceful.rb", "lib/resourceful/authentication_manager.rb", "lib/resourceful/util.rb", "lib/resourceful/resource.rb", "lib/resourceful/memcache_cache_manager.rb", "lib/resourceful/net_http_adapter.rb", "lib/resourceful/http_accessor.rb", "lib/resourceful/stubbed_resource_proxy.rb", "lib/resourceful/header.rb", "lib/resourceful/cache_manager.rb", "lib/resourceful/options_interpreter.rb", "lib/resourceful/response.rb", "lib/resourceful/request.rb", "README.markdown"]
+  s.files = ["lib/resourceful.rb", "lib/resourceful/authentication_manager.rb", "lib/resourceful/util.rb", "lib/resourceful/resource.rb", "lib/resourceful/memcache_cache_manager.rb", "lib/resourceful/net_http_adapter.rb", "lib/resourceful/http_accessor.rb", "lib/resourceful/stubbed_resource_proxy.rb", "lib/resourceful/header.rb", "lib/resourceful/cache_manager.rb", "lib/resourceful/options_interpreter.rb", "lib/resourceful/response.rb", "lib/resourceful/request.rb", "spec/acceptance_shared_specs.rb", "spec/spec.opts", "spec/acceptance_spec.rb", "spec/simple_http_server_shared_spec_spec.rb", "spec/spec_helper.rb", "spec/resourceful/header_spec.rb", "spec/resourceful/authentication_manager_spec.rb", "spec/resourceful/memcache_cache_manager_spec.rb", "spec/resourceful/response_spec.rb", "spec/resourceful/options_interpreter_spec.rb", "spec/resourceful/http_accessor_spec.rb", "spec/resourceful/stubbed_resource_proxy_spec.rb", "spec/resourceful/request_spec.rb", "spec/resourceful/resource_spec.rb", "spec/resourceful/cache_manager_spec.rb", "spec/resourceful/net_http_adapter_spec.rb", "spec/simple_http_server_shared_spec.rb", "Manifest", "Rakefile", "README.markdown", "MIT-LICENSE", "resourceful.gemspec"]
   s.has_rdoc = true
-  s.rdoc_options = ["--main", "README.txt"]
+  s.homepage = %q{http://github.com/paul/resourceful}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Resourceful", "--main", "README.markdown"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{resourceful}
   s.rubygems_version = %q{1.3.1}
@@ -20,11 +24,29 @@ Gem::Specification.new do |s|
     s.specification_version = 2
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<hoe>, [">= 1.8.2"])
+      s.add_runtime_dependency(%q<addressable>, [">= 0"])
+      s.add_runtime_dependency(%q<httpauth>, [">= 0"])
+      s.add_runtime_dependency(%q<rspec>, [">= 0"])
+      s.add_runtime_dependency(%q<facets>, [">= 0"])
+      s.add_runtime_dependency(%q<andand>, [">= 0"])
+      s.add_development_dependency(%q<thin>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
     else
-      s.add_dependency(%q<hoe>, [">= 1.8.2"])
+      s.add_dependency(%q<addressable>, [">= 0"])
+      s.add_dependency(%q<httpauth>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<facets>, [">= 0"])
+      s.add_dependency(%q<andand>, [">= 0"])
+      s.add_dependency(%q<thin>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
     end
   else
-    s.add_dependency(%q<hoe>, [">= 1.8.2"])
+    s.add_dependency(%q<addressable>, [">= 0"])
+    s.add_dependency(%q<httpauth>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<facets>, [">= 0"])
+    s.add_dependency(%q<andand>, [">= 0"])
+    s.add_dependency(%q<thin>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
   end
 end

data/spec/resourceful/cache_manager_spec.rb

@@ -2,8 +2,8 @@ require 'pathname'
 require Pathname(__FILE__).dirname + '../spec_helper'
 
 require 'resourceful/cache_manager'
-
-describe Resourceful::CacheManager do
+ 
+describe Resourceful::AbstractCacheManager do
   before do
     @cm = Resourceful::InMemoryCacheManager.new #cheat, because I cant new a real one. 
   end
@@ -19,40 +19,10 @@ describe Resourceful::CacheManager do
   it 'should have a store method' do
     @cm.should respond_to(:store)
   end
-
+  
   it 'should have a invalidate method' do
     @cm.should respond_to(:invalidate)
   end
-
-  describe '#select_request_headers' do
-    before do
-      @req_header = mock('header', :[] => nil)
-      @request = mock('request', :header => @req_header)
-
-      @resp_header = mock('header', :[] => nil)
-      @response = mock('response', :header => @resp_header)
-    end
-
-    it 'should select the request headers from the Vary header' do
-      @resp_header.should_receive(:[]).with('Vary')
-      @cm.select_request_headers(@request, @response)
-    end
-
-    it 'should pull the values from the request that match keys in the vary header' do
-      @resp_header.should_receive(:[]).with('Vary').twice.and_return(['foo, bar'])
-      @req_header.should_receive(:[]).with('foo').and_return('oof')
-      @req_header.should_receive(:[]).with('bar').and_return('rab')
-
-      header = @cm.select_request_headers(@request, @response)
-      header['foo'].should == 'oof'
-      header['bar'].should == 'rab'
-    end
-
-    it 'should return a new Header object' do
-      @cm.select_request_headers(@request, @response).should be_kind_of(Resourceful::Header)
-    end
-  end
-
 end
 
 describe Resourceful::NullCacheManager do
@@ -80,7 +50,7 @@ describe Resourceful::InMemoryCacheManager do
     @response = mock('response', :header => {}, :cachable? => true)
 
     @entry = mock('cache entry', :response => @response, :valid_for? => true)
-    Resourceful::InMemoryCacheManager::CacheEntry.stub!(:new).and_return(@entry)
+    Resourceful::CacheEntry.stub!(:new).and_return(@entry)
 
     @imcm = Resourceful::InMemoryCacheManager.new
   end
@@ -88,7 +58,7 @@ describe Resourceful::InMemoryCacheManager do
   describe 'finding' do
     before do
       @response.stub!(:authoritative=)
-      @imcm.instance_variable_set("@collection", {'uri' => {@request => @entry}})
+      @imcm.instance_variable_set("@collection", {'uri' => {@request => @response}})
     end
 
     it 'should lookup the response by request' do
@@ -103,9 +73,8 @@ describe Resourceful::InMemoryCacheManager do
 
   describe 'saving' do
     it 'should make a new cache entry' do
-      Resourceful::InMemoryCacheManager::CacheEntry.should_receive(:new).with(
-        Time.utc(2008,5,22,15,00),
-        {},
+      Resourceful::CacheEntry.should_receive(:new).with(
+        @request,
         @response
       )
 
@@ -115,7 +84,7 @@ describe Resourceful::InMemoryCacheManager do
     it 'should store the response entity by request' do
       @imcm.store(@request, @response)
       col = @imcm.instance_variable_get("@collection")
-      col['uri'][@request].response.should == @response
+      col['uri'][@request].should == @response
     end
 
     it 'should check if the response is cachable' do
@@ -142,20 +111,21 @@ describe Resourceful::InMemoryCacheManager do
 
 end
 
-describe Resourceful::InMemoryCacheManager::CacheEntryCollection do
+describe Resourceful::CacheEntryCollection do
   before do
-    @entry_valid   = mock('entry', :valid_for? => true)
-    @entry_invalid = mock('entry', :valid_for? => false)
+    @request = mock('request', :uri => 'this', :request_time => Time.now, :header => {})
+    @valid_resp = stub('valid_resp', :authoritative= => nil, :header => {})
 
-    @request = mock('request')
+    @entry_valid   = mock('entry', :valid_for? => true, :response => @valid_resp)
+    @entry_invalid = mock('entry', :valid_for? => false, :response => stub('invalid_resp'))
 
-    @collection = Resourceful::InMemoryCacheManager::CacheEntryCollection.new
+    @collection = Resourceful::CacheEntryCollection.new
   end
 
   it 'should find the right entry for a request' do
     @collection.instance_variable_set('@entries', [@entry_valid, @entry_invalid])
     @entry_valid.should_receive(:valid_for?).with(@request).and_return(true)
-    @collection[@request].should == @entry_valid
+    @collection[@request].should == @valid_resp
   end
 
   it 'should be nil if no matching entry was found' do
@@ -165,47 +135,89 @@ describe Resourceful::InMemoryCacheManager::CacheEntryCollection do
   end
 
   it 'should store an entry' do
-    @collection[@request] = @entry_valid
-    @collection.instance_variable_get("@entries").should include(@entry_valid)
+    @collection[@request] = @valid_resp
+    @collection.instance_variable_get("@entries").should have(1).items
   end
 
   it 'should replace an existing entry if the existing entry matches the request' do
-    @new_entry = mock('entry', :valid_for? => true)
+    new_resp = stub('new_resp', :authoritative= => nil, :header => {})
 
-    @collection[@request] = @entry_valid
-    @collection[@request] = @new_entry
+    @collection[@request] = @valid_resp
+    @collection[@request] = new_resp
 
-    @collection.instance_variable_get("@entries").should include(@new_entry)
-    @collection.instance_variable_get("@entries").should_not include(@entry_valid)
+    @collection.instance_variable_get("@entries").map{|it| it.response}.should include(new_resp)
+    @collection.instance_variable_get("@entries").map{|it| it.response}.should_not include(@valid_resp)
   end
 
 end
 
-describe Resourceful::InMemoryCacheManager::CacheEntry do
+describe Resourceful::CacheEntry do
   before do
-    @entry = Resourceful::InMemoryCacheManager::CacheEntry.new(
-      Time.utc(2008,5,16,0,0,0), {'Content-Type' => 'text/plain'}, mock('response')
+    @entry = Resourceful::CacheEntry.new(
+      mock('original_request', :header => {'Accept' => 'text/plain'} , 
+           :request_time => Time.utc(2008,5,16,0,0,0), :uri => 'http://foo.invalid'), 
+      mock('response', :header => {'Vary' => 'Accept'})
     )
 
-    @request = mock('request')
+    @request = mock('request', :uri => 'http://foo.invalid')
   end
 
-  [:request_time, :request_vary_headers, :response, :valid_for?].each do |method|
-    it "should respond to ##{method}" do
-      @entry.should respond_to(method)
+  describe "#valid_for?(a_request)" do 
+    it "should true for request to URI w/ matching header " do
+      @entry.valid_for?(mock("new_request", 
+                             :uri => 'http://foo.invalid', 
+                             :header => {'Accept' => 'text/plain'})).should be_true
+    end 
+
+    it "should false for requests against different URIs even if headers match" do
+      @entry.valid_for?(mock("new_request", :uri => 'http://bar.invalid', 
+                             :header => {'Accept' => 'text/plain'})).should be_false
+    end 
+
+    it "should false for requests where headers don't match" do
+      @entry.valid_for?(mock("new_request", :uri => 'http://foo.invalid', 
+                             :header => {'Accept' => 'application/octet-stream'})).should be_false
+    end 
+
+    it "should be false if request has a varying header and the original request was missing that header" do 
+      entry = Resourceful::CacheEntry.new(
+                 mock('original_request', :header => {}, 
+                      :request_time => Time.utc(2008,5,16,0,0,0), :uri => 'http://foo.invalid'), 
+                 mock('response', :header => {'Vary' => 'Accept'}))
+
+      entry.valid_for?(mock("new_request", :uri => 'http://foo.invalid', 
+                             :header => {'Accept' => 'text/plain'})).should be_false
     end
   end
 
-  it 'should be valid for a request if all the vary headers match' do
-    @request.stub!(:header).and_return({'Content-Type' => 'text/plain'})
-    @entry.valid_for?(@request).should be_true
-  end
+  describe '#select_request_headers' do
+    before do
+      @req_header = mock('header', :[] => nil)
+      @request = mock('request', :header => @req_header)
 
-  it 'should not be valid for a request if not all the vary headers match' do
-    @request.stub!(:header).and_return({'Content-Type' => 'text/html'})
-    @entry.valid_for?(@request).should be_false
-  end
+      @resp_header = mock('header', :[] => nil)
+      @response = mock('response', :header => @resp_header)
+    end
+
+    it 'should select the request headers from the Vary header' do
+      @resp_header.should_receive(:[]).with('Vary')
+      @entry.select_request_headers(@request, @response)
+    end
+
+    it 'should pull the values from the request that match keys in the vary header' do
+      @resp_header.should_receive(:[]).with('Vary').twice.and_return(['foo', 'bar'])
+      @req_header.should_receive(:[]).with('foo').and_return('oof')
+      @req_header.should_receive(:[]).with('bar').and_return('rab')
 
+      header = @entry.select_request_headers(@request, @response)
+      header['foo'].should == 'oof'
+      header['bar'].should == 'rab'
+    end
+
+    it 'should return a new Header object' do
+      @entry.select_request_headers(@request, @response).should be_kind_of(Resourceful::Header)
+    end
+  end
 end
 
 

data/spec/resourceful/http_accessor_spec.rb

@@ -23,20 +23,26 @@ describe Resourceful::HttpAccessor, 'init' do
 
   it 'should raise arg error if unrecognized options are passed' do
     lambda {
-      ha = Resourceful::HttpAccessor.new(:foo => 'foo', :bar => 'bar')
+      Resourceful::HttpAccessor.new(:foo => 'foo', :bar => 'bar')
     }.should raise_error(ArgumentError, /Unrecognized options: (foo, bar)|(bar, foo)/)
   end 
 
   it 'should allow an additional user agent token to be passed at init' do
-    Resourceful::HttpAccessor.new(:user_agent => "Super/3000").tap do |ha|
-      ha.user_agent_string.should match(%r{^Super/3000})
-    end
+    ha = Resourceful::HttpAccessor.new(:user_agent => "Super/3000")
+
+    ha.user_agent_string.should match(%r{^Super/3000})
   end 
 
   it 'should allow multiple additional user agent tokens to be passed at init' do
-    Resourceful::HttpAccessor.new(:user_agent => ["Super/3000", "Duper/2.1"]).tap do |ha|
-      ha.user_agent_string.should match(%r{^Super/3000 Duper/2\.1 })
-    end
+    ha = Resourceful::HttpAccessor.new(:user_agent => ["Super/3000", "Duper/2.1"])
+
+    ha.user_agent_string.should match(%r{^Super/3000 Duper/2\.1 })
+  end 
+
+  it 'should allow cache manager to be provided at init' do
+    ha = Resourceful::HttpAccessor.new(:cache_manager => :marker)
+
+    ha.cache_manager.should equal(:marker)
   end 
 
 end 
@@ -123,3 +129,36 @@ describe Resourceful::HttpAccessor do
   end
 
 end
+
+describe Resourceful::HttpAccessor, "(authentication)" do           
+  before do
+    @auth_manager = stub('auth_manager', :add_auth_handler => nil)
+    Resourceful::AuthenticationManager.stub!(:new).and_return(@auth_manager)
+    @ha = Resourceful::HttpAccessor.new()
+  end
+
+  it 'should allow authenticators to be registered' do
+    an_authenticator = stub('an_authenicator')
+    @auth_manager.should_receive(:add_auth_handler).with(an_authenticator)
+
+    @ha.add_authenticator(an_authenticator)
+  end 
+
+  it 'should allow an authenicator to be specified at init' do
+    an_authenticator = stub('an_authenicator')
+    @auth_manager.should_receive(:add_auth_handler).with(an_authenticator)
+
+    Resourceful::HttpAccessor.new(:authenticator => an_authenticator)
+  end 
+
+  it 'should allow multiple authenicators to be specified at init' do
+    authenticator1 = stub('authenicator1')
+    authenticator2 = stub('authenicator2')
+
+    @auth_manager.should_receive(:add_auth_handler).with(authenticator1)
+    @auth_manager.should_receive(:add_auth_handler).with(authenticator2)
+
+    Resourceful::HttpAccessor.new(:authenticators => [authenticator1, authenticator2])
+  end 
+
+end 

data/spec/resourceful/memcache_cache_manager_spec.rb

@@ -0,0 +1,111 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + '../spec_helper'
+
+require 'resourceful/memcache_cache_manager'
+require 'resourceful/request'
+
+describe Resourceful::MemcacheCacheManager do
+  before do
+    @resource = stub('resource', :uri => 'http://foo.invalid/')
+
+    @request = Resourceful::Request.new(:get, @resource)
+    @response = Resourceful::Response.new('http://foo.invalid/', '200', {'Vary' => 'Accept'}, "a body")
+    
+    @memcache = stub('memcache', :get => nil)
+    MemCache.stub!(:new).and_return(@memcache)
+
+    @cache_mngr = Resourceful::MemcacheCacheManager.new('foobar:42')
+  end
+
+  describe "#store(request,response)" do
+    it "should store the new pair in memcache" do
+      @memcache.should_receive(:[]=).with do |key, collection|
+        key.should == Digest::MD5.hexdigest('http://foo.invalid/')
+        collection[@request].should == @response
+      end
+
+      @cache_mngr.store(@request, @response)
+    end 
+  
+    it "should replace existing values if they exist" do
+      entries = Resourceful::CacheEntryCollection.new
+      entries[@request] = @response
+      @memcache.stub!(:[]=).and_return(entries)
+
+      new_request = Resourceful::Request.new(:get, @resource)
+      new_response = Resourceful::Response.new('http://foo.invalid/', '200', {}, "a different body")
+
+      @memcache.should_receive(:[]=).with do |key, collection|
+        collection[new_request].should == new_response
+      end
+      
+      @cache_mngr.store(new_request, new_response)
+    end 
+
+    it "should not store responses that are not cacheable" do
+      @memcache.should_not_receive(:[]=)
+
+      vary_star_response = Resourceful::Response.new('http://foo.invalid/', '200', {'Vary' => '*'}, "a different body")
+ 
+      @cache_mngr.store(@request, vary_star_response)     
+    end 
+  end 
+
+  describe "#lookup" do
+    before do
+      @entries = Resourceful::CacheEntryCollection.new
+      @entries[@request] = @response
+      @memcache.stub!(:get).and_return(@entries)
+    end
+    
+    it "should lookup the entry collection by the URI" do
+      @memcache.should_receive(:get).with(Digest::MD5.hexdigest('http://foo.invalid/')).and_return(@entries)
+
+      @cache_mngr.lookup(@request)
+    end
+ 
+    it "should retrieve responses that match request" do
+      @cache_mngr.lookup(Resourceful::Request.new(:get, @resource)).should == @response
+    end 
+
+    it "should return nil if no responses that match request are found" do
+      @cache_mngr.lookup(Resourceful::Request.new(:get, @resource, "body", {'Accept' => 'text/plain'})).
+        should be_nil
+    end 
+
+    it "should return nil if no responses that resource are found" do
+      @memcache.stub!(:get).and_return(nil)
+
+      @cache_mngr.lookup(Resourceful::Request.new(:get, @resource)).should be_nil
+    end 
+  end 
+
+  describe "#invalidate(url)" do
+    it "should remove all cached responses for that resource from memcache" do
+      @memcache.should_receive(:delete).with(Digest::MD5.hexdigest('http://foo.invalid/'))
+
+      @cache_mngr.invalidate('http://foo.invalid/')
+    end 
+  end 
+end 
+
+describe Resourceful::MemcacheCacheManager, 'init' do 
+  it 'should be createable with single memcache server' do
+    MemCache.should_receive(:new).with(['foobar:42'], anything)
+    
+    Resourceful::MemcacheCacheManager.new('foobar:42')
+  end 
+
+  it 'should be createable with multiple memcache servers' do
+    MemCache.should_receive(:new).with(['foobar:42', 'baz:32'], anything)
+    
+    Resourceful::MemcacheCacheManager.new('foobar:42', 'baz:32')
+  end 
+
+  it 'should create a thread safe memcache client' do
+    MemCache.should_receive(:new).with(anything, {:multithread => true})
+    
+    Resourceful::MemcacheCacheManager.new('foobar:42')
+  end 
+end
+

data/spec/resourceful/options_interpreter_spec.rb

@@ -62,7 +62,15 @@ describe Resourceful::OptionsInterpreter, '#interpret(options)' do
     @interpreter.interpret({}).keys.should_not include(:foo)
   end 
 
-  it 'should not invoked option value munging block if option is not specified'
+  it 'should not invoked option value munging block if option is not specified' do 
+    @interpreter = Resourceful::OptionsInterpreter.new()
+    munging_block_executed = false
+    @interpreter.option(:foo) { |a| munging_block_executed = true }
+
+    lambda {
+      @interpreter.interpret({})
+    }.should_not change{munging_block_executed}
+  end
   
   it 'should use default if option is not specified' do
     @interpreter = Resourceful::OptionsInterpreter.new()

data/spec/simple_http_server_shared_spec.rb

@@ -124,7 +124,7 @@ end unless defined? AuthorizationResponder
 describe 'simple http server', :shared => true do
   before(:all) do
     require 'rack'
-    require 'mongrel'
+    require 'thin'
 
     app = Rack::Builder.new do |env|
       use Rack::ShowExceptions
@@ -145,7 +145,9 @@ describe 'simple http server', :shared => true do
 
     #spawn the server in a separate thread
     @httpd = Thread.new do
-      Rack::Handler::Mongrel.run(app, :Host => '127.0.0.1', :Port => 3000)
+      Thin::Logging.silent = true
+      # Thin::Logging.debug = true
+      Thin::Server.start(app)
     end
     #give the server a chance to initialize
     sleep 0.05

metadata

@@ -1,78 +1,147 @@
 --- !ruby/object:Gem::Specification 
 name: paul-resourceful
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors: 
 - Paul Sadauskas
-- Peter Williams
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-11-22 00:00:00 -08:00
+date: 2008-12-05 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: hoe
+  name: addressable
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.8.2
+        version: "0"
     version: 
-description: 
-email: 
-- psadauskas@gmail.com
-- pezra@barelyenough.org
+- !ruby/object:Gem::Dependency 
+  name: httpauth
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: facets
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: andand
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thin
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: An HTTP library for Ruby that takes advantage of everything HTTP has to offer.
+email: psadauskas@gmail.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- Manifest.txt
-files: 
-- MIT-LICENSE
-- Manifest.txt
-- README.markdown
-- Rakefile
 - lib/resourceful.rb
 - lib/resourceful/authentication_manager.rb
-- lib/resourceful/cache_manager.rb
-- lib/resourceful/header.rb
-- lib/resourceful/http_accessor.rb
+- lib/resourceful/util.rb
+- lib/resourceful/resource.rb
+- lib/resourceful/memcache_cache_manager.rb
 - lib/resourceful/net_http_adapter.rb
+- lib/resourceful/http_accessor.rb
+- lib/resourceful/stubbed_resource_proxy.rb
+- lib/resourceful/header.rb
+- lib/resourceful/cache_manager.rb
 - lib/resourceful/options_interpreter.rb
+- lib/resourceful/response.rb
 - lib/resourceful/request.rb
+- README.markdown
+files: 
+- lib/resourceful.rb
+- lib/resourceful/authentication_manager.rb
+- lib/resourceful/util.rb
 - lib/resourceful/resource.rb
-- lib/resourceful/response.rb
+- lib/resourceful/memcache_cache_manager.rb
+- lib/resourceful/net_http_adapter.rb
+- lib/resourceful/http_accessor.rb
 - lib/resourceful/stubbed_resource_proxy.rb
-- lib/resourceful/util.rb
-- lib/resourceful/version.rb
-- resourceful.gemspec
+- lib/resourceful/header.rb
+- lib/resourceful/cache_manager.rb
+- lib/resourceful/options_interpreter.rb
+- lib/resourceful/response.rb
+- lib/resourceful/request.rb
 - spec/acceptance_shared_specs.rb
+- spec/spec.opts
 - spec/acceptance_spec.rb
-- spec/resourceful/authentication_manager_spec.rb
-- spec/resourceful/cache_manager_spec.rb
+- spec/simple_http_server_shared_spec_spec.rb
+- spec/spec_helper.rb
 - spec/resourceful/header_spec.rb
-- spec/resourceful/http_accessor_spec.rb
-- spec/resourceful/net_http_adapter_spec.rb
+- spec/resourceful/authentication_manager_spec.rb
+- spec/resourceful/memcache_cache_manager_spec.rb
+- spec/resourceful/response_spec.rb
 - spec/resourceful/options_interpreter_spec.rb
+- spec/resourceful/http_accessor_spec.rb
+- spec/resourceful/stubbed_resource_proxy_spec.rb
 - spec/resourceful/request_spec.rb
 - spec/resourceful/resource_spec.rb
-- spec/resourceful/response_spec.rb
-- spec/resourceful/stubbed_resource_proxy_spec.rb
+- spec/resourceful/cache_manager_spec.rb
+- spec/resourceful/net_http_adapter_spec.rb
 - spec/simple_http_server_shared_spec.rb
-- spec/simple_http_server_shared_spec_spec.rb
-- spec/spec.opts
-- spec/spec_helper.rb
+- Manifest
+- Rakefile
+- README.markdown
+- MIT-LICENSE
+- resourceful.gemspec
 has_rdoc: true
-homepage: 
+homepage: http://github.com/paul/resourceful
 post_install_message: 
 rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Resourceful
 - --main
-- README.txt
+- README.markdown
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -85,7 +154,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
+      version: "1.2"
   version: 
 requirements: []
 

data/Manifest.txt

@@ -1,34 +0,0 @@
-MIT-LICENSE
-Manifest.txt
-README.markdown
-Rakefile
-lib/resourceful.rb
-lib/resourceful/authentication_manager.rb
-lib/resourceful/cache_manager.rb
-lib/resourceful/header.rb
-lib/resourceful/http_accessor.rb
-lib/resourceful/net_http_adapter.rb
-lib/resourceful/options_interpreter.rb
-lib/resourceful/request.rb
-lib/resourceful/resource.rb
-lib/resourceful/response.rb
-lib/resourceful/stubbed_resource_proxy.rb
-lib/resourceful/util.rb
-lib/resourceful/version.rb
-resourceful.gemspec
-spec/acceptance_shared_specs.rb
-spec/acceptance_spec.rb
-spec/resourceful/authentication_manager_spec.rb
-spec/resourceful/cache_manager_spec.rb
-spec/resourceful/header_spec.rb
-spec/resourceful/http_accessor_spec.rb
-spec/resourceful/net_http_adapter_spec.rb
-spec/resourceful/options_interpreter_spec.rb
-spec/resourceful/request_spec.rb
-spec/resourceful/resource_spec.rb
-spec/resourceful/response_spec.rb
-spec/resourceful/stubbed_resource_proxy_spec.rb
-spec/simple_http_server_shared_spec.rb
-spec/simple_http_server_shared_spec_spec.rb
-spec/spec.opts
-spec/spec_helper.rb

data/lib/resourceful/version.rb

@@ -1 +0,0 @@
-RESOURCEFUL_VERSION = '0.2'