activerecord 1.15.6 → 2.0.0

data/lib/active_record/associations/has_many_through_association.rb

@@ -9,7 +9,7 @@ module ActiveRecord
       end
 
       def find(*args)
-        options = Base.send(:extract_options_from_args!, args)
+        options = args.extract_options!
 
         conditions = "#{@finder_sql}"
         if sanitized_conditions = sanitize_sql(options[:conditions])
@@ -51,16 +51,14 @@ module ActiveRecord
         through = @reflection.through_reflection
         raise ActiveRecord::HasManyThroughCantAssociateNewRecords.new(@owner, through) if @owner.new_record?
 
-        load_target
-
         klass = through.klass
         klass.transaction do
           flatten_deeper(records).each do |associate|
             raise_on_type_mismatch(associate)
             raise ActiveRecord::HasManyThroughCantAssociateNewRecords.new(@owner, through) unless associate.respond_to?(:new_record?) && !associate.new_record?
 
-            @owner.send(@reflection.through_reflection.name).proxy_target << klass.with_scope(:create => construct_join_attributes(associate)) { klass.create! }
-            @target << associate
+            @owner.send(@reflection.through_reflection.name).proxy_target << klass.send(:with_scope, :create => construct_join_attributes(associate)) { klass.create! }
+            @target << associate if loaded?
           end
         end
 
@@ -69,9 +67,9 @@ module ActiveRecord
 
       [:push, :concat].each { |method| alias_method method, :<< }
 
-      # Remove +records+ from this association.  Does not destroy +records+.
+      # Removes +records+ from this association.  Does not destroy +records+.
       def delete(*records)
-        return if records.empty?
+        records = flatten_deeper(records)
         records.each { |associate| raise_on_type_mismatch(associate) }
 
         through = @reflection.through_reflection
@@ -85,7 +83,7 @@ module ActiveRecord
             raise_on_type_mismatch(associate)
             raise ActiveRecord::HasManyThroughCantDissociateNewRecords.new(@owner, through) unless associate.respond_to?(:new_record?) && !associate.new_record?
 
-            @owner.send(@reflection.through_reflection.name).proxy_target.delete(klass.delete_all(construct_join_attributes(associate)))
+            @owner.send(through.name).proxy_target.delete(klass.delete_all(construct_join_attributes(associate)))
             @target.delete(associate)
           end
         end
@@ -96,22 +94,33 @@ module ActiveRecord
       def build(attrs = nil)
         raise ActiveRecord::HasManyThroughCantAssociateNewRecords.new(@owner, @reflection.through_reflection)
       end
+      alias_method :new, :build
 
       def create!(attrs = nil)
         @reflection.klass.transaction do
-          self << @reflection.klass.with_scope(:create => attrs) { @reflection.klass.create! }
+          self << (object = @reflection.klass.send(:with_scope, :create => attrs) { @reflection.klass.create! })
+          object
         end
       end
 
+      # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been loaded and
+      # calling collection.size if it has. If it's more likely than not that the collection does have a size larger than zero
+      # and you need to fetch that collection afterwards, it'll take one less SELECT query if you use length.
+      def size
+        return @owner.send(:read_attribute, cached_counter_attribute_name) if has_cached_counter?
+        return @target.size if loaded?
+        return count
+      end
+
       # Calculate sum using SQL, not Enumerable
       def sum(*args, &block)
         calculate(:sum, *args, &block)
       end
       
       def count(*args)
-        column_name, options = @reflection.klass.send(:construct_count_options_from_legacy_args, *args)
+        column_name, options = @reflection.klass.send(:construct_count_options_from_args, *args)
         if @reflection.options[:uniq]
-          # This is needed becase 'SELECT count(DISTINCT *)..' is not valid sql statement.
+          # This is needed because 'SELECT count(DISTINCT *)..' is not valid sql statement.
           column_name = "#{@reflection.klass.table_name}.#{@reflection.klass.primary_key}" if column_name == :all
           options.merge!(:distinct => true) 
         end
@@ -123,7 +132,7 @@ module ActiveRecord
           if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
             super
           else
-            @reflection.klass.with_scope(construct_scope) { @reflection.klass.send(method, *args, &block) }
+            @reflection.klass.send(:with_scope, construct_scope) { @reflection.klass.send(method, *args, &block) }
           end
         end
 
@@ -154,11 +163,11 @@ module ActiveRecord
 
         # Construct attributes for :through pointing to owner and associate.
         def construct_join_attributes(associate)
-          returning construct_owner_attributes(@reflection.through_reflection).merge(@reflection.source_reflection.primary_key_name => associate.id) do |join_attributes|
-            if @reflection.options[:source_type]
-              join_attributes.merge!(@reflection.source_reflection.options[:foreign_type] => associate.class.base_class.name.to_s)
-            end
+          join_attributes = construct_owner_attributes(@reflection.through_reflection).merge(@reflection.source_reflection.primary_key_name => associate.id)
+          if @reflection.options[:source_type]
+            join_attributes.merge!(@reflection.source_reflection.options[:foreign_type] => associate.class.base_class.name.to_s)
           end
+          join_attributes
         end
 
         # Associate attributes pointing to owner, quoted.
@@ -226,7 +235,9 @@ module ActiveRecord
             :find   => { :from        => construct_from,
                          :conditions  => construct_conditions,
                          :joins       => construct_joins,
-                         :select      => construct_select } }
+                         :select      => construct_select,
+                         :order       => @reflection.options[:order],
+                         :limit       => @reflection.options[:limit] } }
         end
 
         def construct_sql
@@ -253,11 +264,20 @@ module ActiveRecord
           @conditions ||= [
             (interpolate_sql(@reflection.klass.send(:sanitize_sql, @reflection.options[:conditions])) if @reflection.options[:conditions]),
             (interpolate_sql(@reflection.active_record.send(:sanitize_sql, @reflection.through_reflection.options[:conditions])) if @reflection.through_reflection.options[:conditions]),
+            (interpolate_sql(@reflection.active_record.send(:sanitize_sql, @reflection.source_reflection.options[:conditions])) if @reflection.source_reflection.options[:conditions]),
             ("#{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.klass.inheritance_column} = #{@reflection.klass.quote_value(@reflection.through_reflection.klass.name.demodulize)}" unless @reflection.through_reflection.klass.descends_from_active_record?)
-          ].compact.collect { |condition| "(#{condition})" }.join(' AND ') unless (!@reflection.options[:conditions] && !@reflection.through_reflection.options[:conditions] && @reflection.through_reflection.klass.descends_from_active_record?)
+          ].compact.collect { |condition| "(#{condition})" }.join(' AND ') unless (!@reflection.options[:conditions] && !@reflection.through_reflection.options[:conditions]  && !@reflection.source_reflection.options[:conditions] && @reflection.through_reflection.klass.descends_from_active_record?)
         end
 
         alias_method :sql_conditions, :conditions
+
+        def has_cached_counter?
+          @owner.attribute_present?(cached_counter_attribute_name)
+        end
+
+        def cached_counter_attribute_name
+          "#{@reflection.name}_count"
+        end
     end
   end
 end

data/lib/active_record/associations/has_one_association.rb

@@ -6,23 +6,16 @@ module ActiveRecord
         construct_sql
       end
 
-      def create(attributes = {}, replace_existing = true)
-        record = build(attributes, replace_existing)
-        record.save
-        record
+      def create(attrs = {}, replace_existing = true)
+        new_record(replace_existing) { |klass| klass.create(attrs) }
       end
 
-      def build(attributes = {}, replace_existing = true)
-        record = @reflection.klass.new(attributes)
-
-        if replace_existing
-          replace(record, true) 
-        else
-          record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
-          self.target = record
-        end
+      def create!(attrs = {}, replace_existing = true)
+        new_record(replace_existing) { |klass| klass.create!(attrs) }
+      end
 
-        record
+      def build(attrs = {}, replace_existing = true)
+        new_record(replace_existing) { |klass| klass.new(attrs) }
       end
 
       def replace(obj, dont_save = false)
@@ -75,6 +68,29 @@ module ActiveRecord
           end
           @finder_sql << " AND (#{conditions})" if conditions
         end
+        
+        def construct_scope
+          create_scoping = {}
+          set_belongs_to_association_for(create_scoping)
+          { :create => create_scoping }
+        end
+
+        def new_record(replace_existing)
+          # Make sure we load the target first, if we plan on replacing the existing
+          # instance. Otherwise, if the target has not previously been loaded
+          # elsewhere, the instance we create will get orphaned.
+          load_target if replace_existing
+          record = @reflection.klass.send(:with_scope, :create => construct_scope[:create]) { yield @reflection.klass }
+
+          if replace_existing
+            replace(record, true) 
+          else
+            record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
+            self.target = record
+          end
+
+          record
+        end
     end
   end
 end

data/lib/active_record/attribute_methods.rb

@@ -1,10 +1,13 @@
 module ActiveRecord
   module AttributeMethods #:nodoc:
     DEFAULT_SUFFIXES = %w(= ? _before_type_cast)
+    ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
 
     def self.included(base)
       base.extend ClassMethods
       base.attribute_method_suffix *DEFAULT_SUFFIXES
+      base.cattr_accessor :attribute_types_cached_by_default, :instance_writer => false
+      base.attribute_types_cached_by_default = ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
     end
 
     # Declare and check for suffixed attribute methods.
@@ -43,6 +46,68 @@ module ActiveRecord
         @@attribute_method_regexp.match(method_name)
       end
 
+
+      # Contains the names of the generated attribute methods.
+      def generated_methods #:nodoc:
+        @generated_methods ||= Set.new
+      end
+      
+      def generated_methods?
+        !generated_methods.empty?
+      end
+      
+      # generates all the attribute related methods for columns in the database
+      # accessors, mutators and query methods
+      def define_attribute_methods
+        return if generated_methods?
+        columns_hash.each do |name, column|
+          unless instance_method_already_implemented?(name)
+            if self.serialized_attributes[name]
+              define_read_method_for_serialized_attribute(name)
+            else
+              define_read_method(name.to_sym, name, column)
+            end
+          end
+
+          unless instance_method_already_implemented?("#{name}=")
+            define_write_method(name.to_sym)
+          end
+
+          unless instance_method_already_implemented?("#{name}?")
+            define_question_method(name)
+          end
+        end
+      end
+
+      # Check to see if the method is defined in the model or any of its subclasses that also derive from ActiveRecord.
+      # Raise DangerousAttributeError if the method is defined by ActiveRecord though.
+      def instance_method_already_implemented?(method_name)
+        return true if method_name =~ /^id(=$|\?$|$)/
+        @_defined_class_methods         ||= Set.new(ancestors.first(ancestors.index(ActiveRecord::Base)).collect! { |m| m.public_instance_methods(false) | m.private_instance_methods(false) | m.protected_instance_methods(false) }.flatten)
+        @@_defined_activerecord_methods ||= Set.new(ActiveRecord::Base.public_instance_methods(false) | ActiveRecord::Base.private_instance_methods(false) | ActiveRecord::Base.protected_instance_methods(false))
+        raise DangerousAttributeError, "#{method_name} is defined by ActiveRecord" if @@_defined_activerecord_methods.include?(method_name)
+        @_defined_class_methods.include?(method_name)
+      end
+      
+      alias :define_read_methods :define_attribute_methods
+
+      # +cache_attributes+ allows you to declare which converted attribute values should
+      # be cached. Usually caching only pays off for attributes with expensive conversion
+      # methods, like date columns (e.g. created_at, updated_at).
+      def cache_attributes(*attribute_names)
+        attribute_names.each {|attr| cached_attributes << attr.to_s}
+      end
+
+      # returns the attributes where
+      def cached_attributes
+        @cached_attributes ||=
+          columns.select{|c| attribute_types_cached_by_default.include?(c.type)}.map(&:name).to_set
+      end
+
+      def cache_attribute?(attr_name)
+        cached_attributes.include?(attr_name)
+      end
+
       private
         # Suffixes a, ?, c become regexp /(a|\?|c)$/
         def rebuild_attribute_method_regexp
@@ -54,9 +119,197 @@ module ActiveRecord
         def attribute_method_suffixes
           @@attribute_method_suffixes ||= []
         end
+        
+        # Define an attribute reader method.  Cope with nil column.
+        def define_read_method(symbol, attr_name, column)
+          cast_code = column.type_cast_code('v') if column
+          access_code = cast_code ? "(v=@attributes['#{attr_name}']) && #{cast_code}" : "@attributes['#{attr_name}']"
+
+          unless attr_name.to_s == self.primary_key.to_s
+            access_code = access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
+          end
+          
+          if cache_attribute?(attr_name)
+            access_code = "@attributes_cache['#{attr_name}'] ||= (#{access_code})"
+          end
+          evaluate_attribute_method attr_name, "def #{symbol}; #{access_code}; end"
+        end
+
+        # Define read method for serialized attribute.
+        def define_read_method_for_serialized_attribute(attr_name)
+          evaluate_attribute_method attr_name, "def #{attr_name}; unserialize_attribute('#{attr_name}'); end"
+        end
+
+        # Define an attribute ? method.
+        def define_question_method(attr_name)
+          evaluate_attribute_method attr_name, "def #{attr_name}?; query_attribute('#{attr_name}'); end", "#{attr_name}?"
+        end
+
+        def define_write_method(attr_name)
+          evaluate_attribute_method attr_name, "def #{attr_name}=(new_value);write_attribute('#{attr_name}', new_value);end", "#{attr_name}="
+        end
+
+        # Evaluate the definition for an attribute related method
+        def evaluate_attribute_method(attr_name, method_definition, method_name=attr_name)
+
+          unless method_name.to_s == primary_key.to_s
+            generated_methods << method_name
+          end
+
+          begin
+            class_eval(method_definition, __FILE__, __LINE__)
+          rescue SyntaxError => err
+            generated_methods.delete(attr_name)
+            if logger
+              logger.warn "Exception occurred during reader method compilation."
+              logger.warn "Maybe #{attr_name} is not a valid Ruby identifier?"
+              logger.warn "#{err.message}"
+            end
+          end
+        end
+    end #  ClassMethods
+
+
+    # Allows access to the object attributes, which are held in the @attributes hash, as though they
+    # were first-class methods. So a Person class with a name attribute can use Person#name and
+    # Person#name= and never directly use the attributes hash -- except for multiple assigns with
+    # ActiveRecord#attributes=. A Milestone class can also ask Milestone#completed? to test that
+    # the completed attribute is not nil or 0.
+    #
+    # It's also possible to instantiate related objects, so a Client class belonging to the clients
+    # table with a master_id foreign key can instantiate master through Client#master.
+    def method_missing(method_id, *args, &block)
+      method_name = method_id.to_s
+
+      # If we haven't generated any methods yet, generate them, then
+      # see if we've created the method we're looking for.
+      if !self.class.generated_methods?
+        self.class.define_attribute_methods
+        if self.class.generated_methods.include?(method_name)
+          return self.send(method_id, *args, &block)
+        end
+      end
+      
+      if self.class.primary_key.to_s == method_name
+        id
+      elsif md = self.class.match_attribute_method?(method_name)
+        attribute_name, method_type = md.pre_match, md.to_s
+        if @attributes.include?(attribute_name)
+          __send__("attribute#{method_type}", attribute_name, *args, &block)
+        else
+          super
+        end
+      elsif @attributes.include?(method_name)
+        read_attribute(method_name)
+      else
+        super
+      end
+    end
+
+    # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
+    # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
+    def read_attribute(attr_name)
+      attr_name = attr_name.to_s
+      if !(value = @attributes[attr_name]).nil?
+        if column = column_for_attribute(attr_name)
+          if unserializable_attribute?(attr_name, column)
+            unserialize_attribute(attr_name)
+          else
+            column.type_cast(value)
+          end
+        else
+          value
+        end
+      else
+        nil
+      end
+    end
+
+    def read_attribute_before_type_cast(attr_name)
+      @attributes[attr_name]
+    end
+
+    # Returns true if the attribute is of a text column and marked for serialization.
+    def unserializable_attribute?(attr_name, column)
+      column.text? && self.class.serialized_attributes[attr_name]
+    end
+
+    # Returns the unserialized object of the attribute.
+    def unserialize_attribute(attr_name)
+      unserialized_object = object_from_yaml(@attributes[attr_name])
+
+      if unserialized_object.is_a?(self.class.serialized_attributes[attr_name]) || unserialized_object.nil?
+        @attributes.frozen? ? unserialized_object : @attributes[attr_name] = unserialized_object
+      else
+        raise SerializationTypeMismatch,
+          "#{attr_name} was supposed to be a #{self.class.serialized_attributes[attr_name]}, but was a #{unserialized_object.class.to_s}"
+      end
+    end
+  
+
+    # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+. Empty strings for fixnum and float
+    # columns are turned into nil.
+    def write_attribute(attr_name, value)
+      attr_name = attr_name.to_s
+      @attributes_cache.delete(attr_name)
+      if (column = column_for_attribute(attr_name)) && column.number?
+        @attributes[attr_name] = convert_number_column_value(value)
+      else
+        @attributes[attr_name] = value
+      end
+    end
+
+
+    def query_attribute(attr_name)
+      unless value = read_attribute(attr_name)
+        false
+      else
+        column = self.class.columns_hash[attr_name]
+        if column.nil?
+          if Numeric === value || value !~ /[^0-9]/
+            !value.to_i.zero?
+          else
+            !value.blank?
+          end
+        elsif column.number?
+          !value.zero?
+        else
+          !value.blank?
+        end
+      end
     end
+    
+    # A Person object with a name attribute can ask person.respond_to?("name"), person.respond_to?("name="), and
+    # person.respond_to?("name?") which will all return true.
+    alias :respond_to_without_attributes? :respond_to?
+    def respond_to?(method, include_priv = false)
+      method_name = method.to_s
+      if super
+        return true
+      elsif !self.class.generated_methods?
+        self.class.define_attribute_methods
+        if self.class.generated_methods.include?(method_name)
+          return true
+        end
+      end
+        
+      if @attributes.nil?
+        return super
+      elsif @attributes.include?(method_name)
+        return true
+      elsif md = self.class.match_attribute_method?(method_name)
+        return true if @attributes.include?(md.pre_match)
+      end
+      super
+    end
+    
 
     private
+    
+      def missing_attribute(attr_name, stack)
+        raise ActiveRecord::MissingAttributeError, "missing attribute: #{attr_name}", stack
+      end
+      
       # Handle *? for method_missing.
       def attribute?(attribute_name)
         query_attribute(attribute_name)