activerecord 4.1.15 → 4.2.11.3

data/lib/active_record/migration/command_recorder.rb

@@ -74,7 +74,9 @@ module ActiveRecord
         :rename_index, :rename_column, :add_index, :remove_index, :add_timestamps, :remove_timestamps,
         :change_column_default, :add_reference, :remove_reference, :transaction,
         :drop_join_table, :drop_table, :execute_block, :enable_extension,
-        :change_column, :execute, :remove_columns, :change_column_null # irreversible methods need to be here too
+        :change_column, :execute, :remove_columns, :change_column_null,
+        :add_foreign_key, :remove_foreign_key
+       # irreversible methods need to be here too
       ].each do |method|
         class_eval <<-EOV, __FILE__, __LINE__ + 1
           def #{method}(*args, &block)          # def create_table(*args, &block)
@@ -85,7 +87,7 @@ module ActiveRecord
       alias :add_belongs_to :add_reference
       alias :remove_belongs_to :remove_reference
 
-      def change_table(table_name, options = {})
+      def change_table(table_name, options = {}) # :nodoc:
         yield delegate.update_table_definition(table_name, self)
       end
 
@@ -167,6 +169,21 @@ module ActiveRecord
         [:change_column_null, args]
       end
 
+      def invert_add_foreign_key(args)
+        from_table, to_table, add_options = args
+        add_options ||= {}
+
+        if add_options[:name]
+          options = { name: add_options[:name] }
+        elsif add_options[:column]
+          options = { column: add_options[:column] }
+        else
+          options = to_table
+        end
+
+        [:remove_foreign_key, [from_table, options]]
+      end
+
       # Forwards any missing method call to the \target.
       def method_missing(method, *args, &block)
         if @delegate.respond_to?(method)

data/lib/active_record/migration/join_table.rb

@@ -8,7 +8,7 @@ module ActiveRecord
       end
 
       def join_table_name(table_1, table_2)
-        [table_1.to_s, table_2.to_s].sort.join("_").to_sym
+        ModelSchema.derive_join_table_name(table_1, table_2).to_sym
       end
     end
   end

data/lib/active_record/model_schema.rb

@@ -29,6 +29,10 @@ module ActiveRecord
       # :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.
+      #
+      # If you are organising your models within modules, you can add a suffix to the models within
+      # a namespace by defining a singleton method in the parent module called table_name_suffix which
+      # returns your chosen suffix.
       class_attribute :table_name_suffix, instance_writer: false
       self.table_name_suffix = ""
 
@@ -47,6 +51,19 @@ module ActiveRecord
       self.pluralize_table_names = true
 
       self.inheritance_column = 'type'
+
+      delegate :type_for_attribute, to: :class
+    end
+
+    # Derives the join table name for +first_table+ and +second_table+. The
+    # table names appear in alphabetical order. A common prefix is removed
+    # (useful for namespaced models like Music::Artist and Music::Record):
+    #
+    #   artists, records => artists_records
+    #   records, artists => artists_records
+    #   music_artists, music_records => music_artists_records
+    def self.derive_join_table_name(first_table, second_table) # :nodoc:
+      [first_table.to_s, second_table.to_s].sort.join("\0").gsub(/^(.*_)(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
     end
 
     module ClassMethods
@@ -153,6 +170,10 @@ module ActiveRecord
         (parents.detect{ |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
       end
 
+      def full_table_name_suffix #:nodoc:
+        (parents.detect {|p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
+      end
+
       # Defines the name of the table column which will store the class name on single-table
       # inheritance situations.
       #
@@ -190,7 +211,7 @@ module ActiveRecord
       # 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,
+      # If a sequence name is not explicitly set when using Oracle,
       # it will default to the commonly used pattern of: #{table_name}_seq
       #
       # If a sequence name is not explicitly set when using PostgreSQL, it
@@ -209,50 +230,29 @@ module ActiveRecord
         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] }]
+      def attributes_builder # :nodoc:
+        @attributes_builder ||= AttributeSet::Builder.new(column_types, primary_key)
       end
 
       def column_types # :nodoc:
-        @column_types ||= decorate_columns(columns_hash.dup)
-      end
-
-      def decorate_columns(columns_hash) # :nodoc:
-        return if columns_hash.empty?
-
-        @serialized_column_names ||= self.columns_hash.keys.find_all do |name|
-          serialized_attributes.key?(name)
-        end
-
-        @serialized_column_names.each do |name|
-          columns_hash[name] = AttributeMethods::Serialization::Type.new(columns_hash[name])
-        end
-
-        @time_zone_column_names ||= self.columns_hash.find_all do |name, col|
-          create_time_zone_conversion_attribute?(name, col)
-        end.map!(&:first)
-
-        @time_zone_column_names.each do |name|
-          columns_hash[name] = AttributeMethods::TimeZoneConversion::Type.new(columns_hash[name])
+        @column_types ||= columns_hash.transform_values(&:cast_type).tap do |h|
+          h.default = Type::Value.new
         end
+      end
 
-        columns_hash
+      def type_for_attribute(attr_name) # :nodoc:
+        column_types[attr_name]
       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] }]
+        _default_attributes.dup.to_hash
+      end
+
+      def _default_attributes # :nodoc:
+        @default_attributes ||= attributes_builder.build_from_database(
+          raw_default_values)
       end
 
       # Returns an array of column names as strings.
@@ -263,7 +263,7 @@ module ActiveRecord
       # 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 }
+        @content_columns ||= columns.reject { |c| c.name == primary_key || c.name =~ /(_id|_count)$/ || c.name == inheritance_column }
       end
 
       # Resets all the cached information about columns, which will cause them
@@ -295,28 +295,17 @@ module ActiveRecord
       def reset_column_information
         connection.clear_cache!
         undefine_attribute_methods
-        connection.schema_cache.clear_table_cache!(table_name) if table_exists?
-
-        @arel_engine             = nil
-        @column_defaults         = nil
-        @column_names            = nil
-        @columns                 = nil
-        @columns_hash            = nil
-        @column_types            = nil
-        @content_columns         = nil
-        @dynamic_methods_hash    = nil
-        @inheritance_column      = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
-        @relation                = nil
-        @serialized_column_names = nil
-        @time_zone_column_names  = nil
-        @cached_time_zone        = nil
-      end
+        connection.schema_cache.clear_table_cache!(table_name)
+
+        @arel_engine        = nil
+        @column_names       = nil
+        @column_types       = nil
+        @content_columns    = nil
+        @default_attributes = nil
+        @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
+        @relation           = nil
 
-      # This is a hook for use by modules that need to do extra stuff to
-      # attributes when they are initialized. (e.g. attribute
-      # serialization)
-      def initialize_attributes(attributes, options = {}) #:nodoc:
-        attributes
+        initialize_find_by_cache
       end
 
       private
@@ -337,12 +326,17 @@ module ActiveRecord
             contained = contained.singularize if parent.pluralize_table_names
             contained += '_'
           end
-          "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{table_name_suffix}"
+
+          "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
         else
           # STI subclasses always use their superclass' table.
           base.table_name
         end
       end
+
+      def raw_default_values
+        columns_hash.transform_values(&:default)
+      end
     end
   end
 end

data/lib/active_record/nested_attributes.rb

@@ -485,10 +485,10 @@ module ActiveRecord
     end
 
     # Takes in a limit and checks if the attributes_collection has too many
-    # records. The method will take limits in the form of symbols, procs, and
-    # number-like objects (anything that can be compared with an integer).
+    # records. It accepts limit in the form of symbol, proc, or
+    # number-like object (anything that can be compared with an integer).
     #
-    # Will raise an TooManyRecords error if the attributes_collection is
+    # Raises TooManyRecords error if the attributes_collection is
     # larger than the limit.
     def check_record_limit!(limit, attributes_collection)
       if limit
@@ -516,10 +516,10 @@ module ActiveRecord
 
     # Determines if a hash contains a truthy _destroy key.
     def has_destroy_flag?(hash)
-      ConnectionAdapters::Column.value_to_boolean(hash['_destroy'])
+      Type::Boolean.new.type_cast_from_user(hash['_destroy'])
     end
 
-    # Determines if a new record should be build by checking for
+    # Determines if a new record should be rejected by checking
     # 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)

data/lib/active_record/no_touching.rb

@@ -45,7 +45,7 @@ module ActiveRecord
       NoTouching.applied_to?(self.class)
     end
 
-    def touch(*)
+    def touch(*) # :nodoc:
       super unless no_touching?
     end
   end

data/lib/active_record/persistence.rb

@@ -36,6 +36,23 @@ module ActiveRecord
         end
       end
 
+      # Creates an object (or multiple objects) and saves it to the database,
+      # if validations pass. Raises a RecordInvalid error if validations fail,
+      # unlike Base#create.
+      #
+      # The +attributes+ parameter can be either a Hash or an Array of Hashes.
+      # These describe which attributes to be created on the object, or
+      # multiple objects when given an Array of Hashes.
+      def create!(attributes = nil, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create!(attr, &block) }
+        else
+          object = new(attributes, &block)
+          object.save!
+          object
+        end
+      end
+
       # Given an attributes hash, +instantiate+ returns a new instance of
       # the appropriate class. Accepts only keys as strings.
       #
@@ -48,8 +65,8 @@ module ActiveRecord
       # how this "single-table" inheritance mapping is implemented.
       def instantiate(attributes, column_types = {})
         klass = discriminate_class_for_record(attributes)
-        column_types = klass.decorate_columns(column_types.dup)
-        klass.allocate.init_with('attributes' => attributes, 'column_types' => column_types)
+        attributes = klass.attributes_builder.build_from_database(attributes, column_types)
+        klass.allocate.init_with('attributes' => attributes, 'new_record' => false)
       end
 
       private
@@ -122,7 +139,7 @@ module ActiveRecord
     # Attributes marked as readonly are silently ignored if the record is
     # being updated.
     def save!(*)
-      create_or_update || raise(RecordNotSaved)
+      create_or_update || raise(RecordNotSaved.new("Failed to save the record", self))
     end
 
     # Deletes the record in the database and freezes this instance to
@@ -149,8 +166,9 @@ module ActiveRecord
     # and <tt>destroy</tt> returns +false+. See
     # ActiveRecord::Callbacks for further details.
     def destroy
-      raise ReadOnlyRecord if readonly?
+      raise ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
       destroy_associations
+      self.class.connection.add_transaction_record(self)
       destroy_row if persisted?
       @destroyed = true
       freeze
@@ -164,7 +182,7 @@ module ActiveRecord
     # and <tt>destroy!</tt> raises ActiveRecord::RecordNotDestroyed. See
     # ActiveRecord::Callbacks for further details.
     def destroy!
-      destroy || raise(ActiveRecord::RecordNotDestroyed)
+      destroy || raise(RecordNotDestroyed.new("Failed to destroy the record", self))
     end
 
     # Returns an instance of the specified +klass+ with the attributes of the
@@ -180,7 +198,6 @@ module ActiveRecord
     def becomes(klass)
       became = klass.new
       became.instance_variable_set("@attributes", @attributes)
-      became.instance_variable_set("@attributes_cache", @attributes_cache)
       changed_attributes = @changed_attributes if defined?(@changed_attributes)
       became.instance_variable_set("@changed_attributes", changed_attributes || {})
       became.instance_variable_set("@new_record", new_record?)
@@ -215,6 +232,8 @@ module ActiveRecord
     #
     # This method raises an +ActiveRecord::ActiveRecordError+  if the
     # attribute is marked as readonly.
+    #
+    # See also +update_column+.
     def update_attribute(name, value)
       name = name.to_s
       verify_readonly_attribute(name)
@@ -270,7 +289,8 @@ module ActiveRecord
     # This method raises an +ActiveRecord::ActiveRecordError+ when called on new
     # objects, or when at least one of the attributes is marked as readonly.
     def update_columns(attributes)
-      raise ActiveRecordError, "cannot update on a new record object" unless persisted?
+      raise ActiveRecordError, "cannot update a new record" if new_record?
+      raise ActiveRecordError, "cannot update a destroyed record" if destroyed?
 
       attributes.each_key do |key|
         verify_readonly_attribute(key.to_s)
@@ -349,7 +369,7 @@ module ActiveRecord
     #   # => #<Account id: 1, email: 'account@example.com'>
     #
     # Attributes are reloaded from the database, and caches busted, in
-    # particular the associations cache.
+    # particular the associations cache and the QueryCache.
     #
     # If the record no longer exists in the database <tt>ActiveRecord::RecordNotFound</tt>
     # is raised. Otherwise, in addition to the in-place modification the method
@@ -387,6 +407,7 @@ module ActiveRecord
     def reload(options = nil)
       clear_aggregation_cache
       clear_association_cache
+      self.class.connection.clear_query_cache
 
       fresh_object =
         if options && options[:lock]
@@ -395,25 +416,24 @@ module ActiveRecord
           self.class.unscoped { self.class.find(id) }
         end
 
-      @attributes.update(fresh_object.instance_variable_get('@attributes'))
-
-      @column_types           = self.class.column_types
-      @column_types_override  = fresh_object.instance_variable_get('@column_types_override')
-      @attributes_cache       = {}
-      @new_record             = false
+      @attributes = fresh_object.instance_variable_get('@attributes')
+      @new_record = false
       self
     end
 
     # Saves the record with the updated_at/on attributes set to the current time.
     # Please note that no validation is performed and only the +after_touch+,
     # +after_commit+ and +after_rollback+ callbacks are executed.
-    # If an attribute name is passed, that attribute is updated along with
-    # updated_at/on attributes.
     #
-    #   product.touch               # updates updated_at/on
-    #   product.touch(:designed_at) # updates the designed_at attribute and updated_at/on
+    # If attribute names are passed, they are updated along with updated_at/on
+    # attributes.
+    #
+    #   product.touch                         # updates updated_at/on
+    #   product.touch(:designed_at)           # updates the designed_at attribute and updated_at/on
+    #   product.touch(:started_at, :ended_at) # updates started_at, ended_at and updated_at/on attributes
     #
-    # If used along with +belongs_to+ then +touch+ will invoke +touch+ method on associated object.
+    # If used along with +belongs_to+ then +touch+ will invoke +touch+ method on
+    # associated object.
     #
     #   class Brake < ActiveRecord::Base
     #     belongs_to :car, touch: true
@@ -432,11 +452,11 @@ module ActiveRecord
     #   ball = Ball.new
     #   ball.touch(:updated_at)   # => raises ActiveRecordError
     #
-    def touch(name = nil)
+    def touch(*names)
       raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
 
       attributes = timestamp_attributes_for_update_in_model
-      attributes << name if name
+      attributes.concat(names)
 
       unless attributes.empty?
         current_time = current_time_from_proper_timezone
@@ -449,7 +469,7 @@ module ActiveRecord
 
         changes[self.class.locking_column] = increment_lock if locking_enabled?
 
-        changed_attributes.except!(*changes.keys)
+        clear_attribute_changes(changes.keys)
         primary_key = self.class.primary_key
         self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
       else
@@ -470,7 +490,7 @@ module ActiveRecord
     def relation_for_destroy
       pk         = self.class.primary_key
       column     = self.class.columns_hash[pk]
-      substitute = self.class.connection.substitute_at(column, 0)
+      substitute = self.class.connection.substitute_at(column)
 
       relation = self.class.unscoped.where(
         self.class.arel_table[pk].eq(substitute))
@@ -480,14 +500,14 @@ module ActiveRecord
     end
 
     def create_or_update
-      raise ReadOnlyRecord if readonly?
+      raise ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
       result = new_record? ? _create_record : _update_record
       result != false
     end
 
     # Updates the associated record with values matching those of the instance attributes.
     # Returns the number of affected rows.
-    def _update_record(attribute_names = @attributes.keys)
+    def _update_record(attribute_names = self.attribute_names)
       attributes_values = arel_attributes_with_values_for_update(attribute_names)
       if attributes_values.empty?
         0
@@ -498,7 +518,7 @@ module ActiveRecord
 
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
-    def _create_record(attribute_names = @attributes.keys)
+    def _create_record(attribute_names = self.attribute_names)
       attributes_values = arel_attributes_with_values_for_create(attribute_names)
 
       new_id = self.class.unscoped.insert attributes_values