activerecord 3.1.12 → 3.2.22.1

data/lib/active_record/model_schema.rb

@@ -0,0 +1,368 @@
+require 'active_support/concern'
+
+module ActiveRecord
+  module ModelSchema
+    extend ActiveSupport::Concern
+
+    included do
+      ##
+      # :singleton-method:
+      # Accessor for the prefix type that will be prepended to every primary key column name.
+      # The options are :table_name and :table_name_with_underscore. If the first is specified,
+      # the Product class will look for "productid" instead of "id" as the primary column. If the
+      # latter is specified, the Product class will look for "product_id" instead of "id". Remember
+      # that this is a global setting for all Active Records.
+      cattr_accessor :primary_key_prefix_type, :instance_writer => false
+      self.primary_key_prefix_type = nil
+
+      ##
+      # :singleton-method:
+      # Accessor for the name of the prefix string to prepend to every table name. So if set
+      # to "basecamp_", all table names will be named like "basecamp_projects", "basecamp_people",
+      # etc. This is a convenient way of creating a namespace for tables in a shared database.
+      # By default, the prefix is the empty string.
+      #
+      # If you are organising your models within modules you can add a prefix to the models within
+      # a namespace by defining a singleton method in the parent module called table_name_prefix which
+      # returns your chosen prefix.
+      class_attribute :table_name_prefix, :instance_writer => false
+      self.table_name_prefix = ""
+
+      ##
+      # :singleton-method:
+      # Works like +table_name_prefix+, but appends instead of prepends (set to "_basecamp" gives "projects_basecamp",
+      # "people_basecamp"). By default, the suffix is the empty string.
+      class_attribute :table_name_suffix, :instance_writer => false
+      self.table_name_suffix = ""
+
+      ##
+      # :singleton-method:
+      # Indicates whether table names should be the pluralized versions of the corresponding class names.
+      # If true, the default table name for a Product class will be +products+. If false, it would just be +product+.
+      # See table_name for the full rules on table/class naming. This is true, by default.
+      class_attribute :pluralize_table_names, :instance_writer => false
+      self.pluralize_table_names = true
+    end
+
+    module ClassMethods
+      # Guesses the table name (in forced lower-case) based on the name of the class in the
+      # inheritance hierarchy descending directly from ActiveRecord::Base. So if the hierarchy
+      # looks like: Reply < Message < ActiveRecord::Base, then Message is used
+      # to guess the table name even when called on Reply. The rules used to do the guess
+      # are handled by the Inflector class in Active Support, which knows almost all common
+      # English inflections. You can add new inflections in config/initializers/inflections.rb.
+      #
+      # Nested classes are given table names prefixed by the singular form of
+      # the parent's table name. Enclosing modules are not considered.
+      #
+      # ==== Examples
+      #
+      #   class Invoice < ActiveRecord::Base
+      #   end
+      #
+      #   file                  class               table_name
+      #   invoice.rb            Invoice             invoices
+      #
+      #   class Invoice < ActiveRecord::Base
+      #     class Lineitem < ActiveRecord::Base
+      #     end
+      #   end
+      #
+      #   file                  class               table_name
+      #   invoice.rb            Invoice::Lineitem   invoice_lineitems
+      #
+      #   module Invoice
+      #     class Lineitem < ActiveRecord::Base
+      #     end
+      #   end
+      #
+      #   file                  class               table_name
+      #   invoice/lineitem.rb   Invoice::Lineitem   lineitems
+      #
+      # Additionally, the class-level +table_name_prefix+ is prepended and the
+      # +table_name_suffix+ is appended. So if you have "myapp_" as a prefix,
+      # the table name guess for an Invoice class becomes "myapp_invoices".
+      # Invoice::Lineitem becomes "myapp_invoice_lineitems".
+      #
+      # You can also set your own table name explicitly:
+      #
+      #   class Mouse < ActiveRecord::Base
+      #     self.table_name = "mice"
+      #   end
+      #
+      # Alternatively, you can override the table_name method to define your
+      # own computation. (Possibly using <tt>super</tt> to manipulate the default
+      # table name.) Example:
+      #
+      #   class Post < ActiveRecord::Base
+      #     def self.table_name
+      #       "special_" + super
+      #     end
+      #   end
+      #   Post.table_name # => "special_posts"
+      def table_name
+        reset_table_name unless defined?(@table_name)
+        @table_name
+      end
+
+      def original_table_name #:nodoc:
+        deprecated_original_property_getter :table_name
+      end
+
+      # Sets the table name explicitly. Example:
+      #
+      #   class Project < ActiveRecord::Base
+      #     self.table_name = "project"
+      #   end
+      #
+      # You can also just define your own <tt>self.table_name</tt> method; see
+      # the documentation for ActiveRecord::Base#table_name.
+      def table_name=(value)
+        @original_table_name = @table_name if defined?(@table_name)
+        @table_name          = value && value.to_s
+        @quoted_table_name   = nil
+        @arel_table          = nil
+        @relation            = Relation.new(self, arel_table)
+      end
+
+      def set_table_name(value = nil, &block) #:nodoc:
+        deprecated_property_setter :table_name, value, block
+        @quoted_table_name = nil
+        @arel_table        = nil
+        @relation          = Relation.new(self, arel_table)
+      end
+
+      # Returns a quoted version of the table name, used to construct SQL statements.
+      def quoted_table_name
+        @quoted_table_name ||= connection.quote_table_name(table_name)
+      end
+
+      # Computes the table name, (re)sets it internally, and returns it.
+      def reset_table_name #:nodoc:
+        if abstract_class?
+          self.table_name = if superclass == Base || superclass.abstract_class?
+                              nil
+                            else
+                              superclass.table_name
+                            end
+        elsif superclass.abstract_class?
+          self.table_name = superclass.table_name || compute_table_name
+        else
+          self.table_name = compute_table_name
+        end
+      end
+
+      def full_table_name_prefix #:nodoc:
+        (parents.detect{ |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
+      end
+
+      # The name of the column containing the object's class when Single Table Inheritance is used
+      def inheritance_column
+        if self == Base
+          (@inheritance_column ||= nil) || 'type'
+        else
+          (@inheritance_column ||= nil) || superclass.inheritance_column
+        end
+      end
+
+      def original_inheritance_column #:nodoc:
+        deprecated_original_property_getter :inheritance_column
+      end
+
+      # Sets the value of inheritance_column
+      def inheritance_column=(value)
+        @original_inheritance_column = inheritance_column
+        @inheritance_column          = value.to_s
+        @explicit_inheritance_column = true
+      end
+
+      def set_inheritance_column(value = nil, &block) #:nodoc:
+        deprecated_property_setter :inheritance_column, value, block
+      end
+
+      def sequence_name
+        if base_class == self
+          @sequence_name ||= reset_sequence_name
+        else
+          (@sequence_name ||= nil) || base_class.sequence_name
+        end
+      end
+
+      def original_sequence_name #:nodoc:
+        deprecated_original_property_getter :sequence_name
+      end
+
+      def reset_sequence_name #:nodoc:
+        self.sequence_name = connection.default_sequence_name(table_name, primary_key)
+      end
+
+      # Sets the name of the sequence to use when generating ids to the given
+      # value, or (if the value is nil or false) to the value returned by the
+      # given block. This is required for Oracle and is useful for any
+      # database which relies on sequences for primary key generation.
+      #
+      # If a sequence name is not explicitly set when using Oracle or Firebird,
+      # it will default to the commonly used pattern of: #{table_name}_seq
+      #
+      # If a sequence name is not explicitly set when using PostgreSQL, it
+      # will discover the sequence corresponding to your primary key for you.
+      #
+      #   class Project < ActiveRecord::Base
+      #     self.sequence_name = "projectseq"   # default would have been "project_seq"
+      #   end
+      def sequence_name=(value)
+        @original_sequence_name = @sequence_name if defined?(@sequence_name)
+        @sequence_name          = value.to_s
+      end
+
+      def set_sequence_name(value = nil, &block) #:nodoc:
+        deprecated_property_setter :sequence_name, value, block
+      end
+
+      # Indicates whether the table associated with this class exists
+      def table_exists?
+        connection.schema_cache.table_exists?(table_name)
+      end
+
+      # Returns an array of column objects for the table associated with this class.
+      def columns
+        @columns ||= connection.schema_cache.columns[table_name].map do |col|
+          col = col.dup
+          col.primary = (col.name == primary_key)
+          col
+        end
+      end
+
+      # Returns a hash of column objects for the table associated with this class.
+      def columns_hash
+        @columns_hash ||= Hash[columns.map { |c| [c.name, c] }]
+      end
+
+      # Returns a hash where the keys are column names and the values are
+      # default values when instantiating the AR object for this table.
+      def column_defaults
+        @column_defaults ||= Hash[columns.map { |c| [c.name, c.default] }]
+      end
+
+      # Returns an array of column names as strings.
+      def column_names
+        @column_names ||= columns.map { |column| column.name }
+      end
+
+      # Returns an array of column objects where the primary id, all columns ending in "_id" or "_count",
+      # and columns used for single table inheritance have been removed.
+      def content_columns
+        @content_columns ||= columns.reject { |c| c.primary || c.name =~ /(_id|_count)$/ || c.name == inheritance_column }
+      end
+
+      # Returns a hash of all the methods added to query each of the columns in the table with the name of the method as the key
+      # and true as the value. This makes it possible to do O(1) lookups in respond_to? to check if a given method for attribute
+      # is available.
+      def column_methods_hash #:nodoc:
+        @dynamic_methods_hash ||= column_names.inject(Hash.new(false)) do |methods, attr|
+          attr_name = attr.to_s
+          methods[attr.to_sym]       = attr_name
+          methods["#{attr}=".to_sym] = attr_name
+          methods["#{attr}?".to_sym] = attr_name
+          methods["#{attr}_before_type_cast".to_sym] = attr_name
+          methods
+        end
+      end
+
+      # Resets all the cached information about columns, which will cause them
+      # to be reloaded on the next request.
+      #
+      # The most common usage pattern for this method is probably in a migration,
+      # when just after creating a table you want to populate it with some default
+      # values, eg:
+      #
+      #  class CreateJobLevels < ActiveRecord::Migration
+      #    def up
+      #      create_table :job_levels do |t|
+      #        t.integer :id
+      #        t.string :name
+      #
+      #        t.timestamps
+      #      end
+      #
+      #      JobLevel.reset_column_information
+      #      %w{assistant executive manager director}.each do |type|
+      #        JobLevel.create(:name => type)
+      #      end
+      #    end
+      #
+      #    def down
+      #      drop_table :job_levels
+      #    end
+      #  end
+      def reset_column_information
+        connection.clear_cache!
+        undefine_attribute_methods
+        connection.schema_cache.clear_table_cache!(table_name) if table_exists?
+
+        @column_names = @content_columns = @column_defaults = @columns = @columns_hash = nil
+        @dynamic_methods_hash = nil
+        @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
+        @arel_engine = @relation = nil
+      end
+
+      def clear_cache! # :nodoc:
+        connection.schema_cache.clear!
+      end
+
+      private
+
+      # Guesses the table name, but does not decorate it with prefix and suffix information.
+      def undecorated_table_name(class_name = base_class.name)
+        table_name = class_name.to_s.demodulize.underscore
+        table_name = table_name.pluralize if pluralize_table_names
+        table_name
+      end
+
+      # Computes and returns a table name according to default conventions.
+      def compute_table_name
+        base = base_class
+        if self == base
+          # Nested classes are prefixed with singular parent table name.
+          if parent < ActiveRecord::Base && !parent.abstract_class?
+            contained = parent.table_name
+            contained = contained.singularize if parent.pluralize_table_names
+            contained += '_'
+          end
+          "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{table_name_suffix}"
+        else
+          # STI subclasses always use their superclass' table.
+          base.table_name
+        end
+      end
+
+      def deprecated_property_setter(property, value, block)
+        if block
+          ActiveSupport::Deprecation.warn(
+            "Calling set_#{property} is deprecated. If you need to lazily evaluate " \
+            "the #{property}, define your own `self.#{property}` class method. You can use `super` " \
+            "to get the default #{property} where you would have called `original_#{property}`."
+          )
+
+          define_attr_method property, value, false, &block
+        else
+          ActiveSupport::Deprecation.warn(
+            "Calling set_#{property} is deprecated. Please use `self.#{property} = 'the_name'` instead."
+          )
+
+          define_attr_method property, value, false
+        end
+      end
+
+      def deprecated_original_property_getter(property)
+        ActiveSupport::Deprecation.warn("original_#{property} is deprecated. Define self.#{property} and call super instead.")
+
+        if !instance_variable_defined?("@original_#{property}") && respond_to?("reset_#{property}")
+          send("reset_#{property}")
+        else
+          instance_variable_get("@original_#{property}")
+        end
+      end
+    end
+  end
+end

data/lib/active_record/nested_attributes.rb

@@ -92,8 +92,9 @@ module ActiveRecord
     #     accepts_nested_attributes_for :posts
     #   end
     #
-    # You can now set or update attributes on an associated post model through
-    # the attribute hash.
+    # You can now set or update attributes on the associated posts through
+    # an attribute hash for a member: include the key +:posts_attributes+
+    # with an array of hashes of post attributes as a value.
     #
     # For each hash that does _not_ have an <tt>id</tt> key a new record will
     # be instantiated, unless the hash also contains a <tt>_destroy</tt> key
@@ -116,10 +117,10 @@ module ActiveRecord
     # hashes if they fail to pass your criteria. For example, the previous
     # example could be rewritten as:
     #
-    #    class Member < ActiveRecord::Base
-    #      has_many :posts
-    #      accepts_nested_attributes_for :posts, :reject_if => proc { |attributes| attributes['title'].blank? }
-    #    end
+    #   class Member < ActiveRecord::Base
+    #     has_many :posts
+    #     accepts_nested_attributes_for :posts, :reject_if => proc { |attributes| attributes['title'].blank? }
+    #   end
     #
     #   params = { :member => {
     #     :name => 'joe', :posts_attributes => [
@@ -136,19 +137,19 @@ module ActiveRecord
     #
     # Alternatively, :reject_if also accepts a symbol for using methods:
     #
-    #    class Member < ActiveRecord::Base
-    #      has_many :posts
-    #      accepts_nested_attributes_for :posts, :reject_if => :new_record?
-    #    end
+    #   class Member < ActiveRecord::Base
+    #     has_many :posts
+    #     accepts_nested_attributes_for :posts, :reject_if => :new_record?
+    #   end
     #
-    #    class Member < ActiveRecord::Base
-    #      has_many :posts
-    #      accepts_nested_attributes_for :posts, :reject_if => :reject_posts
+    #   class Member < ActiveRecord::Base
+    #     has_many :posts
+    #     accepts_nested_attributes_for :posts, :reject_if => :reject_posts
     #
-    #      def reject_posts(attributed)
-    #        attributed['title'].blank?
-    #      end
-    #    end
+    #     def reject_posts(attributed)
+    #       attributed['title'].blank?
+    #     end
+    #   end
     #
     # If the hash contains an <tt>id</tt> key that matches an already
     # associated record, the matching record will be modified:
@@ -185,6 +186,29 @@ module ActiveRecord
     #   member.save
     #   member.reload.posts.length # => 1
     #
+    # Nested attributes for an associated collection can also be passed in
+    # the form of a hash of hashes instead of an array of hashes:
+    #
+    #   Member.create(:name             => 'joe',
+    #                 :posts_attributes => { :first  => { :title => 'Foo' },
+    #                                        :second => { :title => 'Bar' } })
+    #
+    # has the same effect as
+    #
+    #   Member.create(:name             => 'joe',
+    #                 :posts_attributes => [ { :title => 'Foo' },
+    #                                        { :title => 'Bar' } ])
+    #
+    # The keys of the hash which is the value for +:posts_attributes+ are
+    # ignored in this case.
+    # However, it is not allowed to use +'id'+ or +:id+ for one of
+    # such keys, otherwise the hash will be wrapped in an array and
+    # interpreted as an attribute hash for a single post.
+    #
+    # Passing attributes for an associated collection in the form of a hash
+    # of hashes can be used with hashes generated from HTTP/HTML parameters,
+    # where there maybe no natural way to submit an array of hashes.
+    #
     # === Saving
     #
     # All changes to models, including the destruction of those marked for
@@ -220,7 +244,7 @@ module ActiveRecord
     #     validates_presence_of :member
     #   end
     module ClassMethods
-      REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |_, value| value.blank? } }
+      REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |key, value| key == '_destroy' || value.blank? } }
 
       # Defines an attributes writer for the specified association(s). If you
       # are using <tt>attr_protected</tt> or <tt>attr_accessible</tt>, then you
@@ -239,7 +263,8 @@ module ActiveRecord
       #   is specified, a record will be built for all attribute hashes that
       #   do not have a <tt>_destroy</tt> value that evaluates to true.
       #   Passing <tt>:all_blank</tt> instead of a Proc will create a proc
-      #   that will reject a record where all the attributes are blank.
+      #   that will reject a record where all the attributes are blank excluding
+      #   any value for _destroy.
       # [:limit]
       #   Allows you to specify the maximum number of the associated records that
       #   can be processed with the nested attributes. If the size of the
@@ -276,13 +301,14 @@ module ActiveRecord
 
             type = (reflection.collection? ? :collection : :one_to_one)
 
+            # remove_possible_method :pirate_attributes=
+            #
             # def pirate_attributes=(attributes)
             #   assign_nested_attributes_for_one_to_one_association(:pirate, attributes, mass_assignment_options)
             # end
             class_eval <<-eoruby, __FILE__, __LINE__ + 1
-              if method_defined?(:#{association_name}_attributes=)
-                remove_method(:#{association_name}_attributes=)
-              end
+              remove_possible_method(:#{association_name}_attributes=)
+
               def #{association_name}_attributes=(attributes)
                 assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes, mass_assignment_options)
               end
@@ -444,11 +470,12 @@ module ActiveRecord
     # has_destroy_flag? or if a <tt>:reject_if</tt> proc exists for this
     # association and evaluates to +true+.
     def reject_new_record?(association_name, attributes)
-      has_destroy_flag?(attributes) || call_reject_if(association_name, attributes)
+      will_be_destroyed?(association_name, attributes) || call_reject_if(association_name, attributes)
     end
 
     def call_reject_if(association_name, attributes)
-      return false if has_destroy_flag?(attributes)
+      return false if will_be_destroyed?(association_name, attributes)
+
       case callback = self.nested_attributes_options[association_name][:reject_if]
       when Symbol
         method(callback).arity == 0 ? send(callback) : send(callback, attributes)
@@ -457,6 +484,15 @@ module ActiveRecord
       end
     end
 
+    # Only take into account the destroy flag if <tt>:allow_destroy</tt> is true
+    def will_be_destroyed?(association_name, attributes)
+      allow_destroy?(association_name) && has_destroy_flag?(attributes)
+    end
+
+    def allow_destroy?(association_name)
+      self.nested_attributes_options[association_name][:allow_destroy]
+    end
+
     def raise_nested_attributes_record_not_found(association_name, record_id)
       raise RecordNotFound, "Couldn't find #{self.class.reflect_on_association(association_name).klass.name} with ID=#{record_id} for #{self.class.name} with ID=#{id}"
     end

data/lib/active_record/persistence.rb

@@ -1,6 +1,53 @@
+require 'active_support/concern'
+
 module ActiveRecord
   # = Active Record Persistence
   module Persistence
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Creates an object (or multiple objects) and saves it to the database, if validations pass.
+      # The resulting object is returned whether the object was saved successfully to the database or not.
+      #
+      # The +attributes+ parameter can be either be a Hash or an Array of Hashes. These Hashes describe the
+      # attributes on the objects that are to be created.
+      #
+      # +create+ respects mass-assignment security and accepts either +:as+ or +:without_protection+ options
+      # in the +options+ parameter.
+      #
+      # ==== Examples
+      #   # Create a single new object
+      #   User.create(:first_name => 'Jamie')
+      #
+      #   # Create a single new object using the :admin mass-assignment security role
+      #   User.create({ :first_name => 'Jamie', :is_admin => true }, :as => :admin)
+      #
+      #   # Create a single new object bypassing mass-assignment security
+      #   User.create({ :first_name => 'Jamie', :is_admin => true }, :without_protection => true)
+      #
+      #   # Create an Array of new objects
+      #   User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }])
+      #
+      #   # Create a single object and pass it into a block to set other attributes.
+      #   User.create(:first_name => 'Jamie') do |u|
+      #     u.is_admin = false
+      #   end
+      #
+      #   # Creating an Array of new objects using a block, where the block is executed for each object:
+      #   User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }]) do |u|
+      #     u.is_admin = false
+      #   end
+      def create(attributes = nil, options = {}, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr, options, &block) }
+        else
+          object = new(attributes, options, &block)
+          object.save
+          object
+        end
+      end
+    end
+
     # Returns true if this object hasn't been saved yet -- that is, a record
     # for the object doesn't exist in the data store yet; otherwise, returns false.
     def new_record?
@@ -114,7 +161,8 @@ module ActiveRecord
       became.instance_variable_set("@attributes_cache", @attributes_cache)
       became.instance_variable_set("@new_record", new_record?)
       became.instance_variable_set("@destroyed", destroyed?)
-      became.type = klass.name unless self.class.descends_from_active_record?
+      became.instance_variable_set("@errors", errors)
+      became.send("#{klass.inheritance_column}=", klass.name) unless self.class.descends_from_active_record?
       became
     end
 
@@ -139,12 +187,18 @@ module ActiveRecord
     # * Callbacks are skipped.
     # * updated_at/updated_on column is not updated if that column is available.
     #
+    # Raises an +ActiveRecordError+ when called on new objects, or when the +name+
+    # attribute is marked as readonly.
     def update_column(name, value)
       name = name.to_s
       raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attributes.include?(name)
       raise ActiveRecordError, "can not update on a new record object" unless persisted?
+
+      updated_count = self.class.unscoped.update_all({ name => value }, self.class.primary_key => id)
+
       raw_write_attribute(name, value)
-      self.class.update_all({ name => value }, self.class.primary_key => id) == 1
+
+      updated_count == 1
     end
 
     # Updates the attributes of the model from the passed-in hash and saves the
@@ -312,19 +366,11 @@ module ActiveRecord
 
       new_id = self.class.unscoped.insert attributes_values
 
-      self.id ||= new_id
+      self.id ||= new_id if self.class.primary_key
 
       IdentityMap.add(self) if IdentityMap.enabled?
       @new_record = false
       id
     end
-
-    # Initializes the attributes array with keys matching the columns from the linked table and
-    # the values matching the corresponding default value of that column, so
-    # that a new instance, or one populated from a passed-in Hash, still has all the attributes
-    # that instances loaded from the database would.
-    def attributes_from_column_definition
-      self.class.column_defaults.dup
-    end
   end
 end

data/lib/active_record/query_cache.rb

@@ -6,19 +6,19 @@ module ActiveRecord
     module ClassMethods
       # Enable the query cache within the block if Active Record is configured.
       def cache(&block)
-        if ActiveRecord::Base.configurations.blank?
-          yield
-        else
+        if ActiveRecord::Base.connected?
           connection.cache(&block)
+        else
+          yield
         end
       end
 
       # Disable the query cache within the block if Active Record is configured.
       def uncached(&block)
-        if ActiveRecord::Base.configurations.blank?
-          yield
-        else
+        if ActiveRecord::Base.connected?
           connection.uncached(&block)
+        else
+          yield
         end
       end
     end