Permalink
Browse files

Integrate ActiveModel::Observing into ActiveRecord

  • Loading branch information...
josh committed Jun 11, 2009
1 parent 59c83af commit 4d703592001eef1f7e670660cd701e32105bd521
@@ -27,12 +27,13 @@
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
@@ -3,67 +3,80 @@
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
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 +86,11 @@ def observed_class
# 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 +102,12 @@ def update(observed_method, object) #:nodoc:
# 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
+end
@@ -9,7 +9,7 @@ class FooObserver < ActiveModel::Observer
class << self
public :new
end
-
+
attr_accessor :stub
def on_spec(record)
@@ -28,12 +28,12 @@ def setup
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,62 +57,70 @@ def setup
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
instance = FooObserver.new
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}"
FooObserver.observe ObservedModel
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}"
FooObserver.observe 'observed_model'
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}"
FooObserver.observe :observed_model
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
FooObserver.instance.stub.expects(:event_with).with(foo)
Foo.send(:changed)
Foo.send(:notify_observers, :on_spec, foo)
end
-
+
test "skips nonexistent observer event" do
foo = Foo.new
Foo.send(:changed)
@@ -59,7 +59,7 @@ def self.load_all!
autoload :Migrator, 'active_record/migration'
autoload :NamedScope, 'active_record/named_scope'
autoload :NestedAttributes, 'active_record/nested_attributes'
- autoload :Observing, 'active_record/observer'
+ autoload :Observer, 'active_record/observer'
autoload :QueryCache, 'active_record/query_cache'
autoload :Reflection, 'active_record/reflection'
autoload :Schema, 'active_record/schema'
@@ -3149,7 +3149,7 @@ def clone_attribute_value(reader_method, attribute_name)
include Locking::Optimistic, Locking::Pessimistic
include AttributeMethods
include Dirty
- include Callbacks, Observing, Timestamp
+ include Callbacks, ActiveModel::Observing, Timestamp
include Associations, AssociationPreload, NamedScope
# AutosaveAssociation needs to be included before Transactions, because we want
Oops, something went wrong.

0 comments on commit 4d70359

Please sign in to comment.