cacheify 0.1.0 → 0.2.0

data/README.rdoc

@@ -1,10 +1,10 @@
 = Cacheify
 
-Simple caching of methods calls.
+Easy caching of methods calls.
 
-Cacheify uses ActiveSupport::Cache::Store to perform caching so, depending on
-what you choose, it may cache to memory, disk, memcache or
-whatever is supported by the cache store.
+Cacheify uses ActiveSupport::Cache::Store to do caching so, depending on
+what you choose, it may cache to memory, disk, memcache or whatever is 
+supported by the cache store.
 
 == Installation
 
@@ -17,23 +17,33 @@ Mixin the Cacheify module, use the +cacheify+ method.
   require 'cacheify'
   
   class Foo
-    include Cacheify
-    cacheify :bar, :expires_in => 1.hour
-    
     def bar
     end
+
+    include Cacheify
+    cacheify :bar, :expires_in => 1.hour
   end
 
 And you're +foo+ instance calls to +bar+ will get cached.
 
   Foo.new.bar # will hit cache if cached, or get cached otherwise
 
-To enable cacheify on existing class just +extend+:
+Caveat: You have to call +cacheify+ *after* defining +bar+.
+
+To enable cacheify on the existing class just +extend+:
 
   Thing.extend Cacheify
   Thing.caches :very_expensive_operation
 
-If you use Cacheify <b>a lot</b>, you may even do:
+To cache a method on a specific object:
+  
+  boo = Thing.new
+  boo.extend Cacheify
+  boo.caches :very_expensive_operation
+
+And only that instance of +Thing+ will have its +very_expensive_operation+ cached.
+
+If you use Cacheify <b>a lot</b>, you may do:
 
   Object.extend Cacheify
 
@@ -50,7 +60,7 @@ The arguments are the same as in ActiveSupport::Cache#lookup_store[http://api.ru
 == More info
 
 * ActiveSupport::Cache[http://api.rubyonrails.org/classes/ActiveSupport/Cache.html] is what's used for caching
-* Why cacheify? {Introductory blog post}[http://blog.hakeraj.com].
+* Why cacheify? {Introductory blog post}[http://blog.hakeraj.com/easy-caching-of-methods-with-cacheify].
 
 == Note on Patches/Pull Requests
  

data/Rakefile

@@ -9,7 +9,7 @@ begin
     gem.description = %Q{Cacheify can cache method calls to memory, disk, memcache or whatever is supported by the ActiveSupport::Cache::Store.}
     gem.email = "sasa@hakeraj.com"
     gem.homepage = "http://github.com/fox/cacheify"
-    gem.authors = ["Saša_Branković"]
+    gem.authors = ["Saša Branković"]
     gem.add_development_dependency "rspec", ">= 1.2.9"
     gem.add_dependency "activesupport"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/cacheify.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cacheify}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Sa\305\241a_Brankovi\304\207"]
-  s.date = %q{2010-03-12}
+  s.authors = ["Sa\305\241a Brankovi\304\207"]
+  s.date = %q{2010-03-16}
   s.description = %q{Cacheify can cache method calls to memory, disk, memcache or whatever is supported by the ActiveSupport::Cache::Store.}
   s.email = %q{sasa@hakeraj.com}
   s.extra_rdoc_files = [

data/lib/cacheify.rb

@@ -30,20 +30,25 @@ module Cacheify
   # === Example
   # cache_method :big_calculation, :expires_in => 5.minutes
   def cacheify(*symbols)
-    options = symbols.extract_options!
+    (self.is_a?(Class) ? self : metaclass).class_eval do
+      options = symbols.extract_options!
 
-    symbols.each do |method|
-      non_cached_method = "_non_cached_#{method}".to_sym 
-      return if respond_to? non_cached_method # cached already, skip it
-      
-      alias_method non_cached_method, method
-      
-      define_method(method) do |*args, &block|
-        cache_name = Digest::MD5.hexdigest(args.inspect)
-        marshalled_result = Cacheify.cache.fetch(cache_name, options) do 
-          send(non_cached_method, *args, &block)
+      symbols.each do |method|
+        non_cached_method = "_non_cached_#{method}".to_sym 
+        return if method_defined?(non_cached_method) # cached already, skip it
+        alias_method non_cached_method, method
+        
+        define_method(method) do |*args, &block|
+          cache_name = Digest::MD5.hexdigest "#{self.class.name}#{method}#{args.inspect}"
+          marshalled_result = Cacheify.cache.fetch(cache_name, options) do 
+            send(non_cached_method, *args, &block)
+          end
         end
       end
     end
   end
+
+  def self.included(obj)
+    obj.extend Cacheify
+  end
 end

data/spec/cacheify_spec.rb

@@ -1,28 +1,70 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-# Example class we'll use in specs
+# Example classes we'll use in specs
+
 class Foo 
   def bar(something = nil)
     "#{rand(99999999)}#{something}"
   end
+  
+  def rab(something = nil)
+    "#{rand(99999999)}#{something}"
+  end
+end
+
+class Hoo
+  def bar(something = nil)
+    "#{rand(99999999)}#{something}"
+  end
+end
+
+class Baz
+  def boo
+    "#{rand(99999999)}"
+  end
 end
 
 describe "Cacheify" do
   before :all do
     Foo.extend Cacheify
-    Foo.cacheify :bar
+    Hoo.extend Cacheify 
+
+    Foo.cacheify :bar, :rab
+    Hoo.cacheify :bar
+
+    foo = Foo.new
+    hoo = Hoo.new
     
-    @foo = Foo.new
-    @first_call = @foo.bar("hello")
+    @foo_bar_1_call = foo.bar("hello")
+    @foo_bar_2_call = foo.bar("hello")
+    @foo_bar_diff_args_1_call = foo.bar("howdy")
+    @foo_rab_1_call = foo.rab("hello")
+    @hoo_bar_1_call = hoo.bar("hello")
+    @hoo_bar_2_call = hoo.bar("hello")
   end
 
-  context "calling method twice on a cachified object" do
+  it "should return cached result second time" do
+    @foo_bar_1_call.should == @foo_bar_2_call
+  end
+  
+  specify "cache should be scoped to class, method name and args" do
+    @hoo_bar_1_call.should_not == @foo_bar_1_call
+    @foo_rab_1_call.should_not == @foo_bar_1_call
+    @foo_bar_diff_args_1_call.should_not == @foo_bar_1_call
+    # @hoo_bar_1_call.should == @hoo_bar_2_call
+  end
+
+  context "Caching of instantiated object" do
     before do
-      @second_call = @foo.bar("hello")
+      baz = Baz.new
+      baz.extend Cacheify
+      baz.cacheify :boo
+      @baz_boo_1_call = baz.boo
+      @baz_boo_2_call = baz.boo
     end
-    
-    it "should return cached result second time" do
-      @first_call.should == @second_call
+
+    it do
+      @baz_boo_1_call.should == @baz_boo_2_call
     end
   end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,10 @@ require 'cacheify'
 require 'spec'
 require 'spec/autorun'
 
+
+Cacheify.cache_store = :memory_store
+
+
 Spec::Runner.configure do |config|
   
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: cacheify
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
-- "Sa\xC5\xA1a_Brankovi\xC4\x87"
+- "Sa\xC5\xA1a Brankovi\xC4\x87"
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-03-12 00:00:00 +01:00
+date: 2010-03-16 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency