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

0
@@ -0,0 +1,13 @@
0
+HasCachedValue
0
+==============
0
+
0
+Introduction goes here.
0
+
0
+
0
+Example
0
+=======
0
+
0
+Example goes here.
0
+
0
+
0
+Copyright (c) 2007 [name of plugin creator], released under the MIT license

0
@@ -0,0 +1,22 @@
0
+require 'rake'
0
+require 'rake/testtask'
0
+require 'rake/rdoctask'
0
+
0
+desc 'Default: run unit tests.'
0
+task :default => :test
0
+
0
+desc 'Test the has_cached_value plugin.'
0
+Rake::TestTask.new(:test) do |t|
0
+  t.libs << 'lib'
0
+  t.pattern = 'test/**/*_test.rb'
0
+  t.verbose = true
0
+end
0
+
0
+desc 'Generate documentation for the has_cached_value plugin.'
0
+Rake::RDocTask.new(:rdoc) do |rdoc|
0
+  rdoc.rdoc_dir = 'rdoc'
0
+  rdoc.title    = 'HasCachedValue'
0
+  rdoc.options << '--line-numbers' << '--inline-source'
0
+  rdoc.rdoc_files.include('README')
0
+  rdoc.rdoc_files.include('lib/**/*.rb')
0
+end

0
@@ -0,0 +1,2 @@
0
+require 'has_cached_value'
0
+ActiveRecord::Base.send :include, HasCachedValueExtension

0
@@ -0,0 +1 @@
0
+# Install hook code here

0
@@ -0,0 +1,199 @@
0
+module HasCachedValueExtension # :nodoc:
0
+  def self.included(base)
0
+    base.extend(ClassMethods)
0
+  end
0
+  module ClassMethods
0
+    # USAGE:
0
+    #  
0
+    # a very simple case in which has_cached_value works just like the .count method on a has_many association:
0
+    #   
0
+    #   class Company < ActiveRecord::Base
0
+    #     has_cached_value :total_employees, :sql => 'select count(*) from employees where company_id = #{id}'
0
+    #   end
0
+    #  
0
+    # a more sophisticated example:
0
+    #  
0
+    #   class User < ActiveRecord::Base
0
+    #     has_many :trinkets
0
+    #     has_many :sales, :through => :trinkets
0
+    #     has_cached_value :remaining_trinket_sales_allotted, :sql => '... very complicated sql here ...'
0
+    #   end
0
+    #  
0
+    #   user = User.find(:first)
0
+    #   user.remaining_trinket_sales_allotted # => 70
0
+    #   Trinket.delete_all # <= any operation that would affect our value
0
+    #   user.remaining_trinket_sales_allotted # => 70
0
+    #   user.remaining_trinket_sales_allotted.reload # => 113
0
+    #  
0
+    # 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
0
+    # in the context of the record instance.
0
+    #  
0
+    #   class User < ActiveRecord::Base
0
+    #     has_cached_value :expensive_calculation, :eval => "some_big_expensize_calculation(self.id)"
0
+    #     has_cached_value :other_expensive_process, :eval => Proc.new {|record| record.other_expensize_process }
0
+    #   end
0
+    #
0
+    
0
+    def has_cached_value(association_id, options = {})
0
+      reflection = create_has_cached_value_reflection(association_id, options)
0
+
0
+      configure_dependency_for_has_cached_value(reflection)
0
+
0
+      reflection.options[:counter_cache] = reflection.options.delete(:cache) if reflection.options[:cache]
0
+      reflection.options[:counter_cache] ||= reflection.name unless false == reflection.options[:counter_cache]
0
+
0
+      association_accessor_method(reflection, ActiveRecord::Associations::HasCachedValueAssociation)
0
+    end
0
+
0
+    private
0
+    
0
+      def configure_dependency_for_has_cached_value(reflection)
0
+        if reflection.options[:counter_cache] && reflection.options[:cache]
0
+          raise ArgumentError, ":cache is an alias for :counter_cache, don't use both options for has_cached_value in #{self.name}"
0
+        end
0
+      
0
+        if !reflection.options[:sql] && !reflection.options[:eval]
0
+          raise ArgumentError, "You must specify either the :eval or :sql options for has_cached_value in #{self.name}"
0
+        end
0
+      
0
+        if reflection.options[:sql] && reflection.options[:eval]
0
+          raise ArgumentError, ":eval and :sql are mutually exclusive options.  You may specify one or the other for has_cached_value in #{self.name}"
0
+        end
0
+      end
0
+    
0
+      def create_has_cached_value_reflection(association_id, options)
0
+        options.assert_valid_keys(:sql, :eval, :cache, :counter_cache)
0
+        
0
+        reflection = ActiveRecord::Reflection::AssociationReflection.new(:has_cached_value, association_id, options, self)
0
+        write_inheritable_hash :reflections, association_id => reflection
0
+        reflection
0
+      end
0
+
0
+      def association_accessor_method(reflection, association_proxy_class)
0
+        define_method(reflection.name) do |*params|
0
+          force_reload = params.first unless params.empty?
0
+          association = instance_variable_get("@#{reflection.name}")
0
+          
0
+          if association.nil? || force_reload
0
+            association = association_proxy_class.new(self, reflection)
0
+            instance_variable_set("@#{reflection.name}", association)
0
+            force_reload ? association.reload : association.load
0
+          end
0
+          association.target.nil? ? nil : association
0
+        end
0
+      end
0
+  end
0
+end
0
+
0
+module ActiveRecord
0
+  module Associations
0
+    class HasCachedValueAssociation
0
+      attr_reader :reflection
0
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$)/ }
0
+
0
+      def initialize(owner, reflection)
0
+        @owner, @reflection = owner, reflection
0
+        reset
0
+      end
0
+      
0
+      def reset
0
+        @target = nil
0
+        @loaded = false
0
+      end
0
+
0
+      def load
0
+        reset
0
+        load_target
0
+      end
0
+
0
+      def reload
0
+        reset
0
+        clear_cache
0
+        load_target
0
+      end
0
+      
0
+      def clear
0
+        clear_cache
0
+        @owner.instance_variable_set("@#{@reflection.name}", nil)
0
+      end
0
+
0
+      def loaded?
0
+        @loaded
0
+      end
0
+      
0
+      def loaded
0
+        @loaded = true
0
+      end
0
+      
0
+      def target
0
+        @target
0
+      end
0
+
0
+      protected
0
+      
0
+        def find_target_by_eval
0
+          if @reflection.options[:eval].is_a?(String)
0
+            eval(@reflection.options[:eval], @owner.send(:binding))
0
+          elsif @reflection.options[:eval].is_a?(Proc)
0
+            @reflection.options[:eval].call(@owner)
0
+          else
0
+            raise ArgumentError.new("The :eval option on a has_cached_value must be either a String or a Proc")
0
+          end
0
+        end
0
+        
0
+        def find_target_by_sql
0
+          @owner.class.count_by_sql(sanitize_sql(interpolate_sql(@reflection.options[:sql])))
0
+        end
0
+        
0
+        def find_target_from_cache
0
+          @owner.send(:read_attribute, @reflection.counter_cache_column) if has_cached_counter?
0
+        end
0
+
0
+        def find_target
0
+          target = find_target_from_cache
0
+          unless target
0
+            target ||= @reflection.options[:sql] ? find_target_by_sql : find_target_by_eval
0
+            update_cache(target)
0
+          end
0
+          target
0
+        end
0
+        
0
+        def update_cache(value)
0
+          return unless has_cached_counter?
0
+          unless @owner.new_record?
0
+            @owner.class.update_all(["#{@reflection.counter_cache_column} = ?", value], ["id = ?", @owner.id])
0
+          end
0
+          @owner.send(:write_attribute, @reflection.counter_cache_column, value)
0
+        end
0
+        
0
+        def clear_cache
0
+          update_cache(nil)
0
+        end
0
+        
0
+        def load_target
0
+          return nil unless defined?(@loaded)
0
+          @target = find_target unless loaded?
0
+          @loaded = true
0
+          @target
0
+        end
0
+
0
+        def has_cached_counter?
0
+          @reflection.options[:counter_cache] && @owner.attribute_names.include?(@reflection.options[:counter_cache].to_s)
0
+        end
0
+        
0
+        def interpolate_sql(sql, record = nil)
0
+          @owner.send(:interpolate_sql, sql, record)
0
+        end
0
+
0
+        def sanitize_sql(sql)
0
+          @owner.class.send(:sanitize_sql, sql)
0
+        end
0
+        
0
+        def method_missing(method, *args, &block)
0
+          if load_target        
0
+            @target.send(method, *args, &block)
0
+          end
0
+        end
0
+    end
0
+  end
0
+end

0
@@ -0,0 +1,4 @@
0
+# desc "Explaining what the task does"
0
+# task :has_cached_value do
0
+#   # Task goes here
0
+# end

0
@@ -0,0 +1,18 @@
0
+sqlite:
0
+  :adapter: sqlite
0
+  :dbfile: plugin.sqlite.db
0
+sqlite3:
0
+  :adapter: sqlite3
0
+  :dbfile: ":memory:"
0
+postgresql:
0
+  :adapter: postgresql
0
+  :username: postgres
0
+  :password: postgres
0
+  :database: plugin_test
0
+  :min_messages: ERROR
0
+mysql:
0
+  :adapter: mysql
0
+  :host: localhost
0
+  :username: rails
0
+  :password:
0
+  :database: plugin_test
0
\ No newline at end of file