activerecord 3.0.0.beta3 → 3.0.0.beta4

data/lib/active_record/fixtures.rb

@@ -3,8 +3,9 @@ require 'yaml'
 require 'csv'
 require 'zlib'
 require 'active_support/dependencies'
-require 'active_support/core_ext/logger'
+require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/logger'
 
 if RUBY_VERSION < '1.9'
   module YAML #:nodoc:
@@ -492,6 +493,7 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
 
   def self.create_fixtures(fixtures_directory, table_names, class_names = {})
     table_names = [table_names].flatten.map { |n| n.to_s }
+    table_names.each { |n| class_names[n.tr('/', '_').to_sym] = n.classify if n.include?('/') }
     connection  = block_given? ? yield : ActiveRecord::Base.connection
 
     table_names_to_fetch = table_names.reject { |table_name| fixture_is_cached?(connection, table_name) }
@@ -502,7 +504,7 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
           fixtures_map = {}
 
           fixtures = table_names_to_fetch.map do |table_name|
-            fixtures_map[table_name] = Fixtures.new(connection, File.split(table_name.to_s).last, class_names[table_name.to_sym], File.join(fixtures_directory, table_name.to_s))
+            fixtures_map[table_name] = Fixtures.new(connection, table_name.tr('/', '_'), class_names[table_name.tr('/', '_').to_sym], File.join(fixtures_directory, table_name))
           end
 
           all_loaded_fixtures.update(fixtures_map)
@@ -514,7 +516,7 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
             # Cap primary key sequences to max(pk).
             if connection.respond_to?(:reset_pk_sequence!)
               table_names.each do |table_name|
-                connection.reset_pk_sequence!(table_name)
+                connection.reset_pk_sequence!(table_name.tr('/', '_'))
               end
             end
           end
@@ -785,16 +787,14 @@ class Fixture #:nodoc:
   end
 
   def key_list
-    columns = @fixture.keys.collect{ |column_name| @connection.quote_column_name(column_name) }
-    columns.join(", ")
+    @fixture.keys.map { |column_name| @connection.quote_column_name(column_name) }.join(', ')
   end
 
   def value_list
-    list = @fixture.inject([]) do |fixtures, (key, value)|
-      col = model_class.columns_hash[key] if model_class.respond_to?(:ancestors) && model_class.ancestors.include?(ActiveRecord::Base)
-      fixtures << @connection.quote(value, col).gsub('[^\]\\n', "\n").gsub('[^\]\\r', "\r")
-    end
-    list * ', '
+    cols = (model_class && model_class < ActiveRecord::Base) ? model_class.columns_hash : {}
+    @fixture.map do |key, value|
+      @connection.quote(value, cols[key]).gsub('[^\]\\n', "\n").gsub('[^\]\\r', "\r")
+    end.join(', ')
   end
 
   def find
@@ -836,8 +836,8 @@ module ActiveRecord
 
       def fixtures(*table_names)
         if table_names.first == :all
-          table_names = Dir["#{fixture_path}/*.yml"] + Dir["#{fixture_path}/*.csv"]
-          table_names.map! { |f| File.basename(f).split('.')[0..-2].join('.') }
+          table_names = Dir["#{fixture_path}/**/*.{yml,csv}"]
+          table_names.map! { |f| f[(fixture_path.size + 1)..-5] }
         else
           table_names = table_names.flatten.map { |n| n.to_s }
         end
@@ -868,9 +868,9 @@ module ActiveRecord
       end
 
       def setup_fixture_accessors(table_names = nil)
-        table_names = [table_names] if table_names && !table_names.respond_to?(:each)
-        (table_names || fixture_table_names).each do |table_name|
-          table_name = table_name.to_s.tr('.', '_')
+        table_names = Array.wrap(table_names || fixture_table_names)
+        table_names.each do |table_name|
+          table_name = table_name.to_s.tr('./', '_')
 
           define_method(table_name) do |*fixtures|
             force_reload = fixtures.pop if fixtures.last == true || fixtures.last == :reload
@@ -889,6 +889,7 @@ module ActiveRecord
 
             instances.size == 1 ? instances.first : instances
           end
+          private table_name
         end
       end
 

data/lib/active_record/locale/en.yml

@@ -9,7 +9,7 @@ en:
     errors:
       messages:
         taken: "has already been taken"
-        record_invalid: "Validation failed: {{errors}}"
+        record_invalid: "Validation failed: %{errors}"
         # Append your own errors here or at the model/attributes scope.
 
       # You can define own errors for models or model attributes.
@@ -18,7 +18,7 @@ en:
       # 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"

data/lib/active_record/locking/optimistic.rb

@@ -23,6 +23,16 @@ 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.
     #
@@ -38,9 +48,6 @@ module ActiveRecord
         cattr_accessor :lock_optimistically, :instance_writer => false
         self.lock_optimistically = true
 
-        alias_method_chain :update, :lock
-        alias_method_chain :attributes_from_column_definition, :lock
-
         class << self
           alias_method :locking_column=, :set_locking_column
         end
@@ -51,8 +58,8 @@ module ActiveRecord
       end
 
       private
-        def attributes_from_column_definition_with_lock
-          result = attributes_from_column_definition_without_lock
+        def attributes_from_column_definition
+          result = super
 
           # If the locking column has no default value set,
           # start the lock version at zero.  Note we can't use
@@ -66,8 +73,8 @@ module ActiveRecord
           return result
         end
 
-        def update_with_lock(attribute_names = @attributes.keys) #:nodoc:
-          return update_without_lock(attribute_names) unless locking_enabled?
+        def update(attribute_names = @attributes.keys) #:nodoc:
+          return super unless locking_enabled?
           return 0 if attribute_names.empty?
 
           lock_col = self.class.locking_column
@@ -86,9 +93,8 @@ module ActiveRecord
               )
             ).arel.update(arel_attributes_values(false, false, attribute_names))
 
-
             unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError, "Attempted to update a stale object"
+              raise ActiveRecord::StaleObjectError, "Attempted to update a stale object: #{self.class.name}"
             end
 
             affected_rows
@@ -100,15 +106,30 @@ module ActiveRecord
           end
         end
 
-      module ClassMethods
-        DEFAULT_LOCKING_COLUMN = 'lock_version'
+        def destroy #:nodoc:
+          return super unless locking_enabled?
+
+          unless new_record?
+            lock_col = self.class.locking_column
+            previous_value = send(lock_col).to_i
+
+            table = self.class.arel_table
+            predicate = table[self.class.primary_key].eq(id)
+            predicate = predicate.and(table[self.class.locking_column].eq(previous_value))
 
-        def self.extended(base)
-          class <<base
-            alias_method_chain :update_counters, :lock
+            affected_rows = self.class.unscoped.where(predicate).delete_all
+
+            unless affected_rows == 1
+              raise ActiveRecord::StaleObjectError, "Attempted to delete a stale object: #{self.class.name}"
+            end
           end
+
+          freeze
         end
 
+      module ClassMethods
+        DEFAULT_LOCKING_COLUMN = 'lock_version'
+
         # Is optimistic locking enabled for this table? Returns true if the
         # +lock_optimistically+ flag is set to true (which it is, by default)
         # and the table includes the +locking_column+ column (defaults to
@@ -140,9 +161,9 @@ module ActiveRecord
 
         # Make sure the lock version column gets updated when counters are
         # updated.
-        def update_counters_with_lock(id, counters)
+        def update_counters(id, counters)
           counters = counters.merge(locking_column => 1) if locking_enabled?
-          update_counters_without_lock(id, counters)
+          super
         end
       end
     end

data/lib/active_record/migration.rb

@@ -384,9 +384,13 @@ module ActiveRecord
     class << self
       def migrate(migrations_path, target_version = nil)
         case
-          when target_version.nil?              then up(migrations_path, target_version)
-          when current_version > target_version then down(migrations_path, target_version)
-          else                                       up(migrations_path, target_version)
+          when target_version.nil?
+            up(migrations_path, target_version)
+          when current_version == 0 && target_version == 0
+          when current_version > target_version
+            down(migrations_path, target_version)
+          else
+            up(migrations_path, target_version)
         end
       end
 

data/lib/active_record/named_scope.rb

@@ -99,11 +99,7 @@ module ActiveRecord
           block_given? ? relation.extending(Module.new(&block)) : relation
         end
 
-        singleton_class.instance_eval do
-          define_method name do |*args|
-            scopes[name].call(*args)
-          end
-        end
+        singleton_class.send :define_method, name, &scopes[name]
       end
 
       def named_scope(*args, &block)

data/lib/active_record/nested_attributes.rb

@@ -1,6 +1,7 @@
 require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/object/try'
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/indifferent_access'
 
 module ActiveRecord
   module NestedAttributes #:nodoc:
@@ -348,14 +349,24 @@ module ActiveRecord
         attributes_collection = attributes_collection.sort_by { |index, _| index.to_i }.map { |_, attributes| attributes }
       end
 
+      association = send(association_name)
+
+      existing_records = if association.loaded?
+        association.to_a
+      else
+        attribute_ids = attributes_collection.map {|a| a['id'] || a[:id] }.compact
+        attribute_ids.present? ? association.all(:conditions => {association.primary_key => attribute_ids}) : []
+      end
+
       attributes_collection.each do |attributes|
         attributes = attributes.with_indifferent_access
 
         if attributes['id'].blank?
           unless reject_new_record?(association_name, attributes)
-            send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
+            association.build(attributes.except(*UNASSIGNABLE_KEYS))
           end
-        elsif existing_record = send(association_name).detect { |record| record.id.to_s == attributes['id'].to_s }
+        elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes['id'].to_s }
+          association.send(:add_record_to_target_with_callbacks, existing_record) unless association.loaded?
           assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
         else
           raise_nested_attributes_record_not_found(association_name, attributes['id'])

data/lib/active_record/observer.rb

@@ -96,7 +96,8 @@ module ActiveRecord
     end
 
     def self.method_added(method)
-      self.observed_methods += [method] if ActiveRecord::Callbacks::CALLBACKS.include?(method.to_sym)
+      method = method.to_sym
+      observed_methods << method if ActiveRecord::Callbacks::CALLBACKS.include?(method)
     end
 
     protected
@@ -104,16 +105,27 @@ module ActiveRecord
         observed_classes.sum([]) { |klass| klass.send(:subclasses) }
       end
 
+      def observe_callbacks?
+        self.class.observed_methods.any?
+      end
+
       def add_observer!(klass)
         super
+        define_callbacks klass if observe_callbacks?
+      end
+
+      def define_callbacks(klass)
+        existing_methods = klass.instance_methods.map(&:to_sym)
+        observer = self
+        observer_name = observer.class.name.underscore.gsub('/', '__')
 
-        # Check if a notifier callback was already added to the given class. If
-        # it was not, add it.
         self.class.observed_methods.each do |method|
-          callback = :"_notify_observers_for_#{method}"
-          if (klass.instance_methods & [callback, callback.to_s]).empty?
-            klass.class_eval "def #{callback}; notify_observers(:#{method}); end"
-            klass.send(method, callback)
+          callback = :"_notify_#{observer_name}_for_#{method}"
+          unless existing_methods.include? callback
+            klass.send(:define_method, callback) do  # def _notify_user_observer_for_before_save
+              observer.update(method, self)          #   observer.update(:before_save, self)
+            end                                      # end
+            klass.send(method, callback)             # before_save :_notify_user_observer_for_before_save
           end
         end
       end

data/lib/active_record/persistence.rb

@@ -0,0 +1,230 @@
+module ActiveRecord
+  module Persistence
+    # Returns true if this object hasn't been saved yet -- that is, a record for the object doesn't exist yet; otherwise, returns false.
+    def new_record?
+      @new_record
+    end
+
+    # Returns true if this object has been destroyed, otherwise returns false.
+    def destroyed?
+      @destroyed
+    end
+
+    # Returns if the record is persisted, i.e. it's not a new record and it was not destroyed.
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+    # :call-seq:
+    #   save(options)
+    #
+    # Saves the model.
+    #
+    # If the model is new a record gets created in the database, otherwise
+    # the existing record gets updated.
+    #
+    # By default, save always run validations. If any of them fail the action
+    # is cancelled and +save+ returns +false+. However, if you supply
+    # :validate => false, validations are bypassed altogether. See
+    # ActiveRecord::Validations for more information.
+    #
+    # There's a series of callbacks associated with +save+. If any of the
+    # <tt>before_*</tt> callbacks return +false+ the action is cancelled and
+    # +save+ returns +false+. See ActiveRecord::Callbacks for further
+    # details.
+    def save(*)
+      create_or_update
+    end
+
+    # Saves the model.
+    #
+    # If the model is new a record gets created in the database, otherwise
+    # the existing record gets updated.
+    #
+    # With <tt>save!</tt> validations always run. If any of them fail
+    # ActiveRecord::RecordInvalid gets raised. See ActiveRecord::Validations
+    # for more information.
+    #
+    # There's a series of callbacks associated with <tt>save!</tt>. If any of
+    # the <tt>before_*</tt> callbacks return +false+ the action is cancelled
+    # and <tt>save!</tt> raises ActiveRecord::RecordNotSaved. See
+    # ActiveRecord::Callbacks for further details.
+    def save!(*)
+      create_or_update || raise(RecordNotSaved)
+    end
+
+    # Deletes the record in the database and freezes this instance to
+    # reflect that no changes should be made (since they can't be
+    # persisted). Returns the frozen instance.
+    #
+    # The row is simply removed with a SQL +DELETE+ statement on the
+    # record's primary key, and no callbacks are executed.
+    #
+    # To enforce the object's +before_destroy+ and +after_destroy+
+    # callbacks, Observer methods, or any <tt>:dependent</tt> association
+    # options, use <tt>#destroy</tt>.
+    def delete
+      self.class.delete(id) if persisted?
+      @destroyed = true
+      freeze
+    end
+
+    # Deletes the record in the database and freezes this instance to reflect that no changes should
+    # be made (since they can't be persisted).
+    def destroy
+      if persisted?
+        self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).delete_all
+      end
+
+      @destroyed = true
+      freeze
+    end
+
+    # Returns an instance of the specified +klass+ with the attributes of the current record. This is mostly useful in relation to
+    # single-table inheritance structures where you want a subclass to appear as the superclass. This can be used along with record
+    # identification in Action Pack to allow, say, <tt>Client < Company</tt> to do something like render <tt>:partial => @client.becomes(Company)</tt>
+    # to render that instance using the companies/company partial instead of clients/client.
+    #
+    # Note: The new instance will share a link to the same attributes as the original class. So any change to the attributes in either
+    # instance will affect the other.
+    def becomes(klass)
+      became = klass.new
+      became.instance_variable_set("@attributes", @attributes)
+      became.instance_variable_set("@attributes_cache", @attributes_cache)
+      became.instance_variable_set("@new_record", new_record?)
+      became.instance_variable_set("@destroyed", destroyed?)
+      became
+    end
+
+    # Updates a single attribute and saves the record without going through the normal validation procedure.
+    # This is especially useful for boolean flags on existing records. The regular +update_attribute+ method
+    # in Base is replaced with this when the validations module is mixed in, which it is by default.
+    def update_attribute(name, value)
+      send("#{name}=", value)
+      save(:validate => false)
+    end
+
+    # Updates all the attributes from the passed-in Hash and saves the record. If the object is invalid, the saving will
+    # fail and false will be returned.
+    def update_attributes(attributes)
+      self.attributes = attributes
+      save
+    end
+
+    # Updates an object just like Base.update_attributes but calls save! instead of save so an exception is raised if the record is invalid.
+    def update_attributes!(attributes)
+      self.attributes = attributes
+      save!
+    end
+
+    # Initializes +attribute+ to zero if +nil+ and adds the value passed as +by+ (default is 1).
+    # The increment is performed directly on the underlying attribute, no setter is invoked.
+    # Only makes sense for number-based attributes. Returns +self+.
+    def increment(attribute, by = 1)
+      self[attribute] ||= 0
+      self[attribute] += by
+      self
+    end
+
+    # Wrapper around +increment+ that saves the record. This method differs from
+    # its non-bang version in that it passes through the attribute setter.
+    # Saving is not subjected to validation checks. Returns +true+ if the
+    # record could be saved.
+    def increment!(attribute, by = 1)
+      increment(attribute, by).update_attribute(attribute, self[attribute])
+    end
+
+    # Initializes +attribute+ to zero if +nil+ and subtracts the value passed as +by+ (default is 1).
+    # The decrement is performed directly on the underlying attribute, no setter is invoked.
+    # Only makes sense for number-based attributes. Returns +self+.
+    def decrement(attribute, by = 1)
+      self[attribute] ||= 0
+      self[attribute] -= by
+      self
+    end
+
+    # Wrapper around +decrement+ that saves the record. This method differs from
+    # its non-bang version in that it passes through the attribute setter.
+    # Saving is not subjected to validation checks. Returns +true+ if the
+    # record could be saved.
+    def decrement!(attribute, by = 1)
+      decrement(attribute, by).update_attribute(attribute, self[attribute])
+    end
+
+    # Assigns to +attribute+ the boolean opposite of <tt>attribute?</tt>. So
+    # if the predicate returns +true+ the attribute will become +false+. This
+    # method toggles directly the underlying value without calling any setter.
+    # Returns +self+.
+    def toggle(attribute)
+      self[attribute] = !send("#{attribute}?")
+      self
+    end
+
+    # Wrapper around +toggle+ that saves the record. This method differs from
+    # its non-bang version in that it passes through the attribute setter.
+    # Saving is not subjected to validation checks. Returns +true+ if the
+    # record could be saved.
+    def toggle!(attribute)
+      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.
+    def reload(options = nil)
+      clear_aggregation_cache
+      clear_association_cache
+      @attributes.update(self.class.send(:with_exclusive_scope) { self.class.find(self.id, options) }.instance_variable_get('@attributes'))
+      @attributes_cache = {}
+      self
+    end
+
+  private
+    def create_or_update
+      raise ReadOnlyRecord if readonly?
+      result = new_record? ? create : update
+      result != false
+    end
+
+    # Updates the associated record with values matching those of the instance attributes.
+    # Returns the number of affected rows.
+    def update(attribute_names = @attributes.keys)
+      attributes_with_values = arel_attributes_values(false, false, attribute_names)
+      return 0 if attributes_with_values.empty?
+      self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).arel.update(attributes_with_values)
+    end
+
+    # Creates a record with values matching those of the instance attributes
+    # and returns its id.
+    def create
+      if self.id.nil? && connection.prefetch_primary_key?(self.class.table_name)
+        self.id = connection.next_sequence_value(self.class.sequence_name)
+      end
+
+      attributes_values = arel_attributes_values
+
+      new_id = if attributes_values.empty?
+        self.class.unscoped.insert connection.empty_insert_statement_value
+      else
+        self.class.unscoped.insert attributes_values
+      end
+
+      self.id ||= new_id
+
+      @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.columns.inject({}) do |attributes, column|
+        attributes[column.name] = column.default unless column.name == self.class.primary_key
+        attributes
+      end
+    end
+  end
+end