activerecord 3.2.22.5 → 4.0.0.beta1

data/lib/active_record/migration/command_recorder.rb

@@ -8,66 +8,125 @@ module ActiveRecord
     # * add_index
     # * add_timestamps
     # * create_table
+    # * create_join_table
     # * remove_timestamps
     # * rename_column
     # * rename_index
     # * rename_table
     class CommandRecorder
-      attr_accessor :commands, :delegate
+      include JoinTable
+
+      attr_accessor :commands, :delegate, :reverting
 
       def initialize(delegate = nil)
         @commands = []
         @delegate = delegate
+        @reverting = false
+      end
+
+      # While executing the given block, the recorded will be in reverting mode.
+      # All commands recorded will end up being recorded reverted
+      # and in reverse order.
+      # For example:
+      #
+      #   recorder.revert{ recorder.record(:rename_table, [:old, :new]) }
+      #   # same effect as recorder.record(:rename_table, [:new, :old])
+      def revert
+        @reverting = !@reverting
+        previous = @commands
+        @commands = []
+        yield
+      ensure
+        @commands = previous.concat(@commands.reverse)
+        @reverting = !@reverting
       end
 
       # record +command+. +command+ should be a method name and arguments.
       # For example:
       #
       #   recorder.record(:method_name, [:arg1, :arg2])
-      def record(*command)
-        @commands << command
+      def record(*command, &block)
+        if @reverting
+          @commands << inverse_of(*command, &block)
+        else
+          @commands << (command << block)
+        end
       end
 
-      # Returns a list that represents commands that are the inverse of the
-      # commands stored in +commands+. For example:
+      # Returns the inverse of the given command. For example:
       #
-      #   recorder.record(:rename_table, [:old, :new])
-      #   recorder.inverse # => [:rename_table, [:new, :old]]
+      #   recorder.inverse_of(:rename_table, [:old, :new])
+      #   # => [:rename_table, [:new, :old]]
       #
       # This method will raise an +IrreversibleMigration+ exception if it cannot
-      # invert the +commands+.
-      def inverse
-        @commands.reverse.map { |name, args|
-          method = :"invert_#{name}"
-          raise IrreversibleMigration unless respond_to?(method, true)
-          send(method, args)
-        }
+      # invert the +command+.
+      def inverse_of(command, args, &block)
+        method = :"invert_#{command}"
+        raise IrreversibleMigration unless respond_to?(method, true)
+        send(method, args, &block)
       end
 
       def respond_to?(*args) # :nodoc:
         super || delegate.respond_to?(*args)
       end
 
-      [:create_table, :change_table, :rename_table, :add_column, :remove_column, :rename_index, :rename_column, :add_index, :remove_index, :add_timestamps, :remove_timestamps, :change_column, :change_column_default].each do |method|
+      [:create_table, :create_join_table, :rename_table, :add_column, :remove_column,
+        :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,
+        :change_column, :execute, :remove_columns, # irreversible methods need to be here too
+      ].each do |method|
         class_eval <<-EOV, __FILE__, __LINE__ + 1
-          def #{method}(*args)          # def create_table(*args)
-            record(:"#{method}", args)  #   record(:create_table, args)
-          end                           # end
+          def #{method}(*args, &block)          # def create_table(*args, &block)
+            record(:"#{method}", args, &block)  #   record(:create_table, args, &block)
+          end                                   # end
         EOV
       end
+      alias :add_belongs_to :add_reference
+      alias :remove_belongs_to :remove_reference
+
+      def change_table(table_name, options = {})
+        yield ConnectionAdapters::Table.new(table_name, self)
+      end
 
       private
 
-      def invert_create_table(args)
-        [:drop_table, [args.first]]
+      module StraightReversions
+        private
+        { transaction:       :transaction,
+          execute_block:     :execute_block,
+          create_table:      :drop_table,
+          create_join_table: :drop_join_table,
+          add_column:        :remove_column,
+          add_timestamps:    :remove_timestamps,
+          add_reference:     :remove_reference,
+        }.each do |cmd, inv|
+          [[inv, cmd], [cmd, inv]].uniq.each do |method, inverse|
+            class_eval <<-EOV, __FILE__, __LINE__ + 1
+              def invert_#{method}(args, &block)    # def invert_create_table(args, &block)
+                [:#{inverse}, args, block]          #   [:drop_table, args, block]
+              end                                   # end
+            EOV
+          end
+        end
+      end
+
+      include StraightReversions
+
+      def invert_drop_table(args, &block)
+        if args.size == 1 && block == nil
+          raise ActiveRecord::IrreversibleMigration, "To avoid mistakes, drop_table is only reversible if given options or a block (can be empty)."
+        end
+        super
       end
 
       def invert_rename_table(args)
         [:rename_table, args.reverse]
       end
 
-      def invert_add_column(args)
-        [:remove_column, args.first(2)]
+      def invert_remove_column(args)
+        raise ActiveRecord::IrreversibleMigration, "remove_column is only reversible if given a type." if args.size <= 2
+        super
       end
 
       def invert_rename_index(args)
@@ -80,26 +139,26 @@ module ActiveRecord
 
       def invert_add_index(args)
         table, columns, options = *args
-        index_name = options.try(:[], :name)
-        options_hash =  index_name ? {:name => index_name} : {:column => columns}
-        [:remove_index, [table, options_hash]]
+        [:remove_index, [table, (options || {}).merge(column: columns)]]
       end
 
-      def invert_remove_timestamps(args)
-        [:add_timestamps, args]
-      end
+      def invert_remove_index(args)
+        table, options = *args
+        raise ActiveRecord::IrreversibleMigration, "remove_index is only reversible if given a :column option." unless options && options[:column]
 
-      def invert_add_timestamps(args)
-        [:remove_timestamps, args]
+        options = options.dup
+        [:add_index, [table, options.delete(:column), options]]
       end
 
+      alias :invert_add_belongs_to :invert_add_reference
+      alias :invert_remove_belongs_to :invert_remove_reference
+
       # Forwards any missing method call to the \target.
       def method_missing(method, *args, &block)
         @delegate.send(method, *args, &block)
       rescue NoMethodError => e
         raise e, e.message.sub(/ for #<.*$/, " via proxy for #{@delegate}")
       end
-
     end
   end
 end

data/lib/active_record/migration/join_table.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  class Migration
+    module JoinTable #:nodoc:
+      private
+
+      def find_join_table_name(table_1, table_2, options = {})
+        options.delete(:table_name) || join_table_name(table_1, table_2)
+      end
+
+      def join_table_name(table_1, table_2)
+        [table_1.to_s, table_2.to_s].sort.join("_").to_sym
+      end
+    end
+  end
+end

data/lib/active_record/model_schema.rb

@@ -1,5 +1,3 @@
-require 'active_support/concern'
-
 module ActiveRecord
   module ModelSchema
     extend ActiveSupport::Concern
@@ -12,8 +10,7 @@ module ActiveRecord
       # 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
+      mattr_accessor :primary_key_prefix_type, instance_writer: false
 
       ##
       # :singleton-method:
@@ -25,14 +22,14 @@ module ActiveRecord
       # 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
+      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
+      class_attribute :table_name_suffix, instance_writer: false
       self.table_name_suffix = ""
 
       ##
@@ -40,8 +37,10 @@ module ActiveRecord
       # 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
+      class_attribute :pluralize_table_names, instance_writer: false
       self.pluralize_table_names = true
+
+      self.inheritance_column = 'type'
     end
 
     module ClassMethods
@@ -105,10 +104,6 @@ module ActiveRecord
         @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
@@ -118,17 +113,17 @@ module ActiveRecord
       # 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
+        value = value && value.to_s
 
-      def set_table_name(value = nil, &block) #:nodoc:
-        deprecated_property_setter :table_name, value, block
+        if defined?(@table_name)
+          return if value == @table_name
+          reset_column_information if connected?
+        end
+
+        @table_name        = value
         @quoted_table_name = nil
         @arel_table        = nil
+        @sequence_name     = nil unless defined?(@explicit_sequence_name) && @explicit_sequence_name
         @relation          = Relation.new(self, arel_table)
       end
 
@@ -139,16 +134,12 @@ module ActiveRecord
 
       # 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
+        self.table_name = if abstract_class?
+          superclass == Base ? nil : superclass.table_name
         elsif superclass.abstract_class?
-          self.table_name = superclass.table_name || compute_table_name
+          superclass.table_name || compute_table_name
         else
-          self.table_name = compute_table_name
+          compute_table_name
         end
       end
 
@@ -156,30 +147,25 @@ module ActiveRecord
         (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
+      # Defines the name of the table column which will store the class name on single-table
+      # inheritance situations.
+      #
+      # The default inheritance column name is +type+, which means it's a
+      # reserved word inside Active Record. To be able to use single-table
+      # inheritance with another column name, or to use the column +type+ in
+      # your own model for something else, you can set +inheritance_column+:
+      #
+      #     self.inheritance_column = 'zoink'
       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
+        (@inheritance_column ||= nil) || superclass.inheritance_column
       end
 
       # Sets the value of inheritance_column
       def inheritance_column=(value)
-        @original_inheritance_column = inheritance_column
-        @inheritance_column          = value.to_s
+        @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
@@ -188,12 +174,9 @@ module ActiveRecord
         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)
+        @explicit_sequence_name = false
+        @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
@@ -211,12 +194,8 @@ module ActiveRecord
       #     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
+        @explicit_sequence_name = true
       end
 
       # Indicates whether the table associated with this class exists
@@ -238,6 +217,25 @@ module ActiveRecord
         @columns_hash ||= Hash[columns.map { |c| [c.name, c] }]
       end
 
+      def column_types # :nodoc:
+        @column_types ||= decorate_columns(columns_hash.dup)
+      end
+
+      def decorate_columns(columns_hash) # :nodoc:
+        return if columns_hash.empty?
+
+        columns_hash.each do |name, col|
+          if serialized_attributes.key?(name)
+            columns_hash[name] = AttributeMethods::Serialization::Type.new(col)
+          end
+          if create_time_zone_conversion_attribute?(name, col)
+            columns_hash[name] = AttributeMethods::TimeZoneConversion::Type.new(col)
+          end
+        end
+
+        columns_hash
+      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
@@ -259,13 +257,12 @@ module ActiveRecord
       # 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|
+        @dynamic_methods_hash ||= column_names.each_with_object(Hash.new(false)) do |attr, methods|
           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
 
@@ -287,7 +284,7 @@ module ActiveRecord
       #
       #      JobLevel.reset_column_information
       #      %w{assistant executive manager director}.each do |type|
-      #        JobLevel.create(:name => type)
+      #        JobLevel.create(name: type)
       #      end
       #    end
       #
@@ -300,14 +297,23 @@ module ActiveRecord
         undefine_attribute_methods
         connection.schema_cache.clear_table_cache!(table_name) if table_exists?
 
-        @column_names = @content_columns = @column_defaults = @columns = @columns_hash = nil
+        @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
-        @arel_engine = @relation = nil
+        @inheritance_column   = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
+        @relation             = nil
       end
 
-      def clear_cache! # :nodoc:
-        connection.schema_cache.clear!
+      # 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
       end
 
       private
@@ -315,8 +321,7 @@ module ActiveRecord
       # 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
+        pluralize_table_names ? table_name.pluralize : table_name
       end
 
       # Computes and returns a table name according to default conventions.
@@ -324,7 +329,7 @@ module ActiveRecord
         base = base_class
         if self == base
           # Nested classes are prefixed with singular parent table name.
-          if parent < ActiveRecord::Base && !parent.abstract_class?
+          if parent < Base && !parent.abstract_class?
             contained = parent.table_name
             contained = contained.singularize if parent.pluralize_table_names
             contained += '_'
@@ -335,34 +340,6 @@ module ActiveRecord
           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