method_cacheable 0.0.3 → 0.0.4

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/lib/method_cacheable.rb

@@ -87,55 +87,95 @@ module MethodCacheable
   end
 
   class MethodCache
-    attr_accessor :caller_object, :method, :args, :options, :cache_operation
-
-    def initialize(caller_object, *method_cache_args)
-      cache_operation      = method_cache_args.map {|x| x if x.is_a? Symbol }.compact.first
-      options           = method_cache_args.map {|x| x if x.is_a? Hash   }.compact.first
-      self.cache_operation = cache_operation||:fetch
-      self.options      = options
-      self.caller_object       = caller_object
+    attr_accessor :caller, :method, :args, :options, :cache_operation
+
+    def initialize(caller, *method_cache_args)
+      self.caller          = caller
+      self.cache_operation = method_cache_args.map {|x| x if x.is_a? Symbol }.compact.first||:fetch
+      self.options         = method_cache_args.map {|x| x if x.is_a? Hash   }.compact.first
+    end
+
+    # Calls the cache based on the given cache_operation
+    # @param [Hash] options Options are passed to the cache store
+    # @see http://api.rubyonrails.org/classes/ActionController/Caching.html#method-i-cache Rails.cache documentation
+    def call
+      case cache_operation
+      when :fetch
+        MethodCacheable.store.fetch(key, options) do
+          send_to_caller
+        end
+      when :read
+        read(method, args)
+      when :write
+        write(method, args) do
+          send_to_caller
+        end
+      end
+    end
+
+    def send_to_caller
+      caller.send method.to_sym, *args
+    end
+
+    def write(method, *args, &block)
+      val = block.call
+      MethodCacheable.store.write(key, val, options)
+    end
+
+    def read(method, *args)
+      MethodCacheable.store.read(key, options)
+    end
+
+    def for(method , *args)
+      self.method = method
+      self.args   = args
+      self
     end
 
     # Uses keytar to create a key based on the method and caller if no method_key exits
     # @see http://github.com/schneems/keytar Keytar, it builds keys
+    #
+    # Method and arguement can optionally be supplied
+    #
     # @return the key used to set the cache
     # @example
     #   cache = User.find(263619).cache   # => #<MethodCacheable::MethodCache ... >
     #   cache.method = "foo"              # => "foo"
     #   cache.key                         # => "users:foo:263619"
-    def key
-      key_method = "#{method}_key".to_sym
-      key = caller_object.send key_method, *args if caller_object.respond_to? key_method
-      key ||= caller_object.build_key(:name => method, :args => args)
+    def key(tmp_method = nil, *tmp_args)
+      tmp_method  ||= method
+      tmp_args    ||= args
+      key_method = "#{tmp_method}_key".to_sym
+      key = caller.send key_method, *tmp_args if caller.respond_to? key_method
+      key ||= caller.build_key(:name => tmp_method, :args => tmp_args)
     end
 
-    # Calls the cache based on the given cache_operation
-    # @param [Hash] options Options are passed to the cache store
-    # @see http://api.rubyonrails.org/classes/ActionController/Caching.html#method-i-cache Rails.cache documentation
-    def call_cache_operation(options = {})
-      if cache_operation == :fetch
-        MethodCacheable.store.fetch(key, options) do
-          caller_object.send method.to_sym, *args
-        end
-      elsif cache_operation == :read
-        MethodCacheable.store.read(key, options)
-      elsif cache_operation == :write
-        val = caller_object.send method.to_sym, *args
-        MethodCacheable.store.write(key, val, options)
-      end
+    # Removes the current key from the cache store
+    def delete(method, *args)
+      self.method = method
+      self.args   = args
+      MethodCacheable.store.delete(key, options)
+    end
+
+    # Checks to see if the key exists in the cache store
+    # @return [boolean]
+    def exist?(method, *args)
+      self.method = method
+      self.args   = args
+      MethodCacheable.store.exist?(key)
     end
+    alias :exists? :exist?
 
-    # Methods caught by method_missing are passed to the caller_object and used to :write, :read, or :fetch from the cache
+    # Methods caught by method_missing are passed to the caller and used to :write, :read, or :fetch from the cache
     #
     # @see MethodCacheable#cache
     def method_missing(method, *args, &blk)
-      if caller_object.respond_to? method
-        self.method = method
-        self.args = args
-        call_cache_operation(options)
+      self.method = method
+      self.args   = args
+      if caller.respond_to? method
+        call
       else
-        super
+        send_to_caller
       end
     end
   end

data/method_cacheable.gemspec

@@ -5,15 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = "method_cacheable"
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Schneems"]
-  s.date = "2011-12-12"
+  s.date = "2011-12-29"
   s.description = "\n    Cache methods quickly and easily\n  "
   s.email = "richard.schneeman@gmail.com"
   s.files = [
-    ".rvmrc",
     ".yardoc/checksums",
     ".yardoc/objects/root.dat",
     ".yardoc/proxy_types",

data/readme.md

@@ -5,6 +5,9 @@ Cache method calls and speed up your Ruby on Rails application with MethodCachea
 Method Cacheable
 ============
 
+In your Model include `MethodCacheable`
+
+app/models/user.rb
 ``` ruby
   class User < ActiveRecord::Base
     include MethodCacheable
@@ -16,7 +19,11 @@ Method Cacheable
       return val
     end
   end
+```
+
+Then use the `#cache` method to fetch results from cache when available
 
+```
   user = User.last
 
   # Call User#expensive_method normally
@@ -45,6 +52,15 @@ in your Gemfile
 
     gem 'method_cacheable'
 
+In an initializer tell MethodCacheable to use the Rails.cache backend. You can use any object here that responds to `#write`, `#read`, and `#fetch`
+
+initializers/method_cacheable.rb
+```ruby
+  MethodCacheable.config do |config|
+    config.store = Rails.cache
+  end
+```
+
 then in your models
 
     include MethodCacheable
@@ -105,4 +121,8 @@ Fork away. If you want to chat about a feature idea, or a question you can find
 
 licensed under MIT License
 Copyright (c) 2011 Schneems. See LICENSE.txt for
-further details.
+further details.
+
+
+
+

data/spec/method_cacheable/method_cache_spec.rb

@@ -2,36 +2,70 @@ require 'spec_helper'
 
 
 describe MethodCacheable::MethodCache do
-  before(:all) do
-    @user = User.new
-  end
 
   before(:each) do
     @uniq ||= 0
     @uniq += 1
   end
 
+  let(:user) { User.new }
+
+  describe 'write & read' do
+    it 'lets us write & read arbitrary items to the cache' do
+      symbol           = :arbitrary_entry
+      arbitrary_string = "whatever"
+      user.cache.write(symbol) {arbitrary_string}
+      user.cache.read(symbol).should == arbitrary_string
+    end
+
+  end
+
+  describe 'key' do
+    it 'returns the key' do
+      user.cache.key(:foo).should == "users:foo:#{user.id}"
+    end
+  end
+
+  describe 'exists?' do
+    it 'returns false if the object has not been cached' do
+      user.cache.exist?(:new_method).should be_false
+    end
+
+    it 'returns true if the object has been cached' do
+      user.cache(:write).foo
+      user.cache.exist?(:foo).should be_true
+    end
+  end
+
+  describe 'delete' do
+    it 'sends delete to underlying cache object' do
+      user.cache.delete(:foo)
+      user.cache.exist?(:foo).should be_false
+    end
+  end
+
+
   describe 'initialize' do
     it 'saves caller' do
-      @user.cache.caller_object.should eq(@user)
+      user.cache.caller.should == user
     end
 
     it 'saves cache_method' do
       cache_method = :fetch
-      @user.cache(cache_method).cache_operation.should eq(cache_method)
+      user.cache(cache_method).cache_operation.should == cache_method
     end
 
     it 'saves options' do
       options = {:foo => "bar"}
-      @user.cache(options).options.should eq(options)
+      user.cache(options).options.should == options
     end
 
     it 'saves options and cache_method' do
       cache_method = :write
       options = {:foo => "bar"}
-      cache = @user.cache(cache_method, options)
-      cache.options.should      eq(options)
-      cache.cache_operation.should eq(cache_method)
+      cache = user.cache(cache_method, options)
+      cache.options.should         == options
+      cache.cache_operation.should == cache_method
     end
   end
 end

data/spec/method_cacheable_spec.rb

@@ -2,8 +2,9 @@ require 'spec_helper'
 
 
 describe MethodCacheable do
+  let(:user) { User.new }
+
   before(:each) do
-    @user = User.new
     @uniq ||= 0
     @uniq += 1
   end
@@ -12,41 +13,41 @@ describe MethodCacheable do
     describe 'calling a cached method' do
       describe 'fetch' do
         it 'should return the result of the normal method' do
-          @user.cache.foo(@uniq).should == @user.foo(@uniq)
+          user.cache.foo(@uniq).should == user.foo(@uniq)
         end
 
         it 'should bypass the normal method if the cache is written' do
-          @user.cache(:write).foo(@uniq)
-          @user.should_not_receive(:foo)
-          @user.cache(:fetch).foo(@uniq)
+          user.cache(:write).foo(@uniq)
+          user.should_not_receive(:foo)
+          user.cache(:fetch).foo(@uniq)
         end
 
         it 'should bypass the normal method if the cache has been fetched before' do
-          @user.cache(:fetch).foo(@uniq)
-          @user.should_not_receive(:foo)
-          @user.cache(:fetch).foo(@uniq)
+          user.cache(:fetch).foo(@uniq)
+          user.should_not_receive(:foo)
+          user.cache(:fetch).foo(@uniq)
         end
 
         it 'should call the normal method if the cache has been not fetched before' do
-          @user.should_receive(:foo)
-          @user.cache(:fetch).foo(@uniq)
+          user.should_receive(:foo)
+          user.cache(:fetch).foo(@uniq)
         end
 
         it 'should call the normal method if the cache has been not fetched before' do
-          @user.should_receive(:foo)
-          @user.cache.foo(@uniq)
+          user.should_receive(:foo)
+          user.cache.foo(@uniq)
         end
 
       end
 
       describe 'read' do
         it 'read should return nil if cache has not been set yet' do
-          @user.cache(:read).foo(@uniq).should eq(nil)
+          user.cache(:read).foo(@uniq).should == nil
         end
 
         it 'read should return value if cache has been set' do
-          result = @user.cache.foo(@uniq)
-          @user.cache(:read).foo(@uniq).should eq(result)
+          result = user.cache.foo(@uniq)
+          user.cache(:read).foo(@uniq).should == result
         end
       end
     end

data/spec/spec_helper.rb

@@ -10,21 +10,36 @@ class Rails
     self
   end
 
-  def self.fetch(key, options, &block)
+  # not quite the same as deleting but it will do
+  def self.delete(key, options = {})
+    eval("@#{key.gsub(':', '_')} = nil")
+  end
+
+  def self.exist?(key)
+    !eval("@#{key.gsub(':', '_')}").nil?
+  end
+
+  def self.fetch(key, options = {}, &block)
     eval("@#{key.gsub(':', '_')} ||= block.call")
   end
 
-  def self.write(key, val, options, &block)
+  def self.write(key, val, options = {}, &block)
     eval("@#{key.gsub(':', '_')} = val")
   end
 
-  def self.read(key, options)
+  def self.read(key, options = {})
     eval("@#{key.gsub(':', '_')}")
   end
 end
 
-
 require 'method_cacheable'
+
+
+MethodCacheable.config do |config|
+  config.store = Rails.cache
+end
+
+
 class User
   include MethodCacheable
   define_keys :foo

metadata

@@ -1,162 +1,121 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: method_cacheable
-version: !ruby/object:Gem::Version 
-  hash: 25
+version: !ruby/object:Gem::Version
+  version: 0.0.4
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 3
-  version: 0.0.3
 platform: ruby
-authors: 
+authors:
 - Schneems
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-12-12 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+date: 2011-12-29 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activesupport
-  prerelease: false
-  type: :runtime
-  requirement: *id001
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  requirement: &70212263196980 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  name: keytar
-  prerelease: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  requirement: *id002
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  prerelease: false
+  version_requirements: *70212263196980
+- !ruby/object:Gem::Dependency
+  name: keytar
+  requirement: &70212263195260 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  name: yard
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
   prerelease: false
-  type: :development
-  requirement: *id003
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: *70212263195260
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70212263175320 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  name: rdiscount
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
+  version_requirements: *70212263175320
+- !ruby/object:Gem::Dependency
+  name: rdiscount
+  requirement: &70212263173780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  requirement: *id004
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
+  prerelease: false
+  version_requirements: *70212263173780
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70212263171900 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 49
-        segments: 
-        - 0
-        - 8
-        - 7
+      - !ruby/object:Gem::Version
         version: 0.8.7
-  name: rake
-  prerelease: false
   type: :development
-  requirement: *id005
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id006 !ruby/object:Gem::Requirement 
+  prerelease: false
+  version_requirements: *70212263171900
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70212263170520 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 1
-        - 5
-        - 2
+      - !ruby/object:Gem::Version
         version: 1.5.2
-  name: jeweler
-  prerelease: false
   type: :development
-  requirement: *id006
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id007 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  name: autotest-standalone
   prerelease: false
-  type: :development
-  requirement: *id007
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id008 !ruby/object:Gem::Requirement 
+  version_requirements: *70212263170520
+- !ruby/object:Gem::Dependency
+  name: autotest-standalone
+  requirement: &70212263169000 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  name: autotest-growl
-  prerelease: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  requirement: *id008
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id009 !ruby/object:Gem::Requirement 
+  prerelease: false
+  version_requirements: *70212263169000
+- !ruby/object:Gem::Dependency
+  name: autotest-growl
+  requirement: &70212263166500 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  name: rspec
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
+  version_requirements: *70212263166500
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70212263164700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  requirement: *id009
-description: "\n    Cache methods quickly and easily\n  "
+  prerelease: false
+  version_requirements: *70212263164700
+description: ! "\n    Cache methods quickly and easily\n  "
 email: richard.schneeman@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .rvmrc
+files:
 - .yardoc/checksums
 - .yardoc/objects/root.dat
 - .yardoc/proxy_types
@@ -190,39 +149,34 @@ files:
 - spec/method_cacheable_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/Schnems/method_cacheable
-licenses: 
+licenses:
 - MIT
 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: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: 588910908911295363
+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: '0'
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Cache methods quickly and easily.
-test_files: 
+test_files:
 - spec/method_cacheable/method_cache_spec.rb
 - spec/method_cacheable_spec.rb
 - spec/spec_helper.rb

data/.rvmrc

@@ -1,17 +0,0 @@
-ruby_string="ree"
-gemset_name="johnny_cache"
-
-if rvm list strings | grep -q "${ruby_string}" ; then
-
-  rvm use "${ruby_string}@${gemset_name}" --create
-
-  # Complain if bundler isn't installed
-  if [[ -z "`gem which bundler 2>&1 | grep -v ERROR`" ]]; then
-    echo "You need bundler:"
-    echo ""
-    echo "    gem install bundler"
-    echo ""
-  fi
-else
-  echo "${ruby_string} was not found, please run 'rvm install ${ruby_string}' and then cd back into the project directory."
-fi