activerecord 4.0.0.rc1 → 4.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e12def830bf51f562de866b6caa052b2e1a83e0d
-  data.tar.gz: 79b4cd4a02f533963a80428fb27c1ed480050b78
+  metadata.gz: 357a6e6e214ac8716f87d6dc1b7444ec9fac7fb8
+  data.tar.gz: 2a02076afbcfa4267ee735a3ae8fe3a9ee9df311
 SHA512:
-  metadata.gz: f28a1e30ab0bee886be06ec885742bb7fec8d1483dc649683f9bad24423bd84009356a099b05bc41fda143f976760d207b787c27ebe0e8d86a7317fbc9e8da1a
-  data.tar.gz: 15d81a227f51f12a3a965ed46522ed3ffbb954f64e86f4b24fcd1bc17baf554273bbe4e0c8e61f68c36e3a4107f14e3f32a52cb5512d6ae221ef14b13de76463
+  metadata.gz: 2d7d4a1faf7d356f0b290884cb1120e18cca36a4cb92db695595a3b9d5e468348f9d4ec3d54810003cde8397c4772b88ec9fefa06e3dda29600d01169ebd76b3
+  data.tar.gz: 1e5d6ce02b031d8c61ad22d7da9482f96975a2662e61ec8e3fe1c4e09472f0822d60bee1e4ef721bab22c6ae07f21ffdc705d6665c0f4a7bee25443c44ace5a7

data/CHANGELOG.md

@@ -1,4 +1,63 @@
-## Rails 4.0.0 (unreleased) ##
+## Rails 4.0.0.rc2 (June 11, 2013) ##
+
+*   Fix `add_column` with `array` option when using PostgreSQL. Fixes #10432
+
+*   Do not overwrite manually built records during one-to-one nested attribute assignment
+
+    For one-to-one nested associations, if you build the new (in-memory)
+    child object yourself before assignment, then the NestedAttributes
+    module will not overwrite it, e.g.:
+
+        class Member < ActiveRecord::Base
+          has_one :avatar
+          accepts_nested_attributes_for :avatar
+
+          def avatar
+            super || build_avatar(width: 200)
+          end
+        end
+
+        member = Member.new
+        member.avatar_attributes = {icon: 'sad'}
+        member.avatar.width # => 200
+
+    *Olek Janiszewski*
+
+*   fixes bug introduced by #3329.  Now, when autosaving associations,
+    deletions happen before inserts and saves.  This prevents a 'duplicate
+    unique value' database error that would occur if a record being created had
+    the same value on a unique indexed field as that of a record being destroyed.
+
+    *Adam Anderson*
+
+
+*   Fix pending migrations error when loading schema and `ActiveRecord::Base.table_name_prefix`
+    is not blank.
+
+    Call `assume_migrated_upto_version` on connection to prevent it from first
+    being picked up in `method_missing`.
+
+    In the base class, `Migration`, `method_missing` expects the argument to be a
+    table name, and calls `proper_table_name` on the arguments before sending to
+    `connection`. If `table_name_prefix` or `table_name_suffix` is used, the schema
+    version changes to `prefix_version_suffix`, breaking `rake test:prepare`.
+
+    Fixes #10411.
+
+    *Kyle Stevens*
+
+*   Mute `psql` output when running rake db:schema:load.
+
+    *Godfrey Chan*
+
+
+## Rails 4.0.0.rc1 (April 29, 2013) ##
+
+*   Trigger a save on `has_one association=(associate)` when the associate contents have changed.
+
+    Fix #8856.
+
+    *Chris Thompson*
 
 *   Allow to use databases.rake tasks without having `Rails.application`.
 
@@ -928,6 +987,11 @@
 
     *Aaron Stone*
 
+*   Allow setting of all libpq connection parameters through the PostgreSQL adapter. See also:
+    http://www.postgresql.org/docs/9.2/static/libpq-connect.html#LIBPQ-PARAMKEYWORDS
+
+    *Lars Kanis*
+
 *   Allow `Relation#where` with no arguments to be chained with new `not` query method.
 
     Example:

data/lib/active_record/associations/association.rb

@@ -164,6 +164,13 @@ module ActiveRecord
         @reflection = @owner.class.reflect_on_association(reflection_name)
       end
 
+      def initialize_attributes(record) #:nodoc:
+        skip_assign = [reflection.foreign_key, reflection.type].compact
+        attributes = create_scope.except(*(record.changed - skip_assign))
+        record.assign_attributes(attributes)
+        set_inverse_instance(record)
+      end
+
       private
 
         def find_target?
@@ -233,10 +240,7 @@ module ActiveRecord
 
         def build_record(attributes)
           reflection.build_association(attributes) do |record|
-            skip_assign = [reflection.foreign_key, reflection.type].compact
-            attributes = create_scope.except(*(record.changed - skip_assign))
-            record.assign_attributes(attributes)
-            set_inverse_instance(record)
+            initialize_attributes(record)
           end
         end
     end

data/lib/active_record/associations/has_one_association.rb

@@ -25,9 +25,8 @@ module ActiveRecord
         raise_on_type_mismatch!(record) if record
         load_target
 
-        # If target and record are nil, or target is equal to record,
-        # we don't need to have transaction.
-        if (target || record) && target != record
+        return self.target if !(target || record)
+        if (target != record) || record.changed?
           transaction_if(save) do
             remove_target!(options[:dependent]) if target && !target.destroyed?
 

data/lib/active_record/attribute_methods/serialization.rb

@@ -63,7 +63,7 @@ module ActiveRecord
         end
 
         def type_cast(value)
-          value.unserialized_value
+          value.unserialized_value @column.type_cast value.value
         end
 
         def type
@@ -72,17 +72,17 @@ module ActiveRecord
       end
 
       class Attribute < Struct.new(:coder, :value, :state) # :nodoc:
-        def unserialized_value
-          state == :serialized ? unserialize : value
+        def unserialized_value(v = value)
+          state == :serialized ? unserialize(v) : value
         end
 
         def serialized_value
           state == :unserialized ? serialize : value
         end
 
-        def unserialize
+        def unserialize(v)
           self.state = :unserialized
-          self.value = coder.load(value)
+          self.value = coder.load(v)
         end
 
         def serialize

data/lib/active_record/autosave_association.rb

@@ -17,7 +17,8 @@ module ActiveRecord
   # be destroyed directly. They will however still be marked for destruction.
   #
   # Note that <tt>autosave: false</tt> is not same as not declaring <tt>:autosave</tt>.
-  # When the <tt>:autosave</tt> option is not present new associations are saved.
+  # When the <tt>:autosave</tt> option is not present then new association records are
+  # saved but the updated association records are not saved.
   #
   # == Validation
   #
@@ -300,7 +301,7 @@ module ActiveRecord
     def association_valid?(reflection, record)
       return true if record.destroyed? || record.marked_for_destruction?
 
-      unless valid = record.valid?(validation_context)
+      unless valid = record.valid?
         if reflection.options[:autosave]
           record.errors.each do |attribute, message|
             attribute = "#{reflection.name}.#{attribute}"

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

@@ -270,6 +270,7 @@ module ActiveRecord
         end
 
         column.limit       = limit
+        column.array       = options[:array] if column.respond_to?(:array)
         column.precision   = options[:precision]
         column.scale       = options[:scale]
         column.default     = options[:default]

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -364,7 +364,9 @@ module ActiveRecord
       # and creates it again using the provided +options+.
       def recreate_database(name, options = {})
         drop_database(name)
-        create_database(name, options)
+        sql = create_database(name, options)
+        reconnect!
+        sql
       end
 
       # Create a new MySQL database with optional <tt>:charset</tt> and <tt>:collation</tt>.

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -330,9 +330,38 @@ module ActiveRecord
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
+        # Defines the primary key field.
+        # Use of the native PostgreSQL UUID type is supported, and can be used
+        # by defining your tables as such:
+        #
+        #   create_table :stuffs, id: :uuid do |t|
+        #     t.string :content
+        #     t.timestamps
+        #   end
+        #
+        # By default, this will use the +uuid_generate_v4()+ function from the
+        # +uuid-ossp+ extension, which MUST be enabled on your databse.  To enable
+        # the +uuid-ossp+ extension, you can use the +enable_extension+ method in your
+        # migrations To use a UUID primary key without +uuid-ossp+ enabled, you can
+        # set the +:default+ option to nil:
+        #
+        #   create_table :stuffs, id: false do |t|
+        #     t.primary_key :id, :uuid, default: nil
+        #     t.uuid :foo_id
+        #     t.timestamps
+        #   end
+        #
+        # You may also pass a different UUID generation function from +uuid-ossp+
+        # or another library.
+        #
+        # Note that setting the UUID primary key default value to +nil+
+        # will require you to assure that you always provide a UUID value
+        # before saving a record (as primary keys cannot be nil).  This might be
+        # done via the SecureRandom.uuid method and a +before_save+ callback,
+        # for instance.
         def primary_key(name, type = :primary_key, options = {})
           return super unless type == :uuid
-          options[:default] ||= 'uuid_generate_v4()'
+          options[:default] = options.fetch(:default, 'uuid_generate_v4()')
           options[:primary_key] = true
           column name, type, options
         end

data/lib/active_record/explain_subscriber.rb

@@ -19,7 +19,7 @@ module ActiveRecord
     # On the other hand, we want to monitor the performance of our real database
     # queries, not the performance of the access to the query cache.
     IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN CACHE)
-    EXPLAINED_SQLS = /\A\s*(select|update|delete|insert)/i
+    EXPLAINED_SQLS = /\A\s*(select|update|delete|insert)\b/i
     def ignore_payload?(payload)
       payload[:exception] || IGNORED_PAYLOADS.include?(payload[:name]) || payload[:sql] !~ EXPLAINED_SQLS
     end

data/lib/active_record/migration.rb

@@ -357,11 +357,14 @@ module ActiveRecord
     class CheckPending
       def initialize(app)
         @app = app
+        @last_check = 0
       end
 
       def call(env)
-        ActiveRecord::Base.logger.silence do
+        mtime = ActiveRecord::Migrator.last_migration.mtime.to_i
+        if @last_check < mtime
           ActiveRecord::Migration.check_pending!
+          @last_check = mtime
         end
         @app.call(env)
       end
@@ -699,6 +702,10 @@ module ActiveRecord
       File.basename(filename)
     end
 
+    def mtime
+      File.mtime filename
+    end
+
     delegate :migrate, :announce, :write, :disable_ddl_transaction, to: :migration
 
     private
@@ -714,6 +721,16 @@ module ActiveRecord
 
   end
 
+  class NullMigration < MigrationProxy #:nodoc:
+    def initialize
+      super(nil, 0, nil, nil)
+    end
+
+    def mtime
+      0
+    end
+  end
+
   class Migrator#:nodoc:
     class << self
       attr_writer :migrations_paths
@@ -784,7 +801,11 @@ module ActiveRecord
       end
 
       def last_version
-        migrations(migrations_paths).last.try(:version)||0
+        last_migration.version
+      end
+
+      def last_migration #:nodoc:
+        migrations(migrations_paths).last || NullMigration.new
       end
 
       def proper_table_name(name)

data/lib/active_record/nested_attributes.rb

@@ -229,6 +229,23 @@ module ActiveRecord
     #     belongs_to :member, inverse_of: :posts
     #     validates_presence_of :member
     #   end
+    #
+    # For one-to-one nested associations, if you build the new (in-memory)
+    # child object yourself before assignment, then this module will not
+    # overwrite it, e.g.:
+    #
+    #   class Member < ActiveRecord::Base
+    #     has_one :avatar
+    #     accepts_nested_attributes_for :avatar
+    #
+    #     def avatar
+    #       super || build_avatar(width: 200)
+    #     end
+    #   end
+    #
+    #   member = Member.new
+    #   member.avatar_attributes = {icon: 'sad'}
+    #   member.avatar.width # => 200
     module ClassMethods
       REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |key, value| key == '_destroy' || value.blank? } }
 
@@ -356,20 +373,28 @@ module ActiveRecord
     def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
       options = self.nested_attributes_options[association_name]
       attributes = attributes.with_indifferent_access
+      existing_record = send(association_name)
 
-      if (options[:update_only] || !attributes['id'].blank?) && (record = send(association_name)) &&
-          (options[:update_only] || record.id.to_s == attributes['id'].to_s)
-        assign_to_or_mark_for_destruction(record, attributes, options[:allow_destroy]) unless call_reject_if(association_name, attributes)
+      if (options[:update_only] || !attributes['id'].blank?) && existing_record &&
+          (options[:update_only] || existing_record.id.to_s == attributes['id'].to_s)
+        assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy]) unless call_reject_if(association_name, attributes)
 
       elsif attributes['id'].present?
         raise_nested_attributes_record_not_found!(association_name, attributes['id'])
 
       elsif !reject_new_record?(association_name, attributes)
-        method = "build_#{association_name}"
-        if respond_to?(method)
-          send(method, attributes.except(*UNASSIGNABLE_KEYS))
+        assignable_attributes = attributes.except(*UNASSIGNABLE_KEYS)
+
+        if existing_record && existing_record.new_record?
+          existing_record.assign_attributes(assignable_attributes)
+          association(association_name).initialize_attributes(existing_record)
         else
-          raise ArgumentError, "Cannot build association `#{association_name}'. Are you trying to build a polymorphic one-to-one association?"
+          method = "build_#{association_name}"
+          if respond_to?(method)
+            send(method, assignable_attributes)
+          else
+            raise ArgumentError, "Cannot build association `#{association_name}'. Are you trying to build a polymorphic one-to-one association?"
+          end
         end
       end
     end

data/lib/active_record/persistence.rb

@@ -99,6 +99,9 @@ module ActiveRecord
     # <tt>before_*</tt> callbacks return +false+ the action is cancelled and
     # +save+ returns +false+. See ActiveRecord::Callbacks for further
     # details.
+    #
+    # Attributes marked as readonly are silently ignored if the record is
+    # being updated.
     def save(*)
       create_or_update
     rescue ActiveRecord::RecordInvalid
@@ -118,6 +121,9 @@ module ActiveRecord
     # the <tt>before_*</tt> callbacks return +false+ the action is cancelled
     # and <tt>save!</tt> raises ActiveRecord::RecordNotSaved. See
     # ActiveRecord::Callbacks for further details.
+    #
+    # Attributes marked as readonly are silently ignored if the record is
+    # being updated.
     def save!(*)
       create_or_update || raise(RecordNotSaved)
     end
@@ -204,6 +210,8 @@ module ActiveRecord
     # * updated_at/updated_on column is updated if that column is available.
     # * Updates all the attributes that are dirty in this object.
     #
+    # This method raises an +ActiveRecord::ActiveRecordError+  if the
+    # attribute is marked as readonly.
     def update_attribute(name, value)
       name = name.to_s
       verify_readonly_attribute(name)
@@ -325,10 +333,44 @@ module ActiveRecord
       toggle(attribute).update_attribute(attribute, self[attribute])
     end
 
-    # Reloads the attributes of this object from the database.
-    # The optional options argument is passed to find when reloading so you
-    # may do e.g. record.reload(lock: true) to reload the same record with
-    # an exclusive row lock.
+    # Reloads the record from the database.
+    #
+    # This method modifies the receiver in-place. Attributes are updated, and
+    # caches busted, in particular the associations cache.
+    #
+    # 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
+    # returns +self+ for convenience.
+    #
+    # The optional <tt>:lock</tt> flag option allows you to lock the reloaded record:
+    #
+    #   reload(lock: true) # reload with pessimistic locking
+    #
+    # Reloading is commonly used in test suites to test something is actually
+    # written to the database, or when some action modifies the corresponding
+    # row in the database but not the object in memory:
+    #
+    #   assert account.deposit!(25)
+    #   assert_equal 25, account.credit        # check it is updated in memory
+    #   assert_equal 25, account.reload.credit # check it is also persisted
+    #
+    # Another commom use case is optimistic locking handling:
+    #
+    #   def with_optimistic_retry
+    #     begin
+    #       yield
+    #     rescue ActiveRecord::StaleObjectError
+    #       begin
+    #         # Reload lock_version in particular.
+    #         reload
+    #       rescue ActiveRecord::RecordNotFound
+    #         # If the record is gone there is nothing to do.
+    #       else
+    #         retry
+    #       end
+    #     end
+    #   end
+    #
     def reload(options = nil)
       clear_aggregation_cache
       clear_association_cache

data/lib/active_record/railtie.rb

@@ -44,7 +44,7 @@ module ActiveRecord
       ActiveRecord::Tasks::DatabaseTasks.migrations_paths = Rails.application.paths['db/migrate'].to_a
       ActiveRecord::Tasks::DatabaseTasks.fixtures_path = File.join Rails.root, 'test', 'fixtures'
 
-      if defined?(ENGINE_PATH) && engine = Rails::Engine.find(ENGINE_PATH)
+      if defined?(APP_RAKEFILE) && engine = Rails::Engine.find(find_engine_path(APP_RAKEFILE))
         if engine.paths['db/migrate'].existent
           ActiveRecord::Tasks::DatabaseTasks.migrations_paths += engine.paths['db/migrate'].to_a
         end

data/lib/active_record/railties/databases.rake

@@ -321,9 +321,13 @@ db_namespace = namespace :db do
 
     # desc "Recreate the test database from an existent schema.rb file"
     task :load_schema => 'db:test:purge' do
-      ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
-      ActiveRecord::Schema.verbose = false
-      db_namespace["schema:load"].invoke
+      begin
+        ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+        ActiveRecord::Schema.verbose = false
+        db_namespace["schema:load"].invoke
+      ensure
+        ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[Rails.env])
+      end
     end
 
     # desc "Recreate the test database from an existent structure.sql file"
@@ -358,7 +362,7 @@ db_namespace = namespace :db do
     end
 
     # desc 'Check for pending migrations and load the test schema'
-    task :prepare do
+    task :prepare => :load_config do
       unless ActiveRecord::Base.configurations.blank?
         db_namespace['test:load'].invoke
       end

data/lib/active_record/relation.rb

@@ -141,34 +141,58 @@ module ActiveRecord
       first || new(attributes, &block)
     end
 
-    # Finds the first record with the given attributes, or creates a record with the attributes
-    # if one is not found.
+    # Finds the first record with the given attributes, or creates a record
+    # with the attributes if one is not found:
     #
-    # ==== Examples
-    #   # Find the first user named Penélope or create a new one.
+    #   # Find the first user named "Penélope" or create a new one.
     #   User.find_or_create_by(first_name: 'Penélope')
-    #   # => <User id: 1, first_name: 'Penélope', last_name: nil>
+    #   # => #<User id: 1, first_name: "Penélope", last_name: nil>
     #
-    #   # Find the first user named Penélope or create a new one.
+    #   # Find the first user named "Penélope" or create a new one.
     #   # We already have one so the existing record will be returned.
     #   User.find_or_create_by(first_name: 'Penélope')
-    #   # => <User id: 1, first_name: 'Penélope', last_name: nil>
+    #   # => #<User id: 1, first_name: "Penélope", last_name: nil>
     #
-    #   # Find the first user named Scarlett or create a new one with a particular last name.
+    #   # Find the first user named "Scarlett" or create a new one with
+    #   # a particular last name.
     #   User.create_with(last_name: 'Johansson').find_or_create_by(first_name: 'Scarlett')
-    #   # => <User id: 2, first_name: 'Scarlett', last_name: 'Johansson'>
+    #   # => #<User id: 2, first_name: "Scarlett", last_name: "Johansson">
     #
-    #   # Find the first user named Scarlett or create a new one with a different last name.
-    #   # We already have one so the existing record will be returned.
+    # This method accepts a block, which is passed down to +create+. The last example
+    # above can be alternatively written this way:
+    #
+    #   # Find the first user named "Scarlett" or create a new one with a
+    #   # different last name.
     #   User.find_or_create_by(first_name: 'Scarlett') do |user|
-    #     user.last_name = "O'Hara"
+    #     user.last_name = 'Johansson'
     #   end
-    #   # => <User id: 2, first_name: 'Scarlett', last_name: 'Johansson'>
+    #   # => #<User id: 2, first_name: "Scarlett", last_name: "Johansson">
+    #
+    # This method always returns a record, but if creation was attempted and
+    # failed due to validation errors it won't be persisted, you get what
+    # +create+ returns in such situation.
+    #
+    # Please note *this method is not atomic*, it runs first a SELECT, and if
+    # there are no results an INSERT is attempted. If there are other threads
+    # or processes there is a race condition between both calls and it could
+    # be the case that you end up with two similar records.
+    #
+    # Whether that is a problem or not depends on the logic of the
+    # application, but in the particular case in which rows have a UNIQUE
+    # constraint an exception may be raised, just retry:
+    #
+    #  begin
+    #    CreditAccount.find_or_create_by(user_id: user.id)
+    #  rescue ActiveRecord::RecordNotUnique
+    #    retry
+    #  end
+    #
     def find_or_create_by(attributes, &block)
       find_by(attributes) || create(attributes, &block)
     end
 
-    # Like <tt>find_or_create_by</tt>, but calls <tt>create!</tt> so an exception is raised if the created record is invalid.
+    # Like <tt>find_or_create_by</tt>, but calls <tt>create!</tt> so an exception
+    # is raised if the created record is invalid.
     def find_or_create_by!(attributes, &block)
       find_by(attributes) || create!(attributes, &block)
     end

data/lib/active_record/relation/delegation.rb

@@ -14,14 +14,14 @@ module ActiveRecord
     delegate :table_name, :quoted_table_name, :primary_key, :quoted_primary_key,
              :connection, :columns_hash, :to => :klass
 
-    module ClassSpecificRelation
+    module ClassSpecificRelation # :nodoc:
       extend ActiveSupport::Concern
 
       included do
         @delegation_mutex = Mutex.new
       end
 
-      module ClassMethods
+      module ClassMethods # :nodoc:
         def name
           superclass.name
         end
@@ -70,7 +70,7 @@ module ActiveRecord
       end
     end
 
-    module ClassMethods
+    module ClassMethods # :nodoc:
       @@subclasses = ThreadSafe::Cache.new(:initial_capacity => 2)
 
       def new(klass, *args)

data/lib/active_record/schema.rb

@@ -43,7 +43,7 @@ module ActiveRecord
 
       unless info[:version].blank?
         initialize_schema_migrations_table
-        assume_migrated_upto_version(info[:version], migrations_paths)
+        connection.assume_migrated_upto_version(info[:version], migrations_paths)
       end
     end
 

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -59,7 +59,7 @@ module ActiveRecord
 
       def structure_load(filename)
         set_psql_env
-        Kernel.system("psql -f #{filename} #{configuration['database']}")
+        Kernel.system("psql -q -f #{filename} #{configuration['database']}")
       end
 
       private

data/lib/active_record/validations/associated.rb

@@ -2,15 +2,15 @@ module ActiveRecord
   module Validations
     class AssociatedValidator < ActiveModel::EachValidator #:nodoc:
       def validate_each(record, attribute, value)
-        if Array.wrap(value).reject {|r| r.marked_for_destruction? || r.valid?(record.validation_context) }.any?
+        if Array.wrap(value).reject {|r| r.marked_for_destruction? || r.valid?}.any?
           record.errors.add(attribute, :invalid, options.merge(:value => value))
         end
       end
     end
 
     module ClassMethods
-      # Validates whether the associated object or objects are all valid
-      # themselves. Works with any kind of association.
+      # Validates whether the associated object or objects are all valid.
+      # Works with any kind of association.
       #
       #   class Book < ActiveRecord::Base
       #     has_many :pages

data/lib/active_record/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   # Returns the version of the currently loaded ActiveRecord as a Gem::Version
   def self.version
-    Gem::Version.new "4.0.0.rc1"
+    Gem::Version.new "4.0.0.rc2"
   end
 
   module VERSION #:nodoc:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 4.0.0.rc1
+  version: 4.0.0.rc2
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-29 00:00:00.000000000 Z
+date: 2013-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.0.0.rc1
+        version: 4.0.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.0.0.rc1
+        version: 4.0.0.rc2
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.0.0.rc1
+        version: 4.0.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.0.0.rc1
+        version: 4.0.0.rc2
 - !ruby/object:Gem::Dependency
   name: arel
   requirement: !ruby/object:Gem::Requirement
@@ -259,7 +259,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.2
 signing_key: 
 specification_version: 4
 summary: Object-relational mapper framework (part of Rails).