activerecord 2.3.18 → 3.0.0.beta

data/lib/active_record/fixtures.rb

@@ -3,7 +3,7 @@ require 'yaml'
 require 'csv'
 require 'zlib'
 require 'active_support/dependencies'
-require 'active_support/test_case'
+require 'active_support/core_ext/logger'
 
 if RUBY_VERSION < '1.9'
   module YAML #:nodoc:
@@ -335,7 +335,6 @@ end
 #   george:
 #     id: 1
 #     name: George the Monkey
-#     pirate_id: 1
 #
 #   ### in fruits.yml
 #
@@ -370,8 +369,8 @@ end
 #   ### in monkeys.yml
 #
 #   george:
+#     id: 1
 #     name: George the Monkey
-#     pirate: reginald
 #     fruits: apple, orange, grape
 #
 #   ### in fruits.yml
@@ -408,7 +407,7 @@ end
 #     subdomain: $LABEL
 #
 # Also, sometimes (like when porting older join table fixtures) you'll need
-# to be able to get ahold of the identifier for a given label. ERB
+# to be able to get a hold of the identifier for a given label. ERB
 # to the rescue:
 #
 #   george_reginald:
@@ -808,27 +807,25 @@ end
 
 module ActiveRecord
   module TestFixtures
-    def self.included(base)
-      base.class_eval do
-        setup :setup_fixtures
-        teardown :teardown_fixtures
-
-        superclass_delegating_accessor :fixture_path
-        superclass_delegating_accessor :fixture_table_names
-        superclass_delegating_accessor :fixture_class_names
-        superclass_delegating_accessor :use_transactional_fixtures
-        superclass_delegating_accessor :use_instantiated_fixtures   # true, false, or :no_instances
-        superclass_delegating_accessor :pre_loaded_fixtures
-
-        self.fixture_table_names = []
-        self.use_transactional_fixtures = false
-        self.use_instantiated_fixtures = true
-        self.pre_loaded_fixtures = false
-
-        self.fixture_class_names = {}
-      end
+    extend ActiveSupport::Concern
+
+    included do
+      setup :setup_fixtures
+      teardown :teardown_fixtures
+
+      superclass_delegating_accessor :fixture_path
+      superclass_delegating_accessor :fixture_table_names
+      superclass_delegating_accessor :fixture_class_names
+      superclass_delegating_accessor :use_transactional_fixtures
+      superclass_delegating_accessor :use_instantiated_fixtures   # true, false, or :no_instances
+      superclass_delegating_accessor :pre_loaded_fixtures
+
+      self.fixture_table_names = []
+      self.use_transactional_fixtures = true
+      self.use_instantiated_fixtures = false
+      self.pre_loaded_fixtures = false
 
-      base.extend ClassMethods
+      self.fixture_class_names = {}
     end
 
     module ClassMethods
@@ -891,7 +888,6 @@ module ActiveRecord
 
             instances.size == 1 ? instances.first : instances
           end
-          private table_name
         end
       end
 

data/lib/active_record/locale/en.yml

@@ -1,48 +1,31 @@
 en:
+  # Attributes names common to most models
+  #attributes:
+    #created_at: "Created at"
+    #updated_at: "Updated at"
+
+  # ActiveRecord models configuration
   activerecord:
     errors:
-      # The values :model, :attribute and :value are always available for interpolation
-      # The value :count is available when applicable. Can be used for pluralization.
       messages:
-        inclusion: "is not included in the list"
-        exclusion: "is reserved"
-        invalid: "is invalid"
-        confirmation: "doesn't match confirmation"
-        accepted: "must be accepted"
-        empty: "can't be empty"
-        blank: "can't be blank"
-        too_long: "is too long (maximum is %{count} characters)"
-        too_short: "is too short (minimum is %{count} characters)"
-        wrong_length: "is the wrong length (should be %{count} characters)"
         taken: "has already been taken"
-        not_a_number: "is not a number"
-        greater_than: "must be greater than %{count}"
-        greater_than_or_equal_to: "must be greater than or equal to %{count}"
-        equal_to: "must be equal to %{count}"
-        less_than: "must be less than %{count}"
-        less_than_or_equal_to: "must be less than or equal to %{count}"
-        odd: "must be odd"
-        even: "must be even"
-        record_invalid: "Validation failed: %{errors}"
+        record_invalid: "Validation failed: {{errors}}"
         # Append your own errors here or at the model/attributes scope.
 
-      full_messages:
-        format: "%{attribute} %{message}"
-
       # You can define own errors for models or model attributes.
       # The values :model, :attribute and :value are always available for interpolation.
       #
       # For example,
       #   models:
       #     user:
-      #       blank: "This is a custom blank message for %{model}: %{attribute}"
+      #       blank: "This is a custom blank message for {{model}}: {{attribute}}"
       #       attributes:
       #         login:
       #           blank: "This is a custom blank message for User login"
       # Will define custom blank validation message for User model and 
       # custom blank validation message for login attribute of User model.
       #models:
-        
+
     # Translate model names. Used in Model.human_name().
     #models:
       # For example,
@@ -55,4 +38,3 @@ en:
       #   user:
       #     login: "Handle"
       # will translate User attribute "login" as "Handle"
-

data/lib/active_record/locking/optimistic.rb

@@ -23,16 +23,6 @@ module ActiveRecord
     #   p2.first_name = "should fail"
     #   p2.save # Raises a ActiveRecord::StaleObjectError
     #
-    # Optimistic locking will also check for stale data when objects are destroyed.  Example:
-    #
-    #   p1 = Person.find(1)
-    #   p2 = Person.find(1)
-    #
-    #   p1.first_name = "Michael"
-    #   p1.save
-    #
-    #   p2.destroy # Raises a ActiveRecord::StaleObjectError
-    #
     # You're then responsible for dealing with the conflict by rescuing the exception and either rolling back, merging,
     # or otherwise apply the business logic needed to resolve the conflict.
     #
@@ -42,17 +32,16 @@ module ActiveRecord
     # To override the name of the lock_version column, invoke the <tt>set_locking_column</tt> method.
     # This method uses the same syntax as <tt>set_table_name</tt>
     module Optimistic
-      def self.included(base) #:nodoc:
-        base.extend ClassMethods
+      extend ActiveSupport::Concern
 
-        base.cattr_accessor :lock_optimistically, :instance_writer => false
-        base.lock_optimistically = true
+      included do
+        cattr_accessor :lock_optimistically, :instance_writer => false
+        self.lock_optimistically = true
 
-        base.alias_method_chain :update, :lock
-        base.alias_method_chain :destroy, :lock
-        base.alias_method_chain :attributes_from_column_definition, :lock
+        alias_method_chain :update, :lock
+        alias_method_chain :attributes_from_column_definition, :lock
 
-        class << base
+        class << self
           alias_method :locking_column=, :set_locking_column
         end
       end
@@ -89,15 +78,17 @@ module ActiveRecord
           attribute_names.uniq!
 
           begin
-            affected_rows = connection.update(<<-end_sql, "#{self.class.name} Update with optimistic locking")
-              UPDATE #{self.class.quoted_table_name}
-              SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false, false, attribute_names))}
-              WHERE #{self.class.primary_key} = #{quote_value(id)}
-              AND #{self.class.quoted_locking_column} = #{quote_value(previous_value)}
-            end_sql
+            relation = self.class.unscoped
+
+            affected_rows = relation.where(
+              relation.table[self.class.primary_key].eq(quoted_id).and(
+                relation.table[self.class.locking_column].eq(quote_value(previous_value))
+              )
+            ).arel.update(arel_attributes_values(false, false, attribute_names))
+
 
             unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError, "Attempted to update a stale object: #{self.class.name}"
+              raise ActiveRecord::StaleObjectError, "Attempted to update a stale object"
             end
 
             affected_rows
@@ -109,29 +100,6 @@ module ActiveRecord
           end
         end
 
-        def destroy_with_lock #:nodoc:
-          return destroy_without_lock unless locking_enabled?
-
-          unless new_record?
-            lock_col = self.class.locking_column
-            previous_value = send(lock_col).to_i
-
-            affected_rows = connection.delete(
-              "DELETE FROM #{self.class.quoted_table_name} " +
-              "WHERE #{connection.quote_column_name(self.class.primary_key)} = #{quoted_id} " +
-                    "AND #{self.class.quoted_locking_column} = #{quote_value(previous_value)}",
-              "#{self.class.name} Destroy"
-            )
-
-            unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError, "Attempted to delete a stale object: #{self.class.name}"
-            end
-          end
-
-          @destroyed = true
-          freeze
-        end
-
       module ClassMethods
         DEFAULT_LOCKING_COLUMN = 'lock_version'
 

data/lib/active_record/migration.rb

@@ -1,5 +1,8 @@
+require 'active_support/core_ext/object/metaclass'
+
 module ActiveRecord
-  class IrreversibleMigration < ActiveRecordError#:nodoc:
+  # Exception that can be raised to stop migrations from going backwards.
+  class IrreversibleMigration < ActiveRecordError
   end
 
   class DuplicateMigrationVersionError < ActiveRecordError#:nodoc:
@@ -103,12 +106,12 @@ module ActiveRecord
   #
   # The Rails package has several tools to help create and apply migrations.
   #
-  # To generate a new migration, you can use 
+  # To generate a new migration, you can use
   #   script/generate migration MyNewMigration
   #
   # where MyNewMigration is the name of your migration. The generator will
-  # create an empty migration file <tt>nnn_my_new_migration.rb</tt> in the <tt>db/migrate/</tt>
-  # directory where <tt>nnn</tt> is the next largest migration number.
+  # create an empty migration file <tt>timestamp_my_new_migration.rb</tt> in the <tt>db/migrate/</tt>
+  # directory where <tt>timestamp</tt> is the UTC formatted date and time that the migration was generated.
   #
   # You may then edit the <tt>self.up</tt> and <tt>self.down</tt> methods of
   # MyNewMigration.
@@ -116,21 +119,21 @@ module ActiveRecord
   # There is a special syntactic shortcut to generate migrations that add fields to a table.
   #   script/generate migration add_fieldname_to_tablename fieldname:string
   #
-  # This will generate the file <tt>nnn_add_fieldname_to_tablename</tt>, which will look like this:
+  # This will generate the file <tt>timestamp_add_fieldname_to_tablename</tt>, which will look like this:
   #   class AddFieldnameToTablename < ActiveRecord::Migration
   #     def self.up
   #       add_column :tablenames, :fieldname, :string
   #     end
-  # 
+  #
   #     def self.down
   #       remove_column :tablenames, :fieldname
   #     end
   #   end
-  # 
+  #
   # To run migrations against the currently configured database, use
   # <tt>rake db:migrate</tt>. This will update the database by running all of the
   # pending migrations, creating the <tt>schema_migrations</tt> table
-  # (see "About the schema_migrations table" section below) if missing. It will also 
+  # (see "About the schema_migrations table" section below) if missing. It will also
   # invoke the db:schema:dump task, which will update your db/schema.rb file
   # to match the structure of your database.
   #
@@ -240,7 +243,7 @@ module ActiveRecord
   # lower than the current schema version: when migrating up, those
   # never-applied "interleaved" migrations will be automatically applied, and
   # when migrating down, never-applied "interleaved" migrations will be skipped.
-  # 
+  #
   # == Timestamped Migrations
   #
   # By default, Rails generates migrations that look like:
@@ -253,7 +256,7 @@ module ActiveRecord
   # off by setting:
   #
   #    config.active_record.timestamped_migrations = false
-  # 
+  #
   # In environment.rb.
   #
   class Migration
@@ -300,8 +303,7 @@ module ActiveRecord
 
           case sym
             when :up, :down
-              klass = (class << self; self; end)
-              klass.send(:alias_method_chain, sym, "benchmarks")
+              metaclass.send(:alias_method_chain, sym, "benchmarks")
           end
         ensure
           @ignore_new_methods = false
@@ -381,20 +383,17 @@ module ActiveRecord
       def migrate(migrations_path, target_version = nil)
         case
           when target_version.nil?              then up(migrations_path, target_version)
-          when current_version == 0 && target_version == 0 then # noop
           when current_version > target_version then down(migrations_path, target_version)
           else                                       up(migrations_path, target_version)
         end
       end
 
       def rollback(migrations_path, steps=1)
-        migrator = self.new(:down, migrations_path)
-        start_index = migrator.migrations.index(migrator.current_migration)
-        
-        return unless start_index
-        
-        finish = migrator.migrations[start_index + steps]
-        down(migrations_path, finish ? finish.version : 0)
+        move(:down, migrations_path, steps)
+      end
+
+      def forward(migrations_path, steps=1)
+        move(:up, migrations_path, steps)
       end
 
       def up(migrations_path, target_version = nil)
@@ -404,7 +403,7 @@ module ActiveRecord
       def down(migrations_path, target_version = nil)
         self.new(:down, migrations_path, target_version).migrate
       end
-      
+
       def run(direction, migrations_path, target_version)
         self.new(direction, migrations_path, target_version).run
       end
@@ -418,7 +417,8 @@ module ActiveRecord
       end
 
       def get_all_versions
-        Base.connection.select_values("SELECT version FROM #{schema_migrations_table_name}").map(&:to_i).sort
+        table = Arel::Table.new(schema_migrations_table_name)
+        Base.connection.select_values(table.project(table['version']).to_sql).map(&:to_i).sort
       end
 
       def current_version
@@ -434,22 +434,35 @@ module ActiveRecord
         # Use the Active Record objects own table_name, or pre/suffix from ActiveRecord::Base if name is a symbol/string
         name.table_name rescue "#{ActiveRecord::Base.table_name_prefix}#{name}#{ActiveRecord::Base.table_name_suffix}"
       end
+
+      private
+
+      def move(direction, migrations_path, steps)
+        migrator = self.new(direction, migrations_path)
+        start_index = migrator.migrations.index(migrator.current_migration)
+
+        if start_index
+          finish = migrator.migrations[start_index + steps]
+          version = finish ? finish.version : 0
+          send(direction, migrations_path, version)
+        end
+      end
     end
 
     def initialize(direction, migrations_path, target_version = nil)
       raise StandardError.new("This database does not yet support migrations") unless Base.connection.supports_migrations?
       Base.connection.initialize_schema_migrations_table
-      @direction, @migrations_path, @target_version = direction, migrations_path, target_version      
+      @direction, @migrations_path, @target_version = direction, migrations_path, target_version
     end
 
     def current_version
       migrated.last || 0
     end
-    
+
     def current_migration
       migrations.detect { |m| m.version == current_version }
     end
-    
+
     def run
       target = migrations.detect { |m| m.version == @target_version }
       raise UnknownMigrationVersionError.new(@target_version) if target.nil?
@@ -466,16 +479,16 @@ module ActiveRecord
       if target.nil? && !@target_version.nil? && @target_version > 0
         raise UnknownMigrationVersionError.new(@target_version)
       end
-      
+
       start = up? ? 0 : (migrations.index(current) || 0)
       finish = migrations.index(target) || migrations.size - 1
       runnable = migrations[start..finish]
-      
+
       # skip the last migration if we're headed down, but not ALL the way down
       runnable.pop if down? && !target.nil?
-      
+
       runnable.each do |migration|
-        Base.logger.info "Migrating to #{migration.name} (#{migration.version})"
+        Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
 
         # On our way up, we skip migrating the ones we've already migrated
         next if up? && migrated.include?(migration.version.to_i)
@@ -501,28 +514,28 @@ module ActiveRecord
     def migrations
       @migrations ||= begin
         files = Dir["#{@migrations_path}/[0-9]*_*.rb"]
-        
+
         migrations = files.inject([]) do |klasses, file|
           version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
-          
+
           raise IllegalMigrationNameError.new(file) unless version
           version = version.to_i
-          
+
           if klasses.detect { |m| m.version == version }
-            raise DuplicateMigrationVersionError.new(version) 
+            raise DuplicateMigrationVersionError.new(version)
           end
 
           if klasses.detect { |m| m.name == name.camelize }
-            raise DuplicateMigrationNameError.new(name.camelize) 
-          end
-          
-          klasses << (MigrationProxy.new).tap do |migration|
-            migration.name     = name.camelize
-            migration.version  = version
-            migration.filename = file
+            raise DuplicateMigrationNameError.new(name.camelize)
           end
+
+          migration = MigrationProxy.new
+          migration.name     = name.camelize
+          migration.version  = version
+          migration.filename = file
+          klasses << migration
         end
-        
+
         migrations = migrations.sort_by(&:version)
         down? ? migrations.reverse : migrations
       end
@@ -539,15 +552,15 @@ module ActiveRecord
 
     private
       def record_version_state_after_migrating(version)
-        sm_table = self.class.schema_migrations_table_name
+        table = Arel::Table.new(self.class.schema_migrations_table_name)
 
         @migrated_versions ||= []
         if down?
-          @migrated_versions.delete(version.to_i)
-          Base.connection.update("DELETE FROM #{sm_table} WHERE version = '#{version}'")
+          @migrated_versions.delete(version)
+          table.where(table["version"].eq(version.to_s)).delete
         else
-          @migrated_versions.push(version.to_i).sort!
-          Base.connection.insert("INSERT INTO #{sm_table} (version) VALUES ('#{version}')")
+          @migrated_versions.push(version).sort!
+          table.insert table["version"] => version.to_s
         end
       end