diff options
Diffstat (limited to 'activemodel')
| -rw-r--r-- | activemodel/lib/active_model.rb | 9 | ||||
| -rw-r--r-- | activemodel/lib/active_model/observing.rb | 116 | ||||
| -rw-r--r-- | activemodel/test/cases/observing_test.rb | 32 |
3 files changed, 95 insertions, 62 deletions
diff --git a/activemodel/lib/active_model.rb b/activemodel/lib/active_model.rb index a3545f1d53..73cee9b88f 100644 --- a/activemodel/lib/active_model.rb +++ b/activemodel/lib/active_model.rb @@ -27,12 +27,13 @@ require 'active_support' module ActiveModel autoload :Base, 'active_model/base' - autoload :Observing, 'active_model/observing' - autoload :Validations, 'active_model/validations' - autoload :Errors, 'active_model/errors' autoload :DeprecatedErrorMethods, 'active_model/deprecated_error_methods' - autoload :TestCase, 'active_model/test_case' + autoload :Errors, 'active_model/errors' + autoload :Observer, 'active_model/observing' + autoload :Observing, 'active_model/observing' autoload :StateMachine, 'active_model/state_machine' + autoload :TestCase, 'active_model/test_case' + autoload :Validations, 'active_model/validations' autoload :ValidationsRepairHelper, 'active_model/validations_repair_helper' end diff --git a/activemodel/lib/active_model/observing.rb b/activemodel/lib/active_model/observing.rb index d3c6d8e482..7bad2397ae 100644 --- a/activemodel/lib/active_model/observing.rb +++ b/activemodel/lib/active_model/observing.rb @@ -1,69 +1,90 @@ require 'observer' require 'singleton' +require 'active_support/core_ext/string/inflections' +require 'active_support/core_ext/array/wrap' module ActiveModel module Observing + extend ActiveSupport::Concern + + included do + extend Observable + end + module ClassMethods - def observers - @observers ||= [] - end - + # 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=(*values) @observers = values.flatten end - + + # Gets the current observers. + def observers + @observers ||= [] + end + + # Instantiate the global Active Record observers. def instantiate_observers observers.each { |o| instantiate_observer(o) } end - - protected - def instantiate_observer(observer) - # string/symbol - if observer.respond_to?(:to_sym) - observer = 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" + + protected + def instantiate_observer(observer) + # string/symbol + if observer.respond_to?(:to_sym) + observer = 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 + + # Notify observers when the observed class is subclassed. + def inherited(subclass) + super + changed + notify_observers :observed_class_inherited, subclass end - end - - # Notify observers when the observed class is subclassed. - def inherited(subclass) - super - changed - notify_observers :observed_class_inherited, subclass - end - end - - def self.included(receiver) - receiver.extend Observable, ClassMethods end + + private + def notify(method) #:nodoc: + self.class.changed + self.class.notify_observers(method, self) + end end class Observer include Singleton - attr_writer :observed_classes class << self - attr_accessor :models # Attaches the observer to the supplied model classes. def observe(*models) - @models = models.flatten - @models.collect! { |model| model.respond_to?(:to_sym) ? model.to_s.camelize.constantize : model } + models.flatten! + models.collect! { |model| model.respond_to?(:to_sym) ? model.to_s.camelize.constantize : model } + define_method(:observed_classes) { models } end - def observed_class_name - @observed_class_name ||= - if guessed_name = name.scan(/(.*)Observer/)[0] - @observed_class_name = guessed_name[0] - end + def observed_classes + Array.wrap(observed_class) end # The class observed by default is inferred from the observer's class name: - # assert_equal [Person], PersonObserver.observed_class + # assert_equal Person, PersonObserver.observed_class def observed_class - if observed_class_name + if observed_class_name = name[/(.*)Observer/, 1] observed_class_name.constantize else nil @@ -73,8 +94,11 @@ module ActiveModel # Start observing the declared classes and their subclasses. def initialize - self.observed_classes = self.class.models if self.class.models - observed_classes.each { |klass| klass.add_observer(self) } + observed_classes.each { |klass| add_observer!(klass) } + end + + def observed_classes + self.class.observed_classes end # Send observed_method(object) if the method exists. @@ -86,12 +110,12 @@ module ActiveModel # Passes the new subclass. def observed_class_inherited(subclass) #:nodoc: self.class.observe(observed_classes + [subclass]) - subclass.add_observer(self) + add_observer!(subclass) end - protected - def observed_classes - @observed_classes ||= [self.class.observed_class] - end + protected + def add_observer!(klass) + klass.add_observer(self) + end end -end
\ No newline at end of file +end diff --git a/activemodel/test/cases/observing_test.rb b/activemodel/test/cases/observing_test.rb index 421ac4b4f8..564451fa2f 100644 --- a/activemodel/test/cases/observing_test.rb +++ b/activemodel/test/cases/observing_test.rb @@ -9,7 +9,7 @@ class FooObserver < ActiveModel::Observer class << self public :new end - + attr_accessor :stub def on_spec(record) @@ -28,12 +28,12 @@ class ObservingTest < ActiveModel::TestCase test "initializes model with no cached observers" do assert ObservedModel.observers.empty?, "Not empty: #{ObservedModel.observers.inspect}" end - + test "stores cached observers in an array" do ObservedModel.observers << :foo assert ObservedModel.observers.include?(:foo), ":foo not in #{ObservedModel.observers.inspect}" end - + test "flattens array of assigned cached observers" do ObservedModel.observers = [[:foo], :bar] assert ObservedModel.observers.include?(:foo), ":foo not in #{ObservedModel.observers.inspect}" @@ -57,22 +57,30 @@ class ObservingTest < ActiveModel::TestCase ObservedModel::Observer.expects(:instance) ObservedModel.instantiate_observers end - + test "passes observers to subclasses" do FooObserver.instance bar = Class.new(Foo) assert_equal Foo.count_observers, bar.count_observers end end - + class ObserverTest < ActiveModel::TestCase def setup ObservedModel.observers = :foo_observer - FooObserver.models = nil + FooObserver.instance_eval do + alias_method :original_observed_classes, :observed_classes + end + end + + def teardown + FooObserver.instance_eval do + alias_method :observed_classes, :original_observed_classes + end end test "guesses implicit observable model name" do - assert_equal 'Foo', FooObserver.observed_class_name + assert_equal Foo, FooObserver.observed_class end test "tracks implicit observable models" do @@ -80,7 +88,7 @@ class ObserverTest < ActiveModel::TestCase assert instance.send(:observed_classes).include?(Foo), "Foo not in #{instance.send(:observed_classes).inspect}" assert !instance.send(:observed_classes).include?(ObservedModel), "ObservedModel in #{instance.send(:observed_classes).inspect}" end - + test "tracks explicit observed model class" do old_instance = FooObserver.new assert !old_instance.send(:observed_classes).include?(ObservedModel), "ObservedModel in #{old_instance.send(:observed_classes).inspect}" @@ -88,7 +96,7 @@ class ObserverTest < ActiveModel::TestCase instance = FooObserver.new assert instance.send(:observed_classes).include?(ObservedModel), "ObservedModel not in #{instance.send(:observed_classes).inspect}" end - + test "tracks explicit observed model as string" do old_instance = FooObserver.new assert !old_instance.send(:observed_classes).include?(ObservedModel), "ObservedModel in #{old_instance.send(:observed_classes).inspect}" @@ -96,7 +104,7 @@ class ObserverTest < ActiveModel::TestCase instance = FooObserver.new assert instance.send(:observed_classes).include?(ObservedModel), "ObservedModel not in #{instance.send(:observed_classes).inspect}" end - + test "tracks explicit observed model as symbol" do old_instance = FooObserver.new assert !old_instance.send(:observed_classes).include?(ObservedModel), "ObservedModel in #{old_instance.send(:observed_classes).inspect}" @@ -104,7 +112,7 @@ class ObserverTest < ActiveModel::TestCase instance = FooObserver.new assert instance.send(:observed_classes).include?(ObservedModel), "ObservedModel not in #{instance.send(:observed_classes).inspect}" end - + test "calls existing observer event" do foo = Foo.new FooObserver.instance.stub = stub @@ -112,7 +120,7 @@ class ObserverTest < ActiveModel::TestCase Foo.send(:changed) Foo.send(:notify_observers, :on_spec, foo) end - + test "skips nonexistent observer event" do foo = Foo.new Foo.send(:changed) |