cached_resource 1.0.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*DS_Store

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--backtrace
+--format d

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Andrew Chan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,36 @@
+# 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.  
+
+## 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.
+
+Turn CachedResource off.  This will cause all ActiveResource responses to be retrieved normally (i.e. via the network). 
+
+	CachedResource.off!
+	
+Turn CachedResource on.
+
+	CachedResource.on!
+	
+Set the cache expiry time to 60 seconds.
+
+	CachedResource.config.cache_time_to_live = 60
+	
+Set a different logger.
+
+	CachedResource.config.logger = MyLogger.new
+	
+Set a different cache store.
+
+	CachedResource.config.cache = MyCacheStore.new
+
+## Usage
+Sit back and relax! If you need to reload a particular request you can do something like:
+
+	MyActiveResource.find(:all, :reload => true)
+
+## Testing
+	rake

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/cached_resource.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cached_resource/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cached_resource"
+  s.version     = CachedResource::VERSION
+  s.authors     = "Andrew Chan"
+  s.email       = "email@suspi.net"
+  s.homepage    = "http://github.com/Ahsizara/cached_resource"
+  s.summary     = %q{Caching for ActiveResource}
+  s.description = %q{Enables request-based caching for ActiveResource}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "activeresource"
+  s.add_dependency "activesupport"
+  s.add_dependency "term-ansicolor"
+
+  s.add_development_dependency "rspec"
+end

data/lib/cached_resource/caching.rb

@@ -0,0 +1,72 @@
+module CachedResource
+  # The Caching module is included in ActiveResource and
+  # handles caching and recaching of responses.
+  module Caching
+    extend ActiveSupport::Concern
+
+    # when included, setup a middle man for find
+    included do
+      class << self
+        alias_method_chain :find, :cache
+      end
+    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
+        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
+      end
+
+      private
+
+      # 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 && log(:read, "#{key} for #{arguments.inspect}")
+        result || find_via_reload(key, *arguments)
+      end
+
+      # 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)
+        CachedResource.cache.write(key, result, :expires_in => CachedResource.config.cache_time_to_live)
+        log(:write, "#{key} for #{arguments.inspect}")
+        result
+      end
+
+      # generate the request cache key
+      def cache_key(*arguments)
+        "#{name.parameterize.gsub("-", "/")}/#{arguments.join('/')}".downcase
+      end
+
+      # log a message indicating a cached resource event
+      def log(type, msg)
+        c = Term::ANSIColor
+        type_string = "Cached Resource #{type.to_s.upcase}"
+
+        case type
+        when :read
+          type_string = c.intense_black + c.bold + type_string + c.clear
+        when :write
+          type_string = c.yellow + c.bold + type_string + c.clear
+        end
+
+        CachedResource.logger.info "#{type_string}  #{msg}"
+      end
+
+    end
+  end
+end

data/lib/cached_resource/config.rb

@@ -0,0 +1,26 @@
+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
+
+    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

data/lib/cached_resource/version.rb

@@ -0,0 +1,3 @@
+module CachedResource
+  VERSION = "1.0.0"
+end

data/lib/cached_resource.rb

@@ -0,0 +1,43 @@
+# sourced from this great gist: https://gist.github.com/947734
+require 'singleton'
+require 'term/ansicolor'
+require 'stringio'
+
+require 'active_support/concern'
+require 'cached_resource/config'
+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
+
+end
+
+# Include caching in ActiveResource::Base
+class ActiveResource::Base
+  include CachedResource::Caching
+end

data/spec/cached_resource/caching_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe CachedResource do
+
+  before(:all) do
+    class Thing < ActiveResource::Base
+      self.site = "http://api.thing.com"
+    end
+
+    @thing = {:thing => {:id => 1, :name => "Ada"}}
+    @other_thing = {:thing => {:id => 1, :name => "Ari"}}
+    @thing_json = @thing.to_json
+    @other_thing_json = @other_thing.to_json
+  end
+
+  describe "when enabled" do
+
+    before(:all) do
+      # it's on by default, but lets call the method
+      # to make sure it works
+      CachedResource.on!
+
+      ActiveResource::HttpMock.reset!
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.get "/things/1.json", {}, @thing_json
+      end
+    end
+
+    it "should cache a response" do
+      result = Thing.find(1)
+      CachedResource.config.cache.read("thing/1").should == result
+    end
+
+    it "should read a response when the request is made again" do
+      Thing.find(1)
+      # only one request should have been made by the test
+      # before this one
+      ActiveResource::HttpMock.requests.length.should == 1
+    end
+
+    it "should remake a request when reloaded" do
+      Thing.find(1, :reload => true)
+      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")
+
+      # change the response
+      ActiveResource::HttpMock.reset!
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.get "/things/1.json", {}, @other_thing_json
+      end
+
+      Thing.find(1, :reload => true)
+      new_result = CachedResource.config.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
+  end
+
+  describe "when disabled" do
+
+    before(:all) do
+      CachedResource.off!
+
+      ActiveResource::HttpMock.reset!
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.get "/things/1.json", {}, @thing_json
+      end
+    end
+
+    it "should cache a response" do
+      result = Thing.find(1)
+      CachedResource.config.cache.read("thing/1").should == result
+    end
+
+    it "should always remake the request" do
+      Thing.find(1)
+      ActiveResource::HttpMock.requests.length.should == 2
+      Thing.find(1)
+      ActiveResource::HttpMock.requests.length.should == 3
+    end
+
+    it "should rewrite the cache for each request" do
+      old_result = CachedResource.config.cache.read("thing/1")
+
+      # change the response
+      ActiveResource::HttpMock.reset!
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.get "/things/1.json", {}, @other_thing_json
+      end
+
+      Thing.find(1)
+      new_result = CachedResource.config.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
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+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
+
+# clear cache at beginning and end of execution
+CachedResource.cache.clear
+at_exit { CachedResource.cache.clear }

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification 
+name: cached_resource
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Andrew Chan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-20 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  name: activeresource
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  name: activesupport
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  name: term-ansicolor
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  name: rspec
+  version_requirements: *id004
+description: Enables request-based caching for ActiveResource
+email: email@suspi.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- MIT-LICENSE
+- README
+- Rakefile
+- cached_resource.gemspec
+- lib/cached_resource.rb
+- lib/cached_resource/caching.rb
+- lib/cached_resource/config.rb
+- lib/cached_resource/version.rb
+- spec/cached_resource/caching_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/Ahsizara/cached_resource
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Caching for ActiveResource
+test_files: 
+- spec/cached_resource/caching_spec.rb
+- spec/spec_helper.rb