cached_values 1.0.1 → 1.7.0

data/README.markdown

@@ -0,0 +1,65 @@
+Cached Values
+=
+
+[http://github.com/JackDanger/cached_values/](http://github.com/JackDanger/cached_values/)
+
+Cache the result of any Ruby expression or SQL into an ActiveRecord attribute. Expire and update automatically.
+
+INSTALL:
+===
+
+* as gem: sudo gem install cached_values
+* as plugin: ./script/plugin install git://github.com/JackDanger/cached_values.git
+
+USAGE:
+===
+
+You can calculate values with a single line in any ActiveRecord model.  To actually save those values you'll need to create
+an attribute in your schema.  By default the cached_value instance will look for an attribute with the same name as itself.
+You can override this by specifying a :cache => :some_attribute option
+
+A very simple case in which cached_values works just like the .count method on a has_many association:
+
+    class Leprechaun < ActiveRecord::Base
+      caches_value :total_gold_coins, :sql => 'select count(*) from gold_coins where leprechaun_id = #{id}'
+    end
+  
+    Company.find(4).total_employees # => 45
+
+A more sophisticated example:
+
+    class Leprechaun < ActiveRecord::Base
+      has_many :lucky_charms
+      has_many :deceived_children, :through => :lucky_charms
+      caches_value :total_children_remaining_to_be_deceived, :sql => '... very complicated sql here ...'
+    end
+  
+    Leprechaun.find(14).total_children_remaining_to_be_deceived # => 6,692,243,122
+
+The values can be of any type.  The plugin will attempt to cast SQL results to the type corresponding with their database cache
+but calculations in Ruby are left alone.
+
+You can also calculate the value in Ruby using a string to be eval'ed or a Proc.  Both are evaluated
+in the context of the record instance.
+
+    class Leprechaun < ActiveRecord::Base
+      caches_value :total_gold, :eval => "some_archaic_and_silly_calculation(gold_coins)"
+      caches_value :total_lucky_charms, :eval => Proc.new {|record| record.calculate_total_lucky_charms }
+    end
+
+The cache is customizable, you can specify which attribute should be used as a cache:
+  
+    caches_value :runic_formula, :sql => '...'          # uses 'runic_formula' column if it exists
+    caches_value :standard_deviation_of_gold_over_time, # uses 'std' column if it exists
+                 :sql => '...', :cache => 'std'
+    caches_value :id, :sql => '...', :cache => false    # does NOT persist to db, just memoize in memory.  This avoids overwriting the attribute of the same name.
+
+ActiveRecord callbacks can be used to reload (update cache and reload instance) at certain times:
+  
+    caches_value :standard_deviation, :sql => '...', :reload => [:before_save, :after_destroy]
+    caches_value :runic_formula, :sql => '...', :reload => :after_create
+
+
+Patches welcome, forks celebrated.
+
+Copyright (c) 2007 Jack Danger Canty @ [http://jåck.com](http://jåck.com), released under the MIT license

data/Rakefile

@@ -1,17 +1,28 @@
-# -*- ruby -*-
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "cached_values"
+    gem.summary = %Q{Memoize and persist calculations into ActiveRecord attributes}
+    gem.description = %Q{Speedup your ActiveRecord by storing and updating the results of SQL or Ruby expressions into record attributes}
+    gem.email = "rubygems@6brand.com"
+    gem.homepage = "http://github.com/JackDanger/cached_values"
+    gem.authors = ["Jack Danger Canty"]
+    gem.add_dependency "object_proxy", ">= 0"
+    gem.add_development_dependency "active_record", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
 
-$:.unshift(File.dirname(__FILE__) + '/lib')
-$:.unshift(File.dirname(__FILE__) + '/lib/cached_values')
 
 
-require 'rubygems'
-require 'hoe'
-require "cached_values"
+task :default => :test
 
-Hoe.new('cached_values', CachedValues::VERSION) do |p|
-  p.rubyforge_name = 'cachedvalues' # if different than lowercase project name
-  p.remote_rdoc_dir = '' # Release to root
-  p.developer('Jack Danger Canty', 'rubygems_cached_values@6brand.com')
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << '.'
+  test.pattern = 'test/*_test.rb'
+  test.verbose = true
 end
-
-# vim: syntax=Ruby

data/VERSION

@@ -0,0 +1 @@
+1.7.0

data/init.rb

@@ -1,3 +1,2 @@
-require 'cached_value'
 require 'cached_values'
 ActiveRecord::Base.send :include, CachedValues

data/install.rb

@@ -1 +1 @@
-puts IO.read(File.join(File.dirname(__FILE__), 'README.txt'))
+puts IO.read(File.join(File.dirname(__FILE__), 'README.markdown'))

data/lib/{cached_values/cached_value.rb → cached_value.rb}

@@ -1,3 +1,4 @@
+gem 'object_proxy'
 require 'object_proxy'
   
 module ActiveRecord
@@ -5,23 +6,16 @@ module ActiveRecord
 
     def initialize(owner, reflection)
       @owner, @reflection = owner, reflection
-      reset
     end
     
-    def reset
-      @target = nil
-    end
-
-    def load
-      reset
-      @target = find_target(true)
+    def load(skip_cache = false)
+      @target = find_target skip_cache
       update_cache(@target)
+      self
     end
 
     def reload
-      @owner.instance_variable_set("@#{@reflection.name}", nil)
-      load
-      @owner.send @reflection.name
+      @owner.send(@reflection.name).load(true)
     end
     
     alias update reload
@@ -29,6 +23,7 @@ module ActiveRecord
     def clear
       clear_cache
       @owner.instance_variable_set("@#{@reflection.name}", nil)
+      self
     end
 
     def target
@@ -82,10 +77,18 @@ module ActiveRecord
       
       def update_cache(value)
         return unless has_cache?
-        unless @owner.new_record?
-          @owner.class.update_all(["#{cache_column} = ?", value], ["id = ?", @owner.id])
-        end
+
         @owner.send(:write_attribute, cache_column, value)
+
+        return if @owner.new_record? || !CachedValues.perform_save?
+
+        exist_conditions = value.nil? ?
+                              [ "#{cache_column} IS NULL AND id = ?", @owner.id ] :
+                              [ "(#{cache_column} = ? AND #{cache_column} IS NOT NULL) AND id = ?", value, @owner.id ]
+
+        return if @owner.class.exists? exist_conditions
+
+        @owner.class.update_all   [ "#{cache_column} = ?", value], ["id = ?", @owner.id ]
       end
       
       def typecast_result(result)

data/lib/cached_values.rb

@@ -1,9 +1,113 @@
 require 'active_record'
-require File.expand_path(File.dirname(__FILE__) + "/cached_values/cached_value")
-require File.expand_path(File.dirname(__FILE__) + "/cached_values/caches_value")
+require File.expand_path(File.dirname(__FILE__) + "/cached_value")
 
 module CachedValues # :nodoc:
-  VERSION = '1.0.1'
+  def self.perform_save?
+    @perform_save ||= true
+  end
+
+  def self.without_saving_record
+    @perform_save = false
+    yield
+    @perform_save = true
+  end
+  
+  # USAGE:
+  #  
+  # a very simple case in which cached_values works just like the .count method on a has_many association:
+  #   
+  #   class Company < ActiveRecord::Base
+  #     caches_value :total_employees, :sql => 'select count(*) from employees where company_id = #{id}'
+  #   end
+  #  
+  # a more sophisticated example:
+  #  
+  #   class User < ActiveRecord::Base
+  #     has_many :trinkets
+  #     has_many :sales, :through => :trinkets
+  #     caches_value :remaining_trinket_sales_allotted, :sql => '... very complicated sql here ...'
+  #   end
+  #  
+  #   user = User.find(:first)
+  #   user.remaining_trinket_sales_allotted # => 70
+  #   Trinket.delete_all # <= any operation that would affect our value
+  #   user.remaining_trinket_sales_allotted # => 70
+  #   user.remaining_trinket_sales_allotted.reload # => 113
+  #  
+  # You can also calculate the value in Ruby.  This can be done by a string to be eval'ed or a Proc.  Both are evaluated
+  # in the context of the record instance.
+  #  
+  #   class User < ActiveRecord::Base
+  #     caches_value :expensive_calculation, :eval => "some_big_expensize_calculation(self.id)"
+  #     caches_value :other_expensive_process, :eval => Proc.new {|record| record.other_expensize_process }
+  #   end
+  #
+    
+  def caches_value(name, options = {})
+    reflection = create_cached_value_reflection(name, options)
+
+    configure_dependency_for_cached_value(reflection)
+
+    reflection.options[:cache] ||= reflection.name unless false == options[:cache]
+
+    cached_value_accessor_method(reflection, ActiveRecord::CachedValue)
+    cached_value_callback_methods(reflection)
+  end
+
+  private
+  
+    def configure_dependency_for_cached_value(reflection)
+    
+      if !reflection.options[:sql] && !reflection.options[:eval]
+        raise ArgumentError, "You must specify either the :eval or :sql options for caches_value in #{self.name}"
+      end
+    
+      if reflection.options[:sql] && reflection.options[:eval]
+        raise ArgumentError, ":eval and :sql are mutually exclusive options.  You may specify one or the other for caches_value in #{self.name}"
+      end
+    end
+  
+    def create_cached_value_reflection(name, options)
+      options.assert_valid_keys(:sql, :eval, :cache, :clear, :load, :reload)
+      
+      reflection = ActiveRecord::Reflection::MacroReflection.new(:cached_value, name, options, self)
+      write_inheritable_hash :reflections, name => reflection
+      reflection
+    end
+
+    def cached_value_accessor_method(reflection, association_proxy_class)
+      define_method(reflection.name) do
+        association = instance_variable_get("@#{reflection.name}")
+        
+        if association.nil?
+          association = association_proxy_class.new(self, reflection)
+          instance_variable_set("@#{reflection.name}", association)
+          association.load
+        end
+        association.target.nil? ? nil : association
+      end
+    end
+    
+    def cached_value_callback_methods(reflection)
+      if events = reflection.options[:reload]
+        events = Array(events).map { |event| event.to_s }
+        ActiveRecord::Callbacks::CALLBACKS.each do |callback|
+          if events.include?(callback)
+            # before_save do |record|
+            send callback do |record|
+              if %{before_save before_create before_destroy}.include?(callback.to_s)
+                CachedValues.without_saving_record do
+                  record.send(reflection.name).reload
+                end
+              else
+                record.send(reflection.name).reload
+              end
+            end
+          end
+        end
+      end
+    end
 end
 
-ActiveRecord::Base.send :include, CachesValues
+
+ActiveRecord::Base.extend CachedValues

data/test/{test_cached_values.rb → cached_values_test.rb}

@@ -1,4 +1,3 @@
-require 'test/unit'
 require File.expand_path(File.dirname(__FILE__) + "/test_helper")
 
 class CachedValuesTest < Test::Unit::TestCase
@@ -97,13 +96,6 @@ class CachedValuesTest < Test::Unit::TestCase
     assert_not_equal value.to_i, @mc_nairn.reload_callback
   end
   
-  def test_clear_callback_should_fire
-    assert @mc_nairn.clear_callback
-    assert @mc_nairn.instance_variable_get("@clear_callback")
-    @mc_nairn.valid?
-    assert_nil @mc_nairn.instance_variable_get("@clear_callback")
-  end
-  
   def test_sql_should_cast_to_integer
     assert @mc_nairn.integer_cast.is_a?(Fixnum)
   end

data/test/database.yml

@@ -1,9 +1,9 @@
 sqlite:
   :adapter: sqlite
-  :dbfile: plugin.sqlite.db
+  :database: plugin.sqlite.db
 sqlite3:
   :adapter: sqlite3
-  :dbfile: ":memory:"
+  :database: ":memory:"
 postgresql:
   :adapter: postgresql
   :username: postgres
@@ -15,4 +15,4 @@ mysql:
   :host: localhost
   :username: rails
   :password:
-  :database: plugin_test
+  :database: plugin_test

data/test/leprechaun.rb

@@ -6,7 +6,6 @@ class Leprechaun < ActiveRecord::Base
   caches_value :favorite_color_in_rot_13_without_cache, :eval => Proc.new {|leprechaun| leprechaun.favorite_color.tr "A-Za-z", "N-ZA-Mn-za-m" }, :cache => false
   caches_value :favorite_color_turned_uppercase_with_explicit_cache, :eval => "favorite_color.upcase", :cache => 'some_other_cache_field'
   caches_value :reload_callback, :eval => "rand(1000)", :reload => [:before_save, :after_validation]
-  caches_value :clear_callback, :eval => "rand(1000)", :clear => :before_validation
   caches_value :float_cast, :sql => "select 82343.222"
   caches_value :integer_cast, :sql => "select 19"
   caches_value :string_cast, :sql => 'select "Top \'o the mornin\' to ya"'

data/test/test_helper.rb

@@ -4,7 +4,9 @@
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 
 require 'rubygems'
+gem 'test-unit'
 require 'test/unit'
+require 'active_support'
 require 'active_record'
 require 'active_record/fixtures'
 require "cached_values"
@@ -16,7 +18,7 @@ ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite3'])
 
 load(File.dirname(__FILE__) + "/schema.rb") if File.exist?(File.dirname(__FILE__) + "/schema.rb")
 
-class Test::Unit::TestCase #:nodoc:
+class ActiveSupport::TestCase #:nodoc:
   
   # def create_fixtures(*table_names)
   #   if block_given?
@@ -27,10 +29,10 @@ class Test::Unit::TestCase #:nodoc:
   # end
 
   # Turn off transactional fixtures if you're working with MyISAM tables in MySQL
-  self.use_transactional_fixtures = true
+  # self.use_transactional_fixtures = true
   
   # Instantiated fixtures are slow, but give you @david where you otherwise would need people(:david)
-  self.use_instantiated_fixtures  = false
+  # self.use_instantiated_fixtures  = false
 
   # Add more helper methods to be used by all tests here...
-end
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: cached_values
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  prerelease: false
+  segments: 
+  - 1
+  - 7
+  - 0
+  version: 1.7.0
 platform: ruby
 authors: 
 - Jack Danger Canty
@@ -9,74 +14,89 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-03-12 00:00:00 -07:00
+date: 2010-05-03 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: hoe
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  name: object_proxy
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.5.1
-    version: 
-description: ""
-email: 
-- rubygems_cached_values@6brand.com
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: active_record
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Speedup your ActiveRecord by storing and updating the results of SQL or Ruby expressions into record attributes
+email: rubygems@6brand.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- README.txt
+- README.markdown
 files: 
-- History.txt
 - MIT-LICENSE
-- Manifest.txt
-- README.txt
+- README.markdown
 - Rakefile
+- VERSION
 - init.rb
 - install.rb
+- lib/cached_value.rb
 - lib/cached_values.rb
-- lib/cached_values/cached_value.rb
-- lib/cached_values/caches_value.rb
 - tasks/cached_values_tasks.rake
+- test/cached_values_test.rb
 - test/database.yml
 - test/leprechaun.rb
 - test/schema.rb
-- test/test_cached_values.rb
 - test/test_helper.rb
 - uninstall.rb
 has_rdoc: true
-homepage: http://github.com/JackDanger/cached_values/
+homepage: http://github.com/JackDanger/cached_values
+licenses: []
+
 post_install_message: 
 rdoc_options: 
-- --main
-- README.txt
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
-rubyforge_project: cachedvalues
-rubygems_version: 1.0.1
+rubyforge_project: 
+rubygems_version: 1.3.6
 signing_key: 
-specification_version: 2
-summary: ""
+specification_version: 3
+summary: Memoize and persist calculations into ActiveRecord attributes
 test_files: 
-- test/test_cached_values.rb
+- test/cached_values_test.rb
+- test/leprechaun.rb
+- test/schema.rb
 - test/test_helper.rb

data/History.txt

@@ -1,7 +0,0 @@
-=== 1.0.1 / 2008-03-12
-
-* The find_target method is now public
-
-=== 1.0.0 / 2008-03-06
-
-* Converted from a Rails plugin

data/Manifest.txt

@@ -1,17 +0,0 @@
-History.txt
-MIT-LICENSE
-Manifest.txt
-README.txt
-Rakefile
-init.rb
-install.rb
-lib/cached_values.rb
-lib/cached_values/cached_value.rb
-lib/cached_values/caches_value.rb
-tasks/cached_values_tasks.rake
-test/database.yml
-test/leprechaun.rb
-test/schema.rb
-test/test_cached_values.rb
-test/test_helper.rb
-uninstall.rb

data/README.txt

@@ -1,66 +0,0 @@
-= Cached Values
-
-* http://github.com/JackDanger/cached_values/
-
-A dead-simple way to calculate any value via Ruby or SQL and (optionally) have it saved in a database field.
-
-== REQUIREMENTS:
-
-* ObjectProxy
-
-== INSTALL:
-
-* as gem: sudo gem install cached_values
-* as plugin: ./script/plugin install git://github.com/JackDanger/cached_values.git
-
-== USAGE:
-
-You can calculate values with a single line in any ActiveRecord model.  To actually save those values you'll need to create
-an attribute in your schema.  By default the cached_value instance will look for an attribute with the same name as itself.
-You can override this by specifying a :cache => :some_attribute option
-
-A very simple case in which cached_values works just like the .count method on a has_many association:
-
-  class Leprechaun < ActiveRecord::Base
-   caches_value :total_gold_coins, :sql => 'select count(*) from gold_coins where leprechaun_id = #{id}'
-  end
-  
-  Company.find(4).total_employees # => 45
-
-A more sophisticated example:
-
-  class Leprechaun < ActiveRecord::Base
-   has_many :lucky_charms
-   has_many :deceived_children, :through => :lucky_charms
-   caches_value :total_children_remaining_to_be_deceived, :sql => '... very complicated sql here ...'
-  end
-  
-  Leprechaun.find(14).total_children_remaining_to_be_deceived # => 6,692,243,122
-
-The values can be of any type.  The plugin will attempt to cast SQL results to the type corresponding with their database cache
-but calculations in Ruby are left alone.
-
-You can also calculate the value in Ruby using a string to be eval'ed or a Proc.  Both are evaluated
-in the context of the record instance.
-
-  class Leprechaun < ActiveRecord::Base
-    caches_value :total_gold, :eval => "some_archaic_and_silly_calculation(self.gold_coins)"
-    caches_value :total_lucky_charms, :eval => Proc.new {|record| record.calculate_total_lucky_charms }
-  end
-
-The cache is customizable, you can specify which attribute should be used as a cache:
-  
-  caches_value :runic_formula, :sql => '...'          # uses 'full_formula' column if it exists
-  caches_value :standard_deviation_of_gold_over_time, # uses 'std' column if it exists
-               :sql => '...', :cache => 'std'
-  caches_value :id, :sql => '...', :cache => false    # does NOT save any cache.  This avoids overwriting an attribute
-
-ActiveRecord callbacks can be used to call load (make sure the value is in memory), clear (flush the cache and
-delete the instance), or reload (flush cache and reload instance) at certain times:
-  
-  caches_value :standard_deviation, :sql => '...', :reload => [:after_save, :before_validation]
-  caches_value :full_formula, :sql => '...', :clear => :after_find
-
-Bugs can be filed at http://code.lighthouseapp.com/projects/4502-hoopla-rails-plugins/
-
-Copyright (c) 2007 Jack Danger Canty @ http://6brand.com, released under the MIT license

data/lib/cached_values/caches_value.rb

@@ -1,104 +0,0 @@
-require 'active_record'
-require File.expand_path(File.dirname(__FILE__) + '/cached_value')
-
-module CachesValues # :nodoc:
-  
-  def self.included(base)
-    unless base.extended_by.include?(CachesValues::ClassMethods)
-      base.extend(ClassMethods)
-    end
-  end
-
-  module ClassMethods
-    # USAGE:
-    #  
-    # a very simple case in which cached_values works just like the .count method on a has_many association:
-    #   
-    #   class Company < ActiveRecord::Base
-    #     caches_value :total_employees, :sql => 'select count(*) from employees where company_id = #{id}'
-    #   end
-    #  
-    # a more sophisticated example:
-    #  
-    #   class User < ActiveRecord::Base
-    #     has_many :trinkets
-    #     has_many :sales, :through => :trinkets
-    #     caches_value :remaining_trinket_sales_allotted, :sql => '... very complicated sql here ...'
-    #   end
-    #  
-    #   user = User.find(:first)
-    #   user.remaining_trinket_sales_allotted # => 70
-    #   Trinket.delete_all # <= any operation that would affect our value
-    #   user.remaining_trinket_sales_allotted # => 70
-    #   user.remaining_trinket_sales_allotted.reload # => 113
-    #  
-    # You can also calculate the value in Ruby.  This can be done by a string to be eval'ed or a Proc.  Both are evaluated
-    # in the context of the record instance.
-    #  
-    #   class User < ActiveRecord::Base
-    #     caches_value :expensive_calculation, :eval => "some_big_expensize_calculation(self.id)"
-    #     caches_value :other_expensive_process, :eval => Proc.new {|record| record.other_expensize_process }
-    #   end
-    #
-    
-    def caches_value(name, options = {})
-      reflection = create_cached_value_reflection(name, options)
-
-      configure_dependency_for_cached_value(reflection)
-
-      reflection.options[:cache] ||= reflection.name unless false == options[:cache]
-
-      cached_value_accessor_method(reflection, ActiveRecord::CachedValue)
-      cached_value_callback_methods(reflection)
-    end
-
-    private
-    
-      def configure_dependency_for_cached_value(reflection)
-      
-        if !reflection.options[:sql] && !reflection.options[:eval]
-          raise ArgumentError, "You must specify either the :eval or :sql options for caches_value in #{self.name}"
-        end
-      
-        if reflection.options[:sql] && reflection.options[:eval]
-          raise ArgumentError, ":eval and :sql are mutually exclusive options.  You may specify one or the other for caches_value in #{self.name}"
-        end
-      end
-    
-      def create_cached_value_reflection(name, options)
-        options.assert_valid_keys(:sql, :eval, :cache, :clear, :load, :reload)
-        
-        reflection = ActiveRecord::Reflection::MacroReflection.new(:cached_value, name, options, self)
-        write_inheritable_hash :reflections, name => reflection
-        reflection
-      end
-
-      def cached_value_accessor_method(reflection, association_proxy_class)
-        define_method(reflection.name) do |*params|
-          force_reload = params.first unless params.empty?
-          association = instance_variable_get("@#{reflection.name}")
-          
-          if association.nil? || force_reload
-            association = association_proxy_class.new(self, reflection)
-            instance_variable_set("@#{reflection.name}", association)
-            force_reload ? association.reload : association.load
-          end
-          association.target.nil? ? nil : association
-        end
-      end
-      
-      def cached_value_callback_methods(reflection)
-        %w{clear reload}.each do |operation|
-          if events = reflection.options[operation.to_sym]
-            events = [events] unless events.is_a?(Array)
-            events.map! { |event| event.to_s }
-            ActiveRecord::Callbacks::CALLBACKS.each do |callback|
-              if events.include?(callback)
-                send(callback, Proc.new {|record| record.send(reflection.name).send(operation)})
-              end
-            end
-          end
-        end
-      end
-  end
-end