association_observers 0.0.3

data/lib/association_observers/activerecord.rb

@@ -0,0 +1,4 @@
+if defined?(ActiveRecord)
+  ActiveRecord::Base.send(:extend, AssociationObservers::ClassMethods)
+  ActiveRecord::Base.send(:include, AssociationObservers::InstanceMethods)
+end

data/lib/association_observers/notifiers/base.rb

@@ -0,0 +1,77 @@
+# -*- encoding : utf-8 -*-
+module Notifier
+  class Base
+    attr_reader :callback, :observers, :options
+    # @param [Symbol] callback callback key to which this observer will respond (:create, :update, :save, :destroy)
+    # @param [Array] observers list of observers asssociations in the symbolized-underscored form (SimpleAssociation => :simple_association)
+    # @param [Hash] options additional options for the notifier
+    # @option options [Class] :observer_class the class of the observer (important when the observer association is polymorphic)
+    def initialize(callback, observers, options = {})
+      @callback = callback
+      @observers = Array(observers)
+      @options = options
+    end
+
+
+    # this function will be triggered by the notify_observers call on the observable model. It is basically
+    # implemented as a filter where it is seen if the triggered callback corresponds to the callback this observer
+    # responds to
+    #
+    # @param [Symbol] callback key from the callback that has just been triggered
+    # @param [Object] observable the object which triggered the callback
+    def update(callback, observable)
+      return unless callback == @callback
+      observers = @options.has_key?(:observer_class) ? self.observers.select{|assoc| observable.association(assoc).klass == @options[:observer_class] } : self.observers
+      notify(observable, observers.map{|assoc| observable.send(assoc)}.compact)
+    end
+
+    # @return [Boolean] whether the action should be executed for the observer
+    def conditions(observable, observer) ; true ; end
+    # @return [Boolean] whether the action should be executed for the observers collection
+    def conditions_many(observable, observers) ; true ; end
+
+    # abstract action; has to be implemented by the subclass
+    def action(observable, observer, callback=@callback)
+      raise "this has to be implemented in your notifier"
+    end
+
+
+
+    private
+
+    # Notifies all observers; filters the observers into two groups: one-to-many and one-to-one collections
+    # @param [Object] observable the object which is notifying
+    # @param [Array] observers the associated observers which will be notified
+    def notify(observable, observers, &block)
+      many, ones = observers.partition{|obs| obs.respond_to?(:size) }
+      action = block_given? ? block : method(:action)
+      notify_many(observable, many, &action)
+      notify_ones(observable, ones, &action)
+    end
+
+    # TODO: make this notify private as soon as possible again
+    public :notify
+
+    # Abstract Method (can be re-defined by other notifiers); here it is defined the default implementation of
+    # handling of many-to-many observers: for each one it will notify its observers, in case these are observed
+    # @param [Object] observable the object which is notifying
+    # @param [Array[ActiveRecord::Relation]] many_observers the observers which will be notified; each element represents a one-to-many relation
+    def notify_many(observable, many_observers)
+      many_observers.each do |observers|
+        observers.find_each(:batch_size => 10) do |observer|
+          yield(observable, observer) if conditions(observable, observer)
+        end if conditions_many(observable, observers)
+      end
+    end
+
+    # Abstract Method (can be re-defined by other notifiers); here it is defined the default implementation of
+    # handling of one-to-one observers: for each one it will notify its observers, in case these are observed
+    # @param [Object] observable the object which is notifying
+    # @param [Array[Object]] observers the observers which will be notified; each element represents a one-to-one association
+    def notify_ones(observable, observers)
+      observers.each do |observer|
+        yield(observable, observer) if conditions(observable, observer)
+      end
+    end
+  end
+end

data/lib/association_observers/notifiers/propagation_notifier.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+# Default Observer which propagates notifications to the observers' observers
+#
+# @author Tiago Cardoso
+class PropagationNotifier < Notifier::Base
+
+  def conditions(observable, observer) ; observer.observable? ; end
+  def conditions_many(observable, observers) ;  observers.klass.observable? ; end
+
+  # propagates the message to the observer's observer if the
+  # observer is indeed observed by any entity
+  def action(observable, observer, callback=@callback)
+    (observer.new_record? or not observer.respond_to?(:delay)) ? observer.send(:notify_observers, callback) : observer.delay.notify_observers(callback)
+  end
+
+end

data/lib/association_observers/railtie.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+module AssociationObservers
+  def self.initialize_railtie
+    ActiveSupport.on_load :active_record do
+      require 'association_observers/activerecord'
+    end
+  end
+  class Railtie < Rails::Railtie
+    initializer 'association_observers.insert_into_active_record' do
+      AssociationObservers.initialize_railtie
+    end
+    initializer 'association_observers.autoload', :before => :set_autoload_paths do |app|
+      app.config.autoload_paths += Rails.root.join("app", "notifiers")
+    end
+  end
+end

data/lib/association_observers/ruby18.rb

@@ -0,0 +1,12 @@
+# -*- encoding : utf-8 -*-
+module AssociationObservers
+  def self.extended_to_s(val)
+    if val.is_a?(Hash)
+      "{#{val.map{|k, v| ":#{k}=>#{extended_to_s(v)}"}.join(",")}}"
+    elsif val.is_a?(Array)
+      "[#{val.map{|a|extended_to_s(a)}.join(",")}]"
+    else
+      val.is_a?(Symbol) ? ":#{val}" : val.is_a?(String) ? "\"#{val}\"" : val
+    end
+  end
+end

data/lib/association_observers/version.rb

@@ -0,0 +1,3 @@
+module AssociationObservers
+  VERSION = "0.0.3"
+end

data/lib/examples/notifiers/update_timestamp_notifier.rb

@@ -0,0 +1,29 @@
+# -*- encoding : utf-8 -*-
+class UpdateTimestampNotifier < Notifier
+  module ObserverMethods
+    def irrelevant_observer_method
+      puts "irrelevantimus"
+    end
+  end
+
+  module ObservableMethods
+    def irrelevant_observable_method
+      puts "up yours"
+    end
+  end
+
+  def action(observable, observer)
+    observer.touch :timestamp
+  end
+
+  private
+
+  def notify_many(observable, many_observers)
+    unless observable.new_record?
+      many_observers.each do |observers|
+        observers.update_all(observers.table[:timestamp].eq(Time.now).to_sql)
+      end
+    end
+  end
+
+end

data/lib/examples/readme_example.rb

@@ -0,0 +1,114 @@
+# -*- encoding : utf-8 -*-
+# Logger
+require 'logger'
+
+LOGGER = Logger.new(STDOUT)
+
+# Notifiers
+class HaveSliceNotifier < Notifier::Base
+
+  def action(cake, kid)
+    cake.update_column(:slices, cake.slices - 1)
+    cake.destroy if cake.slices == 0
+    kid.increment(:slices).save
+  end
+
+end
+
+class BustKidsAssNotifier < Notifier::Base
+
+  module ObserverMethods
+    def bust_kids_ass!
+      LOGGER.info("Slam!!")
+    end
+  end
+
+  module ObservableMethods
+    def is_for_grandpa?
+      true # it is always for grandpa
+    end
+  end
+
+  def conditions(cake, mom)
+    cake.is_for_grandpa?
+  end
+
+  def action(cake, mom)
+    mom.bust_kids_ass!
+  end
+
+end
+
+class TellKidHesFatNotifier < Notifier::Base
+
+  module ObservableMethods
+    def cry!
+      LOGGER.info(":'(")
+    end
+
+    def throw_slices_away!
+      update_column(:slices, 0)
+    end
+  end
+
+  def conditions(kid, mom)
+    kid.slices > 20
+  end
+
+  def action(kid, mom)
+    LOGGER.info("Hey Fatty, BEEFCAKE!!!!!")
+    kid.cry!
+    kid.throw_slices_away!
+  end
+
+end
+
+
+# TABLES
+
+ActiveRecord::Schema.define do
+  create_table :cakes, :force => true do |t|
+    t.integer :slices
+    t.integer :mom_id
+  end
+  create_table :kids, :force => true do |t|
+    t.integer :mom_id
+    t.integer :slices, :default => 0
+  end
+  create_table :moms, :force => true do |t|
+  end
+end
+
+# ENTITIES
+
+class Cake < ActiveRecord::Base
+
+  def self.default_slices ; 8 ; end
+  belongs_to :mom
+  has_one :kid, :through => :mom
+  before_create do |record|
+    record.slices ||= record.class.default_slices
+  end
+end
+
+class Mom < ActiveRecord::Base
+  has_one :kid
+  has_many :cakes
+end
+
+class Kid < ActiveRecord::Base
+  belongs_to :mom
+  has_many :cakes, :through => :mom
+
+  observes :cakes, :notifier => :have_slice, :on => :create
+end
+
+class Mom < ActiveRecord::Base
+  observes :cakes, :on => :destroy, :notifier => :bust_kids_ass
+  observes :kid, :on => :update, :notifier => :tell_kid_hes_fat
+end
+
+
+
+
+

data/spec/activerecord/association_observers_spec.rb

@@ -0,0 +1,548 @@
+# -*- encoding : utf-8 -*-
+require "./spec/spec_helper"
+
+describe AssociationObservers do
+  class TestUpdateNotifier < Notifier::Base
+
+    def action(observable, observer)
+      observer.update_attributes(:updated => true)
+    end
+
+    def notify_many(observable, many_observers)
+      many_observers.each do |observers|
+        observers.update_all(:updated => true)
+      end
+    end
+
+  end
+  
+  class TestDestroyNotifier < Notifier::Base
+
+    def action(observable, observer)
+      observer.update_attributes(:deleted => true)
+    end
+
+    def notify_many(observable, many_observers)
+      many_observers.each do |observers|
+        observers.each do |observer|
+          observer.update_all(:deleted => true)
+        end
+      end
+    end
+
+  end
+  
+
+  class ObservableAbstractTest < ActiveRecord::Base
+    self.table_name ='association_observable_tests'
+    attr_accessible :name
+  end
+
+  class BelongsToObservableTest < ObservableAbstractTest
+    attr_accessible :observer_test
+    has_one :observer_test
+  end
+  class CollectionObservableTest < ObservableAbstractTest
+    attr_accessible :observer_tests
+    has_many :observer_tests
+  end
+  class HasOneObservableTest < ObservableAbstractTest
+    attr_accessible :observer_test
+    belongs_to :observer_test
+  end
+  class HasManyObservableTest < ObservableAbstractTest
+    attr_accessible :observer_test, :has_many_through_observable_tests
+    belongs_to :observer_test
+    has_many :has_many_through_observable_tests
+  end
+  class HasManyThroughObservableTest < ObservableAbstractTest
+    attr_accessible :observer_test, :has_many_observable_test
+    belongs_to :has_many_observable_test
+    has_one :observer_test, :through => :has_many_observable_test
+  end
+
+  class PolymorphicHasManyObservableTest < ObservableAbstractTest
+    attr_accessible :observer
+    belongs_to :observer, :polymorphic => true
+  end
+  class HabtmObservableTest < ObservableAbstractTest
+    attr_accessible :observer_tests
+    has_and_belongs_to_many :observer_tests
+  end
+
+
+  class ObserverAbstractTest < ActiveRecord::Base
+    self.table_name = 'association_observer_tests'
+    attr_accessible :updated, :deleted
+  end
+
+  class ObserverTest < ObserverAbstractTest
+
+    belongs_to :belongs_to_observable_test
+    belongs_to :collection_observable_test
+    has_one :has_one_observable_test
+    has_many :has_many_observable_tests
+
+    has_many :has_many_through_observable_tests, :through => :has_many_observable_tests
+
+    has_many :polymorphic_has_many_observable_tests, :as => :observer
+
+    has_one :observer_observer_test
+
+    has_and_belongs_to_many :habtm_observable_tests
+
+    attr_accessible :belongs_to_observable_test,
+                    :has_one_observable_test,
+                    :has_many_observable_tests,
+                    :has_many_through_observable_tests,
+                    :polymorphic_has_many_observable_tests,
+                    :collection_observable_test,
+                    :observer_observer_test,
+                    :habtm_observable_tests
+
+    observes :habtm_observable_tests, :notifiers => :test_update, :on => :create
+    observes :belongs_to_observable_test,
+             :has_one_observable_test,
+             :collection_observable_test,
+             :has_many_through_observable_tests,
+             :polymorphic_has_many_observable_tests,
+             :has_many_observable_tests,
+             :habtm_observable_tests, :notifiers => :test_update, :on => :update
+    observes :belongs_to_observable_test,
+             :has_one_observable_test,
+             :collection_observable_test,
+             :has_many_through_observable_tests,
+             :has_many_observable_tests,
+             :polymorphic_has_many_observable_tests,
+             :habtm_observable_tests, :notifiers => :test_destroy, :on => :destroy
+  end
+
+  class ObserverObserverTest < ObserverAbstractTest
+    belongs_to :observer_test
+    attr_accessible :observer_test
+
+    observes :observer_test, :notifiers => :test_update, :on => :update
+  end
+
+  ActiveRecord::Schema.define do
+    create_table :association_observer_tests, :force => true do |t|
+      t.column :type, :string # for polymorphic test only
+      t.column :observer_test_id, :integer
+      t.column :belongs_to_observable_test_id, :integer
+      t.column :collection_observable_test_id, :integer
+      t.column :updated, :boolean
+      t.column :deleted, :boolean
+    end
+    create_table :association_observable_tests, :force => true do |t|
+      t.column :observer_test_id, :integer
+      t.column :observer_type, :string # for polymorphic test only
+      t.column :observer_id, :integer # for polymorphic test only
+      t.column :has_many_observable_test_id, :integer
+      t.column :name, :string
+    end
+    create_table :habtm_observable_tests_observer_tests, :id => false, :force => true do |t|
+      t.column :habtm_observable_test_id, :integer
+      t.column :observer_test_id, :integer
+    end
+  end
+
+  let(:observer1) {ObserverTest.create(:has_one_observable_test => HasOneObservableTest.new,
+                                       :has_many_observable_tests => [HasManyObservableTest.new,
+                                                                      HasManyObservableTest.new,
+                                                                      HasManyObservableTest.new])}
+  let(:observer2) { ObserverTest.create }
+  let(:belongs_to_observable) {BelongsToObservableTest.new(:observer_test => observer1)}
+  let(:collection_observable) {CollectionObservableTest.create(:observer_tests => [observer1, observer2])}
+  let(:polymorphic_observable) {PolymorphicHasManyObservableTest.create(:observer => observer2)}
+  describe "observer_methods" do
+    let(:observer) {ObserverObserverTest.new}
+    it "should be available" do
+      observer.should be_observer
+      observer.should_not be_observable
+    end
+  end
+
+  describe "observable_methods" do
+    let(:observable){BelongsToObservableTest.new}
+    it "should be available" do
+      observable.should_not be_observer
+      observable.should be_observable
+    end
+  end
+
+  describe "when the belongs to observable is updated" do
+    before(:each) do
+      belongs_to_observable.update_attributes(:name => "doof")
+    end
+    it "should update its observer" do
+      belongs_to_observable.name.should == "doof"
+      observer1.reload.should be_updated
+      observer1.should_not be_deleted
+    end
+  end
+  # TODO: currently failing spec; after_destroy not being triggered in rspec: investigate further
+  pending "when the belongs to observable is deleted" do
+    before(:each) do
+      observer1.belongs_to_observable_test.destroy
+    end
+    it "should destroy its observer" do
+      observer1.reload.should be_deleted
+    end
+  end
+  describe "when the observable hides itself" do
+    before(:each) do
+      observer1.update_column(:updated, nil)
+      belongs_to_observable.unobservable!
+      belongs_to_observable.update_attributes(:name => "doof")
+    end
+    it "should not update its observer" do
+      observer1.belongs_to_observable_test.name.should == "doof"
+      observer1.reload.should_not be_updated
+    end
+  end
+  describe "when the has one observable is updated" do
+    before(:each) do
+      observer1.has_one_observable_test.update_attributes(:name => "doof")
+    end
+    it "should update its observer" do
+      observer1.has_one_observable_test.name.should == "doof"
+      observer1.reload.should be_updated
+      observer1.should_not be_deleted
+    end
+  end
+  describe "when one of the has many observables is updated" do
+    before(:each) do
+      observer1.has_many_observable_tests.first.update_attributes(:name => "doof")
+    end
+    it "should update its observer" do
+      observer1.has_many_observable_tests.first.name.should == "doof"
+      observer1.reload.should be_updated
+      observer1.should_not be_deleted
+    end
+    describe "and afterwards deleted" do
+      before(:each) do
+        observer1.update_column(:deleted, false)
+        observer1.has_many_observable_tests.first.destroy
+      end
+      it "should update its observer" do
+        observer1.reload.should be_deleted
+      end
+    end
+  end
+  describe "when one of the polymorphic has many is updated" do
+    before(:each) do
+      observer1.polymorphic_has_many_observable_tests = [PolymorphicHasManyObservableTest.new,
+                                                         PolymorphicHasManyObservableTest.new,
+                                                         PolymorphicHasManyObservableTest.new]
+      observer1.update_column(:updated, false)
+      observer1.reload
+    end
+    it "should update its observer" do
+      observer1.polymorphic_has_many_observable_tests.first.update_attributes(:name => "doof")
+      observer1.polymorphic_has_many_observable_tests.first.name.should == "doof"
+      observer1.reload.should be_updated
+      observer1.should_not be_deleted
+    end
+    describe "having another polymorphic observable of same type somewhere else" do
+      before(:each) do
+        observer2.update_column(:updated, false)
+      end
+      it "should not update its observer" do
+        observer1.polymorphic_has_many_observable_tests.first.update_attributes(:name => "doof")
+        observer1.polymorphic_has_many_observable_tests.first.name.should == "doof"
+        observer1.reload.should be_updated
+        observer1.should_not be_deleted
+        observer2.reload.should_not be_updated
+        observer2.should_not be_deleted
+      end
+    end
+  end
+  describe "when the has many through has been updated" do
+    before(:each) do
+      observer1.has_many_observable_tests.first.has_many_through_observable_tests.create
+      observer1.update_column(:updated, false)
+    end
+    it "should update its observer" do
+      observer1.has_many_observable_tests.first.has_many_through_observable_tests.first.update_attributes(:name => "doof")
+      observer1.has_many_observable_tests.first.has_many_through_observable_tests.first.name.should == "doof"
+      observer1.reload.should be_updated
+      observer1.should_not be_deleted
+    end
+  end
+  describe "when an has and belongs to many association" do
+    describe "has been created" do
+      before(:each) do
+        observer1.update_column(:updated, false)
+        observer1.habtm_observable_tests.create(:name => "doof")
+      end
+      it "should update its observer" do
+        observer1.habtm_observable_tests.first.name.should == "doof"
+        observer1.reload.should be_updated
+        observer1.should_not be_deleted
+      end
+      describe "and then updated" do
+        before(:each) do
+          observer1.update_column(:updated, false)
+          observer1.habtm_observable_tests.first.update_attributes(:name => "superdoof")
+        end
+        it "should update its observer" do
+          observer1.habtm_observable_tests.first.name.should == "superdoof"
+          observer1.reload.should be_updated
+          observer1.should_not be_deleted
+        end
+      end
+      describe "and afterwards deleted" do
+        before(:each) do
+          observer1.update_column(:deleted, false)
+          observer1.habtm_observable_tests.delete(observer1.habtm_observable_tests.first)
+        end
+        it "should update its observer" do
+          observer1.reload.should be_deleted
+        end
+      end
+      describe "and completely replaced" do
+        before(:each) do
+          observer1.update_column(:updated, false)
+          observer1.update_column(:deleted, false)
+          observer1.habtm_observable_tests = [HabtmObservableTest.new]
+        end
+        it "should update and delete the observer" do
+          observer1.reload.should be_updated
+          observer1.reload.should be_deleted
+        end
+      end
+
+    end
+    describe "has been linked from an existing assoc" do
+      before(:each) do
+        t = HabtmObservableTest.create(:name => "doof")
+        observer1.habtm_observable_tests << t
+        observer1.update_column(:updated, false)
+        observer1.habtm_observable_tests.first.update_attributes(:name => "superdoof")
+      end
+      it "should update its observer" do
+        observer1.habtm_observable_tests.first.name.should == "superdoof"
+        observer1.reload.should be_updated
+        observer1.should_not be_deleted
+      end
+      describe "and afterwards deleted" do
+        before(:each) do
+          observer1.update_column(:deleted, false)
+          observer1.habtm_observable_tests.delete(observer1.habtm_observable_tests.first)
+        end
+        it "should update its observer" do
+          observer1.reload.should be_deleted
+        end
+      end
+
+    end
+  end
+  describe "when the collection observable is updated" do
+    before(:each) do
+      collection_observable.update_attributes(:name => "doof")
+    end
+    it "should update its observers" do
+      collection_observable.name.should == "doof"
+      observer1.reload.should be_updated
+      observer1.should_not be_deleted
+      observer2.reload.should be_updated
+      observer2.should_not be_deleted
+    end
+  end
+
+  describe "when the observer has an observer itself" do
+    let(:observer_observer) { ObserverObserverTest.create }
+    before(:each) do
+      observer1.update_attribute(:observer_observer_test, observer_observer)
+    end
+    describe "when the belongs to observable is updated" do
+      before(:each) do
+        belongs_to_observable.update_attributes(:name => "doof")
+      end
+      it "should update its observer and its observer's observer" do
+        belongs_to_observable.name.should == "doof"
+        observer1.reload.should be_updated
+        observer_observer.reload.should be_updated
+      end
+    end
+    describe "when the has one observable is updated" do
+      before(:each) do
+        observer_observer.observer_test.has_one_observable_test.update_attributes(:name => "doof")
+      end
+      it "should update its observer and its observer's observer" do
+        observer_observer.observer_test.has_one_observable_test.name.should == "doof"
+        observer1.reload.should be_updated
+        observer_observer.reload.should be_updated
+      end
+    end
+    describe "when one of the has many observables is updated" do
+      before(:each) do
+        observer_observer.observer_test.has_many_observable_tests.first.update_attributes(:name => "doof")
+      end
+      it "should update its observer and its observer's observer" do
+        observer_observer.observer_test.has_many_observable_tests.first.name.should == "doof"
+        observer1.reload.should be_updated
+        observer_observer.reload.should be_updated
+      end
+    end
+    describe "when one of the polymorphic has many is updated" do
+      before(:each) do
+        observer1.polymorphic_has_many_observable_tests = [PolymorphicHasManyObservableTest.new,
+                                                           PolymorphicHasManyObservableTest.new,
+                                                           PolymorphicHasManyObservableTest.new]
+        observer1.update_column(:updated, false)
+        observer_observer.update_column(:updated, false)
+      end
+      it "should update its observer" do
+        observer_observer.observer_test.polymorphic_has_many_observable_tests.first.update_attributes(:name => "doof")
+        observer_observer.observer_test.polymorphic_has_many_observable_tests.first.name.should == "doof"
+        observer1.reload.should be_updated
+        observer_observer.reload.should be_updated
+      end
+    end
+    describe "when the has many through has been updated" do
+      before(:each) do
+        observer1.has_many_observable_tests.first.has_many_through_observable_tests.create
+        observer1.update_column(:updated, false)
+        observer_observer.update_column(:updated, false)
+      end
+      it "should update its observer" do
+        observer1.has_many_observable_tests.first.has_many_through_observable_tests.first.update_attributes(:name => "doof")
+        observer1.has_many_observable_tests.first.has_many_through_observable_tests.first.name.should == "doof"
+        observer1.reload.should be_updated
+        observer_observer.reload.should be_updated
+      end
+    end
+    describe "when the collection observable is updated" do
+      before(:each) do
+        collection_observable
+        observer_observer.observer_test.reload.collection_observable_test.update_attributes(:name => "doof")
+      end
+      it "should update its observers and its observer's observer" do
+        observer_observer.observer_test.collection_observable_test.name.should == "doof"
+        observer1.reload.should be_updated
+        observer_observer.reload.should be_updated
+      end
+    end
+  end
+
+
+  describe "when the association is polymorphic" do
+    class HasOnePolymorphicObservableTest < ObservableAbstractTest
+      self.table_name ='association_polymorphic_observable_tests'
+      belongs_to :observer, :polymorphic => true
+      attr_accessible :observer
+    end
+
+    class ObserverTest < ObserverAbstractTest
+      has_one :has_one_polymorphic_observable_test, :as => :observer
+      attr_accessible :has_one_polymorphic_observable_test
+      observes :has_one_polymorphic_observable_test, :as => :observer, :notifiers => :test_update, :on => :update
+    end
+
+    class OtherPossibleObserverTest < ActiveRecord::Base # Why Active::Record? The association klass is the base class
+      self.table_name = 'association_observer_tests'
+      attr_accessible :updated, :deleted
+      has_one :has_one_polymorphic_observable_test, :as => :observer
+      attr_accessible :has_one_polymorphic_observable_test
+      # does not define observables, therefore should not observe
+    end
+
+    ActiveRecord::Schema.define do
+      create_table :association_polymorphic_observable_tests, :force => true do |t|
+        t.column :observer_id, :integer
+        t.column :observer_type, :string
+        t.column :name, :string
+      end
+    end
+    let(:polymorphic_observable) { HasOnePolymorphicObservableTest.create(:observer => ObserverTest.new) }
+    let(:observer) {polymorphic_observable.observer}
+    before(:each) do
+      observer.update_column(:updated, nil)
+    end
+    describe "when the has one association is updated" do
+      before(:each) do
+        polymorphic_observable.update_attributes(:name => "doof")
+      end
+      it "should update its observer" do
+        polymorphic_observable.name.should == "doof"
+        observer.reload.should be_updated
+      end
+    end
+    describe "when the observable is not observed" do
+      let(:other_polymorphic_observable) { HasOnePolymorphicObservableTest.create(:observer => OtherPossibleObserverTest.new) }
+      let(:non_observer){ other_polymorphic_observable.observer }
+      describe " and the observable is updated" do
+        before(:each) do
+          other_polymorphic_observable.update_attributes(:name => "doof")
+        end
+        it "should not update its (non) observer" do
+          other_polymorphic_observable.name.should == "doof"
+          non_observer.reload.should_not be_updated
+        end
+      end
+    end
+
+  end
+
+  describe "when the association is a joined through" do
+    class HasOneThroughObservableTest < ObservableAbstractTest
+      self.table_name ='association_polymorphic_observable_tests'
+      belongs_to :has_one_observable_test
+      has_one :observer_test, :through => :has_one_observable_test
+      attr_accessible :has_one_observable_test
+    end
+
+    class HasOneObservableTest < ObservableAbstractTest
+      has_one :has_one_through_observable_test
+      attr_accessible :has_one_through_observable_test
+    end
+
+    class ObserverTest < ObserverAbstractTest
+      has_one :has_one_through_observable_test, :through => :has_one_observable_test
+      attr_accessible :has_one_through_observable_test
+      observes :has_one_through_observable_test, :notifiers => :test_update, :on => :update
+    end
+
+    ActiveRecord::Schema.define do
+      add_column :association_polymorphic_observable_tests, :has_one_observable_test_id, :integer
+    end
+
+    let(:through_observable) { HasOneThroughObservableTest.create(:has_one_observable_test => HasOneObservableTest.new(:observer_test => ObserverTest.new)) }
+    let(:observer) {through_observable.has_one_observable_test.observer_test}
+    describe "when the has one association is updated" do
+      before(:each) do
+        observer.update_attributes(:updated => nil)
+        through_observable.reload
+        through_observable.update_attributes(:name => "doof")
+      end
+      it "should update its observer" do
+        through_observable.name.should == "doof"
+        observer.reload.should be_updated
+      end
+    end
+
+  end
+
+  # TODO: should this be responsibility of the associations or from the observers? check further into this
+  pending "when an observable also observes its observer" do
+    ActiveRecord::Schema.define do
+      add_column :association_observable_tests, :successful, :boolean
+    end
+    before(:all) do
+      class HasOneObservableTest < ObservableAbstractTest
+        observes :observer_test, :notifiers => :test_update, :on => :update
+      end
+    end
+    describe "when something changes on the observable" do
+      before(:each) do
+        observer1.has_one_observable_test.update_attributes(:name => "doof")
+      end
+      it "should update only the observer (and therefore avoid infinite cycle)" do
+        observer1.has_one_observable_test.name.should == "doof"
+        observer1.reload.should be_updated
+      end
+    end
+  end
+
+end