Use ActiveRecord pattern for observers

Define own subclass of ActiveModel::Observer that takes care of hooking
into models and inheritance. As well as being a seemingly cleaner
separation of concerns, this allows us to handle single-columnfamily
inheritance properly in the context of observers.

Gets rid of Cequel::Model::Observing mixin -- functionality is defined
instead on Cequel::Model::Observer.

lib/cequel/model.rb

@@ -12,7 +12,7 @@
 require 'cequel/model/local_association'
 require 'cequel/model/mass_assignment_security'
 require 'cequel/model/naming'
-require 'cequel/model/observing'
+require 'cequel/model/observer'
 require 'cequel/model/persistence'
 require 'cequel/model/properties'
 require 'cequel/model/remote_association'
@@ -34,6 +34,7 @@ module Cequel
   module Model
 
     extend ActiveSupport::Concern
+    extend ActiveModel::Observing::ClassMethods
 
     included do
       @_cequel = ClassInternals.new(self)
@@ -44,7 +45,7 @@ module Model
       include Naming
       include Callbacks
       include Validations
-      include Observing
+      include ActiveModel::Observing
       include Dirty
       include MassAssignmentSecurity
       include Associations

lib/cequel/model/callbacks.rb

@@ -6,9 +6,13 @@ module Callbacks
 
       extend ActiveSupport::Concern
 
+      HOOKS = [:save, :create, :update, :destroy, :validation]
+      CALLBACKS = HOOKS.map { |hook| [:"before_#{hook}", :"after_#{hook}"] }.
+        flatten
+
       included do
         extend ActiveModel::Callbacks
-        define_model_callbacks :save, :create, :update, :destroy
+        define_model_callbacks *HOOKS
       end
 
       def save(*args)

lib/cequel/model/inheritable.rb

@@ -24,6 +24,7 @@ def initialize(*args, &block)
       end
 
       def inherited(subclass)
+        super
         unless @_cequel.type_column
           raise ArgumentError,
             "Can't subclass model class that does not define a type column"

lib/cequel/model/observer.rb

@@ -0,0 +1,42 @@
+module Cequel
+
+  module Model
+
+    # 
+    # This is ripped directly off of ActiveRecord::Observer
+    #
+    class Observer < ActiveModel::Observer
+
+      protected
+
+      def observed_classes
+        klasses = super
+        klasses + klasses.map { |klass| klass.descendants }.flatten
+      end
+
+      def add_observer!(klass)
+        super
+        define_callbacks klass
+      end
+
+      def define_callbacks(klass)
+        observer = self
+        observer_name = observer.class.name.underscore.gsub('/', '__')
+
+        Cequel::Model::Callbacks::CALLBACKS.each do |callback|
+          next unless respond_to?(callback)
+          callback_meth = :"_notify_#{observer_name}_for_#{callback}"
+          unless klass.respond_to?(callback_meth)
+            klass.send(:define_method, callback_meth) do |&block|
+              observer.update(callback, self, &block)
+            end
+            klass.send(callback, callback_meth)
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

lib/cequel/model/validations.rb

@@ -8,7 +8,6 @@ module Validations
 
       included do
         include ActiveModel::Validations
-        define_model_callbacks :validation
         alias_method_chain :valid?, :callbacks # XXX is there no better way?
       end
 

spec/examples/model/observing_spec.rb → spec/examples/model/observer_spec.rb

@@ -1,8 +1,8 @@
 require File.expand_path('../spec_helper', __FILE__)
 
-describe Cequel::Model::Observing do
+describe Cequel::Model::Observer do
   before do
-    Cequel::Model.observers = [:post_observer]
+    Cequel::Model.observers = [:post_observer, :asset_observer]
     Cequel::Model.instantiate_observers
   end
 
@@ -74,4 +74,13 @@
 
     it_should_behave_like 'observing callbacks', :before_validation, :after_validation
   end
+
+  context 'with inheritence' do
+    it 'should observe subclass' do
+      connection.stub(:execute).
+        with("INSERT INTO assets (id, label, class_name) VALUES (1, 'Cequel', 'Photo')")
+      photo = Photo.create!(:id => 1, :label => 'Cequel')
+      photo.should have_observed(:before_save)
+    end
+  end
 end

spec/models/asset.rb

@@ -1,7 +1,18 @@
 class Asset
+
   include Cequel::Model
 
   key :id, :integer
   column :class_name, :ascii
   column :label, :varchar
+
+  def observed!(callback)
+    @observed ||= []
+    @observed << callback
+  end
+
+  def has_observed?(callback)
+    @observed.include?(callback)
+  end
+
 end

spec/models/asset_observer.rb

@@ -0,0 +1,5 @@
+class AssetObserver < Cequel::Model::Observer
+  def before_save(asset)
+    asset.observed!(:before_save)
+  end
+end

spec/models/post_observer.rb

@@ -1,4 +1,4 @@
-class PostObserver < ActiveModel::Observer
+class PostObserver < Cequel::Model::Observer
 
   def before_create(post)
     post.observed!(:before_create)