methodmissing-scrooge 2.2.0 → 2.2.1

data/README.textile

@@ -214,7 +214,7 @@ h2. Todo
 
 * Deeper coverage for Scrooge::AttributesProxy ( pending conversion to a subclass of Hash instead )
 
-* Extract Scrooge::Callsite
+* Test cases for Scrooge::Callsite
 
 * Track both columns AND association invocations off Scrooge::Callsite
 

data/VERSION.yml

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

data/lib/callsite.rb

@@ -0,0 +1,76 @@
+module Scrooge
+  class Callsite
+    
+    # Represents a Callsite and is a container for any columns and 
+    # associations ( coming soon ) referenced at the callsite.
+    #
+    
+    Mutex = Mutex.new
+    
+    attr_accessor :klass,
+                  :signature,
+                  :columns,
+                  :associations
+    
+    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
+      end
+    end
+    
+    # Flag an association as seen
+    #
+    def association!( association )
+      Mutex.synchronize do
+        @associations << association
+      end
+    end
+    
+    private
+    
+      # Is the table a container for STI models ?
+      # 
+      def inheritable?
+        @klass.column_names.include?( inheritance_column )
+      end
+    
+      # Ensure that at least the primary key and optionally the inheritance
+      # column ( for STI ) is set. 
+      #
+      def setup_columns
+        if inheritable?
+          Set.new([primary_key, inheritance_column])
+        else
+          Set.new([primary_key])
+        end    
+      end
+    
+      # Stubbed for future use
+      #
+      def setup_associations
+        Set.new
+      end
+    
+      # Memoize a string representation of the inheritance column
+      #
+      def inheritance_column
+        @inheritance_column ||= @klass.inheritance_column.to_s
+      end
+
+      # Memoize a string representation of the primary
+      #    
+      def primary_key
+        @primary_key ||= @klass.primary_key.to_s
+      end    
+    
+  end
+end

data/lib/optimizations/columns/attributes_proxy.rb

@@ -0,0 +1,138 @@
+class Hash
+  
+  # TODO: Circumvent this hack  
+  alias_method :update_without_scrooge, :update
+  def update(other)
+    update_without_scrooge(other.to_hash)
+  end
+  
+end
+
+module Scrooge
+  module Optimizations
+    module Columns
+      class AttributesProxy < Hash
+        
+        # Hash like Proxy container for attributes
+        #        
+        
+        attr_accessor :callsite_signature, :scrooge_columns, :fully_fetched, :klass
+
+        def self.setup(record, scrooge_columns, klass, callsite_signature)
+          hash = new.replace(record)
+          hash.scrooge_columns = scrooge_columns.dup
+          hash.fully_fetched = false
+          hash.klass = klass
+          hash.callsite_signature = callsite_signature
+          hash
+        end
+
+        # Delegate Hash keys to all defined columns
+        #
+        def keys
+          @klass.column_names
+        end
+
+        # Let #has_key? consider defined columns
+        #
+        def has_key?(attr_name)
+          keys.include?(attr_name.to_s)
+        end
+
+        alias_method :include?, :has_key?
+        alias_method :key?, :has_key?
+        alias_method :member?, :has_key?
+
+        # Lazily augment and load missing attributes
+        #
+        def [](attr_name)
+          attr_s = attr_name.to_s
+          if interesting_for_scrooge?( attr_s )
+            augment_callsite!( attr_s )
+            fetch_remaining
+            @scrooge_columns << attr_s
+          end
+          super
+        end
+
+        def fetch(*args, &block)
+          self[args[0]]
+          super
+        end
+
+        def []=(attr_name, value)
+          @scrooge_columns << attr_name.to_s
+          super
+        end
+        
+        alias_method :store, :[]=
+
+        def dup
+          super.dup_self
+        end
+
+        def to_hash
+          fetch_remaining
+          super
+        end
+
+        def to_a
+          fetch_remaining
+          super
+        end
+
+        def delete(attr_name)
+          self[attr_name]
+          super
+        end
+
+        def update(hash)
+          @fully_fetched = true
+          super
+        end
+        
+        alias_method :merge!, :update
+
+        def fetch_remaining
+          unless @fully_fetched
+            columns_to_fetch = @klass.column_names - @scrooge_columns.to_a
+            unless columns_to_fetch.empty?
+              fetch_remaining!( columns_to_fetch )
+            end
+            @fully_fetched = true
+          end
+        end
+
+        protected
+
+          def fetch_remaining!( columns_to_fetch )
+            begin
+              new_object = fetch_record_with_remaining_columns( columns_to_fetch )
+            rescue ActiveRecord::RecordNotFound
+              raise ActiveRecord::MissingAttributeError, "scrooge cannot fetch missing attribute(s) #{columns_to_fetch.to_a.join(', ')} because record went away"
+            end
+            replace(new_object.instance_variable_get(:@attributes).merge(self))
+          end
+
+          def fetch_record_with_remaining_columns( columns_to_fetch )
+            @klass.send(:with_exclusive_scope) do
+              @klass.find(self[@klass.primary_key], :select=>@klass.scrooge_select_sql(columns_to_fetch))
+            end
+          end
+
+          def interesting_for_scrooge?( attr_s )
+            has_key?(attr_s) && !@scrooge_columns.include?(attr_s)
+          end
+
+          def augment_callsite!( attr_s )
+            @klass.scrooge_seen_column!(callsite_signature, attr_s)
+          end
+
+          def dup_self
+            @scrooge_columns = @scrooge_columns.dup
+            self
+          end
+      end
+    end
+  end
+end    

data/lib/optimizations/columns/macro.rb

@@ -0,0 +1,186 @@
+module Scrooge
+  module Optimizations 
+    module Columns
+      module Macro
+        
+        class << self
+          
+          # Inject into ActiveRecord
+          #
+          def install!
+            if scrooge_installable?
+              ActiveRecord::Base.send( :extend,  Scrooge::Optimizations::Columns::SingletonMethods )
+              ActiveRecord::Base.send( :include, Scrooge::Optimizations::Columns::InstanceMethods )              
+            end  
+          end
+      
+          private
+          
+            def scrooge_installable?
+              !ActiveRecord::Base.included_modules.include?( Scrooge::Optimizations::Columns::InstanceMethods )
+            end
+         
+        end
+        
+      end
+      
+      module SingletonMethods
+     
+        ScroogeBlankString = "".freeze
+        ScroogeComma = ",".freeze 
+        ScroogeRegexSanitize = /(?:LIMIT|WHERE|FROM|GROUP\s*BY|HAVING|ORDER\s*BY|PROCEDURE|FOR\s*UPDATE|INTO\s*OUTFILE).*/i
+        ScroogeRegexJoin = /(?:left|inner|outer|cross)*\s*(?:straight_join|join)/i
+        
+        @@scrooge_select_regexes = {}
+        
+        # Augment a given callsite signature with a column / attribute.
+        #
+        def scrooge_seen_column!( callsite_signature, attr_name )
+          scrooge_callsite( callsite_signature ).column!( attr_name )
+        end        
+        
+        # Generates a SELECT snippet for this Model from a given Set of columns
+        #
+        def scrooge_select_sql( set )
+          set.map{|a| attribute_with_table( a ) }.join( ScroogeComma )
+        end        
+        
+        # Marshal.load
+        # 
+        def _load(str)
+          Marshal.load(str)
+        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_signature = (caller[ActiveRecord::Base::ScroogeCallsiteSample] << callsite_sql( sql )).hash
+            callsite_set = scrooge_callsite(callsite_signature).columns
+            sql = sql.gsub(scrooge_select_regex, "SELECT #{scrooge_select_sql(callsite_set)} FROM")
+            result = connection.select_all(sanitize_sql(sql), "#{name} Load Scrooged").collect! do |record|
+              instantiate( Scrooge::Optimizations::Columns::AttributesProxy.setup(record, callsite_set, self, callsite_signature) )
+            end
+          end        
+        
+            # Generate a regex that respects the table name as well to catch
+            # verbose SQL from JOINS etc.
+            # 
+            def scrooge_select_regex
+              @@scrooge_select_regexes[self.table_name] ||= Regexp.compile( "SELECT (`?(?:#{table_name})?`?.?\\*) FROM" )
+            end
+
+            # Trim any conditions
+            #
+            def callsite_sql( sql )
+              sql.gsub(ScroogeRegexSanitize, ScroogeBlankString)
+            end
+                    
+      end
+      
+      module InstanceMethods
+        
+        def self.included( base )
+          base.alias_method_chain :delete, :scrooge
+          base.alias_method_chain :destroy, :scrooge
+          base.alias_method_chain :respond_to?, :scrooge
+        end
+        
+        # Is this instance being handled by scrooge?
+        #
+        def scrooged?
+          @attributes.is_a?(Scrooge::Optimizations::Columns::AttributesProxy)
+        end        
+        
+        # Delete should fully load all the attributes before the @attributes hash is frozen
+        #
+        def delete_with_scrooge
+          scrooge_fetch_remaining
+          delete_without_scrooge
+        end        
+      
+        # Destroy should fully load all the attributes before the @attributes hash is frozen
+        #
+        def destroy_with_scrooge
+          scrooge_fetch_remaining
+          destroy_without_scrooge
+        end      
+        
+        # Augment callsite info for new model class when using STI
+        #
+        def becomes(klass)
+          returning klass.new do |became|
+            became.instance_variable_set("@attributes", @attributes)
+            became.instance_variable_set("@attributes_cache", @attributes_cache)
+            became.instance_variable_set("@new_record", new_record?)
+            if scrooged?
+              self.class.scrooge_callsite(@attributes.callsite_signature).columns.each do |attrib|
+                became.class.scrooge_seen_column!(@attributes.callsite_signature, attrib)
+              end
+            end
+          end
+        end     
+
+        # Marshal
+        # force a full load if needed, and remove any possibility for missing attr flagging
+        #
+        def _dump(depth)
+          scrooge_fetch_remaining
+          scrooge_dump_flag_this
+          str = Marshal.dump(self)
+          scrooge_dump_unflag_this
+          str
+        end
+        
+        # Enables us to use Marshal.dump inside our _dump method without an infinite loop
+        #
+        def respond_to_with_scrooge?(symbol, include_private=false)
+          if symbol == :_dump && scrooge_dump_flagged?
+            false
+          else
+            respond_to_without_scrooge?(symbol, include_private)
+          end
+        end
+
+        private
+
+          # Flag Marshal dump in progress
+          #
+          def scrooge_dump_flag_this
+            Thread.current[:scrooge_dumping_objects] ||= []
+            Thread.current[:scrooge_dumping_objects] << object_id
+          end
+
+          # Flag Marhsal dump not in progress
+          #
+          def scrooge_dump_unflag_this
+            Thread.current[:scrooge_dumping_objects].delete(object_id)
+          end
+
+          # Flag scrooge as dumping ( excuse my French )
+          #
+          def scrooge_dump_flagged?
+            Thread.current[:scrooge_dumping_objects] &&
+            Thread.current[:scrooge_dumping_objects].include?(object_id)
+          end
+
+          # Fetch any missing attributes
+          #
+          def scrooge_fetch_remaining
+            @attributes.fetch_remaining if scrooged?
+          end
+        
+      end
+      
+    end
+  end
+end

data/lib/scrooge.rb

@@ -1,19 +1,14 @@
 $:.unshift(File.dirname(__FILE__))
 
 require 'set'
-require 'attributes_proxy'
+require 'callsite'
+require 'optimizations/columns/attributes_proxy'
+require 'optimizations/columns/macro'
 
 module ActiveRecord
   class Base
 
-    @@scrooge_mutex = Mutex.new
     @@scrooge_callsites = {}
-    @@scrooge_select_regexes = {}
-
-    ScroogeBlankString = "".freeze
-    ScroogeComma = ",".freeze 
-    ScroogeRegexWhere = /WHERE.*/i
-    ScroogeRegexJoin = /(?:left|inner|outer|cross)*\s*(?:straight_join|join)/i
     ScroogeCallsiteSample = 0..10
 
     class << self
@@ -29,198 +24,43 @@ module ActiveRecord
           find_by_sql_without_scrooge(sql)
         end
       end
-
-      # Populate the storage for a given callsite signature
-      #
-      def scrooge_callsite_set!(callsite_signature, set)
-        @@scrooge_callsites[self.table_name][callsite_signature] = set
-      end  
-
-      # Reference storage for a given callsite signature
-      #
-      def scrooge_callsite_set(callsite_signature)
-        scrooge_callsites
-        @@scrooge_callsites[self.table_name][callsite_signature]
-      end
       
       # Expose known callsites for this model
       #      
       def scrooge_callsites
         @@scrooge_callsites[self.table_name] ||= {}
       end
-      
+
+      # Fetch or setup a callsite instance for a given signature
+      #
+      def scrooge_callsite( callsite_signature )
+        @@scrooge_callsites[self.table_name] ||= {}
+        @@scrooge_callsites[self.table_name][callsite_signature] ||= callsite( callsite_signature )
+      end
+
       # Flush all known callsites.Mostly a test helper.
       #      
       def scrooge_flush_callsites!
         @@scrooge_callsites[self.table_name] = {}
       end
-       
-      # Augment a given callsite signature with a column / attribute.
-      #
-      def augment_scrooge_callsite!( callsite_signature, attr_name )
-        set = set_for_callsite( callsite_signature )  # make set if needed - eg unserialized models after restart
-        @@scrooge_mutex.synchronize do
-          set << attr_name
-        end
-      end
-
-      # Generates a SELECT snippet for this Model from a given Set of columns
-      #
-      def scrooge_sql( set )
-        set.map{|a| attribute_with_table( a ) }.join( ScroogeComma )
-      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_signature = (caller[ScroogeCallsiteSample] << sql.gsub(ScroogeRegexWhere, ScroogeBlankString)).hash
-        callsite_set = set_for_callsite(callsite_signature)
-        sql = sql.gsub(scrooge_select_regex, "SELECT #{scrooge_sql(callsite_set)} FROM")
-        result = connection.select_all(sanitize_sql(sql), "#{name} Load Scrooged").collect! do |record|
-          instantiate(Scrooge::AttributesProxy.new(record, callsite_set, self, callsite_signature))
+        # Initialize a callsite
+        #
+        def callsite( signature )
+          Scrooge::Callsite.new( self, signature )      
         end
-      end
 
-      # Return an attribute Set for a given callsite signature.
-      # Respects already tracked columns and ensures at least the primary key
-      # if this is a fresh callsite.
-      #
-      def set_for_callsite( callsite_signature )
-        @@scrooge_mutex.synchronize do
-          callsite_set = scrooge_callsite_set(callsite_signature)
-          unless callsite_set
-            callsite_set = scrooge_default_callsite_set
-            scrooge_callsite_set!(callsite_signature, callsite_set) 
-          end
-          callsite_set
+        # Link the column to its table
+        #
+        def attribute_with_table( attr_name )
+          "#{quoted_table_name}.#{attr_name.to_s}"
         end
-      end
-
-      # Ensure that the inheritance column is defined for the callsite if
-      # this is an STI klass tree. 
-      #
-      def scrooge_default_callsite_set
-        if column_names.include?( self.inheritance_column.to_s )
-          Set.new([self.primary_key.to_s, self.inheritance_column.to_s])
-        else
-          Set.new([self.primary_key.to_s])
-        end    
-      end
-
-      # Generate a regex that respects the table name as well to catch
-      # verbose SQL from JOINS etc.
-      # 
-      def scrooge_select_regex
-        @@scrooge_select_regexes[self.table_name] ||= Regexp.compile( "SELECT (`?(?:#{table_name})?`?.?\\*) FROM" )
-      end
-
-      # Link the column to its table
-      #
-      def attribute_with_table( attr_name )
-        "#{quoted_table_name}.#{attr_name.to_s}"
-      end
 
     end  # class << self
 
-    # Is this instance being handled by scrooge?
-    #
-    def scrooged?
-      @attributes.is_a?(Scrooge::AttributesProxy)
-    end
-    
-    # Delete should fully load all the attributes before the @attributes hash is frozen
-    #
-    alias_method :delete_without_scrooge, :delete
-    def delete
-      scrooge_fetch_remaining
-      delete_without_scrooge
-    end
-
-    # Destroy should fully load all the attributes before the @attributes hash is frozen
-    #
-    alias_method :destroy_without_scrooge, :destroy
-    def destroy
-      scrooge_fetch_remaining
-      destroy_without_scrooge
-    end
-
-    # Augment callsite info for new model class when using STI
-    #
-    def becomes(klass)
-      returning klass.new do |became|
-        became.instance_variable_set("@attributes", @attributes)
-        became.instance_variable_set("@attributes_cache", @attributes_cache)
-        became.instance_variable_set("@new_record", new_record?)
-        if scrooged?
-          self.class.scrooge_callsite_set(@attributes.callsite_signature).each do |attrib|
-            became.class.augment_scrooge_callsite!(@attributes.callsite_signature, attrib)
-          end
-        end
-      end
-    end
-
-    # Marshal
-    # force a full load if needed, and remove any possibility for missing attr flagging
-    #
-    def _dump(depth)
-      scrooge_fetch_remaining
-      scrooge_dump_flag_this
-      str = Marshal.dump(self)
-      scrooge_dump_unflag_this
-      str
-    end
-
-    # Marshal.load
-    # 
-    def self._load(str)
-      Marshal.load(str)
-    end
-
-    # Enables us to use Marshal.dump inside our _dump method without an infinite loop
-    #
-    alias_method :respond_to_without_scrooge, :respond_to?
-    def respond_to?(symbol, include_private=false)
-      if symbol == :_dump && scrooge_dump_flagged?
-        false
-      else
-        respond_to_without_scrooge(symbol, include_private)
-      end
-    end
-
-    private
-
-    # Flag Marshal dump in progress
-    #
-    def scrooge_dump_flag_this
-      Thread.current[:scrooge_dumping_objects] ||= []
-      Thread.current[:scrooge_dumping_objects] << object_id
-    end
-
-    # Flag Marhsal dump not in progress
-    #
-    def scrooge_dump_unflag_this
-      Thread.current[:scrooge_dumping_objects].delete(object_id)
-    end
-
-    # Flag scrooge as dumping ( excuse my French )
-    #
-    def scrooge_dump_flagged?
-      Thread.current[:scrooge_dumping_objects] && Thread.current[:scrooge_dumping_objects].include?(object_id)
-    end
-
-    def scrooge_fetch_remaining
-      @attributes.fetch_remaining if scrooged?
-    end
-
   end
-end
+end
+
+Scrooge::Optimizations::Columns::Macro.install!

data/test/scrooge_test.rb

@@ -37,27 +37,22 @@ class ScroogeTest < ActiveSupport::TestCase
   
   test "should be able to retrieve a callsite form a given signature" do
     assert MysqlUser.find(:first).scrooged?
-    assert_instance_of Set, MysqlUser.scrooge_callsite_set( first_callsite )
-  end
-  
-  test "should be able to populate the callsite for a given signature" do
-    MysqlUser.scrooge_callsite_set!(123456, Set[1,2,3])
-    assert_equal MysqlUser.scrooge_callsite_set(123456), Set[1,2,3]
+    assert_instance_of Scrooge::Callsite, MysqlUser.scrooge_callsite( first_callsite )
   end
   
   test "should be able to augment an existing callsite with attributes" do
     MysqlUser.find(:first)
-    MysqlUser.augment_scrooge_callsite!( first_callsite, 'Password' )
-    assert MysqlUser.scrooge_callsite_set( first_callsite ).include?( 'Password' )
+    MysqlUser.scrooge_seen_column!( first_callsite, 'Password' )
+    assert MysqlUser.scrooge_callsite( first_callsite ).columns.include?( 'Password' )
   end
   
   test "should be able to generate a SQL select snippet from a given set" do
-    assert_equal MysqlUser.scrooge_sql( Set['Password','User','Host'] ), "`user`.User,`user`.Password,`user`.Host"
+    assert_equal MysqlUser.scrooge_select_sql( Set['Password','User','Host'] ), "`user`.User,`user`.Password,`user`.Host"
   end
  
   test "should be able to augment an existing callsite when attributes is referenced that we haven't seen yet" do
     user = MysqlUser.find(:first)
-    MysqlUser.expects(:augment_scrooge_callsite!).times(2)
+    MysqlUser.expects(:scrooge_seen_column!).times(2)
     user.Password
     user.Host
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: methodmissing-scrooge
 version: !ruby/object:Gem::Version 
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors: 
 - "Lourens Naud\xC3\xA9"
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-13 00:00:00 -07:00
+date: 2009-03-15 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -27,7 +27,11 @@ files:
 - README
 - README.textile
 - VERSION.yml
-- lib/attributes_proxy.rb
+- lib/callsite.rb
+- lib/optimizations
+- lib/optimizations/columns
+- lib/optimizations/columns/attributes_proxy.rb
+- lib/optimizations/columns/macro.rb
 - lib/scrooge.rb
 - test/helper.rb
 - test/models

data/lib/attributes_proxy.rb

@@ -1,121 +0,0 @@
-module Scrooge
-  class AttributesProxy
-    attr_reader :callsite_signature
-
-    def initialize(record, scrooge_columns, klass, callsite_signature)
-      @attributes = record
-      @scrooge_columns = scrooge_columns.dup
-      @fully_fetched = false
-      @klass = klass
-      @callsite_signature = callsite_signature
-    end
-
-    # Delegate Hash keys to all defined columns
-    #
-    def keys
-      @klass.column_names
-    end
-
-    # Let #has_key? consider defined columns
-    #
-    def has_key?(attr_name)
-      keys.include?(attr_name.to_s)
-    end
-
-    alias_method :include?, :has_key?
-    alias_method :key?, :has_key?
-
-    # Lazily augment and load missing attributes
-    #
-    def [](attr_name)
-      attr_s = attr_name.to_s
-      if interesting_for_scrooge?( attr_s )
-        augment_callsite!( attr_s )
-        fetch_remaining
-        @scrooge_columns << attr_s
-      end
-      @attributes[attr_s]
-    end
-
-    def fetch(*args, &block)
-      self[args[0]]
-      @attributes.fetch(*args, &block)
-    end
-
-    def []=(attr_name, value)
-      attr_s = attr_name.to_s
-      @attributes[attr_s] = value
-      @scrooge_columns << attr_s
-    end
-
-    def dup
-      super.dup_self
-    end
-
-    def to_a
-      fetch_remaining
-      @attributes.to_a
-    end
-
-    def delete(attr_name)
-      self[attr_name]
-      @attributes.delete(attr_name)
-    end
-
-    def update(hash)
-      hash.to_hash.each do |k, v|
-        self[k] = v
-      end
-    end
-
-    def to_hash
-      fetch_remaining
-      @attributes
-    end
-
-    def freeze
-      @attributes.freeze
-    end
-
-    def frozen?
-      @attributes.frozen?
-    end
-
-    def fetch_remaining
-      unless @fully_fetched
-        columns_to_fetch = @klass.column_names - @scrooge_columns.to_a
-        unless columns_to_fetch.empty?
-          begin
-            new_object = fetch_record_with_remaining_columns( columns_to_fetch )
-          rescue ActiveRecord::RecordNotFound
-            raise ActiveRecord::MissingAttributeError, "scrooge cannot fetch missing attribute(s) because record went away"
-          end
-          @attributes = new_object.instance_variable_get(:@attributes).merge(@attributes)
-        end
-        @fully_fetched = true
-      end
-    end
-
-    protected
-
-    def fetch_record_with_remaining_columns( columns_to_fetch )
-      @klass.send(:with_exclusive_scope) do
-        @klass.find(@attributes[@klass.primary_key], :select=>@klass.scrooge_sql(columns_to_fetch))
-      end
-    end
-
-    def interesting_for_scrooge?( attr_s )
-      has_key?(attr_s) && !@scrooge_columns.include?(attr_s)
-    end
-
-    def augment_callsite!( attr_s )
-      @klass.augment_scrooge_callsite!(callsite_signature, attr_s)
-    end
-
-    def dup_self
-      @attributes = @attributes.dup
-      @scrooge_columns = @scrooge_columns.dup
-      self
-    end
-  end
-end