method_cacher 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+/.idea/

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
+environment_id="ruby-1.9.2-p180@method_cacher"
+
+#
+# Uncomment following line if you want options to be set only for given project.
+#
+# PROJECT_JRUBY_OPTS=( --1.9 )
+#
+# The variable PROJECT_JRUBY_OPTS requires the following to be run in shell:
+#
+#    chmod +x ${rvm_path}/hooks/after_use_jruby_opts
+#
+
+#
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+#
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+
+  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
+  then
+    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  if ! rvm --create use  "$environment_id"
+  then
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  fi
+fi
+
+#
+# If you use an RVM gemset file to install a list of gems (*.gems), you can have
+# it be automatically loaded. Uncomment the following and adjust the filename if
+# necessary.
+#
+# filename=".gems"
+# if [[ -s "$filename" ]]
+# then
+#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
+# fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && ! command -v bundle >/dev/null
+# then
+#   printf "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && command -v bundle
+# then
+#   bundle install
+# fi
+
+if [[ $- == *i* ]] # check for interactive shells
+then
+    echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
+else 
+	echo "Using: $GEM_HOME" # don't use colors in interactive shells
+fi
+

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.0.1
+
++ initial release

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in method_cacher.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: .
+  specs:
+    method_cacher (0.0.1.alpha)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.11)
+      activesupport (= 3.0.11)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activesupport (3.0.11)
+    archive-tar-minitar (0.5.2)
+    builder (2.1.2)
+    columnize (0.3.6)
+    diff-lcs (1.1.3)
+    i18n (0.5.0)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+    supermodel (0.1.6)
+      activemodel (~> 3.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  method_cacher!
+  rspec
+  ruby-debug19
+  supermodel

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 Yaron Walfish
+
+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.md

@@ -0,0 +1,85 @@
+# Method Cacher
+
+Wraps specified methods with a mechanism that caches the return values.
+
+__Features:__
+
++ Can cache both instance and singleton (i.e. class) methods.
++ Differentiates among calls to a method with different arguments.
++ Generates methods to provide access the original uncached methods.
++ Generates methods to clear the cache of each cached method.
++ To specify methods to be cached, just call `caches_method :foo, :bar ...` before or after the actual definition of `foo` and `bar`.
++ When used with Rails, it automatically uses the cache store configured in Rails.
+
+## Installation
+
+Add the `method_cacher` gem your Gemfile and run the `bundle` command to install it.
+
+```ruby
+gem 'method_cacher'
+```
+
+__Requires Ruby 1.9.2 or later.__
+
+## Configuration
+
+...
+
+## Usage
+
+Include the method cacher module in the class whose methods you wish to cache.
+
+```ruby
+include MethodCacher::Base
+```
+
+The module is included automatically for ActiveRecord when used in Rails.
+
+Call `cache_method` from within the class definition, listing the names of the methods that are to be cached.
+
+```ruby
+cache_method :instance_foo, :instance_bar, singleton: [:singleton_foo, :singleton_bar], obj_key: proc { |obj| obj.obj_key }
+```
+
+Instance methods are specified as symbol arguments.
+
+__Options:__
+
++ :singleton - Singleton methods to be cached are specified in an array of symbols passed through this option.
++ :obj\_key - A _proc_ that accepts the cached object as a single parameter.  This _proc_ should return a value identifying this object.
+    If this option is not specified, the object key defaults to the value returned by a method named _id_, which is convenient for usage
+    with ActiveRecord objects.
+
+`cache_method` can take any number of instance or singleton methods at once.
+
+Subsequent calls to `cache_method` are possible in order to specify additional methods to be cached.
+Specifying :obj\_id multiple times results in the last one being used for the class.
+
+`cache_method` can be called _before_ or _after_ the specified methods are defined.
+
+```ruby
+cache_method :foo # this works
+def foo
+...
+end
+
+def bar
+...
+end
+cache_method :bar # this also works
+```
+
+`cache_method` replaces each specified method with a cached version.
+
+The cached versions take the same arguments as the originals, with different arguments caching separately.
+
+Each of the original methods is made accessible through the alias `uncached_` followed by the method's name.
+E.g. if the method is `foo`, the original is aliased as `uncached_foo`.
+
+`cache_method` also adds methods to clear the cache of each cached method.
+These methods are named `clear_cache_for_` followed by the cached method's name.
+The clear cache methods take identical arguments as their respective original and cached methods, and only
+clear the cache for the given set of arguments.
+
+So for example, issuing `clear_cache_for_foo('a')`, would clear the cache for a call to `foo('a')`
+but not to `foo('b')`.

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/method_cacher.rb

@@ -0,0 +1,4 @@
+require "rubygems"
+require "method_cacher/version"
+require "method_cacher/base"
+require "method_cacher/railtie" if defined? Rails

data/lib/method_cacher/base.rb

@@ -0,0 +1,159 @@
+require 'active_support/concern'
+require 'active_support/core_ext'
+require 'set'
+
+module MethodCacher
+  # An object that holds configuration vars for MethodCacher
+  class Configuration
+    def caching_strategy= strategy
+      @caching_strategy = strategy
+    end
+
+    def caching_strategy
+      if @caching_strategy
+        @caching_strategy
+      elsif defined? Rails
+        Rails.cache  # default to the rails caching strategy if it's a Rails app
+      end
+    end
+  end
+
+  @@config = MethodCacher::Configuration.new
+  mattr_reader :config
+
+  # Gives a block configuration style like that of Rails.
+  def self.configure(&block)
+    if block_given?
+      if block.arity == 1
+        # allows this style config: MethodCacher.configure do |config| config.variable = ... end
+        yield config
+      else
+        # allows this style config: MethodCacher.configure do config.variable = ... end
+        # While this option is more elegant because it doesn't require a block variable, it loses access to
+        # methods defined in the calling context because the context switches to that of the self object.
+        instance_eval &block
+      end
+    end
+  end
+
+  module Base
+    extend ActiveSupport::Concern
+
+       # default object key proc
+    OBJECT_KEY_PROC_DEFAULT = lambda { |obj| obj.id }
+
+    module ClassMethods
+
+      attr_accessor :methods_to_be_cached, :cached_methods, :obj_key
+      attr_accessor :singleton_methods_to_be_cached, :singleton_cached_methods
+
+      def caches_method(*method_names)
+        initialize_variables
+
+        # process parameters
+        options = method_names.extract_options!
+
+        self.obj_key = options[:obj_key] || self.obj_key # if obj_key is given in the option, replace it with what's given
+        self.methods_to_be_cached += method_names
+        self.singleton_methods_to_be_cached += [options[:singleton]].flatten
+
+        # Cache all currently defined instance methods that are given in the parameters.
+        self.methods_to_be_cached.clone.each do |method_name|
+          add_cached_method(method_name) if (private_instance_methods + protected_instance_methods + public_instance_methods).include?(method_name)
+        end
+
+        # Cache all currently defined singleton methods given in the parameters.
+        self.singleton_methods_to_be_cached.clone.each do |method_name|
+          singleton_add_cached_method(method_name) if singleton_methods.include?(method_name)
+        end
+      end
+
+      # This callback adds caching to the methods that were not defined yet when caches_method was called.
+      def method_added(method_name)
+        super
+        initialize_variables
+        add_cached_method(method_name) if self.methods_to_be_cached.include?(method_name) #and  public_instance_methods.include?(method_name) # commented section is for testing the related spec
+      end
+
+      # Same as method_added but for singleton methods.
+      def singleton_method_added(method_name)
+        super
+        initialize_variables
+        singleton_add_cached_method(method_name) if self.singleton_methods_to_be_cached.include?(method_name)
+      end
+
+      private
+
+      # Initialize class instance variables for instance method caching.
+      def initialize_variables
+        self.obj_key ||= OBJECT_KEY_PROC_DEFAULT # identifies the object of this class, defaults to the object's id if defined
+
+        self.methods_to_be_cached ||= Set.new  # stores the names of the methods designated to be cached
+        self.cached_methods ||= Set.new # stores the methods that are cached
+
+        # initialize class instance variables for singleton method caching
+        self.singleton_methods_to_be_cached ||= Set.new  # stores the names of the methods designated to be cached
+        self.singleton_cached_methods ||= Set.new # stores the methods that are cached
+      end
+
+      # Creates the key used to cache a singleton method of the object.
+      def singleton_cached_method_key(method_name, *args)
+        [self.name, method_name, *args]
+      end
+
+      # Adds code to the class to cache the given instance method.
+      def add_cached_method(method_name)
+        self.methods_to_be_cached.delete(method_name)
+        self.cached_methods <<= method_name
+
+        # TODO: Make cached methods have the same accessibility (i.e. public/private/protected) as the original method.
+        class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+          alias :uncached_#{method_name} :#{method_name}
+          def #{method_name}(*args)
+            key = cached_method_key(:#{method_name}, *args)
+            key.nil? ? uncached_#{method_name}(*args) : MethodCacher.config.caching_strategy.fetch(key) { uncached_#{method_name}(*args) }  # cache only for non-nil keys
+          end
+
+          def clear_cache_for_#{method_name}(*args)
+            MethodCacher.config.caching_strategy.delete(cached_method_key(:#{method_name}, *args))
+          end
+        END_EVAL
+      end
+
+      # Adds code to the class to cache the given singleton method.
+      def singleton_add_cached_method(method_name)
+        self.singleton_methods_to_be_cached.delete(method_name)
+        self.singleton_cached_methods <<= method_name
+        class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+          class <<self
+            alias :uncached_#{method_name} :#{method_name}
+            def #{method_name}(*args)
+              MethodCacher.config.caching_strategy.fetch(singleton_cached_method_key(:#{method_name}, *args)) { uncached_#{method_name}(*args) }
+            end
+
+            def clear_cache_for_#{method_name}(*args)
+              MethodCacher.config.caching_strategy.delete(singleton_cached_method_key(:#{method_name}, *args))
+            end
+          end
+        END_EVAL
+      end
+
+    end
+
+    module InstanceMethods
+
+      # A helper that clears the cache for all the cached methods of this object that are argument-less.
+      def clear_method_cache
+        self.class.cached_methods.each { |method_name| MethodCacher.config.caching_strategy.delete(cached_method_key(method_name)) }
+      end
+
+      private
+
+      # Creates the key used to cache a method of the object.
+      def cached_method_key(method_name, *args)
+        obj_key = self.class.obj_key.call(self)
+        [self.class.name, obj_key, method_name, *args]
+      end
+    end
+  end
+end

data/lib/method_cacher/railtie.rb

@@ -0,0 +1,10 @@
+module MethodCacher
+  class Railtie < Rails::Railtie
+    initializer 'methodcacher.model_additions' do
+      ActiveSupport.on_load :active_record do
+        include Base
+      end
+    end
+  end
+end
+

data/lib/method_cacher/version.rb

@@ -0,0 +1,3 @@
+module MethodCacher
+  VERSION = '0.0.1'
+end

data/method_cacher.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)  # $: is the load path
+require 'method_cacher/version'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Yaron Walfish"]
+  gem.email         = ["yaronw@yaronw.com"]
+  gem.description   = %q{Caches Instance and Singleton Methods}
+  gem.summary       = %q{Wraps specified instance and singleton methods with the Rails caching mechanism.}
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "method_cacher"
+  gem.require_paths = ["lib"]
+  gem.version       = MethodCacher::VERSION
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'supermodel'
+  gem.add_development_dependency 'activesupport'
+  gem.add_development_dependency 'ruby-debug19'
+end

data/spec/method_cacher/base_spec.rb

@@ -0,0 +1,276 @@
+require 'spec_helper'
+require 'active_support/cache'
+require 'method_cacher/base_test_helper'
+
+describe MethodCacher::Configuration do
+  describe "yield style configuration" do
+    it "should assign configuration variables" do
+      MethodCacher.configure do |c|
+        c.caching_strategy = "test1"
+      end
+
+      MethodCacher.config.caching_strategy.should == "test1"
+    end
+  end
+
+  describe "eval style configuration" do
+    it "should assign configuration variables" do
+      MethodCacher.configure do
+        config.caching_strategy = "test2"
+      end
+
+      MethodCacher.config.caching_strategy.should == "test2"
+    end
+  end
+end
+
+describe MethodCacher::Base do
+  before (:all) do
+    MethodCacher.configure do
+      config.caching_strategy = ActiveSupport::Cache.lookup_store(:memory_store)
+    end
+  end
+
+  describe "#caches_method" do
+    context "when specified BEFORE the declaration of the methods to be cached" do
+      it "should cache the INSTANCE method associated with the names given in the arguments" do
+        obj = FirstClass.new
+        [:foo1, :foo2].each do |name|
+          lambda { obj.send(name) }.should be_twice_the_same # verify that original function is not called twice
+          obj.send(name).should == Dummy.current_value # verify that the right value is actually cached
+        end
+      end
+
+      it "should not cache INSTANCE methods whose names are not given in the arguments" do
+        obj = FirstClass.new
+        lambda { obj.foo3 }.should_not be_twice_the_same
+      end
+
+      it "should cache the SINGLETON methods associated with the names given in the :singleton option array" do
+        [:bar1, :bar2].each do |name|
+          lambda { FirstClass.send(name) }.should be_twice_the_same
+          FirstClass.send(name).should == Dummy.current_value
+        end
+      end
+
+      it "should not cache SINGLETON methods whose names are not given in the :singleton option" do
+        lambda { FirstClass.bar3 }.should_not be_twice_the_same
+      end
+
+      it "should cache INSTANCE methods given in separate calls" do
+        (1..4).to_a.collect { |x| :"foo#{x}" }.each do |name|
+          obj = SeventhClass.new
+          lambda { obj.send(name) }.should be_twice_the_same
+        end
+      end
+
+      it "should cache SINGLETON methods given in separate calls" do
+        (1..4).to_a.collect { |x| :"bar#{x}" }.each do |name|
+          lambda { SeventhClass.send(name) }.should be_twice_the_same
+        end
+      end
+
+      it "should cache protected INSTANCE methods" do
+        obj = EighthClass.new
+        debugger
+        lambda { obj.send(:foo1) }.should be_twice_the_same
+      end
+
+      it "should cache private INSTANCE methods" do
+        obj = EighthClass.new
+        lambda { obj.send(:foo3) }.should be_twice_the_same
+      end
+    end
+
+    context "when specified AFTER the declaration of the methods to be cached" do
+      it "should cache the INSTANCE method associated with the names given in the arguments" do
+        obj = SecondClass.new
+        [:foo1, :foo2].each do |name|
+          lambda { obj.send(name) }.should be_twice_the_same
+          obj.send(name).should == Dummy.current_value
+        end
+      end
+
+      it "should not cache INSTANCE methods whose names are not given in the arguments" do
+        obj = SecondClass.new
+        lambda { obj.foo3 }.should_not be_twice_the_same
+      end
+
+      it "should cache the SINGLETON methods associated with the names given in the :singleton option array" do
+        [:bar1, :bar2].each do |name|
+          lambda { SecondClass.send(name) }.should be_twice_the_same
+          SecondClass.send(name).should == Dummy.current_value
+        end
+      end
+
+      it "should not cache SINGLETON methods whose names are not given in the :singleton option" do
+        lambda { SecondClass.bar3 }.should_not be_twice_the_same
+      end
+
+      it "should cache INSTANCE methods given in separate calls" do
+        (5..8).to_a.collect { |x| :"foo#{x}" }.each do |name|
+          obj = SeventhClass.new
+          lambda { obj.send(name) }.should be_twice_the_same
+        end
+      end
+
+      it "should cache SINGLETON methods given in separate calls" do
+        (5..8).to_a.collect { |x| :"bar#{x}" }.each do |name|
+          lambda { SeventhClass.send(name) }.should be_twice_the_same
+        end
+      end
+
+      it "should cache protected INSTANCE methods" do
+        obj = EighthClass.new
+        lambda { obj.send(:foo2) }.should be_twice_the_same
+      end
+
+      it "should cache private INSTANCE methods" do
+        obj = EighthClass.new
+        lambda { obj.send(:foo4) }.should be_twice_the_same
+      end
+    end
+
+    describe "cache key mechanism for INSTANCE methods" do
+      context "when caching an INSTANCE method of one object" do
+        it "should have different sets of arguments cache separately" do
+          obj = FirstClass.new
+          lambda { obj.foo1(1,2) }.should be_twice_the_same
+          lambda { obj.foo1(1,3) }.should be_twice_the_same
+          obj.foo1(1,3).should_not == obj.foo1(1,2)
+        end
+      end
+
+      context "when caching the same INSTANCE method with identical parameter sets and of the same class" do
+        it "should have objects whose :obj_key proc evaluates differently cache separately" do
+          obj1 = ThirdClass.new
+          obj1.obj_key = 1
+          obj2 = ThirdClass.new
+          obj2.obj_key = 2
+
+          obj1.foo # cache methods
+          obj2.foo
+
+          obj2.foo.should_not == obj1.foo
+        end
+
+        it "should have objects whose :obj_key proc evaluates the same cache one value" do
+          obj1 = ThirdClass.new
+          obj1.obj_key = 1
+          obj2 = ThirdClass.new
+          obj2.obj_key = 1
+
+          obj1.foo # cache methods
+          obj2.foo
+
+          obj2.foo.should == obj1.foo
+        end
+      end
+
+      context "when caching INSTANCE methods of identical names with identical parameter sets, and identical :obj_key proc values" do
+        it "should have different classes cache separately" do
+          obj1 = ThirdClass.new
+          obj1.obj_key = 1
+          obj2 = FourthClass.new
+          obj2.obj_key = 1
+
+          obj1.foo # cache methods
+          obj2.foo
+
+          obj2.foo.should_not == obj1.foo
+        end
+      end
+
+      it "should default the :obj_key option to the instance method named 'id'" do
+        # test that the :obj_key mechanism is working for the default 'id' class
+        obj1 = FifthClass.new
+        obj1.id = 1
+        obj2 = FifthClass.new
+        obj2.id = 2
+
+        obj1.foo # cache methods
+        obj2.foo
+
+        obj2.foo.should_not == obj1.foo
+      end
+
+      it "should raise an exception if neither an :obj_key option is given nor the default fallback :id method is defined" do
+        obj = SixthClass.new
+        lambda { obj.foo }.should raise_error(NoMethodError)
+      end
+    end
+
+    describe "cache key mechanism for SINGLETON methods" do
+      context "when caching a SINGLETON method of one class" do
+        it "should have different sets of arguments cache separately" do
+          lambda { FirstClass.bar1(1,2) }.should be_twice_the_same
+          lambda { FirstClass.bar1(1,3) }.should be_twice_the_same
+          FirstClass.bar1(1,3).should_not == FirstClass.bar1(1,2)
+        end
+      end
+
+      context "when caching SINGLETON methods of identical names with identical parameter sets" do
+        it "should have different classes cache separately" do
+          ThirdClass.bar # cache methods
+          FourthClass.bar
+
+          FourthClass.bar.should_not == ThirdClass.bar
+        end
+      end
+    end
+
+    describe "dynamic methods creation" do
+      context "when caching an INSTANCE method" do
+        it "should include a method named uncached_[name of original method] that calls the original uncached method" do
+          obj = FirstClass.new
+
+          # works for methods without arguments
+          lambda { obj.uncached_foo1 }.should_not be_twice_the_same # uncached function should not cache      # for testing this assertion: def uncached_#{method_name} \n rand 1000000000 \n end
+          obj.uncached_foo1.should == Dummy.current_value  # uncached function should call original method    # for testing this assertion: def uncached_#{method_name} \n 1 \n end
+
+          # works for methods with arguments
+          lambda { obj.uncached_foo1(1,2) }.should_not be_twice_the_same # uncached function should not cache
+          obj.uncached_foo1(1,2).should == Dummy.current_value(1,2)  # uncached function should call original method
+        end
+
+        it "should include a method named clear_cache_for_[name of original method] that clears the cache for a specific method with specific arguments" do
+          obj = FirstClass.new
+
+          # works for methods without arguments
+          val = obj.foo1
+          obj.clear_cache_for_foo1
+          obj.foo1.should_not == val
+
+          # works for methods with arguments
+          val = obj.foo1(1,2)
+          obj.clear_cache_for_foo1(1,2)
+          obj.foo1(1,2).should_not == val
+        end
+      end
+
+      context "when caching a SINGLETON method" do
+        it "should include a method that calls the original uncached method" do
+          # works for methods without arguments
+          lambda { FirstClass.uncached_bar1 }.should_not be_twice_the_same # should not cache
+          FirstClass.uncached_bar1.should == Dummy.current_value  # uncached function should call original method
+
+          # works for methods with arguments
+          lambda { FirstClass.uncached_bar1(1,2) }.should_not be_twice_the_same # should not cache
+          FirstClass.uncached_bar1(1,2).should == Dummy.current_value(1,2)  # uncached function should call original method
+        end
+
+        it "should include a method named clear_cache_for_[name of original method] that clears the cache for a specific method with specific arguments" do
+          # works for methods without arguments
+          val = FirstClass.bar1
+          FirstClass.clear_cache_for_bar1
+          FirstClass.bar1.should_not == val
+
+          # works for methods with arguments
+          val = FirstClass.bar1(1,2)
+          FirstClass.clear_cache_for_bar1(1,2)
+          FirstClass.bar1(1,2).should_not == val
+        end
+      end
+    end
+  end
+end

data/spec/method_cacher/base_test_helper.rb

@@ -0,0 +1,264 @@
+# Provides a function that returns a different value with each call and also bases the return value on the arguments given.
+module Dummy
+  @@counter = 0
+  def self.function(*args)
+    @@counter += 1
+    current_value(*args)
+  end
+
+  # returns the current value of function without changin it
+  def self.current_value(*args)
+    "#{@@counter} #{args}"
+  end
+end
+
+# for testing method caching when caches_method is called before the methods are defined
+class FirstClass
+  include MethodCacher::Base
+
+  def id
+    object_id
+  end
+
+  caches_method :foo1, :foo2, singleton: [:bar1, :bar2]  #, :obj_key => proc { |s| s.object_id }
+  # test instance methods.
+  def foo1(*args)
+    Dummy.function(*args)
+  end
+
+  def foo2(*args)
+    Dummy.function(*args)
+  end
+
+  def foo3(*args)
+    Dummy.function(*args)
+  end
+
+  class <<self
+    # test singleton (i.e. class) methods.
+    def bar1(*args)
+      Dummy.function(*args)
+    end
+
+    def bar2(*args)
+      Dummy.function(*args)
+    end
+
+    def bar3(*args)
+      Dummy.function(*args)
+    end
+  end
+end
+
+# for testing method caching when caches_method is called after the methods are defined
+class SecondClass
+  include MethodCacher::Base
+
+  def id
+    object_id
+  end
+
+  # test instance methods.
+  def foo1
+    Dummy.function
+  end
+
+  def foo2
+    Dummy.function
+  end
+
+  def foo3
+    Dummy.function
+  end
+
+  class <<self
+    # test singleton (i.e. class) methods.
+    def bar1
+      Dummy.function
+    end
+
+    def bar2
+      Dummy.function
+    end
+
+    def bar3
+      Dummy.function
+    end
+  end
+
+  caches_method :foo1, :foo2, singleton: [:bar1, :bar2]
+end
+
+# for testing :obj_key option and cache differentiation
+class ThirdClass
+  include  MethodCacher::Base
+
+  attr_accessor :obj_key
+
+  caches_method :foo, singleton: :bar, obj_key: proc { |obj| obj.obj_key }
+
+  def foo
+    Dummy.function
+  end
+
+  def self.bar
+    Dummy.function
+  end
+end
+
+# same as previous class
+class FourthClass
+  include  MethodCacher::Base
+
+  attr_accessor :obj_key
+
+  caches_method :foo, singleton: :bar, obj_key: proc { |obj| obj.obj_key }
+
+  def foo
+    Dummy.function
+  end
+
+  def self.bar
+    Dummy.function
+  end
+end
+
+# for testing :obj_key option default
+class FifthClass
+  include  MethodCacher::Base
+
+  attr_accessor :id
+
+  caches_method :foo
+
+  def foo
+    Dummy.function
+  end
+end
+
+# for testing when the :obj_key option is undefined and the default id method is missing
+class SixthClass
+  include  MethodCacher::Base
+
+  caches_method :foo
+
+  def foo
+    Dummy.function
+  end
+end
+
+# for testing adding methods to be cached using separate caches_method calls
+class SeventhClass
+  include MethodCacher::Base
+
+  def id
+    object_id
+  end
+
+  caches_method :foo1, singleton: :bar1
+  caches_method :foo2, singleton: :bar2
+  caches_method :foo3, :foo4, singleton: [:bar3, :bar4]
+
+  # test instance methods.
+  def foo1
+    Dummy.function
+  end
+
+  def foo2
+    Dummy.function
+  end
+
+  def foo3
+    Dummy.function
+  end
+
+  def foo4
+    Dummy.function
+  end
+
+  def foo5
+    Dummy.function
+  end
+
+  def foo6
+    Dummy.function
+  end
+
+  def foo7
+    Dummy.function
+  end
+
+  def foo8
+    Dummy.function
+  end
+
+  class <<self
+    # test singleton (i.e. class) methods.
+    def bar1
+      Dummy.function
+    end
+
+    def bar2
+      Dummy.function
+    end
+
+    def bar3
+      Dummy.function
+    end
+
+    def bar4
+      Dummy.function
+    end
+
+    def bar5
+      Dummy.function
+    end
+
+    def bar6
+      Dummy.function
+    end
+
+    def bar7
+      Dummy.function
+    end
+
+    def bar8
+      Dummy.function
+    end
+  end
+
+  caches_method :foo5, singleton: :bar5
+  caches_method :foo6, singleton: :bar6
+  caches_method :foo7, :foo8, singleton: [:bar7, :bar8]
+end
+
+# for testing caching of private and protected instance methods
+class EighthClass
+  include MethodCacher::Base
+
+  def id
+    object_id
+  end
+
+  caches_method :foo1, :foo3
+
+  protected
+  def foo1
+    Dummy.function
+  end
+
+  def foo2
+    Dummy.function
+  end
+
+  private
+  def foo3
+    Dummy.function
+  end
+
+  def foo4
+    Dummy.function
+  end
+
+  #caches_method :foo2, :foo4
+end

data/spec/rspec_matchers.rb

@@ -0,0 +1,14 @@
+RSpec::Matchers.define :be_twice_the_same do |options|
+  match do |proc|
+    cached = proc.call
+    proc.call == cached
+  end
+
+  failure_message_for_should do |proc|
+    "expected #{proc} to return the same value when called twice"
+  end
+
+  failure_message_for_should_not do |proc|
+    "expected #{proc} to return two different values when called twice"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$:.push File.expand_path(".", __FILE__)  # $: is the load path
+require 'method_cacher'
+require 'rspec_matchers'
+require 'ruby-debug'

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: method_cacher
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Yaron Walfish
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2156410720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156410720
+- !ruby/object:Gem::Dependency
+  name: supermodel
+  requirement: &2156410000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156410000
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2156408920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156408920
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &2156408100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156408100
+description: Caches Instance and Singleton Methods
+email:
+- yaronw@yaronw.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/method_cacher.rb
+- lib/method_cacher/base.rb
+- lib/method_cacher/railtie.rb
+- lib/method_cacher/version.rb
+- method_cacher.gemspec
+- spec/method_cacher/base_spec.rb
+- spec/method_cacher/base_test_helper.rb
+- spec/method_cacher_spec.rb
+- spec/rspec_matchers.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Wraps specified instance and singleton methods with the Rails caching mechanism.
+test_files:
+- spec/method_cacher/base_spec.rb
+- spec/method_cacher/base_test_helper.rb
+- spec/method_cacher_spec.rb
+- spec/rspec_matchers.rb
+- spec/spec_helper.rb