cached_resource 1.0.1 → 2.0.1

data/README.md

@@ -1,34 +1,58 @@
-# CachedResource 
-CachedResource helps ActiveResource by caching responses according to request parameters.  It can help reduce the lag created by making repeated requests across the network.  
+# CachedResource [![Build Status](https://secure.travis-ci.org/Ahsizara/cached_resource.png)](http://travis-ci.org/Ahsizara/cached_resource)
+CachedResource is a Ruby gem whose goal is to increase the performance of interacting with web services via ActiveResource by caching responses based on request parameters.  It can help reduce the lag created by making repeated requests across a network.
 
 ## Installation
 	gem install cached_resource
 
 ## Configuration
-CachedResource works "out of the box" with ActiveResource.  By default, it caches responses to an `ActiveSupport::Cache::MemoryStore` and logs to an `ActiveSupport::BufferedLogger` attached to a `StringIO` object.  **In a Rails 3 environment**, CachedResource will attach itself to the Rails logger and cache.
+Enable CachedResource across all ActiveResources.  You could put this code in config/initializers.
 
-Turn CachedResource off.  This will cause all ActiveResource responses to be retrieved normally (i.e. via the network). 
+	class ActiveResource::Base
+		cached_resource
+	end
+
+Enable CachedResource for a single class.
+
+	class MyActiveResource < ActiveResource::Base
+		cached_resource
+	end
+
+### 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`
+* `:ttl` The time in seconds until the cache should expire. Default: `604800`
+* `:logger` The logger to which CachedResource messages should be written. Default: The `Rails.logger` if available, or an `ActiveSupport::BufferedLogger`
+* `:enabled` Default: `true`
+
+You can set them like this:
+
+	cached_resource :cache => MyCacheStore.new, :ttl => 60, :logger => MyLogger.new, :enabled => false
+
+You can also change these options on the fly.
+
+Turn CachedResource off.  This will cause all responses to be retrieved normally (i.e. via the network).
+
+	MyActiveResource.cached_resource.off!
 
-	CachedResource.off!
-	
 Turn CachedResource on.
 
-	CachedResource.on!
-	
+	MyActiveResource.cached_resource.on!
+
 Set the cache expiry time to 60 seconds.
 
-	CachedResource.config.cache_time_to_live = 60
-	
+	MyActiveResource.cached_resource.ttl = 60
+
 Set a different logger.
 
-	CachedResource.config.logger = MyLogger.new
-	
+	MyActiveResource.cached_resource.logger = MyLogger.new
+
 Set a different cache store.
 
-	CachedResource.config.cache = MyCacheStore.new
+	MyActiveResource.cached_resource.cache = MyCacheStore.new
 
 ## Usage
-Sit back and relax! If you need to reload a particular request you can do something like:
+Sit back and relax! If you need to reload a particular request you can do something like this:
 
 	MyActiveResource.find(:all, :reload => true)
 
@@ -36,5 +60,8 @@ Sit back and relax! If you need to reload a particular request you can do someth
 	rake
 
 ## Credit/Inspiration
-quamen and [this gist](http://gist.github.com/947734)
-latimes and [this plugin](http://github.com/latimes/cached_resource)
+* quamen and [this gist](http://gist.github.com/947734)
+* latimes and [this plugin](http://github.com/latimes/cached_resource)
+
+## Future Work
+* Cached collection lookups

data/cached_resource.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
+  s.add_dependency "rake"
   s.add_dependency "activeresource"
   s.add_dependency "activesupport"
 

data/lib/cached_resource.rb

@@ -1,41 +1,18 @@
-require 'singleton'
 require 'stringio'
+require 'ostruct'
 
 require 'active_support/concern'
-require 'cached_resource/config'
+require 'cached_resource/cached_resource'
+require 'cached_resource/nilio'
+require 'cached_resource/configuration'
 require 'cached_resource/caching'
 require 'cached_resource/version'
 
 module CachedResource
-
-  # Switch cache usage off
-  def self.off!
-    self.config.cache_enabled = false
-  end
-
-  # Switch cache usage on
-  def self.on!
-    self.config.cache_enabled = true
-  end
-
-  # retrieve the configured logger
-  def self.logger
-    config.logger
-  end
-
-  # retrieve the configured cache store
-  def self.cache
-    config.cache
-  end
-
-  # Retrieve the configuration object
-  def self.config
-    @@config ||= CachedResource::Config.instance
-  end
-
+  # nada
 end
 
-# Include caching in ActiveResource::Base
+# Include model methods in ActiveResource::Base
 class ActiveResource::Base
-  include CachedResource::Caching
+  include CachedResource::Model
 end

data/lib/cached_resource/cached_resource.rb

@@ -0,0 +1,28 @@
+module CachedResource
+  # The Model module is included in ActiveResource::Base and
+  # provides methods to enable caching and manipulate the caching
+  # configuration
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_accessor :cached_resource
+
+        # 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
+        # and establishing the necessary methods.
+        def setup_cached_resource!(options)
+          @cached_resource = CachedResource::Configuration.new(options)
+          send :include, CachedResource::Caching
+          @cached_resource
+        end
+      end
+    end
+
+  end
+end

data/lib/cached_resource/caching.rb

@@ -4,7 +4,6 @@ module CachedResource
   module Caching
     extend ActiveSupport::Concern
 
-    # when included, setup a middle man for find
     included do
       class << self
         alias_method_chain :find, :cache
@@ -12,12 +11,11 @@ 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
       def find_with_cache(*arguments)
         arguments << {} unless arguments.last.is_a?(Hash)
-        should_reload = arguments.last.delete(:reload) || !CachedResource.config.cache_enabled
+        should_reload = arguments.last.delete(:reload) || !cached_resource.enabled
         arguments.pop if arguments.last.empty?
         key = cache_key(arguments)
 
@@ -33,8 +31,8 @@ module CachedResource
       # 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 = CachedResource.cache.read(key).try(:dup)
-        result && CachedResource.logger.info("#{CachedResource::Config::LOGGER_PREFIX} READ #{key} for #{arguments.inspect}")
+        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)
       end
 
@@ -42,8 +40,8 @@ module CachedResource
       # for the request.
       def find_via_reload(key, *arguments)
         result = find_without_cache(*arguments)
-        CachedResource.cache.write(key, result, :expires_in => CachedResource.config.cache_time_to_live)
-        CachedResource.logger.info("#{CachedResource::Config::LOGGER_PREFIX} WRITE #{key} for #{arguments.inspect}")
+        cached_resource.cache.write(key, result, :expires_in => cached_resource.ttl)
+        cached_resource.logger.info("#{CachedResource::Configuration::LOGGER_PREFIX} WRITE #{key} for #{arguments.inspect}")
         result
       end
 

data/lib/cached_resource/configuration.rb

@@ -0,0 +1,42 @@
+module CachedResource
+  # The Configuration class manages class specific options
+  # for cached resource.
+  class Configuration < OpenStruct
+
+    # default or fallback cache without rails
+    CACHE = ActiveSupport::Cache::MemoryStore.new
+
+    # default of fallback logger without rails
+    LOGGER = ActiveSupport::BufferedLogger.new(NilIO.new)
+
+    # prefix for log messages
+    LOGGER_PREFIX = "[cached_resource]"
+
+    # Initialize a Configuration with the given options, overriding any
+    # defaults. The following options exist for cached resource:
+    # :enabled, default: true
+    # :ttl, default: 604800
+    # :cache, default: Rails.cache or ActiveSupport::Cache::MemoryStore.new,
+    # :logger, default: Rails.logger or ActiveSupport::BufferedLogger.new(NilIO.new)
+    def initialize(options={})
+      super ({
+        :enabled => true,
+        :ttl => 604800,
+        :cache => defined?(Rails.cache)  && Rails.cache || CACHE,
+        :logger => defined?(Rails.logger) && Rails.logger || LOGGER
+      }.merge(options))
+    end
+
+    # enable caching
+    def on!
+      self.enabled = true
+    end
+
+    # disable caching
+    def off!
+      self.enabled = false
+    end
+
+  end
+end
+

data/lib/cached_resource/nilio.rb

@@ -0,0 +1,19 @@
+module CachedResource
+  # NilIO emulates a null device (like /dev/null). This sort of
+  # doesn't belong here, but it's a dependency of cached resource.
+  class NilIO < StringIO
+
+    # Write to the null device. Disregards
+    # string parameter and returns the length
+    # of the string in bytes.
+    def write(string)
+      string.bytesize
+    end
+
+    # Read form the null device.  Always returns nil.
+    def read(length=nil, buffer=nil)
+      nil
+    end
+
+  end
+end

data/lib/cached_resource/version.rb

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

data/spec/cached_resource/caching_spec.rb

@@ -5,6 +5,7 @@ describe CachedResource do
   before(:all) do
     class Thing < ActiveResource::Base
       self.site = "http://api.thing.com"
+      cached_resource
     end
 
     @thing = {:thing => {:id => 1, :name => "Ada"}}
@@ -13,12 +14,18 @@ describe CachedResource do
     @other_thing_json = @other_thing.to_json
   end
 
+  after(:all) do
+    Thing.cached_resource.cache.clear
+    Object.send(:remove_const, :Thing)
+  end
+
   describe "when enabled" do
 
-    before(:all) do
+    before(:each) do
       # it's on by default, but lets call the method
       # to make sure it works
-      CachedResource.on!
+      Thing.cached_resource.cache.clear
+      Thing.cached_resource.on!
 
       ActiveResource::HttpMock.reset!
       ActiveResource::HttpMock.respond_to do |mock|
@@ -28,23 +35,32 @@ describe CachedResource do
 
     it "should cache a response" do
       result = Thing.find(1)
-      CachedResource.config.cache.read("thing/1").should == result
+      Thing.cached_resource.cache.read("thing/1").should == result
     end
 
     it "should read a response when the request is made again" do
+      # make a request
       Thing.find(1)
-      # only one request should have been made by the test
-      # before this one
+      # make the same request
+      Thing.find(1)
+      # only one request should have happened
       ActiveResource::HttpMock.requests.length.should == 1
     end
 
     it "should remake a request when reloaded" do
+      # make a request
+      Thing.find(1)
+      # make the same request, but reload it
       Thing.find(1, :reload => true)
+      # we should get two requests
       ActiveResource::HttpMock.requests.length.should == 2
     end
 
     it "should rewrite the cache when the request is reloaded" do
-      old_result = CachedResource.config.cache.read("thing/1")
+      # make a request
+      Thing.find(1)
+      # get the cached result of the request
+      old_result = Thing.cached_resource.cache.read("thing/1")
 
       # change the response
       ActiveResource::HttpMock.reset!
@@ -53,18 +69,31 @@ describe CachedResource do
       end
 
       Thing.find(1, :reload => true)
-      new_result = CachedResource.config.cache.read("thing/1")
+      new_result = Thing.cached_resource.cache.read("thing/1")
       # since active resources are equal if and only if they
       # are the same object or an instance of the same class,
       # not new?, and have the same id.
       new_result.name.should_not == old_result.name
     end
+
+    it "should remake the request when the ttl expires" do
+      # set cache time to live to 1 second
+      Thing.cached_resource.ttl = 1
+      # make a request
+      Thing.find(1)
+      # wait for the cache to expire
+      sleep(1.5)
+      # make the same request
+      Thing.find(1)
+      ActiveResource::HttpMock.requests.length.should == 2
+    end
   end
 
   describe "when disabled" do
 
-    before(:all) do
-      CachedResource.off!
+    before(:each) do
+      Thing.cached_resource.cache.clear
+      Thing.cached_resource.off!
 
       ActiveResource::HttpMock.reset!
       ActiveResource::HttpMock.respond_to do |mock|
@@ -74,18 +103,19 @@ describe CachedResource do
 
     it "should cache a response" do
       result = Thing.find(1)
-      CachedResource.config.cache.read("thing/1").should == result
+      Thing.cached_resource.cache.read("thing/1").should == result
     end
 
     it "should always remake the request" do
       Thing.find(1)
-      ActiveResource::HttpMock.requests.length.should == 2
+      ActiveResource::HttpMock.requests.length.should == 1
       Thing.find(1)
-      ActiveResource::HttpMock.requests.length.should == 3
+      ActiveResource::HttpMock.requests.length.should == 2
     end
 
     it "should rewrite the cache for each request" do
-      old_result = CachedResource.config.cache.read("thing/1")
+      Thing.find(1)
+      old_result = Thing.cached_resource.cache.read("thing/1")
 
       # change the response
       ActiveResource::HttpMock.reset!
@@ -94,7 +124,7 @@ describe CachedResource do
       end
 
       Thing.find(1)
-      new_result = CachedResource.config.cache.read("thing/1")
+      new_result = Thing.cached_resource.cache.read("thing/1")
       # since active resources are equal if and only if they
       # are the same object or an instance of the same class,
       # not new?, and have the same id.

data/spec/cached_resource/configuration_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe "CachedResource::Configuration" do
+
+  let(:configuration) { CachedResource::Configuration.new }
+
+  describe "by default" do
+    it "should be enabled" do
+      configuration.enabled.should == true
+    end
+
+    it "should have a cache expiry of 1 week" do
+      configuration.ttl.should == 604800
+    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
+      end
+
+      it "should cache responses in a memory store" do
+        configuration.cache.class.should == ActiveSupport::Cache::MemoryStore
+      end
+    end
+
+    describe "inside a Rails environment" do
+      before(:each) do
+        Rails = OpenStruct.new(:logger => "logger", :cache => "cache")
+        load "cached_resource/configuration.rb"
+      end
+
+      after(:each) do
+        # remove the rails constant and unbind the
+        # cache and logger from the configuration
+        # defaults
+        Object.send(:remove_const, :Rails)
+        load "cached_resource/configuration.rb"
+      end
+
+      it "should be logging to the rails logger" do
+        configuration.logger.should == "logger"
+      end
+
+      it "should cache responses in a memory store" do
+        configuration.cache.should == "cache"
+      end
+    end
+  end
+
+  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"
+      end
+    end
+
+    after(:each) do
+      Object.send(:remove_const, :Foo)
+    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"
+    end
+  end
+
+  describe "when multiple are initialized through cached resource" do
+    before(:each) do
+      class Foo < ActiveResource::Base
+        cached_resource
+      end
+
+      class Bar < ActiveResource::Base
+        cached_resource
+      end
+    end
+
+    after(:each) do
+      Object.send(:remove_const, :Foo)
+      Object.send(:remove_const, :Bar)
+    end
+
+    it "they should have different configuration objects" do
+      Foo.cached_resource.object_id.should_not == Bar.cached_resource.object_id
+    end
+
+    it "they should have the same cache" do
+      Foo.cached_resource.cache.should == Bar.cached_resource.cache
+      Foo.cached_resource.cache.object_id.should == Bar.cached_resource.cache.object_id
+    end
+
+    it "they should have the same ttl" do
+      Foo.cached_resource.ttl.should == Bar.cached_resource.ttl
+    end
+
+    it "they should have the same logger" do
+      Foo.cached_resource.logger.should == Bar.cached_resource.logger
+      Foo.cached_resource.logger.object_id.should == Bar.cached_resource.logger.object_id
+    end
+
+    it "they should have the same enablement" do
+      Foo.cached_resource.enabled.should == Bar.cached_resource.enabled
+    end
+
+  end
+
+
+end

data/spec/cached_resource/nilio_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe CachedResource::NilIO do
+  before(:all) do
+    @null_device = CachedResource::NilIO.new
+  end
+
+  it "should discard any data written" do
+    @null_device.write("I am writing something")
+    @null_device.readlines.should be_blank
+  end
+
+  it "should provide no data when read" do
+    @null_device.read(200).should == nil
+  end
+
+  it "should report EOF" do
+    @null_device.eof?.should == true
+  end
+end

data/spec/spec_helper.rb

@@ -12,6 +12,5 @@ RSpec.configure do |config|
   # nada
 end
 
-# clear cache at beginning and end of execution
-CachedResource.cache.clear
-at_exit { CachedResource.cache.clear }
+# change the logger so that we log to STDOUT
+# CachedResource.logger = ActiveSupport::BufferedLogger.new(STDOUT)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cached_resource
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 13
   prerelease: 
   segments: 
-  - 1
+  - 2
   - 0
   - 1
-  version: 1.0.1
+  version: 2.0.1
 platform: ruby
 authors: 
 - Andrew Chan
@@ -15,10 +15,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-21 00:00:00 Z
+date: 2011-11-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: activeresource
+  name: rake
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
@@ -32,7 +32,7 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: activeresource
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
@@ -46,7 +46,7 @@ dependencies:
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: activesupport
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
@@ -57,8 +57,22 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
+  type: :runtime
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
 description: Enables request-based caching for ActiveResource
 email: email@suspi.net
 executables: []
@@ -76,10 +90,14 @@ files:
 - Rakefile
 - cached_resource.gemspec
 - lib/cached_resource.rb
+- lib/cached_resource/cached_resource.rb
 - lib/cached_resource/caching.rb
-- lib/cached_resource/config.rb
+- lib/cached_resource/configuration.rb
+- lib/cached_resource/nilio.rb
 - lib/cached_resource/version.rb
 - spec/cached_resource/caching_spec.rb
+- spec/cached_resource/configuration_spec.rb
+- spec/cached_resource/nilio_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/Ahsizara/cached_resource
 licenses: []
@@ -116,4 +134,6 @@ specification_version: 3
 summary: Caching for ActiveResource
 test_files: 
 - spec/cached_resource/caching_spec.rb
+- spec/cached_resource/configuration_spec.rb
+- spec/cached_resource/nilio_spec.rb
 - spec/spec_helper.rb

data/lib/cached_resource/config.rb

@@ -1,29 +0,0 @@
-module CachedResource
-  # The Config class is a singleton that contains
-  # global configuration options for CacheResource
-  class Config
-    include Singleton
-
-    # set default cache time to live to 1 week
-    DEFAULT_CACHE_TIME_TO_LIVE = 604800
-
-    # prefix for log messages
-    LOGGER_PREFIX = "[cached_resource]"
-
-    attr_accessor :cache_enabled, :cache_time_to_live, :logger, :cache
-
-    # initialize the config with caching enabled and
-    # a default cache expiry of 7 days.  Also initializes
-    # the logging and caching mechanisms, setting them to
-    # the Rails logger and cache if available. If unavailable,
-    # sets them to active support equivalents
-    def initialize
-      @cache_enabled = true
-      @cache_time_to_live = DEFAULT_CACHE_TIME_TO_LIVE
-
-      @cache = defined?(Rails.cache)  && Rails.cache || ActiveSupport::Cache::MemoryStore.new
-      @logger = defined?(Rails.logger) && Rails.logger || ActiveSupport::BufferedLogger.new(StringIO.new)
-    end
-
-  end
-end