cached_resource 2.0.1 → 2.1.1a

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3

data/README.md

@@ -4,14 +4,26 @@ CachedResource is a Ruby gem whose goal is to increase the performance of intera
 ## Installation
 	gem install cached_resource
 
+## Compatibility
+CachedResource has been tested with the following Ruby versions:
+
+* 1.8.7
+* 1.9.2
+* 1.9.3
+
+CachedResource is designed to be framework agnostic, but will hook into Rails for caching and logging.  If there is a `Rails.cache` and/or a `Rails.logger`, then it _should_ be OK.  It is known to work with the following Rails versions:
+
+* 3.1.3
+* 3.2.2
+
 ## Configuration
-Enable CachedResource across all ActiveResources.  You could put this code in config/initializers.
+**Set up CachedResource across all ActiveResources:**
 
 	class ActiveResource::Base
 		cached_resource
 	end
 
-Enable CachedResource for a single class.
+Or set up CachedResource for a single class:
 
 	class MyActiveResource < ActiveResource::Base
 		cached_resource
@@ -20,18 +32,20 @@ Enable CachedResource for a single class.
 ### Options
 CachedResource accepts the following options:
 
-* `:cache` The cache store that CacheResource should use. Default: The `Rails.cache` if available, or an `ActiveSupport::Cache::MemoryStore`
+* `:enabled` Default: `true`
 * `:ttl` The time in seconds until the cache should expire. Default: `604800`
+* `:collection_synchronize` Use collections to generate cache entries for individuals.  Update the existing cached principal collection with new individuals.  Default: `false`
+* `:collection_arguments` The arguments that identify the principal collection request. Default: `[:all]`
 * `:logger` The logger to which CachedResource messages should be written. Default: The `Rails.logger` if available, or an `ActiveSupport::BufferedLogger`
-* `:enabled` Default: `true`
+* `:cache` The cache store that CacheResource should use. Default: The `Rails.cache` if available, or an `ActiveSupport::Cache::MemoryStore`
 
 You can set them like this:
 
-	cached_resource :cache => MyCacheStore.new, :ttl => 60, :logger => MyLogger.new, :enabled => false
+	cached_resource :cache => MyCacheStore.new, :ttl => 60, :collection_synchronize => true, :logger => MyLogger.new, :enabled => false
 
-You can also change these options on the fly.
+You can also change them on the fly.
 
-Turn CachedResource off.  This will cause all responses to be retrieved normally (i.e. via the network).
+Turn CachedResource off.  This will cause all responses to be retrieved normally (i.e. via the network). All responses will still be cached.
 
 	MyActiveResource.cached_resource.off!
 
@@ -43,6 +57,14 @@ Set the cache expiry time to 60 seconds.
 
 	MyActiveResource.cached_resource.ttl = 60
 
+Enable collection synchronization.  This will cause a call to `MyActiveResource.all` to also create cache entries for each of its members.  So, for example, a later call to `MyActiveResource.find(1)` will be read from the cache instead of requested from the remote service.
+
+	MyActiveResource.cached_resource.collection_synchronize = true
+
+Change the arguments that identify the principal collection request.  If for some reason you are concerned with a collection that is retrieved at a non-standard URL, you may specify the Ruby arguments that produce that URL.  When `collection_synchronize` is `true`, the collection returned from a request that matches these arguments will be cached and later updated when one of its members is retrieved.
+
+	MyActiveResource.cached_resource.collection_arguments = [:all, :params => {:name => "Bob"}]
+
 Set a different logger.
 
 	MyActiveResource.cached_resource.logger = MyLogger.new
@@ -51,8 +73,19 @@ Set a different cache store.
 
 	MyActiveResource.cached_resource.cache = MyCacheStore.new
 
+### Caveats
+If you set up CachedResource across all ActiveResources or any subclass of ActiveResource that will be inherited by other classes and you want some of those others to have independent CachedResource configurations, then check out the example below:
+
+	class ActiveResource::Base
+		cached_resource
+	end
+
+	class MyActiveResource < ActiveResource::Base
+		self.cached_resource = CachedResource::Configuration.new(:collection_synchronize => true)
+	end
+
 ## Usage
-Sit back and relax! If you need to reload a particular request you can do something like this:
+Sit back and relax! If you need to reload a particular request you can pass `:reload => true` into the options hash like this:
 
 	MyActiveResource.find(:all, :reload => true)
 
@@ -63,5 +96,10 @@ Sit back and relax! If you need to reload a particular request you can do someth
 * quamen and [this gist](http://gist.github.com/947734)
 * latimes and [this plugin](http://github.com/latimes/cached_resource)
 
+## Feedback/Problems
+Feedback is greatly appreciated! Check out this project's [issue tracker](https://github.com/Ahsizara/cached_resource/issues) if you've got anything to say.
+
 ## Future Work
-* Cached collection lookups
+This may change at any time.
+
+* Consider checksums to improve the determination of freshness/changédness

data/Rakefile

@@ -1,5 +1,4 @@
 require "bundler/gem_tasks"
-
 require 'rspec/core/rake_task'
 
 desc "Run all examples"

data/lib/cached_resource/cached_resource.rb

@@ -9,12 +9,12 @@ module CachedResource
       class << self
         attr_accessor :cached_resource
 
-        # initialize cached resource or retrieve the current cached resource configuration
+        # Initialize cached resource or retrieve the current cached resource configuration.
         def cached_resource(options={})
           defined?(@cached_resource) && @cached_resource || setup_cached_resource!(options)
         end
 
-        # setup cached resource for this class by creating a new configuration
+        # Set up cached resource for this class by creating a new configuration
         # and establishing the necessary methods.
         def setup_cached_resource!(options)
           @cached_resource = CachedResource::Configuration.new(options)
@@ -24,5 +24,15 @@ module CachedResource
       end
     end
 
+    module ClassMethods
+      # Copy a superclass's cached resource configuration if
+      # it's defined.  Unfortunately, this means that any subclass
+      # that wants an independent configuration will need to execute:
+      # self.cached_resource = CachedResource::Configuration.new(options={})
+      def inherited(child)
+        child.cached_resource = self.cached_resource if defined?(@cached_resource)
+      end
+    end
+
   end
 end

data/lib/cached_resource/caching.rb

@@ -11,41 +11,91 @@ module CachedResource
     end
 
     module ClassMethods
-      # find a resource using the cache or resend the request
-      # if :reload is set to true or caching is disabled
+      # Find a resource using the cache or resend the request
+      # if :reload is set to true or caching is disabled.
       def find_with_cache(*arguments)
         arguments << {} unless arguments.last.is_a?(Hash)
         should_reload = arguments.last.delete(:reload) || !cached_resource.enabled
         arguments.pop if arguments.last.empty?
         key = cache_key(arguments)
 
-        begin
-          (should_reload ? find_via_reload(key, *arguments) : find_via_cache(key, *arguments))
-        rescue ActiveResource::ServerError, ActiveResource::ConnectionError, SocketError => e
-          raise(e)
-        end
+        should_reload ? find_via_reload(key, *arguments) : find_via_cache(key, *arguments)
       end
 
       private
 
-      # try to find a cached response for the given key.  If
+      # Try to find a cached response for the given key.  If
       # no cache entry exists, send a new request.
       def find_via_cache(key, *arguments)
-        result = cached_resource.cache.read(key).try(:dup)
-        result && cached_resource.logger.info("#{CachedResource::Configuration::LOGGER_PREFIX} READ #{key} for #{arguments.inspect}")
-        result || find_via_reload(key, *arguments)
+        cache_read(key) || find_via_reload(key, *arguments)
       end
 
-      # re/send the request to fetch the resource. Cache the response
+      # Re/send the request to fetch the resource. Cache the response
       # for the request.
       def find_via_reload(key, *arguments)
-        result = find_without_cache(*arguments)
-        cached_resource.cache.write(key, result, :expires_in => cached_resource.ttl)
-        cached_resource.logger.info("#{CachedResource::Configuration::LOGGER_PREFIX} WRITE #{key} for #{arguments.inspect}")
+        object = find_without_cache(*arguments)
+        cache_collection_synchronize(object, *arguments) if cached_resource.collection_synchronize
+        cache_write(key, object)
+        object
+      end
+
+      # If this is a pure, unadulterated "all" request
+      # write cache entries for all its members
+      # otherwise update an existing collection if possible.
+      def cache_collection_synchronize(object, *arguments)
+        if object.is_a? Array
+          update_singles_cache(object)
+          # update the collection only if this is a subset of it
+          update_collection_cache(object) unless is_collection?(*arguments)
+        else
+          update_collection_cache(object)
+        end
+      end
+
+      # Update the cache of singles with an array of updates.
+      def update_singles_cache(updates)
+        updates = Array(updates)
+        updates.each { |object| cache_write(object.send(primary_key), object) }
+      end
+
+      # Update the "mother" collection with an array of updates.
+      def update_collection_cache(updates)
+        updates = Array(updates)
+        collection = cache_read(cached_resource.collection_arguments)
+
+        if collection && !updates.empty?
+          store = RUBY_VERSION.to_f < 1.9 ? ActiveSupport::OrderedHash.new : {}
+          index = collection.inject(store) { |hash, object| hash[object.send(primary_key)] = object; hash }
+          updates.each { |object| index[object.send(primary_key)] = object }
+          cache_write(cached_resource.collection_arguments, index.values)
+        end
+      end
+
+      # Determine if the given arguments represent
+      # the entire collection of objects.
+      def is_collection?(*arguments)
+        arguments == cached_resource.collection_arguments
+      end
+
+      # Read a entry from the cache for the given key.
+      # The key is processed to make sure it is valid.
+      def cache_read(key)
+        key = cache_key(Array(key)) unless key.is_a? String
+        object = cached_resource.cache.read(key).try(:dup)
+        object && cached_resource.logger.info("#{CachedResource::Configuration::LOGGER_PREFIX} READ #{key}")
+        object
+      end
+
+      # Write an entry to the cache for the given key and value.
+      # The key is processed to make sure it is valid.
+      def cache_write(key, object)
+        key = cache_key(Array(key)) unless key.is_a? String
+        result = cached_resource.cache.write(key, object, :expires_in => cached_resource.ttl)
+        result && cached_resource.logger.info("#{CachedResource::Configuration::LOGGER_PREFIX} WRITE #{key}")
         result
       end
 
-      # generate the request cache key
+      # Generate the request cache key.
       def cache_key(*arguments)
         "#{name.parameterize.gsub("-", "/")}/#{arguments.join('/')}".downcase
       end

data/lib/cached_resource/configuration.rb

@@ -16,23 +16,27 @@ module CachedResource
     # defaults. The following options exist for cached resource:
     # :enabled, default: true
     # :ttl, default: 604800
+    # :collection_synchronize, default: false,
+    # :collection_arguments, default: [:all]
     # :cache, default: Rails.cache or ActiveSupport::Cache::MemoryStore.new,
     # :logger, default: Rails.logger or ActiveSupport::BufferedLogger.new(NilIO.new)
     def initialize(options={})
-      super ({
+      super({
         :enabled => true,
         :ttl => 604800,
+        :collection_synchronize => false,
+        :collection_arguments => [:all],
         :cache => defined?(Rails.cache)  && Rails.cache || CACHE,
         :logger => defined?(Rails.logger) && Rails.logger || LOGGER
       }.merge(options))
     end
 
-    # enable caching
+    # Enables caching.
     def on!
       self.enabled = true
     end
 
-    # disable caching
+    # Disables caching.
     def off!
       self.enabled = false
     end

data/lib/cached_resource/version.rb

@@ -1,3 +1,3 @@
 module CachedResource
-  VERSION = "2.0.1"
+  VERSION = "2.1.1a"
 end

data/spec/cached_resource/caching_spec.rb

@@ -10,6 +10,9 @@ describe CachedResource do
 
     @thing = {:thing => {:id => 1, :name => "Ada"}}
     @other_thing = {:thing => {:id => 1, :name => "Ari"}}
+    @thing2 = {:thing => {:id => 2, :name => "Joe"}}
+    @other_thing2 = {:thing => {:id => 2, :name => "Jeb"}}
+    @thing3 = {:thing => {:id => 3, :name => "Stu"}}
     @thing_json = @thing.to_json
     @other_thing_json = @other_thing.to_json
   end
@@ -20,7 +23,6 @@ describe CachedResource do
   end
 
   describe "when enabled" do
-
     before(:each) do
       # it's on by default, but lets call the method
       # to make sure it works
@@ -87,10 +89,143 @@ describe CachedResource do
       Thing.find(1)
       ActiveResource::HttpMock.requests.length.should == 2
     end
+
+    describe "when collection synchronize is enabled" do
+      before(:each) do
+        Thing.cached_resource.cache.clear
+        Thing.cached_resource.collection_synchronize = true
+
+        ActiveResource::HttpMock.reset!
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get "/things/1.json", {}, @thing_json
+          mock.get "/things.json", {}, [@thing[:thing]].to_json(:root => :thing)
+        end
+
+        # make a request for all things
+        Thing.all
+      end
+
+      it "should write cache entries for its members" do
+        result = Thing.find(1)
+        # only the all request should have been made
+        ActiveResource::HttpMock.requests.length.should == 1
+        # the result should be cached with the appropriate key
+        Thing.cached_resource.cache.read("thing/1").should == result
+      end
+
+      it "should rewrite cache entries for its members when reloaded" do
+        # get the soon to be stale result so that we have a cache entry
+        old_result = Thing.find(1)
+        # change the server
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get "/things/1.json", {}, @other_thing_json
+          mock.get "/things.json", {}, [@other_thing[:thing]].to_json(:root => :thing)
+        end
+        # reload the collection
+        Thing.all(:reload => true)
+        # get the updated result, read from the cache
+        result = Thing.find(1)
+        Thing.cached_resource.cache.read("thing/all")[0].should == result
+        Thing.cached_resource.cache.read("thing/all")[0].name.should == result.name
+      end
+
+      it "should update the collection when an individual request is reloaded" do
+        # change the server
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get "/things/1.json", {}, @other_thing_json
+          mock.get "/things.json", {}, [@other_thing[:thing]].to_json(:root => :thing)
+        end
+
+        # reload the individual
+        result = Thing.find(1, :reload => true)
+        Thing.cached_resource.cache.read("thing/all")[0].should == result
+        Thing.cached_resource.cache.read("thing/all")[0].name.should == result.name
+      end
+
+      it "should update both the collection and the member cache entries when a subset of the collection is retrieved" do
+        # create cache entries for 1 and all
+        old_individual = Thing.find(1)
+        old_collection = Thing.all
+
+        # change the server
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get "/things.json?name=Ari", {}, [@other_thing[:thing]].to_json(:root => :thing)
+        end
+
+        # make a request for a subset of the "mother" collection
+        result = Thing.find(:all, :params => {:name => "Ari"})
+        # the collection should be updated to reflect the server change
+        Thing.cached_resource.cache.read("thing/all")[0].should == result[0]
+        Thing.cached_resource.cache.read("thing/all")[0].name.should == result[0].name
+        # the individual should be updated to reflect the server change
+        Thing.cached_resource.cache.read("thing/1").should == result[0]
+        Thing.cached_resource.cache.read("thing/1").name.should == result[0].name
+      end
+
+      it "should maintain the order of the collection when updating it" do
+        # change the server to return a longer collection
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get "/things.json", {}, [@thing[:thing], @thing3[:thing], @thing2[:thing]].to_json(:root => :thing)
+        end
+
+        # create cache entry for the collection (we reload because in before block we make an all request)
+        old_collection = Thing.all(:reload => true)
+
+        # change the server's response for the thing with id 2
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get "/things/2.json", {}, @other_thing2.to_json(:root => :thing)
+        end
+
+        # get thing 2, thereby updating the collection
+        result = Thing.find(2, :reload => true)
+        # get the updated collection from the cache
+        updated_collection = Thing.all
+        # name should have changed to "Jeb"
+        updated_collection[2].name.should == result.name
+        # the updated collection should have the elements in the same order
+        old_collection.each_with_index do |thing, i|
+          updated_collection[i].id.should == thing.id
+        end
+      end
+    end
+
+    describe "when collection synchronize is disabled" do
+      before(:each) do
+        Thing.cached_resource.cache.clear
+        Thing.cached_resource.collection_synchronize = false
+
+        ActiveResource::HttpMock.reset!
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get "/things/1.json", {}, @thing_json
+          mock.get "/things.json", {}, [@thing[:thing]].to_json(:root => :thing)
+        end
+
+        # make a request for all things
+        Thing.all
+      end
+
+      it "should not write cache entries for its members" do
+        result = Thing.find(1)
+        # both the all in the before each and this request should have been made
+        ActiveResource::HttpMock.requests.length.should == 2
+      end
+
+      it "should not update the collection when an individual request is reloaded" do
+        # change the server
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get "/things/1.json", {}, @other_thing_json
+          mock.get "/things.json", {}, [@other_thing[:thing]].to_json(:root => :thing)
+        end
+
+        # reload the individual
+        result = Thing.find(1, :reload => true)
+        # the ids are the same, but the names should be different
+        Thing.cached_resource.cache.read("thing/all")[0].name.should_not == result.name
+      end
+    end
   end
 
   describe "when disabled" do
-
     before(:each) do
       Thing.cached_resource.cache.clear
       Thing.cached_resource.off!

data/spec/cached_resource/configuration_spec.rb

@@ -13,10 +13,22 @@ describe "CachedResource::Configuration" do
       configuration.ttl.should == 604800
     end
 
+    it "should disable collection synchronization" do
+      configuration.collection_synchronize.should == false
+    end
+
+    it "should default to :all for collection arguments" do
+      configuration.collection_arguments.should == [:all]
+    end
+
     describe "outside a Rails environment" do
       it "should be logging to a buffered logger attached to a NilIO" do
         configuration.logger.class.should == ActiveSupport::BufferedLogger
-        configuration.logger.instance_variable_get(:@log).class.should == CachedResource::NilIO
+        # ActiveSupport switched around the log destination variables
+        # Check if either are what we expect to be compatible
+        old_as = configuration.logger.instance_variable_get(:@log).class == CachedResource::NilIO
+        new_as = configuration.logger.instance_variable_get(:@log_dest).class == CachedResource::NilIO
+        (old_as || new_as).should == true
       end
 
       it "should cache responses in a memory store" do
@@ -51,7 +63,13 @@ describe "CachedResource::Configuration" do
   describe "when initialized through cached resource" do
     before(:each) do
       class Foo < ActiveResource::Base
-        cached_resource :ttl => 1, :cache => "cache", :logger => "logger", :enabled => false, :custom => "irrelevant"
+        cached_resource :ttl => 1,
+                        :cache => "cache",
+                        :logger => "logger",
+                        :enabled => false,
+                        :collection_synchronize => true,
+                        :collection_arguments => [:every],
+                        :custom => "irrelevant"
       end
     end
 
@@ -60,14 +78,18 @@ describe "CachedResource::Configuration" do
     end
 
     it "should relfect the specified options" do
-      Foo.cached_resource.ttl.should == 1
-      Foo.cached_resource.cache.should == "cache"
-      Foo.cached_resource.logger.should == "logger"
-      Foo.cached_resource.enabled.should == false
-      Foo.cached_resource.custom.should == "irrelevant"
+      cr = Foo.cached_resource
+      cr.ttl.should == 1
+      cr.cache.should == "cache"
+      cr.logger.should == "logger"
+      cr.enabled.should == false
+      cr.collection_synchronize.should == true
+      cr.collection_arguments.should == [:every]
+      cr.custom.should == "irrelevant"
     end
   end
 
+  # re-evaluate
   describe "when multiple are initialized through cached resource" do
     before(:each) do
       class Foo < ActiveResource::Base
@@ -108,5 +130,71 @@ describe "CachedResource::Configuration" do
 
   end
 
+  describe "when cached resource is inherited" do
+    before(:each) do
+      class Bar < ActiveResource::Base
+        cached_resource :ttl => 1,
+                        :cache => "cache",
+                        :logger => "logger",
+                        :enabled => false,
+                        :collection_synchronize => true,
+                        :collection_arguments => [:every],
+                        :custom => "irrelevant"
+      end
+
+      class Foo < Bar
+      end
+    end
+
+    after(:each) do
+      Object.send(:remove_const, :Foo)
+      Object.send(:remove_const, :Bar)
+    end
+
+    it "it should make sure each subclass has the same configuration" do
+      Bar.cached_resource.object_id.should == Foo.cached_resource.object_id
+    end
+
+  end
+
+  describe "when cached resource is inherited and then overriden" do
+    before(:each) do
+      class Bar < ActiveResource::Base
+        cached_resource :ttl => 1,
+                        :cache => "cache",
+                        :logger => "logger",
+                        :enabled => false,
+                        :collection_synchronize => true,
+                        :collection_arguments => [:every],
+                        :custom => "irrelevant"
+      end
+
+      class Foo < Bar
+        # override the superclasses configuration
+        self.cached_resource = CachedResource::Configuration.new(:ttl => 60)
+      end
+    end
+
+    after(:each) do
+      Object.send(:remove_const, :Foo)
+      Object.send(:remove_const, :Bar)
+    end
+
+    it "should have the specified options" do
+      cr = Foo.cached_resource
+      cr.ttl.should == 60
+    end
+
+    it "should have the default options for anything unspecified" do
+      cr = Foo.cached_resource
+      cr.cache.class.should == ActiveSupport::Cache::MemoryStore
+      cr.logger.class.should == ActiveSupport::BufferedLogger
+      cr.enabled.should == true
+      cr.collection_synchronize.should == false
+      cr.collection_arguments.should == [:all]
+      cr.custom.should == nil
+    end
+
+  end
 
 end

data/spec/spec_helper.rb

@@ -1,16 +1,11 @@
 require 'rubygems'
 require 'bundler/setup'
-
 require 'active_resource'
 require 'active_support'
 
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'cached_resource'
 
-
 RSpec.configure do |config|
   # nada
 end
-
-# change the logger so that we log to STDOUT
-# CachedResource.logger = ActiveSupport::BufferedLogger.new(STDOUT)

metadata

@@ -1,89 +1,89 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: cached_resource
-version: !ruby/object:Gem::Version 
-  hash: 13
-  prerelease: 
-  segments: 
-  - 2
-  - 0
-  - 1
-  version: 2.0.1
+version: !ruby/object:Gem::Version
+  version: 2.1.1a
+  prerelease: 5
 platform: ruby
-authors: 
+authors:
 - Andrew Chan
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-11-17 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: activeresource
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activeresource
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: activesupport
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id004
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Enables request-based caching for ActiveResource
 email: email@suspi.net
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - MIT-LICENSE
 - README.md
@@ -101,39 +101,31 @@ files:
 - spec/spec_helper.rb
 homepage: http://github.com/Ahsizara/cached_resource
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Caching for ActiveResource
-test_files: 
+test_files:
 - spec/cached_resource/caching_spec.rb
 - spec/cached_resource/configuration_spec.rb
 - spec/cached_resource/nilio_spec.rb
 - spec/spec_helper.rb
+has_rdoc: