activerecord 3.2.3 → 3.2.4.rc1

data/CHANGELOG.md

@@ -1,4 +1,13 @@
-## Rails 3.2.3 (unreleased) ##
+## Rails 3.2.4 (unreleased) ##
+
+*   Perf fix: Don't load the records when doing assoc.delete_all.
+    GH #6289. *Jon Leighton*
+
+*   Association preloading shouldn't be affected by the current scoping.
+    This could cause infinite recursion and potentially other problems.
+    See GH #5667. *Jon Leighton*
+
+## Rails 3.2.3 (March 30, 2012) ##
 
 *   Added find_or_create_by_{attribute}! dynamic method. *Andrew White*
 

data/README.rdoc

@@ -203,7 +203,7 @@ The latest version of Active Record can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub
 
-* https://github.com/rails/rails/tree/master/activerecord
+* https://github.com/rails/rails/tree/3-2-stable/activerecord
 
 
 == License

data/lib/active_record/associations/collection_association.rb

@@ -154,7 +154,7 @@ module ActiveRecord
       #
       # See delete for more info.
       def delete_all
-        delete(load_target).tap do
+        delete(:all).tap do
           reset
           loaded!
         end
@@ -226,7 +226,17 @@ module ActiveRecord
       # are actually removed from the database, that depends precisely on
       # +delete_records+. They are in any case removed from the collection.
       def delete(*records)
-        delete_or_destroy(records, options[:dependent])
+        dependent = options[:dependent]
+
+        if records.first == :all
+          if loaded? || dependent == :destroy
+            delete_or_destroy(load_target, dependent)
+          else
+            delete_records(:all, dependent)
+          end
+        else
+          delete_or_destroy(records, dependent)
+        end
       end
 
       # Destroy +records+ and remove them from this association calling
@@ -481,6 +491,8 @@ module ActiveRecord
             raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
                                   "new records could not be saved."
           end
+
+          target
         end
 
         def concat_records(records)

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -44,13 +44,20 @@ module ActiveRecord
 
         def delete_records(records, method)
           if sql = options[:delete_sql]
+            records = load_target if records == :all
             records.each { |record| owner.connection.delete(interpolate(sql, record)) }
           else
-            relation = join_table
-            stmt = relation.where(relation[reflection.foreign_key].eq(owner.id).
-              and(relation[reflection.association_foreign_key].in(records.map { |x| x.id }.compact))
-            ).compile_delete
-            owner.connection.delete stmt
+            relation  = join_table
+            condition = relation[reflection.foreign_key].eq(owner.id)
+
+            unless records == :all
+              condition = condition.and(
+                relation[reflection.association_foreign_key].
+                  in(records.map { |x| x.id }.compact)
+              )
+            end
+
+            owner.connection.delete(relation.where(condition).compile_delete)
           end
         end
 

data/lib/active_record/associations/has_many_association.rb

@@ -89,8 +89,12 @@ module ActiveRecord
             records.each { |r| r.destroy }
             update_counter(-records.length) unless inverse_updates_counter_cache?
           else
-            keys  = records.map { |r| r[reflection.association_primary_key] }
-            scope = scoped.where(reflection.association_primary_key => keys)
+            if records == :all
+              scope = scoped
+            else
+              keys  = records.map { |r| r[reflection.association_primary_key] }
+              scope = scoped.where(reflection.association_primary_key => keys)
+            end
 
             if method == :delete_all
               update_counter(-scope.delete_all)

data/lib/active_record/associations/has_many_through_association.rb

@@ -126,6 +126,10 @@ module ActiveRecord
         def delete_records(records, method)
           ensure_not_nested
 
+          # This is unoptimised; it will load all the target records
+          # even when we just want to delete everything.
+          records = load_target if records == :all
+
           scope = through_association.scoped.where(construct_join_attributes(*records))
 
           case method

data/lib/active_record/associations/preloader/association.rb

@@ -77,7 +77,7 @@ module ActiveRecord
             # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
             # Make several smaller queries if necessary or make one query if the adapter supports it
             sliced  = owner_keys.each_slice(model.connection.in_clause_length || owner_keys.size)
-            records = sliced.map { |slice| records_for(slice) }.flatten
+            records = sliced.map { |slice| records_for(slice).to_a }.flatten
           end
 
           # Each record may have multiple owners, and vice-versa
@@ -93,7 +93,8 @@ module ActiveRecord
         end
 
         def build_scope
-          scope = klass.scoped
+          scope = klass.unscoped
+          scope.default_scoped = true
 
           scope = scope.where(process_conditions(options[:conditions]))
           scope = scope.where(process_conditions(preload_options[:conditions]))

data/lib/active_record/attribute_methods.rb

@@ -64,6 +64,7 @@ module ActiveRecord
           return if attribute_methods_generated?
           superclass.define_attribute_methods unless self == base_class
           super(column_names)
+          column_names.each { |name| define_external_attribute_method(name) }
           @attribute_methods_generated = true
         end
       end

data/lib/active_record/attribute_methods/read.rb

@@ -67,26 +67,27 @@ module ActiveRecord
           # we first define with the __temp__ identifier, and then use alias method to
           # rename it to what we want.
           def define_method_attribute(attr_name)
-            cast_code = attribute_cast_code(attr_name)
-
             generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
               def __temp__
-                #{internal_attribute_access_code(attr_name, cast_code)}
+                #{internal_attribute_access_code(attr_name, attribute_cast_code(attr_name))}
               end
               alias_method '#{attr_name}', :__temp__
               undef_method :__temp__
             STR
+          end
 
+        private
+
+          def define_external_attribute_method(attr_name)
             generated_external_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
               def __temp__(v, attributes, attributes_cache, attr_name)
-                #{external_attribute_access_code(attr_name, cast_code)}
+                #{external_attribute_access_code(attr_name, attribute_cast_code(attr_name))}
               end
               alias_method '#{attr_name}', :__temp__
               undef_method :__temp__
             STR
           end
 
-        private
           def cacheable_column?(column)
             attribute_types_cached_by_default.include?(column.type)
           end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -43,6 +43,7 @@ module ActiveRecord
                   end
                   time = time.in_time_zone rescue nil if time
                   write_attribute(:#{attr_name}, original_time)
+                  #{attr_name}_will_change!
                   @attributes_cache["#{attr_name}"] = time
                 end
               EOV

data/lib/active_record/base.rb

@@ -450,12 +450,12 @@ module ActiveRecord #:nodoc:
       private
 
       def relation #:nodoc:
-        @relation ||= Relation.new(self, arel_table)
+        relation ||= Relation.new(self, arel_table)
 
         if finder_needs_type_condition?
-          @relation.where(type_condition).create_with(inheritance_column.to_sym => sti_name)
+          relation.where(type_condition).create_with(inheritance_column.to_sym => sti_name)
         else
-          @relation
+          relation
         end
       end
     end
@@ -489,7 +489,6 @@ module ActiveRecord #:nodoc:
         @marked_for_destruction = false
         @previously_changed = {}
         @changed_attributes = {}
-        @relation = nil
 
         ensure_proper_type
 

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

@@ -92,14 +92,18 @@ module ActiveRecord
       # #connection can be called any number of times; the connection is
       # held in a hash keyed by the thread id.
       def connection
-        @reserved_connections[current_connection_id] ||= checkout
+        synchronize do
+          @reserved_connections[current_connection_id] ||= checkout
+        end
       end
 
       # Is there an open connection that is being used for the current thread?
       def active_connection?
-        @reserved_connections.fetch(current_connection_id) {
-          return false
-        }.in_use?
+        synchronize do
+          @reserved_connections.fetch(current_connection_id) {
+            return false
+          }.in_use?
+        end
       end
 
       # Signal that the thread is finished with the current connection.
@@ -286,17 +290,19 @@ connection.  For example: ActiveRecord::Base.connection.close
       private
 
       def release(conn)
-        thread_id = nil
-
-        if @reserved_connections[current_connection_id] == conn
-          thread_id = current_connection_id
-        else
-          thread_id = @reserved_connections.keys.find { |k|
-            @reserved_connections[k] == conn
-          }
-        end
+        synchronize do
+          thread_id = nil
+
+          if @reserved_connections[current_connection_id] == conn
+            thread_id = current_connection_id
+          else
+            thread_id = @reserved_connections.keys.find { |k|
+              @reserved_connections[k] == conn
+            }
+          end
 
-        @reserved_connections.delete thread_id if thread_id
+          @reserved_connections.delete thread_id if thread_id
+        end
       end
 
       def new_connection

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

@@ -269,7 +269,15 @@ module ActiveRecord
       #  remove_column(:suppliers, :qualification)
       #  remove_columns(:suppliers, :qualification, :experience)
       def remove_column(table_name, *column_names)
-        columns_for_remove(table_name, *column_names).each {|column_name| execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{column_name}" }
+        if column_names.flatten!
+          message = 'Passing array to remove_columns is deprecated, please use ' +
+                    'multiple arguments, like: `remove_columns(:posts, :foo, :bar)`'
+          ActiveSupport::Deprecation.warn message, caller
+        end
+
+        columns_for_remove(table_name, *column_names).each do |column_name|
+          execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{column_name}"
+        end
       end
       alias :remove_columns :remove_column
 

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -525,7 +525,7 @@ module ActiveRecord
       def pk_and_sequence_for(table)
         execute_and_free("SHOW CREATE TABLE #{quote_table_name(table)}", 'SCHEMA') do |result|
           create_table = each_hash(result).first[:"Create Table"]
-          if create_table.to_s =~ /PRIMARY KEY\s+\((.+)\)/
+          if create_table.to_s =~ /PRIMARY KEY\s+(?:USING\s+\w+\s+)?\((.+)\)/
             keys = $1.split(",").map { |key| key.gsub(/[`"]/, "") }
             keys.length == 1 ? [keys.first, nil] : nil
           else

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -264,7 +264,7 @@ module ActiveRecord
 
         # increase timeout so mysql server doesn't disconnect us
         wait_timeout = @config[:wait_timeout]
-        wait_timeout = 2592000 unless wait_timeout.is_a?(Fixnum)
+        wait_timeout = 2147483 unless wait_timeout.is_a?(Fixnum)
         variable_assignments << "@@wait_timeout = #{wait_timeout}"
 
         execute("SET #{variable_assignments.join(', ')}", :skip_logging)

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -1067,14 +1067,25 @@ module ActiveRecord
 
       # Maps logical Rails types to PostgreSQL-specific data types.
       def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-        return super unless type.to_s == 'integer'
-        return 'integer' unless limit
-
-        case limit
-          when 1, 2; 'smallint'
-          when 3, 4; 'integer'
-          when 5..8; 'bigint'
-          else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
+        case type.to_s
+        when 'binary'
+          # PostgreSQL doesn't support limits on binary (bytea) columns.
+          # The hard limit is 1Gb, because of a 32-bit size field, and TOAST.
+          case limit
+          when nil, 0..0x3fffffff; super(type)
+          else raise(ActiveRecordError, "No binary type has byte size #{limit}.")
+          end
+        when 'integer'
+          return 'integer' unless limit
+  
+          case limit
+            when 1, 2; 'smallint'
+            when 3, 4; 'integer'
+            when 5..8; 'bigint'
+            else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
+          end
+        else
+          super
         end
       end
 

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -407,7 +407,14 @@ module ActiveRecord
 
       def remove_column(table_name, *column_names) #:nodoc:
         raise ArgumentError.new("You must specify at least one column name. Example: remove_column(:people, :first_name)") if column_names.empty?
-        column_names.flatten.each do |column_name|
+
+        if column_names.flatten!
+          message = 'Passing array to remove_columns is deprecated, please use ' +
+                    'multiple arguments, like: `remove_columns(:posts, :foo, :bar)`'
+          ActiveSupport::Deprecation.warn message, caller
+        end
+
+        column_names.each do |column_name|
           alter_table(table_name) do |definition|
             definition.columns.delete(definition[column_name])
           end

data/lib/active_record/fixtures.rb

@@ -419,11 +419,15 @@ module ActiveRecord
       cache_for_connection(connection).update(fixtures_map)
     end
 
-    def self.instantiate_fixtures(object, fixture_name, fixtures, load_instances = true)
+    #--
+    # TODO:NOTE: in the next version, the __with_new_arity suffix and
+    #   the method with the old arity will be removed.
+    #++
+    def self.instantiate_fixtures__with_new_arity(object, fixture_set, load_instances = true) # :nodoc:
       if load_instances
-        fixtures.each do |name, fixture|
+        fixture_set.each do |fixture_name, fixture|
           begin
-            object.instance_variable_set "@#{name}", fixture.find
+            object.instance_variable_set "@#{fixture_name}", fixture.find
           rescue FixtureClassNotFound
             nil
           end
@@ -431,9 +435,24 @@ module ActiveRecord
       end
     end
 
+    # The use with parameters  <tt>(object, fixture_set_name, fixture_set, load_instances = true)</tt>  is deprecated,  +fixture_set_name+  parameter is not used.
+    # Use as:
+    #
+    #   instantiate_fixtures(object, fixture_set, load_instances = true)
+    def self.instantiate_fixtures(object, fixture_set, load_instances = true, rails_3_2_compatibility_argument = true)
+      unless load_instances == true || load_instances == false
+        ActiveSupport::Deprecation.warn(
+          "ActiveRecord::Fixtures.instantiate_fixtures with parameters (object, fixture_set_name, fixture_set, load_instances = true) is deprecated and shall be removed from future releases.  Use it with parameters (object, fixture_set, load_instances = true) instead (skip fixture_set_name).",
+          caller)
+        fixture_set = load_instances
+        load_instances = rails_3_2_compatibility_argument
+      end
+      instantiate_fixtures__with_new_arity(object, fixture_set, load_instances)
+    end
+
     def self.instantiate_all_loaded_fixtures(object, load_instances = true)
-      all_loaded_fixtures.each do |table_name, fixtures|
-        ActiveRecord::Fixtures.instantiate_fixtures(object, table_name, fixtures, load_instances)
+      all_loaded_fixtures.each_value do |fixture_set|
+        ActiveRecord::Fixtures.instantiate_fixtures(object, fixture_set, load_instances)
       end
     end
 
@@ -659,9 +678,6 @@ module ActiveRecord
         "#{@fixture_path}.yml"
       end
 
-      def yaml_fixtures_key(path)
-        ::File.basename(@fixture_path).split(".").first
-      end
   end
 
   class Fixture #:nodoc:
@@ -893,8 +909,8 @@ module ActiveRecord
           ActiveRecord::Fixtures.instantiate_all_loaded_fixtures(self, load_instances?)
         else
           raise RuntimeError, 'Load fixtures before instantiating them.' if @loaded_fixtures.nil?
-          @loaded_fixtures.each do |fixture_name, fixtures|
-            ActiveRecord::Fixtures.instantiate_fixtures(self, fixture_name, fixtures, load_instances?)
+          @loaded_fixtures.each_value do |fixture_set|
+            ActiveRecord::Fixtures.instantiate_fixtures(self, fixture_set, load_instances?)
           end
         end
       end

data/lib/active_record/identity_map.rb

@@ -90,7 +90,7 @@ module ActiveRecord
       end
 
       def add(record)
-        repository[record.class.symbolized_sti_name][record.id] = record
+        repository[record.class.symbolized_sti_name][record.id] = record if contain_all_columns?(record)
       end
 
       def remove(record)
@@ -104,6 +104,12 @@ module ActiveRecord
       def clear
         repository.clear
       end
+
+      private
+
+        def contain_all_columns?(record)
+          (record.class.column_names - record.attribute_names).empty?
+        end
     end
 
     # Reinitialize an Identity Map model object from +coder+.

data/lib/active_record/inheritance.rb

@@ -63,15 +63,7 @@ module ActiveRecord
         record_id = sti_class.primary_key && record[sti_class.primary_key]
 
         if ActiveRecord::IdentityMap.enabled? && record_id
-          if (column = sti_class.columns_hash[sti_class.primary_key]) && column.number?
-            record_id = record_id.to_i
-          end
-          if instance = IdentityMap.get(sti_class, record_id)
-            instance.reinit_with('attributes' => record)
-          else
-            instance = sti_class.allocate.init_with('attributes' => record)
-            IdentityMap.add(instance)
-          end
+          instance = use_identity_map(sti_class, record_id, record)
         else
           instance = sti_class.allocate.init_with('attributes' => record)
         end
@@ -122,6 +114,21 @@ module ActiveRecord
 
       private
 
+      def use_identity_map(sti_class, record_id, record)
+        if (column = sti_class.columns_hash[sti_class.primary_key]) && column.number?
+          record_id = record_id.to_i
+        end
+
+        if instance = IdentityMap.get(sti_class, record_id)
+          instance.reinit_with('attributes' => record)
+        else
+          instance = sti_class.allocate.init_with('attributes' => record)
+          IdentityMap.add(instance)
+        end
+
+        instance
+      end
+
       def find_sti_class(type_name)
         if type_name.blank? || !columns_hash.include?(inheritance_column)
           self

data/lib/active_record/railtie.rb

@@ -72,7 +72,13 @@ module ActiveRecord
     # and then establishes the connection.
     initializer "active_record.initialize_database" do |app|
       ActiveSupport.on_load(:active_record) do
-        self.configurations = app.config.database_configuration
+        db_connection_type = "DATABASE_URL"
+        unless ENV['DATABASE_URL']
+          db_connection_type  = "database.yml"
+          self.configurations = app.config.database_configuration
+        end
+        Rails.logger.info "Connecting to database specified by #{db_connection_type}"
+
         establish_connection
       end
     end

data/lib/active_record/railties/databases.rake

@@ -387,9 +387,9 @@ db_namespace = namespace :db do
         set_psql_env(abcs[Rails.env])
         search_path = abcs[Rails.env]['schema_search_path']
         unless search_path.blank?
-          search_path = search_path.split(",").map{|search_path_part| "--schema=#{search_path_part.strip}" }.join(" ")
+          search_path = search_path.split(",").map{|search_path_part| "--schema=#{Shellwords.escape(search_path_part.strip)}" }.join(" ")
         end
-        `pg_dump -i -s -x -O -f #{filename} #{search_path} #{abcs[Rails.env]['database']}`
+        `pg_dump -i -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(abcs[Rails.env]['database'])}`
         raise 'Error dumping database' if $?.exitstatus == 1
       when /sqlite/
         dbfile = abcs[Rails.env]['database']

data/lib/active_record/relation.rb

@@ -403,6 +403,8 @@ module ActiveRecord
     # If you need to destroy dependent associations or call your <tt>before_*</tt> or
     # +after_destroy+ callbacks, use the +destroy_all+ method instead.
     def delete_all(conditions = nil)
+      raise ActiveRecordError.new("delete_all doesn't support limit scope") if self.limit_value
+
       IdentityMap.repository[symbolized_base_class] = {} if IdentityMap.enabled?
       if conditions
         where(conditions).delete_all

data/lib/active_record/relation/finder_methods.rb

@@ -185,9 +185,8 @@ module ActiveRecord
     #   Person.exists?(['name LIKE ?', "%#{query}%"])
     #   Person.exists?
     def exists?(id = false)
-      return false if id.nil?
-
       id = id.id if ActiveRecord::Base === id
+      return false if id.nil?
 
       join_dependency = construct_join_dependency_for_association_find
       relation = construct_relation_for_association_find(join_dependency)

data/lib/active_record/scoping/named.rb

@@ -34,7 +34,7 @@ module ActiveRecord
             if current_scope
               current_scope.clone
             else
-              scope = relation.clone
+              scope = relation
               scope.default_scoped = true
               scope
             end
@@ -48,7 +48,7 @@ module ActiveRecord
           if current_scope
             current_scope.scope_for_create
           else
-            scope = relation.clone
+            scope = relation
             scope.default_scoped = true
             scope.scope_for_create
           end
@@ -191,7 +191,7 @@ module ActiveRecord
       protected
 
         def valid_scope_name?(name)
-          if respond_to?(name, true)
+          if logger && respond_to?(name, true)
             logger.warn "Creating scope :#{name}. " \
                         "Overwriting existing method #{self.name}.#{name}."
           end

data/lib/active_record/transactions.rb

@@ -327,7 +327,8 @@ module ActiveRecord
         @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
         if @_start_transaction_state[:level] < 1
           restore_state = remove_instance_variable(:@_start_transaction_state)
-          @attributes = @attributes.dup if @attributes.frozen?
+          was_frozen = @attributes.frozen?
+          @attributes = @attributes.dup if was_frozen
           @new_record = restore_state[:new_record]
           @destroyed  = restore_state[:destroyed]
           if restore_state.has_key?(:id)
@@ -336,6 +337,7 @@ module ActiveRecord
             @attributes.delete(self.class.primary_key)
             @attributes_cache.delete(self.class.primary_key)
           end
+          @attributes.freeze if was_frozen
         end
       end
     end

data/lib/active_record/validations/uniqueness.rb

@@ -54,13 +54,13 @@ module ActiveRecord
 
       def build_relation(klass, table, attribute, value) #:nodoc:
         column = klass.columns_hash[attribute.to_s]
-        value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s if column.text?
+        value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s if value && column.text?
 
         if !options[:case_sensitive] && value && column.text?
           # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
           relation = klass.connection.case_insensitive_comparison(table, attribute, column, value)
         else
-          value    = klass.connection.case_sensitive_modifier(value)
+          value    = klass.connection.case_sensitive_modifier(value) if value
           relation = table[attribute].eq(value)
         end
 
@@ -81,7 +81,7 @@ module ActiveRecord
       #
       #   class Person < ActiveRecord::Base
       #     validates_uniqueness_of :user_name, :scope => :account_id
-      #   end 
+      #   end
       #
       # Or even multiple scope parameters. For example, making sure that a teacher can only be on the schedule once
       # per semester for a particular class.

data/lib/active_record/version.rb

@@ -2,8 +2,8 @@ module ActiveRecord
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 2
-    TINY  = 3
-    PRE   = nil
+    TINY  = 4
+    PRE   = "rc1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
   end

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

@@ -13,9 +13,9 @@ class <%= migration_class_name %> < ActiveRecord::Migration
 <% attributes.each do |attribute| -%>
   <%- if migration_action -%>
     <%= migration_action %>_column :<%= table_name %>, :<%= attribute.name %><% if migration_action == 'add' %>, :<%= attribute.type %><%= attribute.inject_options %><% end %>
-    <% if attribute.has_index? && migration_action == 'add' %>
+    <%- if attribute.has_index? && migration_action == 'add' -%>
     add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
-    <% end -%>
+    <%- end -%>
   <%- end -%>
 <%- end -%>
   end

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord
 version: !ruby/object:Gem::Version 
-  hash: 9
-  prerelease: false
+  hash: -3869655734
+  prerelease: 6
   segments: 
   - 3
   - 2
-  - 3
-  version: 3.2.3
+  - 4
+  - rc
+  - 1
+  version: 3.2.4.rc1
 platform: ruby
 authors: 
 - David Heinemeier Hansson
@@ -15,43 +17,48 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-30 00:00:00 -03:00
-default_executable: 
+date: 2012-05-28 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 9
+        hash: -3869655734
         segments: 
         - 3
         - 2
-        - 3
-        version: 3.2.3
-  requirement: *id001
+        - 4
+        - rc
+        - 1
+        version: 3.2.4.rc1
   type: :runtime
-  name: activesupport
-  prerelease: false
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  name: activemodel
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 9
+        hash: -3869655734
         segments: 
         - 3
         - 2
-        - 3
-        version: 3.2.3
-  requirement: *id002
+        - 4
+        - rc
+        - 1
+        version: 3.2.4.rc1
   type: :runtime
-  name: activemodel
-  prerelease: false
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  name: arel
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -62,12 +69,12 @@ dependencies:
         - 0
         - 2
         version: 3.0.2
-  requirement: *id003
   type: :runtime
-  name: arel
-  prerelease: false
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
+  name: tzinfo
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -78,10 +85,8 @@ dependencies:
         - 3
         - 29
         version: 0.3.29
-  requirement: *id004
   type: :runtime
-  name: tzinfo
-  prerelease: false
+  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: []
@@ -240,7 +245,6 @@ 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: []
 
@@ -264,16 +268,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.22
 signing_key: 
 specification_version: 3
 summary: Object-relational mapper framework (part of Rails).