activerecord 2.3.18 → 3.0.0.beta

data/lib/active_record/named_scope.rb

@@ -1,34 +1,48 @@
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/object/metaclass'
+
 module ActiveRecord
   module NamedScope
-    # All subclasses of ActiveRecord::Base have one named scope:
-    # * <tt>scoped</tt> - which allows for the creation of anonymous \scopes, on the fly: <tt>Shirt.scoped(:conditions => {:color => 'red'}).scoped(:include => :washing_instructions)</tt>
-    #
-    # These anonymous \scopes tend to be useful when procedurally generating complex queries, where passing
-    # intermediate values (scopes) around as first-class objects is convenient.
-    #
-    # You can define a scope that applies to all finders using ActiveRecord::Base.default_scope.
-    def self.included(base)
-      base.extend ClassMethods
-    end
+    extend ActiveSupport::Concern
 
     module ClassMethods
-      def scopes
-        read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+      # Returns a relation if invoked without any arguments.
+      #
+      #   posts = Post.scoped
+      #   posts.size # Fires "select count(*) from  posts" and returns the count
+      #   posts.each {|p| puts p.name } # Fires "select * from posts" and loads post objects
+      #
+      # Returns an anonymous named scope if any options are supplied.
+      #
+      #   shirts = Shirt.scoped(:conditions => {:color => 'red'})
+      #   shirts = shirts.scoped(:include => :washing_instructions)
+      #
+      # Anonymous \scopes tend to be useful when procedurally generating complex queries, where passing
+      # intermediate values (scopes) around as first-class objects is convenient.
+      #
+      # You can define a scope that applies to all finders using ActiveRecord::Base.default_scope.
+      def scoped(options = {}, &block)
+        if options.present?
+          Scope.init(self, options, &block)
+        else
+          current_scoped_methods ? unscoped.merge(current_scoped_methods) : unscoped.spawn
+        end
       end
 
-      def scoped(scope, &block)
-        Scope.new(self, scope, &block)
+      def scopes
+        read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
       end
 
       # Adds a class method for retrieving and querying objects. A scope represents a narrowing of a database query,
       # such as <tt>:conditions => {:color => :red}, :select => 'shirts.*', :include => :washing_instructions</tt>.
       #
       #   class Shirt < ActiveRecord::Base
-      #     named_scope :red, :conditions => {:color => 'red'}
-      #     named_scope :dry_clean_only, :joins => :washing_instructions, :conditions => ['washing_instructions.dry_clean_only = ?', true]
+      #     scope :red, :conditions => {:color => 'red'}
+      #     scope :dry_clean_only, :joins => :washing_instructions, :conditions => ['washing_instructions.dry_clean_only = ?', true]
       #   end
-      # 
-      # The above calls to <tt>named_scope</tt> define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red, 
+      #
+      # The above calls to <tt>scope</tt> define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red,
       # in effect, represents the query <tt>Shirt.find(:all, :conditions => {:color => 'red'})</tt>.
       #
       # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by Shirt.red is not an Array; it resembles the association object
@@ -54,7 +68,7 @@ module ActiveRecord
       # Named \scopes can also be procedural:
       #
       #   class Shirt < ActiveRecord::Base
-      #     named_scope :colored, lambda { |color|
+      #     scope :colored, lambda { |color|
       #       { :conditions => { :color => color } }
       #     }
       #   end
@@ -64,7 +78,7 @@ module ActiveRecord
       # Named \scopes can also have extensions, just as with <tt>has_many</tt> declarations:
       #
       #   class Shirt < ActiveRecord::Base
-      #     named_scope :red, :conditions => {:color => 'red'} do
+      #     scope :red, :conditions => {:color => 'red'} do
       #       def dom_id
       #         'red_shirts'
       #       end
@@ -76,122 +90,101 @@ module ActiveRecord
       # <tt>proxy_options</tt> method on the proxy itself.
       #
       #   class Shirt < ActiveRecord::Base
-      #     named_scope :colored, lambda { |color|
+      #     scope :colored, lambda { |color|
       #       { :conditions => { :color => color } }
       #     }
       #   end
       #
       #   expected_options = { :conditions => { :colored => 'red' } }
       #   assert_equal expected_options, Shirt.colored('red').proxy_options
-      def named_scope(name, options = {}, &block)
+      def scope(name, options = {}, &block)
         name = name.to_sym
 
+        if !scopes[name] && respond_to?(name, true)
+          raise ArgumentError, "Cannot define scope :#{name} because #{self.name}.#{name} method already exists."
+        end
+
         scopes[name] = lambda do |parent_scope, *args|
-          Scope.new(parent_scope, case options
-            when Hash
+          Scope.init(parent_scope, case options
+            when Hash, Relation
               options
             when Proc
-              if self.model_name != parent_scope.model_name
-                options.bind(parent_scope).call(*args)
-              else
-                options.call(*args)
-              end
+              options.call(*args)
           end, &block)
         end
-
-        singleton_class.send :define_method, name do |*args|
-          scopes[name].call(self, *args)
+        metaclass.instance_eval do
+          define_method name do |*args|
+            scopes[name].call(self, *args)
+          end
         end
       end
-    end
 
-    class Scope
-      attr_reader :proxy_scope, :proxy_options, :current_scoped_methods_when_defined
-      NON_DELEGATE_METHODS = %w(nil? send object_id class extend find size count sum average maximum minimum paginate first last empty? any? respond_to?).to_set
-      [].methods.each do |m|
-        unless m =~ /^__/ || NON_DELEGATE_METHODS.include?(m.to_s)
-          delegate m, :to => :proxy_found
-        end
+      def named_scope(*args, &block)
+        ActiveSupport::Deprecation.warn("Base.named_scope has been deprecated, please use Base.scope instead", caller)
+        scope(*args, &block)
       end
+    end
 
-      delegate :scopes, :with_scope, :scoped_methods, :to => :proxy_scope
+    class Scope < Relation
+      attr_accessor :current_scoped_methods_when_defined
 
-      def initialize(proxy_scope, options, &block)
-        options ||= {}
-        [options[:extend]].flatten.each { |extension| extend extension } if options[:extend]
-        extend Module.new(&block) if block_given?
-        unless (Scope === proxy_scope || ActiveRecord::Associations::AssociationCollection === proxy_scope)
-          @current_scoped_methods_when_defined = proxy_scope.send(:current_scoped_methods)
-        end
-        @proxy_scope, @proxy_options = proxy_scope, options.except(:extend)
-      end
+      delegate :scopes, :with_scope, :with_exclusive_scope, :scoped_methods, :scoped, :to => :klass
 
-      def reload
-        load_found; self
-      end
+      def self.init(klass, options, &block)
+        relation = new(klass, klass.arel_table)
 
-      def first(*args)
-        if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash))
-          proxy_found.first(*args)
+        scope = if options.is_a?(Hash)
+          klass.scoped.apply_finder_options(options.except(:extend))
         else
-          find(:first, *args)
+          options ? klass.scoped.merge(options) : klass.scoped
         end
-      end
 
-      def last(*args)
-        if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash))
-          proxy_found.last(*args)
-        else
-          find(:last, *args)
-        end
-      end
+        relation = relation.merge(scope)
 
-      def size
-        @found ? @found.length : count
-      end
+        Array.wrap(options[:extend]).each {|extension| relation.send(:extend, extension) } if options.is_a?(Hash)
+        relation.send(:extend, Module.new(&block)) if block_given?
 
-      def empty?
-        @found ? @found.empty? : count.zero?
+        relation.current_scoped_methods_when_defined = klass.send(:current_scoped_methods)
+        relation
       end
 
-      def respond_to?(method, include_private = false)
-        super || @proxy_scope.respond_to?(method, include_private)
+      def first(*args)
+        if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
+          to_a.first(*args)
+        else
+          args.first.present? ? apply_finder_options(args.first).first : super
+        end
       end
 
-      def any?
-        if block_given?
-          proxy_found.any? { |*block_args| yield(*block_args) }
+      def last(*args)
+        if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
+          to_a.last(*args)
         else
-          !empty?
+          args.first.present? ? apply_finder_options(args.first).last : super
         end
       end
 
-      protected
-      def proxy_found
-        @found || load_found
+      def ==(other)
+        other.respond_to?(:to_ary) ? to_a == other.to_a : false
       end
 
       private
+
       def method_missing(method, *args, &block)
-        if scopes.include?(method)
-          scopes[method].call(self, *args)
-        else
-          with_scope({:find => proxy_options, :create => proxy_options[:conditions].is_a?(Hash) ?  proxy_options[:conditions] : {}}, :reverse_merge) do
-            method = :new if method == :build
-            if current_scoped_methods_when_defined && !scoped_methods.include?(current_scoped_methods_when_defined)
-              with_scope current_scoped_methods_when_defined do
-                proxy_scope.send(method, *args, &block)
-              end
+        if klass.respond_to?(method)
+          with_scope(self) do
+            if current_scoped_methods_when_defined && !scoped_methods.include?(current_scoped_methods_when_defined) && !scopes.include?(method)
+              with_scope(current_scoped_methods_when_defined) { klass.send(method, *args, &block) }
             else
-              proxy_scope.send(method, *args, &block)
+              klass.send(method, *args, &block)
             end
           end
+        else
+          super
         end
       end
 
-      def load_found
-        @found = find(:all)
-      end
     end
+
   end
 end

data/lib/active_record/nested_attributes.rb

@@ -1,12 +1,16 @@
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/object/try'
+
 module ActiveRecord
   module NestedAttributes #:nodoc:
     class TooManyRecords < ActiveRecordError
     end
 
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.class_inheritable_accessor :nested_attributes_options, :instance_writer => false
-      base.nested_attributes_options = {}
+    extend ActiveSupport::Concern
+
+    included do
+      class_inheritable_accessor :nested_attributes_options, :instance_writer => false
+      self.nested_attributes_options = {}
     end
 
     # == Nested Attributes
@@ -45,14 +49,14 @@ module ActiveRecord
     # create the member and avatar in one go:
     #
     #   params = { :member => { :name => 'Jack', :avatar_attributes => { :icon => 'smiling' } } }
-    #   member = Member.create(params)
+    #   member = Member.create(params[:member])
     #   member.avatar.id # => 2
     #   member.avatar.icon # => 'smiling'
     #
     # It also allows you to update the avatar through the member:
     #
-    #   params = { :member' => { :avatar_attributes => { :id => '2', :icon => 'sad' } } }
-    #   member.update_attributes params['member']
+    #   params = { :member => { :avatar_attributes => { :id => '2', :icon => 'sad' } } }
+    #   member.update_attributes params[:member]
     #   member.avatar.icon # => 'sad'
     #
     # By default you will only be able to set and update attributes on the
@@ -71,7 +75,7 @@ module ActiveRecord
     #   member.avatar_attributes = { :id => '2', :_destroy => '1' }
     #   member.avatar.marked_for_destruction? # => true
     #   member.save
-    #   member.avatar #=> nil
+    #   member.reload.avatar #=> nil
     #
     # Note that the model will _not_ be destroyed until the parent is saved.
     #
@@ -175,7 +179,7 @@ module ActiveRecord
     #   member.posts.detect { |p| p.id == 2 }.marked_for_destruction? # => true
     #   member.posts.length #=> 2
     #   member.save
-    #   member.posts.length # => 1
+    #   member.reload.posts.length # => 1
     #
     # === Saving
     #
@@ -239,11 +243,11 @@ module ActiveRecord
             # def pirate_attributes=(attributes)
             #   assign_nested_attributes_for_one_to_one_association(:pirate, attributes)
             # end
-            class_eval <<-EOS, __FILE__, __LINE__ + 1
+            class_eval %{
               def #{association_name}_attributes=(attributes)
                 assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
               end
-            EOS
+            }, __FILE__, __LINE__
           else
             raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
           end
@@ -315,7 +319,7 @@ module ActiveRecord
     #   })
     #
     # Will update the name of the Person with ID 1, build a new associated
-    # person with the name `John', and mark the associatied Person with ID 2
+    # person with the name `John', and mark the associated Person with ID 2
     # for destruction.
     #
     # Also accepts an Array of attribute hashes:
@@ -340,24 +344,14 @@ 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)
-            association.build(attributes.except(*UNASSIGNABLE_KEYS))
+            send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
           end
-        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?
+        elsif existing_record = send(association_name).detect { |record| record.id.to_s == attributes['id'].to_s }
           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

@@ -1,59 +1,6 @@
-require 'singleton'
-require 'set'
+require 'active_support/core_ext/class/attribute'
 
 module ActiveRecord
-  module Observing # :nodoc:
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      # Activates the observers assigned. Examples:
-      #
-      #   # Calls PersonObserver.instance
-      #   ActiveRecord::Base.observers = :person_observer
-      #
-      #   # Calls Cacher.instance and GarbageCollector.instance
-      #   ActiveRecord::Base.observers = :cacher, :garbage_collector
-      #
-      #   # Same as above, just using explicit class references
-      #   ActiveRecord::Base.observers = Cacher, GarbageCollector
-      #
-      # Note: Setting this does not instantiate the observers yet. +instantiate_observers+ is
-      # called during startup, and before each development request.
-      def observers=(*observers)
-        @observers = observers.flatten
-      end
-
-      # Gets the current observers.
-      def observers
-        @observers ||= []
-      end
-
-      # Instantiate the global Active Record observers.
-      def instantiate_observers
-        return if @observers.blank?
-        @observers.each do |observer|
-          if observer.respond_to?(:to_sym) # Symbol or String
-            observer.to_s.camelize.constantize.instance
-          elsif observer.respond_to?(:instance)
-            observer.instance
-          else
-            raise ArgumentError, "#{observer} must be a lowercase, underscored class name (or an instance of the class itself) responding to the instance method. Example: Person.observers = :big_brother # calls BigBrother.instance"
-          end
-        end
-      end
-
-      protected
-        # Notify observers when the observed class is subclassed.
-        def inherited(subclass)
-          super
-          changed
-          notify_observers :observed_class_inherited, subclass
-        end
-    end
-  end
-
   # Observer classes respond to lifecycle callbacks to implement trigger-like
   # behavior outside the original class. This is a great way to reduce the
   # clutter that normally comes when the model class is burdened with
@@ -139,58 +86,35 @@ module ActiveRecord
   # load their observers by calling <tt>ModelObserver.instance</tt> before. Observers are
   # singletons and that call instantiates and registers them.
   #
-  class Observer
-    include Singleton
-
-    class << self
-      # Attaches the observer to the supplied model classes.
-      def observe(*models)
-        models.flatten!
-        models.collect! { |model| model.is_a?(Symbol) ? model.to_s.camelize.constantize : model }
-        define_method(:observed_classes) { Set.new(models) }
-      end
-
-      # The class observed by default is inferred from the observer's class name:
-      #   assert_equal Person, PersonObserver.observed_class
-      def observed_class
-        if observed_class_name = name[/(.*)Observer/, 1]
-          observed_class_name.constantize
-        else
-          nil
-        end
-      end
-    end
+  class Observer < ActiveModel::Observer
+    class_attribute :observed_methods
+    self.observed_methods = []
 
-    # Start observing the declared classes and their subclasses.
     def initialize
-      Set.new(observed_classes + observed_subclasses).each { |klass| add_observer! klass }
+      super
+      observed_subclasses.each { |klass| add_observer!(klass) }
     end
 
-    # Send observed_method(object) if the method exists.
-    def update(observed_method, object) #:nodoc:
-      send(observed_method, object) if respond_to?(observed_method)
-    end
-
-    # Special method sent by the observed class when it is inherited.
-    # Passes the new subclass.
-    def observed_class_inherited(subclass) #:nodoc:
-      self.class.observe(observed_classes + [subclass])
-      add_observer!(subclass)
+    def self.method_added(method)
+      self.observed_methods += [method] if ActiveRecord::Callbacks::CALLBACKS.include?(method.to_sym)
     end
 
     protected
-      def observed_classes
-        Set.new([self.class.observed_class].compact.flatten)
-      end
-
       def observed_subclasses
         observed_classes.sum([]) { |klass| klass.send(:subclasses) }
       end
 
       def add_observer!(klass)
-        klass.add_observer(self)
-        if respond_to?(:after_find) && !klass.method_defined?(:after_find)
-          klass.class_eval 'def after_find() end'
+        super
+
+        # 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)
+          end
         end
       end
   end