activerecord 3.2.0.rc1 → 3.2.0.rc2

data/lib/active_record/associations/association.rb

@@ -230,13 +230,8 @@ module ActiveRecord
         end
 
         def build_record(attributes, options)
-          attributes = (attributes || {}).reverse_merge(creation_attributes)
-
           reflection.build_association(attributes, options) do |record|
-            record.assign_attributes(
-              create_scope.except(*record.changed),
-              :without_protection => true
-            )
+            record.assign_attributes(create_scope.except(*record.changed), :without_protection => true)
           end
         end
     end

data/lib/active_record/attribute_methods.rb

@@ -35,48 +35,26 @@ module ActiveRecord
       # accessors, mutators and query methods.
       def define_attribute_methods
         return if attribute_methods_generated?
-
-        if base_class == self
-          super(column_names)
-          @attribute_methods_generated = true
-        else
-          base_class.define_attribute_methods
-        end
+        superclass.define_attribute_methods unless self == base_class
+        super(column_names)
+        @attribute_methods_generated = true
       end
 
       def attribute_methods_generated?
-        if base_class == self
-          @attribute_methods_generated ||= false
-        else
-          base_class.attribute_methods_generated?
-        end
-      end
-
-      def generated_attribute_methods
-        @generated_attribute_methods ||= (base_class == self ? super : base_class.generated_attribute_methods)
+        @attribute_methods_generated ||= false
       end
 
+      # We will define the methods as instance methods, but will call them as singleton
+      # methods. This allows us to use method_defined? to check if the method exists,
+      # which is fast and won't give any false positives from the ancestors (because
+      # there are no ancestors).
       def generated_external_attribute_methods
-        @generated_external_attribute_methods ||= begin
-          if base_class == self
-            # We will define the methods as instance methods, but will call them as singleton
-            # methods. This allows us to use method_defined? to check if the method exists,
-            # which is fast and won't give any false positives from the ancestors (because
-            # there are no ancestors).
-            Module.new { extend self }
-          else
-            base_class.generated_external_attribute_methods
-          end
-        end
+        @generated_external_attribute_methods ||= Module.new { extend self }
       end
 
       def undefine_attribute_methods
-        if base_class == self
-          super
-          @attribute_methods_generated = false
-        else
-          base_class.undefine_attribute_methods
-        end
+        super
+        @attribute_methods_generated = false
       end
 
       def instance_method_already_implemented?(method_name)
@@ -84,19 +62,31 @@ module ActiveRecord
           raise DangerousAttributeError, "#{method_name} is defined by ActiveRecord"
         end
 
-        super
+        if superclass == Base
+          super
+        else
+          # If B < A and A defines its own attribute method, then we don't want to overwrite that.
+          defined = method_defined_within?(method_name, superclass, superclass.generated_attribute_methods)
+          defined && !ActiveRecord::Base.method_defined?(method_name) || super
+        end
       end
 
       # A method name is 'dangerous' if it is already defined by Active Record, but
       # not by any ancestors. (So 'puts' is not dangerous but 'save' is.)
-      def dangerous_attribute_method?(method_name)
-        active_record = ActiveRecord::Base
-        superclass    = ActiveRecord::Base.superclass
-
-        (active_record.method_defined?(method_name) ||
-         active_record.private_method_defined?(method_name)) &&
-        !superclass.method_defined?(method_name) &&
-        !superclass.private_method_defined?(method_name)
+      def dangerous_attribute_method?(name)
+        method_defined_within?(name, Base)
+      end
+
+      def method_defined_within?(name, klass, sup = klass.superclass)
+        if klass.method_defined?(name) || klass.private_method_defined?(name)
+          if sup.method_defined?(name) || sup.private_method_defined?(name)
+            klass.instance_method(name).owner != sup.instance_method(name).owner
+          else
+            true
+          end
+        else
+          false
+        end
       end
 
       def attribute_method?(attribute)

data/lib/active_record/attribute_methods/read.rb

@@ -30,15 +30,33 @@ module ActiveRecord
         end
 
         def undefine_attribute_methods
-          if base_class == self
-            generated_external_attribute_methods.module_eval do
-              instance_methods.each { |m| undef_method(m) }
-            end
+          generated_external_attribute_methods.module_eval do
+            instance_methods.each { |m| undef_method(m) }
           end
 
           super
         end
 
+        def type_cast_attribute(attr_name, attributes, cache = {}) #:nodoc:
+          return unless attr_name
+          attr_name = attr_name.to_s
+
+          if generated_external_attribute_methods.method_defined?(attr_name)
+            if attributes.has_key?(attr_name) || attr_name == 'id'
+              generated_external_attribute_methods.send(attr_name, attributes[attr_name], attributes, cache, attr_name)
+            end
+          elsif !attribute_methods_generated?
+            # If we haven't generated the caster methods yet, do that and
+            # then try again
+            define_attribute_methods
+            type_cast_attribute(attr_name, attributes, cache)
+          else
+            # If we get here, the attribute has no associated DB column, so
+            # just return it verbatim.
+            attributes[attr_name]
+          end
+        end
+
         protected
           # We want to generate the methods via module_eval rather than define_method,
           # because define_method is slower on dispatch and uses more memory (because it
@@ -105,25 +123,7 @@ module ActiveRecord
       # 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)
-        return unless attr_name
-
-        attr_name = attr_name.to_s
-        methods   = self.class.generated_external_attribute_methods
-
-        if methods.method_defined?(attr_name)
-          if @attributes.has_key?(attr_name) || attr_name == 'id'
-            methods.send(attr_name, @attributes[attr_name], @attributes, @attributes_cache, attr_name)
-          end
-        elsif !self.class.attribute_methods_generated?
-          # If we haven't generated the caster methods yet, do that and
-          # then try again
-          self.class.define_attribute_methods
-          read_attribute(attr_name)
-        else
-          # If we get here, the attribute has no associated DB column, so
-          # just return it verbatim.
-          @attributes[attr_name]
-        end
+        self.class.type_cast_attribute(attr_name, @attributes, @attributes_cache)
       end
 
       private

data/lib/active_record/attribute_methods/serialization.rb

@@ -58,6 +58,18 @@ module ActiveRecord
           self.serialized_attributes = serialized_attributes.merge(attr_name.to_s => coder)
         end
 
+        def initialize_attributes(attributes) #:nodoc:
+          super
+
+          serialized_attributes.each do |key, coder|
+            if attributes.key?(key)
+              attributes[key] = Attribute.new(coder, attributes[key], :serialized)
+            end
+          end
+
+          attributes
+        end
+
         private
 
         def attribute_cast_code(attr_name)
@@ -69,14 +81,6 @@ module ActiveRecord
         end
       end
 
-      def set_serialized_attributes
-        self.class.serialized_attributes.each do |key, coder|
-          if @attributes.key?(key)
-            @attributes[key] = Attribute.new(coder, @attributes[key], :serialized)
-          end
-        end
-      end
-
       def type_cast_attribute_for_write(column, value)
         if column && coder = self.class.serialized_attributes[column.name]
           Attribute.new(coder, value, :unserialized)

data/lib/active_record/base.rb

@@ -469,7 +469,7 @@ module ActiveRecord #:nodoc:
       #   # Instantiates a single new object bypassing mass-assignment security
       #   User.new({ :first_name => 'Jamie', :is_admin => true }, :without_protection => true)
       def initialize(attributes = nil, options = {})
-        @attributes = attributes_from_column_definition
+        @attributes = self.class.initialize_attributes(self.class.column_defaults.dup)
         @association_cache = {}
         @aggregation_cache = {}
         @attributes_cache = {}
@@ -482,7 +482,6 @@ module ActiveRecord #:nodoc:
         @relation = nil
 
         ensure_proper_type
-        set_serialized_attributes
 
         populate_with_current_scope_attributes
 
@@ -503,11 +502,9 @@ module ActiveRecord #:nodoc:
       #   post.init_with('attributes' => { 'title' => 'hello world' })
       #   post.title # => 'hello world'
       def init_with(coder)
-        @attributes = coder['attributes']
+        @attributes = self.class.initialize_attributes(coder['attributes'])
         @relation = nil
 
-        set_serialized_attributes
-
         @attributes_cache, @previously_changed, @changed_attributes = {}, {}, {}
         @association_cache = {}
         @aggregation_cache = {}
@@ -534,7 +531,7 @@ module ActiveRecord #:nodoc:
         _run_after_initialize_callbacks if respond_to?(:_run_after_initialize_callbacks)
 
         @changed_attributes = {}
-        attributes_from_column_definition.each do |attr, orig_value|
+        self.class.column_defaults.each do |attr, orig_value|
           @changed_attributes[attr] = orig_value if field_changed?(attr, orig_value, @attributes[attr])
         end
 

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -301,15 +301,8 @@ module ActiveRecord
       # Adds a new index to the table. +column_name+ can be a single Symbol, or
       # an Array of Symbols.
       #
-      # The index will be named after the table and the first column name,
-      # unless you pass <tt>:name</tt> as an option.
-      #
-      # When creating an index on multiple columns, the first column is used as a name
-      # for the index. For example, when you specify an index on two columns
-      # [<tt>:first</tt>, <tt>:last</tt>], the DBMS creates an index for both columns as well as an
-      # index for the first column <tt>:first</tt>. Using just the first name for this index
-      # makes sense, because you will never have to create a singular index with this
-      # name.
+      # The index will be named after the table and the column name(s), unless
+      # you pass <tt>:name</tt> as an option.
       #
       # ===== Examples
       #

data/lib/active_record/counter_cache.rb

@@ -65,7 +65,7 @@ module ActiveRecord
     #   Post.update_counters [10, 15], :comment_count => 1
     #   # Executes the following SQL:
     #   # UPDATE posts
-    #   #    SET comment_count = COALESCE(comment_count, 0) + 1,
+    #   #    SET comment_count = COALESCE(comment_count, 0) + 1
     #   #  WHERE id IN (10, 15)
     def update_counters(id, counters)
       updates = counters.map do |counter_name, value|

data/lib/active_record/identity_map.rb

@@ -111,13 +111,12 @@ module ActiveRecord
     # model object.
     def reinit_with(coder)
       @attributes_cache = {}
-      dirty = @changed_attributes.keys
-      @attributes.update(coder['attributes'].except(*dirty))
+      dirty      = @changed_attributes.keys
+      attributes = self.class.initialize_attributes(coder['attributes'].except(*dirty))
+      @attributes.update(attributes)
       @changed_attributes.update(coder['attributes'].slice(*dirty))
       @changed_attributes.delete_if{|k,v| v.eql? @attributes[k]}
 
-      set_serialized_attributes
-
       run_callbacks :find
 
       self

data/lib/active_record/locking/optimistic.rb

@@ -64,21 +64,6 @@ module ActiveRecord
           send(lock_col + '=', previous_lock_value + 1)
         end
 
-        def attributes_from_column_definition
-          result = self.class.column_defaults.dup
-
-          # If the locking column has no default value set,
-          # start the lock version at zero. Note we can't use
-          # <tt>locking_enabled?</tt> at this point as
-          # <tt>@attributes</tt> may not have been initialized yet.
-
-          if result.key?(self.class.locking_column) && lock_optimistically
-            result[self.class.locking_column] ||= 0
-          end
-
-          result
-        end
-
         def update(attribute_names = @attributes.keys) #:nodoc:
           return super unless locking_enabled?
           return 0 if attribute_names.empty?
@@ -180,6 +165,18 @@ module ActiveRecord
           counters = counters.merge(locking_column => 1) if locking_enabled?
           super
         end
+
+        # If the locking column has no default value set,
+        # start the lock version at zero. Note we can't use
+        # <tt>locking_enabled?</tt> at this point as
+        # <tt>@attributes</tt> may not have been initialized yet.
+        def initialize_attributes(attributes) #:nodoc:
+          if attributes.key?(locking_column) && lock_optimistically
+            attributes[locking_column] ||= 0
+          end
+
+          attributes
+        end
       end
     end
   end

data/lib/active_record/migration/command_recorder.rb

@@ -59,7 +59,7 @@ module ActiveRecord
       private
 
       def invert_create_table(args)
-        [:drop_table, args]
+        [:drop_table, [args.first]]
       end
 
       def invert_rename_table(args)

data/lib/active_record/persistence.rb

@@ -368,13 +368,5 @@ module ActiveRecord
       @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/railties/databases.rake

@@ -38,6 +38,7 @@ db_namespace = namespace :db do
   desc 'Create the database from config/database.yml for the current Rails.env (use db:create:all to create all dbs in the config)'
   task :create => :load_config do
     configs_for_environment.each { |config| create_database(config) }
+    ActiveRecord::Base.establish_connection(configs_for_environment.first)
   end
 
   def mysql_creation_options(config)

data/lib/active_record/relation.rb

@@ -7,7 +7,7 @@ module ActiveRecord
     JoinOperation = Struct.new(:relation, :join_class, :on)
     ASSOCIATION_METHODS = [:includes, :eager_load, :preload]
     MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :where, :having, :bind]
-    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :from, :reorder, :reverse_order, :uniq]
+    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :from, :reordering, :reverse_order, :uniq]
 
     include FinderMethods, Calculations, SpawnMethods, QueryMethods, Batches, Explain, Delegation
 

data/lib/active_record/relation/calculations.rb

@@ -168,7 +168,7 @@ module ActiveRecord
 
     # This method is designed to perform select by a single column as direct SQL query
     # Returns <tt>Array</tt> with values of the specified column name
-    # The values has same data type as column. 
+    # The values has same data type as column.
     #
     # Examples:
     #
@@ -177,9 +177,9 @@ module ActiveRecord
     #   Person.where(:confirmed => true).limit(5).pluck(:id)
     #
     def pluck(column_name)
-      scope = self.select(column_name)
-      self.connection.select_values(scope.to_sql).map! do |value|
-        type_cast_using_column(value, column_for(column_name))
+      column_name = column_name.to_s
+      klass.connection.select_all(select(column_name).arel).map! do |attributes|
+        klass.type_cast_attribute(attributes.keys.first, klass.initialize_attributes(attributes))
       end
     end
 

data/lib/active_record/relation/finder_methods.rb

@@ -134,7 +134,7 @@ module ActiveRecord
     def last(*args)
       if args.any?
         if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
-          if order_values.empty? && reorder_value.nil?
+          if order_values.empty?
             order("#{primary_key} DESC").limit(*args).reverse
           else
             to_a.last(*args)

data/lib/active_record/relation/query_methods.rb

@@ -9,7 +9,7 @@ module ActiveRecord
                   :select_values, :group_values, :order_values, :joins_values,
                   :where_values, :having_values, :bind_values,
                   :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value,
-                  :from_value, :reorder_value, :reverse_order_value,
+                  :from_value, :reordering_value, :reverse_order_value,
                   :uniq_value
 
     def includes(*args)
@@ -63,10 +63,10 @@ module ActiveRecord
     #   => [#<Model field: "value", other_field: "value", and_one_more: "value">]
     #
     # Any attributes that do not have fields retrieved by a select
-    # will return `nil` when the getter method for that attribute is used:
+    # will raise a ActiveModel::MissingAttributeError when the getter method for that attribute is used:
     #
     #   >> Model.select(:field).first.other_field
-    #   => nil
+    #   => ActiveModel::MissingAttributeError: missing attribute: other_field
     def select(value = Proc.new)
       if block_given?
         to_a.select {|*block_args| value.call(*block_args) }
@@ -97,7 +97,8 @@ module ActiveRecord
       return self if args.blank?
 
       relation = clone
-      relation.reorder_value = args.flatten
+      relation.reordering_value = true
+      relation.order_values = args.flatten
       relation
     end
 
@@ -263,7 +264,7 @@ module ActiveRecord
 
       arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
 
-      order = @reorder_value ? @reorder_value : @order_values
+      order = @order_values
       order = reverse_sql_order(order) if @reverse_order_value
       arel.order(*order.uniq.reject{|o| o.blank?}) unless order.empty?
 

data/lib/active_record/relation/spawn_methods.rb

@@ -22,7 +22,7 @@ module ActiveRecord
         end
       end
 
-      (Relation::MULTI_VALUE_METHODS - [:joins, :where]).each do |method|
+      (Relation::MULTI_VALUE_METHODS - [:joins, :where, :order]).each do |method|
         value = r.send(:"#{method}_values")
         merged_relation.send(:"#{method}_values=", merged_relation.send(:"#{method}_values") + value) if value.present?
       end
@@ -48,7 +48,7 @@ module ActiveRecord
 
       merged_relation.where_values = merged_wheres
 
-      (Relation::SINGLE_VALUE_METHODS - [:lock, :create_with]).each do |method|
+      (Relation::SINGLE_VALUE_METHODS - [:lock, :create_with, :reordering]).each do |method|
         value = r.send(:"#{method}_value")
         merged_relation.send(:"#{method}_value=", value) unless value.nil?
       end
@@ -57,6 +57,15 @@ module ActiveRecord
 
       merged_relation = merged_relation.create_with(r.create_with_value) unless r.create_with_value.empty?
 
+      if (r.reordering_value)
+        # override any order specified in the original relation
+        merged_relation.reordering_value = true
+        merged_relation.order_values = r.order_values
+      else
+        # merge in order_values from r
+        merged_relation.order_values += r.order_values
+      end
+
       # Apply scope extension modules
       merged_relation.send :apply_modules, r.extensions
 

data/lib/active_record/scoping/default.rb

@@ -12,7 +12,7 @@ module ActiveRecord
       end
 
       module ClassMethods
-        # Returns a scope for this class without taking into account the default_scope.
+        # Returns a scope for the model without the default_scope.
         #
         #   class Post < ActiveRecord::Base
         #     def self.default_scope
@@ -23,18 +23,20 @@ module ActiveRecord
         #   Post.all          # Fires "SELECT * FROM posts WHERE published = true"
         #   Post.unscoped.all # Fires "SELECT * FROM posts"
         #
-        # This method also accepts a block meaning that all queries inside the block will
+        # This method also accepts a block. All queries inside the block will
         # not use the default_scope:
         #
         #   Post.unscoped {
         #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
         #   }
         #
-        # It is recommended to use block form of unscoped because chaining unscoped with <tt>scope</tt>
-        # does not work. Assuming that <tt>published</tt> is a <tt>scope</tt> following two statements are same.
+        # It is recommended to use the block form of unscoped because chaining
+        # unscoped with <tt>scope</tt> does not work.  Assuming that
+        # <tt>published</tt> is a <tt>scope</tt>, the following two statements
+        # are equal: the default_scope is applied on both.
         #
-        # Post.unscoped.published
-        # Post.published
+        #   Post.unscoped.published
+        #   Post.published
         def unscoped #:nodoc:
           block_given? ? relation.scoping { yield } : relation
         end

data/lib/active_record/scoping/named.rb

@@ -118,16 +118,16 @@ module ActiveRecord
         # when they are used. For example, the following would be incorrect:
         #
         #   class Post < ActiveRecord::Base
-        #     scope :recent, where('published_at >= ?', Time.now - 1.week)
+        #     scope :recent, where('published_at >= ?', Time.current - 1.week)
         #   end
         #
-        # The example above would be 'frozen' to the <tt>Time.now</tt> value when the <tt>Post</tt>
+        # The example above would be 'frozen' to the <tt>Time.current</tt> value when the <tt>Post</tt>
         # class was defined, and so the resultant SQL query would always be the same. The correct
         # way to do this would be via a lambda, which will re-evaluate the scope each time
         # it is called:
         #
         #   class Post < ActiveRecord::Base
-        #     scope :recent, lambda { where('published_at >= ?', Time.now - 1.week) }
+        #     scope :recent, lambda { where('published_at >= ?', Time.current - 1.week) }
         #   end
         #
         # Named \scopes can also have extensions, just as with <tt>has_many</tt> declarations:

data/lib/active_record/session_store.rb

@@ -51,11 +51,11 @@ module ActiveRecord
   class SessionStore < ActionDispatch::Session::AbstractStore
     module ClassMethods # :nodoc:
       def marshal(data)
-        ActiveSupport::Base64.encode64(Marshal.dump(data)) if data
+        ::Base64.encode64(Marshal.dump(data)) if data
       end
 
       def unmarshal(data)
-        Marshal.load(ActiveSupport::Base64.decode64(data)) if data
+        Marshal.load(::Base64.decode64(data)) if data
       end
 
       def drop_table!
@@ -169,11 +169,11 @@ module ActiveRecord
     # are implemented as class methods that you may override. By default,
     # marshaling data is
     #
-    #   ActiveSupport::Base64.encode64(Marshal.dump(data))
+    #   ::Base64.encode64(Marshal.dump(data))
     #
     # and unmarshaling data is
     #
-    #   Marshal.load(ActiveSupport::Base64.decode64(data))
+    #   Marshal.load(::Base64.decode64(data))
     #
     # This marshaling behavior is intended to store the widest range of
     # binary session data in a +text+ column. For higher performance,

data/lib/active_record/version.rb

@@ -3,7 +3,7 @@ module ActiveRecord
     MAJOR = 3
     MINOR = 2
     TINY  = 0
-    PRE   = "rc1"
+    PRE   = "rc2"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
   end

data/lib/rails/generators/active_record/migration/migration_generator.rb

@@ -3,7 +3,7 @@ require 'rails/generators/active_record'
 module ActiveRecord
   module Generators
     class MigrationGenerator < Base
-      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+      argument :attributes, :type => :array, :default => [], :banner => "field[:type][:index] field[:type][:index]"
 
       def create_migration_file
         set_local_assigns!

data/lib/rails/generators/active_record/migration/templates/migration.rb

@@ -2,14 +2,20 @@ class <%= migration_class_name %> < ActiveRecord::Migration
 <%- if migration_action == 'add' -%>
   def change
 <% attributes.each do |attribute| -%>
-    add_column :<%= table_name %>, :<%= attribute.name %>, :<%= attribute.type %>
+    add_column :<%= table_name %>, :<%= attribute.name %>, :<%= attribute.type %><%= attribute.inject_options %>
+    <%- if attribute.has_index? -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+    <%- end %>
 <%- end -%>
   end
 <%- else -%>
   def up
 <% attributes.each do |attribute| -%>
   <%- if migration_action -%>
-    <%= migration_action %>_column :<%= table_name %>, :<%= attribute.name %><% if migration_action == 'add' %>, :<%= attribute.type %><% end %>
+    <%= migration_action %>_column :<%= table_name %>, :<%= attribute.name %><% if migration_action == 'add' %>, :<%= attribute.type %><%= attribute.inject_options %><% end %>
+    <% if attribute.has_index? && migration_action == 'add' %>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+    <% end -%>
   <%- end -%>
 <%- end -%>
   end
@@ -17,7 +23,7 @@ class <%= migration_class_name %> < ActiveRecord::Migration
   def down
 <% attributes.reverse.each do |attribute| -%>
   <%- if migration_action -%>
-    <%= migration_action == 'add' ? 'remove' : 'add' %>_column :<%= table_name %>, :<%= attribute.name %><% if migration_action == 'remove' %>, :<%= attribute.type %><% end %>
+    <%= migration_action == 'add' ? 'remove' : 'add' %>_column :<%= table_name %>, :<%= attribute.name %><% if migration_action == 'remove' %>, :<%= attribute.type %><%= attribute.inject_options %><% end %>
   <%- end -%>
 <%- end -%>
   end

data/lib/rails/generators/active_record/model/model_generator.rb

@@ -3,7 +3,7 @@ require 'rails/generators/active_record'
 module ActiveRecord
   module Generators
     class ModelGenerator < Base
-      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+      argument :attributes, :type => :array, :default => [], :banner => "field[:type][:index] field[:type][:index]"
 
       check_class_collision
 
@@ -26,6 +26,10 @@ module ActiveRecord
         template 'module.rb', File.join('app/models', "#{class_path.join('/')}.rb") if behavior == :invoke
       end
 
+      def attributes_with_index
+        attributes.select { |a| a.has_index? || (a.reference? && options[:indexes]) }
+      end
+
       hook_for :test_framework
 
       protected

data/lib/rails/generators/active_record/model/templates/migration.rb

@@ -2,16 +2,14 @@ class <%= migration_class_name %> < ActiveRecord::Migration
   def change
     create_table :<%= table_name %> do |t|
 <% attributes.each do |attribute| -%>
-      t.<%= attribute.type %> :<%= attribute.name %>
+      t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
 <% end -%>
 <% if options[:timestamps] %>
       t.timestamps
 <% end -%>
     end
-<% if options[:indexes] -%>
-<% attributes.select {|attr| attr.reference? }.each do |attribute| -%>
-    add_index :<%= table_name %>, :<%= attribute.name %>_id
-<% end -%>
+<% attributes_with_index.each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
 <% end -%>
   end
 end

metadata

@@ -1,69 +1,100 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: activerecord
-version: !ruby/object:Gem::Version
-  version: 3.2.0.rc1
-  prerelease: 6
+version: !ruby/object:Gem::Version 
+  hash: 977940591
+  prerelease: true
+  segments: 
+  - 3
+  - 2
+  - 0
+  - rc2
+  version: 3.2.0.rc2
 platform: ruby
-authors:
+authors: 
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-20 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-01-04 00:00:00 -02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: activesupport
-  requirement: &2156029700 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - =
-      - !ruby/object:Gem::Version
-        version: 3.2.0.rc1
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 977940591
+        segments: 
+        - 3
+        - 2
+        - 0
+        - rc2
+        version: 3.2.0.rc2
   type: :runtime
-  prerelease: false
-  version_requirements: *2156029700
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: activemodel
-  requirement: &2156028220 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - =
-      - !ruby/object:Gem::Version
-        version: 3.2.0.rc1
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 977940591
+        segments: 
+        - 3
+        - 2
+        - 0
+        - rc2
+        version: 3.2.0.rc2
   type: :runtime
-  prerelease: false
-  version_requirements: *2156028220
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: arel
-  requirement: &2156025120 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
+      - !ruby/object:Gem::Version 
+        hash: 977940606
+        segments: 
+        - 3
+        - 0
+        - 0
+        - rc1
         version: 3.0.0.rc1
   type: :runtime
-  prerelease: false
-  version_requirements: *2156025120
-- !ruby/object:Gem::Dependency
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: tzinfo
-  requirement: &2156024360 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
+      - !ruby/object:Gem::Version 
+        hash: 41
+        segments: 
+        - 0
+        - 3
+        - 29
         version: 0.3.29
   type: :runtime
-  prerelease: false
-  version_requirements: *2156024360
-description: Databases on Rails. Build a persistent domain model by mapping database
-  tables to Ruby classes. Strong conventions for associations, validations, aggregations,
-  migrations, and testing come baked-in.
+  version_requirements: *id004
+description: Databases on Rails. Build a persistent domain model by mapping database tables to Ruby classes. Strong conventions for associations, validations, aggregations, migrations, and testing come baked-in.
 email: david@loudthinking.com
 executables: []
+
 extensions: []
-extra_rdoc_files:
+
+extra_rdoc_files: 
 - README.rdoc
-files:
+files: 
 - CHANGELOG.md
 - MIT-LICENSE
 - README.rdoc
@@ -213,30 +244,44 @@ files:
 - lib/rails/generators/active_record/session_migration/session_migration_generator.rb
 - lib/rails/generators/active_record/session_migration/templates/migration.rb
 - lib/rails/generators/active_record.rb
+has_rdoc: true
 homepage: http://www.rubyonrails.org
 licenses: []
+
 post_install_message: 
-rdoc_options:
+rdoc_options: 
 - --main
 - README.rdoc
-require_paths:
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>'
-    - !ruby/object:Gem::Version
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
       version: 1.3.1
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.7
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Object-relational mapper framework (part of Rails).
 test_files: []
+