methodmissing-scrooge 2.2.3 → 3.0.0

data/README.textile

@@ -72,7 +72,7 @@ h4. As a Gem
 
 h2. Stability
 
-The whole ActiveRecord test suite passes with scrooge, except for 9 failures related to callsite augmentation (note the SQL reload snippets below).Thoughts on handling or circumventing this much appreciated. 
+The whole Rails 2.3.2 ActiveRecord test suite passes with scrooge, except for 13 failures related to callsite augmentation (note the SQL reload snippets below). Thoughts on handling or circumventing this much appreciated. 
 
 <pre>
 <code>
@@ -203,7 +203,7 @@ on subsequent requests :
 
 h4. How it tracks
 
-The ActiveRecord attributes Hash is replaced with a proxy that automatically augments the callsite with any attributes referenced through the Hash lookup keys.We're also able to learn which associations is invoked from a given callsite, for preloading on subsequent requests.
+The ActiveRecord attributes Hash is replaced with a proxy that automatically augments the callsite with any attributes referenced through the Hash lookup keys. We're also able to learn which associations is invoked from a given callsite, for preloading on subsequent requests.
 
 h4. Storage
 
@@ -221,12 +221,14 @@ The tracking and scoping phases is superseded by this implementation - none of t
 
 h2. Todo
 
-* Deeper coverage for Scrooge::AttributesProxy ( pending conversion to a subclass of Hash instead )
+* Deeper coverage for Scrooge::AttributesProxy, possible handling of replace
 
-* Test cases for Scrooge::Callsite
+* More test cases for Scrooge::Callsite
 
 * Have invoking Model#attributes not associate all columns with the callsite
 
 * Avoid possible missing attribute exceptions for destroyed objects
 
+* Track rows of result set to allow more targeted loading of associations for a callsite
+
 (c) 2009 Lourens Naudé (methodmissing) and Stephen Sykes (sdsykes)

data/Rakefile

@@ -1,3 +1,5 @@
+# coding: UTF-8
+
 require 'rake'
 require 'rake/testtask'
 require 'test/helper'
@@ -24,7 +26,7 @@ begin
   Jeweler::Tasks.new do |s|
     s.name = "scrooge"
     s.summary = "Scrooge - Fetch exactly what you need"
-    s.email = "lourens@methodmissing.com or sds@switchstep.com"
+    s.email = "lourens@methodmissing.com or sdsykes@gmail.com"
     s.homepage = "http://github.com/methodmissing/scrooge"
     s.description = "An ActiveRecord attribute tracker to ensure production
     Ruby applications only fetch the database content needed to minimize wire traffic

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 2
-:patch: 3
-:major: 2
+:major: 3
+:minor: 0
+:patch: 0

data/lib/callsite.rb

@@ -2,10 +2,10 @@ module Scrooge
   class Callsite
     
     # Represents a Callsite and is a container for any columns and 
-    # associations ( coming soon ) referenced at the callsite.
+    # associations referenced at the callsite.
     #
     
-    Mutex = Mutex.new
+    Mtx = Mutex.new
     
     attr_accessor :klass,
                   :signature,
@@ -15,40 +15,52 @@ module Scrooge
     def initialize( klass, signature )
       @klass = klass
       @signature = signature
-      @columns = setup_columns 
-      @associations = setup_associations
     end
     
     # Flag a column as seen
     #
     def column!( column )
-      Mutex.synchronize do 
-        @columns << column
+      Mtx.synchronize do 
+        columns << column
       end
     end
     
-    # Diff known associations with given includes
-    #
-    def preload( includes )
-      # Ignore nested includes for the time being
-      #
-      if includes.is_a?(Hash)
-        includes
-      else  
-        @associations.merge( Array(includes) ).to_a
-      end
-    end  
-    
     # Flag an association as seen
     #
     def association!( association )
-      Mutex.synchronize do
-        @associations << association if preloadable_association?( association )
+      Mtx.synchronize do
+        associations << association if preloadable_association?( association )
       end
     end
     
+    def inspect
+      "<##{@klass.name} :select => '#{@klass.scrooge_select_sql( columns )}', :include => [#{associations_for_inspect}]>"
+    end
+    
+    # Lazy init default columns
+    #
+    def default_columns
+      @default_columns ||= setup_columns
+    end
+    
+    # Lazy init columns
+    #
+    def columns
+      @columns ||= default_columns.dup
+    end  
+  
+    # Lazy init associations
+    #
+    def associations
+      @associations ||= setup_associations
+    end
+    
     private
     
+      def associations_for_inspect
+        associations.map{|a| ":#{a.to_s}" }.join(', ')
+      end
+    
       # Only register associations that isn't polymorphic or a collection
       #
       def preloadable_association?( association )
@@ -68,11 +80,11 @@ module Scrooge
         if inheritable?
           Set.new([primary_key, inheritance_column])
         else
-          Set.new([primary_key])
+          primary_key.blank? ? Set.new : Set.new([primary_key])
         end    
       end
     
-      # Stubbed for future use
+      # Start with no registered associations
       #
       def setup_associations
         Set.new

data/lib/optimizations/associations/macro.rb

@@ -8,16 +8,16 @@ module Scrooge
           # Inject into ActiveRecord
           #
           def install!
-            if scrooge_installable?
+            unless scrooge_installed?
               ActiveRecord::Base.send( :extend,  SingletonMethods )
-              ActiveRecord::Base.send( :include, InstanceMethods )              
+              ActiveRecord::Associations::AssociationProxy.send( :include, InstanceMethods )              
             end  
           end
       
-          private
+          protected
           
-            def scrooge_installable?
-              !ActiveRecord::Base.included_modules.include?( InstanceMethods )
+            def scrooge_installed?
+              ActiveRecord::Associations::AssociationProxy.included_modules.include?( InstanceMethods )
             end
          
         end
@@ -27,99 +27,62 @@ module Scrooge
       module SingletonMethods
       
         @@preloadable_associations = {}
-        FindAssociatedRegex = /find_associated_records/
       
         def self.extended( base )
           eigen = class << base; self; end
-          eigen.instance_eval do
-            # Let :scrooge_callsite be a valid find option
-            #
-            remove_const(:VALID_FIND_OPTIONS)
-            const_set( :VALID_FIND_OPTIONS, [ :conditions, :include, :joins, :limit, :offset, :order, :select, :readonly, :group, :having, :from, :lock, :scrooge_callsite ] )
-          end
-          eigen.alias_method_chain :find, :scrooge
-          eigen.alias_method_chain :find_every, :scrooge
+          # not used at present
         end
-      
-        # Let .find setup callsite information and preloading.
-        #
-        def find_with_scrooge(*args)
-          options = args.extract_options!
-          validate_find_options(options)
-          set_readonly_option!(options)
 
-          if (_caller = caller).grep( FindAssociatedRegex ).empty?
-            cs_signature = callsite_signature( _caller, options.except(:conditions, :limit, :offset) )
-            options[:scrooge_callsite], options[:include] = cs_signature, scrooge_callsite(cs_signature).preload( options[:include] )
-          end
-
-          case args.first
-            when :first then find_initial(options)
-            when :last  then find_last(options)
-            when :all   then find_every(options)
-            else             find_from_ids(args, options)
+        def preload_scrooge_associations(result_set, callsite_sig)
+          scrooge_preloading_exclude do
+            callsite_associations = scrooge_callsite(callsite_sig).associations.to_a
+            preload_associations(result_set, callsite_associations) unless callsite_associations.empty?
           end
         end
-      
-        # Override find_ever to pass along the callsite signature
-        #
-        def find_every_with_scrooge(options)
-          include_associations = merge_includes(scope(:find, :include), options[:include])
 
-          if include_associations.any? && references_eager_loaded_tables?(options)
-            records = find_with_associations(options)
-          else
-            records = find_by_sql(construct_finder_sql(options), options[:scrooge_callsite])
-            if include_associations.any?
-              preload_associations(records, include_associations)
-            end
+        def scrooge_preloading_exclude
+          unless Thread.current[:scrooge_preloading]
+            Thread.current[:scrooge_preloading] = true
+            yield
+            Thread.current[:scrooge_preloading] = false
           end
-
-          records.each { |record| record.readonly! } if options[:readonly]
-
-          records
-        end      
+        end
         
         # Let's not preload polymorphic associations or collections
         #      
         def preloadable_associations
-          @@preloadable_associations[self.name] ||= reflect_on_all_associations.reject{|a| a.options[:polymorphic] || a.macro == :has_many }.map{|a| a.name }
-        end              
-              
+          @@preloadable_associations[self.name] ||= 
+            reflect_on_all_associations.reject{|a| a.options[:polymorphic] || a.macro == :has_many}.map(&:name)
+        end
+
       end
       
       module InstanceMethods
-                
-        # Association getter with Scrooge support
-        #
-        def association_instance_get(name)
-          association = instance_variable_get("@#{name}")
-          if association.respond_to?(:loaded?)
-            scrooge_seen_association!( name )
-            association
-          end
+        
+        def self.included( base )
+          base.alias_method_chain :load_target, :scrooge
         end
 
-        # Association setter with Scrooge support
+        # note AssociationCollection has its own version of load_target, but we don't
+        # do collections at the moment anyway
         #
-        def association_instance_set(name, association)
-          scrooge_seen_association!( name )
-          instance_variable_set("@#{name}", association)
-        end
-        
-        # Register an association with Scrooge
-        #
-        def scrooge_seen_association!( association )
-          if scrooged? && !scrooge_seen_association?( association )
-            @attributes.scrooge_associations << association
-            self.class.scrooge_callsite( @attributes.callsite_signature ).association!( association ) 
-          end
+        def load_target_with_scrooge
+          scrooge_seen_association!(@reflection.name)
+          load_target_without_scrooge
         end
-        
+
         private
         
-          def scrooge_seen_association?( association )
-            @attributes.scrooge_associations.include?( association )
+          # Register an association with Scrooge
+          #
+          def scrooge_seen_association!( association )
+            if @owner.scrooged? && !@loaded
+              @owner.class.scrooge_callsite(callsite_signature).association!(association)
+            end
+          end
+          
+          def callsite_signature
+            @owner.instance_variable_get(:@attributes).callsite_signature
           end
         
       end

data/lib/optimizations/columns/attributes_proxy.rb

@@ -31,12 +31,11 @@ module Scrooge
         # Hash container for attributes with scrooge monitoring of attribute access
         #        
 
-        attr_accessor :callsite_signature, :scrooge_columns, :scrooge_associations, :fully_fetched, :klass, :updateable_result_set
+        attr_accessor :callsite_signature, :scrooge_columns, :fully_fetched, :klass, :updateable_result_set
 
-        def self.setup(record, scrooge_columns, scrooge_associations, klass, callsite_signature, updateable_result_set)
+        def self.setup(record, scrooge_columns, klass, callsite_signature, updateable_result_set)
           hash = new.replace(record)
           hash.scrooge_columns = scrooge_columns.dup
-          hash.scrooge_associations = scrooge_associations.dup
           hash.fully_fetched = false
           hash.klass = klass
           hash.callsite_signature = callsite_signature
@@ -141,7 +140,6 @@ module Scrooge
 
           def dup_self
             @scrooge_columns = @scrooge_columns.dup
-            @scrooge_associations = @scrooge_associations.dup
             self
           end
       end

data/lib/optimizations/columns/macro.rb

@@ -56,36 +56,41 @@ module Scrooge
         #
         def scrooge_reload( p_keys, missing_columns )
           sql_keys = p_keys.collect{|pk| "'#{pk}'"}.join(ScroogeComma)
-          connection.send( :select, "SELECT #{scrooge_select_sql(missing_columns)} FROM #{quoted_table_name} WHERE #{quoted_table_name}.#{primary_key} IN (#{sql_keys})" )
+          connection.send( :select, "SELECT #{scrooge_select_sql(missing_columns)} FROM #{quoted_table_name} WHERE #{quoted_table_name}.#{primary_key} IN (#{sql_keys})", "#{name} Scrooge Reload" )
         end
         
+        # Only scope n-1 rows by default.
+        # 
+        def scope_with_scrooge?( sql )
+          sql =~ scrooge_select_regex && 
+          column_names.include?(self.primary_key.to_s) &&
+          sql !~ ScroogeRegexJoin
+        end        
+        
         private
-
-          # Only scope n-1 rows by default.
-          # Stephen: Temp. relaxed the LIMIT constraint - please advise.
-          def scope_with_scrooge?( sql )
-            sql =~ scrooge_select_regex && 
-            column_names.include?(self.primary_key.to_s) &&
-            sql !~ ScroogeRegexJoin
-          end
         
           # Find through callsites.
           #
-          def find_by_sql_with_scrooge( sql, callsite_sig = nil )
-            callsite_sig ||= callsite_signature( caller, callsite_sql( sql ) )
+          def find_by_sql_with_scrooge(sql)
+            callsite_sig = callsite_signature( caller, callsite_sql( sql ) )
             callsite_columns = scrooge_callsite(callsite_sig).columns
-            callsite_associations = scrooge_callsite(callsite_sig).associations
             sql = sql.gsub(scrooge_select_regex, "SELECT #{scrooge_select_sql(callsite_columns)} FROM")
             results = connection.select_all(sanitize_sql(sql), "#{name} Load Scrooged")
+
             result_set = ResultSets::ResultArray.new
             updateable = ResultSets::UpdateableResultSet.new(result_set, self)
             results.inject(result_set) do |memo, record|
-              memo << instantiate(ScroogedAttributes.setup(record, callsite_columns, callsite_associations, self, callsite_sig, updateable))
+              memo << instantiate(ScroogedAttributes.setup(record, callsite_columns, self, callsite_sig, updateable))
             end
+
+            if Associations::Macro.scrooge_installed?
+              preload_scrooge_associations(result_set, callsite_sig)
+            end
+
+            result_set
           end
         
-          def find_by_sql_without_scrooge( sql, callsite = nil )
-            scrooge_unlink_callsite!( callsite ) if callsite
+          def find_by_sql_without_scrooge( sql)
             connection.select_all(sanitize_sql(sql), "#{name} Load").collect! do |record|
               instantiate( UnscroogedAttributes.setup(record) )
             end
@@ -140,8 +145,8 @@ module Scrooge
         #
         def becomes_with_scrooge(klass)
           if scrooged?
-            self.class.scrooge_callsite(@attributes.callsite_signature).columns.each do |attrib|
-              klass.scrooge_seen_column!(@attributes.callsite_signature, attrib)
+            self.class.scrooge_callsite(callsite_signature).columns.each do |attrib|
+              klass.scrooge_seen_column!(callsite_signature, attrib)
             end
           end
           becomes_without_scrooge(klass)
@@ -168,6 +173,12 @@ module Scrooge
             respond_to_without_scrooge?(symbol, include_private)
           end
         end
+        
+        # Expose this record's callsite signature
+        #
+        def callsite_signature
+          @attributes.callsite_signature
+        end
 
         private
 

data/lib/optimizations/result_sets/updateable_result_set.rb

@@ -16,6 +16,9 @@ module Scrooge
           @klass = klass  # expected class of items in the array
         end
         
+        # Called by a ScroogedAttributes hash when it is asked for a column
+        # that was not fetched from the DB
+        #
         def reload_columns!(columns_to_fetch)
           reloaded_columns = hash_by_primary_key(reload_columns_for_ids(columns_to_fetch, result_set_ids))
           if !reloaded_columns.has_key?(@updaters_attributes[primary_key_name])
@@ -40,6 +43,10 @@ module Scrooge
           end.uniq
         end
         
+        # The result set is weak referenced by its object_id
+        # So we check that a unique id matches what we have remembered to make sure
+        # that we got the right object (object ids are recycled by ruby)
+        #
         def result_set
           return nil unless @result_set_object_id
           result_set = ObjectSpace._id2ref(@result_set_object_id)
@@ -48,10 +55,17 @@ module Scrooge
           nil
         end
         
+        # When called from after_find and after_initialize, the object
+        # being accessed (and causing the reload) is not in the result set yet.
+        # We make sure that we add its attributes to result_set_attributes so it
+        # gets reloaded too
+        #
         def default_attributes
           [@updaters_attributes]
         end
         
+        # Ids of the items to be reloaded
+        #
         def result_set_ids
           result_set_attributes.inject([]) do |memo, attributes|
             unless attributes.fully_fetched
@@ -61,16 +75,22 @@ module Scrooge
           end
         end
         
+        # Update the result set with attributes provided, as returned by
+        # the sql server
+        #
         def update_with(remaining_attributes)
           current_attributes = hash_by_primary_key(result_set_attributes)
           remaining_attributes.each do |r_id, r_att|
             old_attributes = current_attributes[r_id]
             if old_attributes
-              old_attributes.update(r_att.merge(old_attributes))
+              old_attributes.update(r_att.merge(old_attributes)) # must call update, do not use reverse_update
             end
           end
         end
         
+        # Make an efficient data structure to access items when the
+        # primary key is known
+        #
         def hash_by_primary_key(rows)
           rows.inject({}) {|memo, row| memo[row[primary_key_name]] = row; memo}
         end

data/lib/scrooge.rb

@@ -19,11 +19,11 @@ module ActiveRecord
       # Determine if a given SQL string is a candidate for callsite <=> columns
       # optimization.
       #     
-      def find_by_sql(sql, callsite_signature = nil)
+      def find_by_sql(sql)
         if scope_with_scrooge?(sql)
-          find_by_sql_with_scrooge(sql, callsite_signature)
+          find_by_sql_with_scrooge(sql)
         else
-          find_by_sql_without_scrooge(sql, callsite_signature)
+          find_by_sql_without_scrooge(sql)
         end
       end
       
@@ -79,4 +79,4 @@ module ActiveRecord
 end
 
 Scrooge::Optimizations::Columns::Macro.install!
-Scrooge::Optimizations::Associations::Macro.install!
+Scrooge::Optimizations::Associations::Macro.install!

data/test/callsite_test.rb

@@ -0,0 +1,41 @@
+require "#{File.dirname(__FILE__)}/helper"
+ 
+Scrooge::Test.prepare!
+
+class CallsiteTest < ActiveSupport::TestCase
+  
+  def setup
+    @callsite = Scrooge::Callsite.new( MysqlTablePrivilege, 123456 )
+  end
+  
+  test "should initialize with a default set of columns" do
+    assert @callsite.columns.empty?
+    assert_equal Scrooge::Callsite.new( MysqlUser, 123456 ).columns, Set["User"]
+    Scrooge::Callsite.any_instance.stubs(:inheritable?).returns(true)
+    Scrooge::Callsite.any_instance.stubs(:inheritance_column).returns("inheritance")
+    assert_equal Scrooge::Callsite.new( MysqlUser, 123456 ).columns, Set["User","inheritance"]
+  end
+
+  test "should be inspectable" do
+    @callsite.association! :mysql_user
+    @callsite.column! :db
+    assert_equal @callsite.inspect, "<#MysqlTablePrivilege :select => '`tables_priv`.db', :include => [:mysql_user]>"
+  end
+  
+  test "should flag a column as seen" do
+    assert_difference '@callsite.columns.size' do
+      @callsite.column! :Db
+    end
+  end
+  
+  test "should flag only preloadable associations as seen" do
+    assert_no_difference '@callsite.associations.size' do
+      @callsite.association! :undefined
+    end
+    assert_difference '@callsite.associations.size', 2 do
+      @callsite.association! :column_privilege
+      @callsite.association! :mysql_user
+    end
+  end
+
+end  

data/test/helper.rb

@@ -2,6 +2,7 @@ require File.join( File.dirname(__FILE__), 'setup' )
 require 'rubygems'
 require 'mocha'
 require 'active_support/test_case'
+ENV["BACKTRACE"] = "1"
 
 module Scrooge
   class Test
@@ -13,7 +14,8 @@ module Scrooge
       def prepare!
         require 'test/unit'
         connect!
-        require_models()
+        require File.join( File.dirname(__FILE__), 'scrooge_helper' ) unless defined?(ActiveRecord::Base.connection.class::IGNORED_SQL)
+        require_models()      
       end
             
       def setup!
@@ -31,7 +33,7 @@ module Scrooge
       end
 
       def test_files
-        glob( "#{File.dirname(__FILE__)}/*_test.rb" )
+        glob( "#{File.dirname(__FILE__)}/**/*_test.rb" )
       end
 
       private
@@ -85,4 +87,4 @@ module Scrooge
   end
 end
 
-Scrooge::Test.setup!
+Scrooge::Test.setup!

data/test/models/mysql_column_privilege.rb

@@ -0,0 +1,7 @@
+class MysqlColumnPrivilege < ActiveRecord::Base
+  set_table_name 'columns_priv'
+  set_primary_key nil 
+  
+  belongs_to :mysql_user, :class_name => 'MysqlUser', :foreign_key => 'User'
+  
+end

data/test/models/mysql_host.rb

@@ -0,0 +1,5 @@
+class MysqlHost < ActiveRecord::Base  
+  set_table_name 'host'
+  set_primary_key 'Host'
+  
+end  

data/test/models/mysql_table_privilege.rb

@@ -0,0 +1,8 @@
+class MysqlTablePrivilege < ActiveRecord::Base
+  set_table_name 'tables_priv'
+  set_primary_key nil 
+  
+  belongs_to :mysql_user, :class_name => 'MysqlUser', :foreign_key => 'User'
+  belongs_to :column_privilege, :class_name => 'MysqlColumnPrivilege', :foreign_key => 'Column_priv' 
+  
+end

data/test/models/mysql_user.rb

@@ -2,7 +2,12 @@ class MysqlUser < ActiveRecord::Base
   set_table_name 'user'
   set_primary_key 'User'
   
+  has_many :table_privileges, :class_name => 'MysqlTablePrivilege', :foreign_key => 'User'
+  has_many :column_privileges, :class_name => 'MysqlColumnPrivilege', :foreign_key => 'User'
+  belongs_to :host, :class_name => 'MysqlHost', :foreign_key => 'Host'
+  
   def after_initialize
     max_connections if @attributes.has_key?("max_user_connections")
   end
+  
 end

data/test/optimizations/associations/macro_test.rb

@@ -0,0 +1,27 @@
+require "#{File.dirname(__FILE__)}/../../helper"
+ 
+Scrooge::Test.prepare!
+
+class OptimizationsAssociationsMacroTest < ActiveSupport::TestCase
+  
+  test "should be able to flag any associations instantiated from a record" do
+    @user = MysqlUser.find(:first)
+    @user.host
+    assert_equal MysqlUser.scrooge_callsite( @user.callsite_signature ).associations, Set[:host]
+  end
+
+  test "should only flag preloadable associations" do
+    Scrooge::Callsite.any_instance.expects(:association!).once
+    @user = MysqlUser.find(:first)
+    @user.host
+    assert_equal MysqlUser.scrooge_callsite( @user.callsite_signature ).associations, Set.new
+  end
+  
+  test "should be able to identify all preloadable associations for a given Model" do
+    assert_equal MysqlUser.preloadable_associations, [:host]
+    assert_equal MysqlHost.preloadable_associations, []
+    assert_equal MysqlColumnPrivilege.preloadable_associations, [:mysql_user]
+    assert_equal MysqlTablePrivilege.preloadable_associations, [:mysql_user, :column_privilege]
+  end
+  
+end  

data/test/scrooge_helper.rb

@@ -0,0 +1,12 @@
+# Borrowed from active record's helper
+ActiveRecord::Base.connection.class.class_eval do
+  IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /SHOW FIELDS/]
+
+  def execute_with_query_record(sql, name = nil, &block)
+    $queries_executed ||= []
+    $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
+    execute_without_query_record(sql, name, &block)
+  end
+
+  alias_method_chain :execute, :query_record
+end

data/test/scrooge_test.rb

@@ -1,9 +1,9 @@
 require "#{File.dirname(__FILE__)}/helper"
- 
+
 Scrooge::Test.prepare!
- 
-class ScroogeTest < ActiveSupport::TestCase
-  
+
+class ScroogeTest < ActiveRecord::TestCase
+
   teardown do
     MysqlUser.scrooge_flush_callsites!
   end
@@ -39,6 +39,10 @@ class ScroogeTest < ActiveSupport::TestCase
     assert MysqlUser.find(:first).scrooged?
     assert_instance_of Scrooge::Callsite, MysqlUser.scrooge_callsite( first_callsite )
   end
+
+  test "should not flag records via Model.find with a custom :select requirement as scrooged" do
+    assert !MysqlUser.find(:first, :select => 'user.Password' ).scrooged?
+  end
   
   test "should be able to augment an existing callsite with attributes" do
     MysqlUser.find(:first)
@@ -68,6 +72,10 @@ class ScroogeTest < ActiveSupport::TestCase
     [:max_connections, :max_user_connections].each {|f| MysqlUser.find(:first).read_attribute(f)}
   end
   
+  test "should make 3 queries to fetch same item twice due to reload and remembering" do
+    assert_queries(3) {2.times {MysqlUser.find(:first).max_connections}}
+  end
+  
   def first_callsite
     MysqlUser.scrooge_callsites.to_a.flatten.first
   end

data/test/setup.rb

@@ -1,3 +1,3 @@
 require 'rubygems'
 require 'activerecord'
-require File.join( File.dirname(__FILE__), '..', 'lib', 'scrooge' )
+require File.join( File.dirname(__FILE__), '..', 'lib', 'scrooge' )

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: methodmissing-scrooge
 version: !ruby/object:Gem::Version 
-  version: 2.2.3
+  version: 3.0.0
 platform: ruby
 authors: 
 - "Lourens Naud\xC3\xA9"
@@ -10,12 +10,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-18 00:00:00 -07:00
+date: 2009-03-22 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
 description: An ActiveRecord attribute tracker to ensure production Ruby applications only fetch the database content needed to minimize wire traffic and reduce conversion overheads to native Ruby types.
-email: lourens@methodmissing.com or sds@switchstep.com
+email: lourens@methodmissing.com or sdsykes@gmail.com
 executables: []
 
 extensions: []
@@ -38,9 +38,17 @@ files:
 - lib/optimizations/result_sets/result_array.rb
 - lib/optimizations/result_sets/updateable_result_set.rb
 - lib/scrooge.rb
+- test/callsite_test.rb
 - test/helper.rb
 - test/models
+- test/models/mysql_column_privilege.rb
+- test/models/mysql_host.rb
+- test/models/mysql_table_privilege.rb
 - test/models/mysql_user.rb
+- test/optimizations
+- test/optimizations/associations
+- test/optimizations/associations/macro_test.rb
+- test/scrooge_helper.rb
 - test/scrooge_test.rb
 - test/setup.rb
 - rails/init.rb