association_observers 0.0.3 → 0.0.4

data/.travis.yml

@@ -9,6 +9,6 @@ rvm:
   - 1.9.3
   - jruby
   - rbx
-script: bundle exec rspec spec
+script: bundle exec rake spec
 before_script:
   - mysql -e 'create database association_observers;'

data/Gemfile

@@ -6,9 +6,12 @@ group :development do
 end
 
 gem 'activerecord'
+gem 'datamapper'
+gem 'dm-mysql-adapter'
 
 platforms :ruby do
   gem 'mysql2'
+
 end
 
 

data/README.md

@@ -1,11 +1,11 @@
 # AssociationObservers
 
-This is an alternative implementation of the observer pattern. As you may know, Ruby (and Rails/ActiveRecord) already have an
+This is an alternative implementation of the observer pattern. As you may know, Ruby (and Rails/ActiveRecord, and DataMapper) already have an
 implementation of it. This implementation is a variation of the pattern, so it is not supposed to supersede the existing
 implementations, but "complete" them for the specific use-cases addressed.
 
 [![Build Status](https://travis-ci.org/TiagoCardoso1983/association_observers.png?branch=master)](https://travis-ci.org/TiagoCardoso1983/association_observers)
-
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/TiagoCardoso1983/association_observers)
 
 ## Comparison with the Observer Pattern
 
@@ -26,6 +26,9 @@ functionality)
 Observers there are external entities which observe models. They don't exactly work as links between two models, just
 extract functionality (callbacks) which would otherwise flood the model. For that, they're great. For the rest, not really.
 
+## Comparison with DataMapper Observers
+
+Currently doesn't support callbacks on collections (even though it supports observation for any method, cool!)
 
 ### Installation
 
@@ -189,12 +192,19 @@ the ObserverMethods and the ObservableMethods, which will be included in the res
 
 ### TODOs
 
-* Support for other ORM's (currently only supporting ActiveRecord)
+* Support for other ORM's (currently supporting ActiveRecord and DataMapper)
 * Support for other Message Queue libraries (only supporting DelayedJob, rescue, everything that "#delay"s)
 * Action routine definition on the "#observes" declaration (sometimes one does not need the overhead of writing a notifier)
-* Observe method calls (currently only observing model callbacks)
 * Overall spec readability
 
+* ActiveRecord: Observe method calls (currently only observing model callbacks)
+* DataMapper: Support Many-to-Many collection observation (currently ignoring)
+
+## STATUS
+
+* Support for ActiveRecord
+* Support for DataMapper
+
 ### Rails
 
 The observer models have to be eager-loaded for the observer/observable behaviour to be extended in the respective associations.

data/Rakefile

@@ -1,3 +1,22 @@
 require "bundler/gem_tasks"
 
-task :default do ;; end
+task :default do ;; end
+
+require 'rspec/core/rake_task'
+
+
+RSpec::Core::RakeTask.new(:active_record_spec) do |t|
+  t.rspec_opts = ['--options', "\"./.rspec\""]
+  t.pattern   = "spec/activerecord/*_spec.rb"
+end
+
+RSpec::Core::RakeTask.new(:data_mapper_spec) do |t|
+  t.rspec_opts = ['--options', "\"./.rspec\""]
+  t.pattern   = "spec/datamapper/*_spec.rb"
+end
+
+task :spec do |t|
+  Rake::Task["active_record_spec"].invoke rescue (failed = true)
+  Rake::Task["data_mapper_spec"].invoke rescue (failed = true)
+  raise "failed" if failed
+end

data/association_observers.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |gem|
   gem.name          = "association_observers"
   gem.version       = AssociationObservers::VERSION
   gem.authors       = ["Tiago Cardoso"]
-  gem.email         = ["tiago@restorm.com"]
+  gem.email         = ["cardoso_tiago@hotmail.com"]
   gem.description   = %q{This is an alternative implementation of the observer pattern. As you may know, Ruby (and Rails/ActiveRecord) already have an
   implementation of it. This implementation is a variation of the pattern, so it is not supposed to supersede the existing
   implementations, but "complete" them for the specific use-cases addressed.}
@@ -32,4 +32,6 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency("pry")
   gem.add_development_dependency("pry-doc")
   gem.add_development_dependency("awesome_print")
+
+  gem.add_dependency("activesupport")
 end

data/database.yml

@@ -2,4 +2,13 @@ activerecord:
   adapter: mysql2
   encoding: utf8
   username: root
-  database: association_observers
+  database: association_observers
+
+
+datamapper:
+  adapter: mysql
+  user: root
+  password:
+  database: association_observers
+  host: 127.0.0.1
+  port: 3306

data/lib/association_observers.rb

@@ -4,6 +4,8 @@ require "association_observers/notifiers/base"
 require "association_observers/notifiers/propagation_notifier"
 
 require "association_observers/ruby18" if RUBY_VERSION < "1.9"
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/string/inflections"
 
 # Here it is defined the basic behaviour of how observer/observable model associations are set. There are here three
 # main roles defined: The observer associations, the observable associations, and the notifiers (the real observers).
@@ -22,18 +24,41 @@ require "association_observers/ruby18" if RUBY_VERSION < "1.9"
 #
 # @author Tiago Cardoso
 module AssociationObservers
-  # translation of AR callbacks to collection callbacks; we want to ignore the update on collections because neither
-  # add nor remove shall be considered an update event in the observables
-  # @example
-  #   class RichMan < ActiveRecord::Base
-  #     has_many :cars
-  #     observes :cars, :on => :update
-  #     ...
-  #   end
-  #
-  #   in this example, for instance, the rich man wants only to be notified when the cars are update, not when he
-  #   gets a new one or when one of them goes to the dumpster
-  COLLECTION_CALLBACKS_MAPPER = {:create => :add, :save => :add, :destroy => :remove}
+
+  # @abstract
+  # @return [Symbol] ORM instance method name which checks whether the record is a new instance
+  def self.check_new_record_method
+    raise "should be defined in an adapter for the used ORM"
+  end
+
+  # @abstract
+  # @return [Symbol] ORM collection method name to get the model of its children
+  def self.fetch_model_from_collection
+    raise "should be defined in an adapter for the used ORM"
+  end
+
+  # @abstract
+  # implementation of an ORM-specifc batched each enumerator on a collection
+  def self.batched_each(collection, batch, &block)
+    raise "should be defined in an adapter for the used ORM"
+  end
+
+  # @abstract
+  # checks the parameters received by the observer DSL call, handles unexpected input according by triggering exceptions,
+  # warnings, deprecation messages
+  # @param [Class] observer the observer class
+  # @param [Array] observable_associations collection of the names of associations on the observer which will be observed
+  # @param [Array] notifier_classes collection of the notifiers for the observation
+  # @param [Array] observer_callbacks collection of the callbacks/methods to be observed
+  def self.validate_parameters(observer, observable_associations, notifier_classes, observer_callbacks)
+    raise "should be defined in an adapter for the used ORM"
+  end
+
+
+  def self.included(model)
+    model.extend ClassMethods
+    model.send :include, InstanceMethods
+  end
 
   # Methods to be added to observer associations
   module IsObserverMethods
@@ -41,15 +66,77 @@ module AssociationObservers
 
     module ClassMethods
       def observer? ; true ; end
+
+      private
+
+      # @abstract
+      # includes modules in the observer model
+      def observer_extensions ; ; end
+
+
+      # @param [Array] association_names collection  of association names
+      # @return [Array] a collection of association class/options pairs
+      def get_association_options_pairs(association_names)
+        raise "should be defined in an adapter for the used ORM"
+      end
+
+      # @param [Array] associations collection of association names
+      # @return [Array] the collection of associations which match collection associations
+      def filter_collection_associations(associations)
+        raise "should be defined in an adapter for the used ORM"
+      end
+
+
+      # given a collection of callbacks, it defines a private routine for each of them; this subroutine will notify the observers
+      # which look on the callback the subroutine it is addressed to
+      # @param [Array] callbacks a collection of callbacks as understood by the observers (:create, :update, :update, :destroy)
+      # @param [Array] notifiers a collection of notifier classes
+      # @return [Array] a collection of callback/sob-routine pairs
+      def define_collection_callback_routines(callbacks, notifiers)
+        raise "should be defined in an adapter for the used ORM"
+      end
+
+      # given a set of collection associations and a collection of callback/method_name pairs, it redefines the association
+      # setting the respective callback routines for each of them
+      # @param [Array] associations a collection of plural association names
+      # @param [Hash, Array] callback_procs a collection of callback/method_name pairs
+      def redefine_collection_associations_with_collection_callbacks(associations, callback_procs)
+        raise "should be defined in an adapter for the used ORM"
+      end
     end
   end
 
   # Methods to be added to observable associations
   module IsObservableMethods
-    def self.included(base) ; base.extend(ClassMethods) ; end
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
     module ClassMethods
       def observable? ; true ; end
+
+      private
+
+      # @abstract
+      # includes modules in the observable model
+      def observable_extensions ; ; end
+
+      # @abstract
+      # loads the notifiers and observers for this observable class
+      # @param [Array] notifiers notifiers to be included
+      # @param [Array] callbacks collection of callbacks/methods to be observed
+      # @param [Class] observer_class class of the observer
+      # @param [Symbol] association_name name by which this observable is known in the observer
+      def set_observers(notifiers, callbacks, observer_class, association_name)
+        raise "should be defined in an adapter for the used ORM"
+      end
+
+      # @abstract
+      # sets the triggering by callbacks of the notification
+      # @param [Array] callbacks callbacks which will be observed and trigger notification behaviour
+      def set_notification_on_callbacks(callbacks)
+        raise "should be defined in an adapter for the used ORM"
+      end
     end
 
     def unobservable! ; @unobservable = true ; end
@@ -85,17 +172,23 @@ module AssociationObservers
       opts = args.extract_options!
       observer_class = self
 
-      plural_associations = args.select{ |arg| self.reflections[arg].collection? }
+
+      # standard observer association methods
+      include IsObserverMethods
+
+      observer_extensions
+
+      plural_associations = filter_collection_associations(args)
 
       association_name = (opts[:as] || self.name.demodulize.underscore).to_s
       notifier_classes = Array(opts[:notifiers] || opts[:notifier]).map{|notifier| notifier.to_s.end_with?("_notifier") ? notifier : "#{notifier}_notifier".to_s }
       observer_callbacks = Array(opts[:on] || [:save, :destroy])
 
       # no observer, how are you supposed to observe?
-      raise "Invalid callback; possible options: :create, :update, :save, :destroy" unless observer_callbacks.all?{|o|[:create,:update,:save,:destroy].include?(o.to_sym)}
+      AssociationObservers::validate_parameters(self, args, notifier_classes, observer_callbacks)
+
+
 
-      # standard observer association methods
-      include IsObserverMethods
 
       notifier_classes.map!{|notifier_class|notifier_class.to_s.classify.constantize} << PropagationNotifier
 
@@ -105,42 +198,20 @@ module AssociationObservers
       end
 
       # 1: for each observed association, define behaviour
-      self.reflect_on_all_associations.select{ |r| args.include?(r.name) }.map{|r| [r.klass, r.options] }.each do |klass, options|
+      get_association_options_pairs(args).each do |klass, options|
         klass.instance_eval do
 
-          include ActiveModel::Observing
-
-          # load observers from this observable association
-          observer_association_name = (options[:as] || association_name).to_s
-          notifier_classes.each do |notifier_class|
-            observer_callbacks.each do |callback|
-              options = {}
-              observer_association = self.reflect_on_association(observer_association_name.to_sym) ||
-                                     self.reflect_on_association(observer_association_name.pluralize.to_sym)
-              options[:observer_class] = observer_class.base_class if observer_association.options[:polymorphic]
-
-              self.add_observer notifier_class.new(callback, observer_association.name, options)
-              include "#{notifier_class.name}::ObservableMethods".constantize if notifier_class.constants.map(&:to_sym).include?(:ObservableMethods)
-            end
-          end
+          include IsObservableMethods
 
-          # sets the callbacks to inform observers
-          observer_callbacks.each do |callback|
-            if [:create, :update].include?(callback)
-              real_callback = :save
-              callback_opts = {:on => callback}
-            else
-              real_callback = callback
-              callback_opts = {}
-            end
-            send("after_#{real_callback}", callback_opts) do
-              notify! callback
-            end
-          end
+          observable_extensions
 
           attr_reader :unobservable
 
-          include IsObservableMethods
+          # load observers from this observable association
+          set_observers(notifier_classes, observer_callbacks, observer_class, (options[:as] || association_name).to_s)
+
+          # sets the callbacks to inform observers
+          set_notification_on_callbacks(observer_callbacks)
         end
 
       end
@@ -148,45 +219,8 @@ module AssociationObservers
       # 2. for each collection association, insert after add and after remove callbacks
 
       # first step is defining the methods which will be called by the collection callbacks.
-      callback_procs = observer_callbacks.map do |callback|
-        notifier_classes.map do |notifier_class|
-          routine_name = :"__observer_#{callback}_callback_for_#{notifier_class.name.demodulize.underscore}__"
-          class_eval <<-END
-            def #{routine_name}(element)
-              callback = element.class.observer_instances.detect do |notifier|
-                notifier.class.name == '#{notifier_class}' and notifier.callback == :#{callback}
-              end
-              callback.notify(element, [self]) unless callback.nil?
-            end
-            private :#{routine_name}
-          END
-          [callback, routine_name]
-        end
-      end.flatten(1)
-
       # second step is redefining the associations with the proper callbacks to be triggered
-      plural_associations.each do |assoc|
-        a = self.reflect_on_association(assoc)
-        callbacks = Hash[callback_procs.group_by{|code, proc| COLLECTION_CALLBACKS_MAPPER[code] }.reject{|k, v| k.nil? }.map{ |code, val| [:"after_#{code}", val.map(&:last)] }]
-        next if callbacks.empty?
-        # this snippet takes care that the array of callbacks which will get inserted in the association will not
-        # overwrite whatever callbacks you may have already defined
-        callbacks.each do |callback, procs|
-          callbacks[callback] += Array(a.options[callback])
-        end
-
-        if RUBY_VERSION < "1.9"
-          assoc_options = AssociationObservers::extended_to_s(a.options)
-          callback_options = AssociationObservers::extended_to_s(callbacks)
-        else
-          assoc_options = a.options.to_s
-          callback_options = callbacks
-        end
-
-        class_eval <<-END
-          #{a.macro} :#{assoc}, #{assoc_options}.merge(#{callback_options})
-        END
-      end
+      redefine_collection_associations_with_collection_callbacks(plural_associations, define_collection_callback_routines(observer_callbacks, notifier_classes))
 
     end
   end
@@ -195,5 +229,6 @@ end
 if defined?(Rails::Railtie) # RAILS
   require 'association_observers/railtie'
 else
-  require 'association_observers/activerecord'
+  require 'association_observers/activerecord' if defined?(ActiveRecord)
+  require 'association_observers/datamapper' if defined?(DataMapper)
 end

data/lib/association_observers/activerecord.rb

@@ -1,4 +1,135 @@
+# -*- encoding : utf-8 -*-
 if defined?(ActiveRecord)
-  ActiveRecord::Base.send(:extend, AssociationObservers::ClassMethods)
-  ActiveRecord::Base.send(:include, AssociationObservers::InstanceMethods)
+
+  module AssociationObservers
+    def self.check_new_record_method
+      :new_record?
+    end
+
+    def self.fetch_model_from_collection
+      :klass
+    end
+
+    def self.batched_each(collection, batch, &block)
+      collection.find_each(:batch_size => batch, &block)
+    end
+
+    def self.validate_parameters(observer, observable_associations, notifier_names, callbacks)
+      raise "Invalid callback; possible options: :create, :update, :save, :destroy" unless callbacks.all?{|o|[:create,:update,:save,:destroy].include?(o.to_sym)}
+    end
+
+    # translation of AR callbacks to collection callbacks; we want to ignore the update on collections because neither
+    # add nor remove shall be considered an update event in the observables
+    # @example
+    #   class RichMan < ActiveRecord::Base
+    #     has_many :cars
+    #     observes :cars, :on => :update
+    #     ...
+    #   end
+    #
+    #   in this example, for instance, the rich man wants only to be notified when the cars are update, not when he
+    #   gets a new one or when one of them goes to the dumpster
+    COLLECTION_CALLBACKS_MAPPER = {:create => :add, :save => :add, :destroy => :remove}
+
+    module IsObservableMethods
+      module ClassMethods
+
+        private
+
+        def set_observers(notifiers, callbacks, observer_class, association_name)
+          notifiers.each do |notifier|
+            callbacks.each do |callback|
+              options = {}
+              observer_association = self.reflect_on_association(association_name.to_sym) ||
+                                     self.reflect_on_association(association_name.pluralize.to_sym)
+              options[:observer_class] = observer_class.base_class if observer_association.options[:polymorphic]
+
+              self.add_observer notifier.new(callback, observer_association.name, options)
+              include "#{notifier.name}::ObservableMethods".constantize if notifier.constants.map(&:to_sym).include?(:ObservableMethods)
+            end
+          end
+        end
+
+        def set_notification_on_callbacks(callbacks)
+          callbacks.each do |callback|
+            if [:create, :update].include?(callback)
+              real_callback = :save
+              callback_opts = {:on => callback}
+            else
+              real_callback = callback
+              callback_opts = {}
+            end
+            send("after_#{real_callback}", callback_opts) do
+              notify! callback
+            end
+          end
+        end
+      end
+    end
+
+    module IsObserverMethods
+
+      module ClassMethods
+
+        private
+
+        def get_association_options_pairs(association_names)
+          reflect_on_all_associations.select{ |r| association_names.include?(r.name) }.map{|r| [r.klass, r.options] }
+        end
+
+        def filter_collection_associations(associations)
+          associations.select{ |arg| self.reflections[arg].collection? }
+        end
+
+        def define_collection_callback_routines(callbacks, notifiers)
+          callbacks.map do |callback|
+            notifiers.map do |notifier|
+              routine_name = :"__observer_#{callback}_callback_for_#{notifier.name.demodulize.underscore}__"
+              class_eval <<-END
+                def #{routine_name}(element)
+                  callback = element.class.observer_instances.detect do |notifier|
+                    notifier.class.name == '#{notifier}' and notifier.callback == :#{callback}
+                  end
+                  callback.notify(element, [self]) unless callback.nil?
+                end
+                private :#{routine_name}
+              END
+              [callback, routine_name]
+            end
+          end.flatten(1)
+        end
+
+        def redefine_collection_associations_with_collection_callbacks(associations, callback_procs)
+          associations.each do |assoc|
+            a = self.reflect_on_association(assoc)
+            callbacks = Hash[callback_procs.group_by{|code, proc| COLLECTION_CALLBACKS_MAPPER[code] }.reject{|k, v| k.nil? }.map{ |code, val| [:"after_#{code}", val.map(&:last)] }]
+            next if callbacks.empty? # no callbacks, no need to redefine association
+
+            # this snippet takes care that the array of callbacks which will get inserted in the association will not
+            # overwrite whatever callbacks you may have already defined
+            callbacks.each do |callback, procedures|
+              callbacks[callback] += Array(a.options[callback])
+            end
+
+            # bullshit ruby 1.8 can't stringify hashes, arrays, symbols nor strings correctly
+            if RUBY_VERSION < "1.9"
+              assoc_options = AssociationObservers::extended_to_s(a.options)
+              callback_options = AssociationObservers::extended_to_s(callbacks)
+            else
+              assoc_options = a.options.to_s
+              callback_options = callbacks
+            end
+
+            class_eval <<-END
+              #{a.macro} :#{assoc}, #{assoc_options}.merge(#{callback_options})
+            END
+          end
+        end
+      end
+    end
+  end
+
+
+
+  ActiveRecord::Base.send(:include, AssociationObservers)
 end

data/lib/association_observers/datamapper.rb

@@ -0,0 +1,113 @@
+# -*- encoding : utf-8 -*-
+if defined?(DataMapper)
+  module AssociationObservers
+    def self.check_new_record_method
+      :new?
+    end
+
+    def self.fetch_model_from_collection
+      :model
+    end
+
+    def self.batched_each(collection, batch, &block)
+      collection.each(&block) # datamapper batches already by 500 https://groups.google.com/forum/?fromgroups=#!searchin/datamapper/batches/datamapper/lAZWFN4TWAA/G1Gu-ams_QMJ
+    end
+
+    def self.validate_parameters(observer, observable_associations, notifier_names, callbacks)
+      observable_associations.each do |o|
+        if observer.relationships[o].is_a?(DataMapper::Associations::ManyToMany::Relationship)
+          warn "this gem does not currently support observation behaviour for many to many relationships"
+        end
+      end
+    end
+
+    module IsObservableMethods
+      def self.included(model)
+        model.extend(ClassMethods)
+        model.send :include, InstanceMethods
+      end
+
+      module ClassMethods
+        def notifiers
+          @notifiers ||= []
+        end
+        private
+
+        def set_observers(ntfs, callbacks, observer_class, association_name)
+          ntfs.each do |notifier|
+            callbacks.each do |callback|
+              options = {} # todo: use this for polymorphics
+              observer_association = self.relationships[association_name]||
+                                     self.relationships[association_name.pluralize]
+              notifiers << notifier.new(callback, observer_association.name, options)
+              include "#{notifier.name}::ObservableMethods".constantize if notifier.constants.map(&:to_sym).include?(:ObservableMethods)
+            end
+          end
+        end
+
+        def set_notification_on_callbacks(callbacks)
+          callbacks.each do |callback|
+            after callback do
+              notify! callback
+            end
+          end
+        end
+
+      end
+
+      module InstanceMethods
+
+
+        private
+
+
+        def notify_observers(callback)
+          self.class.notifiers.each{|notifier| notifier.update(callback, self)}
+        end
+      end
+    end
+
+    module IsObserverMethods
+
+      module ClassMethods
+
+        private
+
+        def observer_extensions
+          #include DataMapper::Observer
+        end
+
+        def get_association_options_pairs(association_names)
+          # TODO: find better way to figure out the class of the relationship entity
+          relationships.select{|r|association_names.include?(r.name)}.map{|r| [(r.is_a?(DataMapper::Associations::ManyToOne::Relationship) ? r.parent_model : r.child_model), r.options] }
+        end
+
+        def filter_collection_associations(associations)
+          associations.select{ |arg| self.relationships[arg].options[:max] == Infinity }
+        end
+
+        def define_collection_callback_routines(callbacks, notifiers)
+          callbacks
+        end
+
+        def redefine_collection_associations_with_collection_callbacks(associations, callbacks)
+          associations.each do |assoc|
+            callbacks.each do |callback|
+              relationship = relationships[assoc]
+              model_method = relationship.is_a?(DataMapper::Associations::ManyToOne::Relationship ) ?
+                             :parent_model :
+                             :child_model
+              relationship.send(model_method).after callback do
+                notify! callback
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+
+
+  DataMapper::Model.append_inclusions AssociationObservers
+end

data/lib/association_observers/notifiers/base.rb

@@ -58,7 +58,7 @@ module Notifier
     # @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|
+        AssociationObservers::batched_each(observers, 10) do |observer|
           yield(observable, observer) if conditions(observable, observer)
         end if conditions_many(observable, observers)
       end

data/lib/association_observers/notifiers/propagation_notifier.rb

@@ -5,12 +5,12 @@
 class PropagationNotifier < Notifier::Base
 
   def conditions(observable, observer) ; observer.observable? ; end
-  def conditions_many(observable, observers) ;  observers.klass.observable? ; end
+  def conditions_many(observable, observers) ; observers.send(AssociationObservers::fetch_model_from_collection).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)
+    (observer.send(AssociationObservers::check_new_record_method) or not observer.respond_to?(:delay)) ? observer.send(:notify_observers, callback) : observer.delay.notify_observers(callback)
   end
 
 end

data/lib/association_observers/railtie.rb

@@ -4,9 +4,12 @@ module AssociationObservers
     ActiveSupport.on_load :active_record do
       require 'association_observers/activerecord'
     end
+    ActiveSupport.on_load :data_mapper do
+      require 'association_observers/datamapper'
+    end
   end
   class Railtie < Rails::Railtie
-    initializer 'association_observers.insert_into_active_record' do
+    initializer 'association_observers.insert_into_orm' do
       AssociationObservers.initialize_railtie
     end
     initializer 'association_observers.autoload', :before => :set_autoload_paths do |app|

data/lib/association_observers/version.rb

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

data/spec/active_record_helper.rb

@@ -0,0 +1,5 @@
+# -*- encoding : utf-8 -*-
+require 'rubygems'
+require 'active_record'
+ActiveRecord::Base.configurations = YAML.load_file(File.join(File.expand_path('../..', __FILE__), 'database.yml'))
+ActiveRecord::Base.establish_connection("activerecord")

data/spec/activerecord/association_observers_spec.rb

@@ -1,6 +1,8 @@
 # -*- encoding : utf-8 -*-
+require "./spec/active_record_helper"
 require "./spec/spec_helper"
 
+
 describe AssociationObservers do
   class TestUpdateNotifier < Notifier::Base
 

data/spec/{examples → activerecord}/readme_example_spec.rb

@@ -1,4 +1,5 @@
 # -*- encoding : utf-8 -*-
+require "./spec/active_record_helper"
 require './spec/spec_helper'
 require 'examples/readme_example'
 

data/spec/datamapper/association_observers_spec.rb

@@ -0,0 +1,387 @@
+# -*- encoding : utf-8 -*-
+require "./spec/datamapper_helper"
+require "./spec/spec_helper"
+
+
+describe AssociationObservers do
+  class TestUpdateNotifier < Notifier::Base
+
+    def action(observable, observer)
+      if observer.dirty?
+        observer.updated = true
+      else
+        observer.update!(:updated => true)
+      end
+    end
+
+    def notify_many(observable, many_observers)
+      many_observers.each do |observers|
+        observers.update!(:updated => true)
+      end
+    end
+
+  end
+  
+  class TestDestroyNotifier < Notifier::Base
+
+    def action(observable, observer)
+      observer.update(:deleted => true)
+    end
+
+    def notify_many(observable, many_observers)
+      many_observers.each do |observers|
+        observers.each do |observer|
+          observer.update!(:deleted => true)
+        end
+      end
+    end
+
+  end
+  
+
+  class BelongsToObservableTest 
+    include DataMapper::Resource
+    property :id, Serial
+    property :name, String
+
+    has 1, :observer_test
+
+    def bang
+      "Bang"
+    end
+
+  end
+  class CollectionObservableTest 
+    include DataMapper::Resource
+    property :id, Serial
+    property :name, String
+
+    has n, :observer_tests
+  end
+  class HasOneObservableTest 
+    include DataMapper::Resource
+    property :id, Serial
+    property :name, String
+
+    belongs_to :observer_test, :required => false
+  end
+  class HasManyObservableTest 
+    include DataMapper::Resource
+    property :id, Serial
+    property :name, String
+
+    belongs_to :observer_test, :required => false
+    has n, :has_many_through_observable_tests
+  end
+  class HasManyThroughObservableTest 
+    include DataMapper::Resource
+    property :id, Serial
+    property :name, String
+
+    belongs_to :has_many_observable_test, :required => false
+    has 1, :observer_test, :through => :has_many_observable_test
+  end
+
+  class HabtmObservableTest
+    include DataMapper::Resource
+    property :id, Serial
+    property :name, String
+
+    has n, :observer_tests, :through => Resource
+  end
+
+
+
+  class ObserverTest
+    include DataMapper::Resource
+
+    property :id, Serial
+    property :type, Discriminator
+    property :updated, Boolean
+    property :deleted, Boolean
+
+    belongs_to :belongs_to_observable_test, :required => false
+    belongs_to :collection_observable_test, :required => false
+    has 1, :has_one_observable_test
+    has n, :has_many_observable_tests
+
+    has n, :has_many_through_observable_tests, :through => :has_many_observable_tests, :via => :target, :required => false
+
+
+    has 1, :observer_observer_test
+
+    has n, :habtm_observable_tests, :through => Resource
+
+    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,
+             :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,
+             :habtm_observable_tests, :notifiers => :test_destroy, :on => :destroy
+    observes :belongs_to_observable_test, :notifiers => :test_update, :on => :bang
+  end
+
+  class ObserverObserverTest
+    include DataMapper::Resource
+
+    property :id, Serial
+    property :type, Discriminator
+    property :updated, Boolean
+    property :deleted, Boolean
+
+    belongs_to :observer_test, :required => false
+
+    observes :observer_test, :notifiers => :test_update, :on => :update
+  end
+
+  DataMapper.finalize
+
+  DataMapper.auto_migrate!
+
+  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.create(:observer_test => observer1)}
+  let(:collection_observable) {CollectionObservableTest.create(:observer_tests => [observer1, 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 association gets banged" do
+    before(:each) do
+      belongs_to_observable.bang
+    end
+    it "should update its observer" do
+      observer1.reload.should be_updated
+      observer1.should_not be_deleted
+    end
+  end
+
+  describe "when the belongs to observable is updated" do
+    before(:each) do
+      belongs_to_observable.update(: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
+  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!(:updated => nil)
+      belongs_to_observable.unobservable!
+      belongs_to_observable.update(: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(: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(: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!(: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 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!(:updated => false)
+    end
+    it "should update its observer" do
+      observer1.has_many_observable_tests.first.has_many_through_observable_tests.first.update(: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 the collection observable is updated" do
+    before(:each) do
+      collection_observable.update(: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(:observer_observer_test => observer_observer)
+    end
+    describe "when the belongs to observable is updated" do
+      before(:each) do
+        belongs_to_observable.update(: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(: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(: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 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!(:updated => false)
+        observer_observer.update!(:updated => false)
+      end
+      it "should update its observer" do
+        observer1.has_many_observable_tests.first.has_many_through_observable_tests.first.update(: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(: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 a joined through" do
+    class HasOneThroughObservableTest
+      include DataMapper::Resource
+      property :id, Serial
+      property :name, String
+
+      belongs_to :has_one_observable_test, :required => false
+      has 1, :observer_test, :through => :has_one_observable_test
+    end
+
+    class HasOneObservableTest
+      has 1, :has_one_through_observable_test
+    end
+
+    class ObserverTest
+
+      has 1, :has_one_through_observable_test, :through => :has_one_observable_test
+      observes :has_one_through_observable_test, :notifiers => :test_update, :on => :update
+    end
+
+    DataMapper.auto_upgrade!
+
+    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(:updated => nil)
+        through_observable.update(: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
+
+    class ObservableAbstractTest
+      property :successful, Boolean
+    end
+
+    DataMapper.auto_upgrade!
+
+    before(:all) do
+      class HasOneObservableTest
+        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(: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

data/spec/datamapper_helper.rb

@@ -0,0 +1,7 @@
+# -*- encoding : utf-8 -*-
+require 'rubygems'
+require 'data_mapper'
+
+datamapper_config = YAML.load_file(File.join(File.expand_path('../..', __FILE__), 'database.yml'))["datamapper"]
+
+DataMapper.setup(:default, datamapper_config)

data/spec/spec_helper.rb

@@ -1,13 +1,7 @@
 # -*- encoding : utf-8 -*-
 require 'rubygems'
-require 'active_record'
 require './lib/association_observers'
 
-
-ActiveRecord::Base.configurations = YAML.load_file(File.join(File.expand_path('../..', __FILE__), 'database.yml'))
-ActiveRecord::Base.establish_connection("activerecord")
-
-
 require 'rspec'
 require 'database_cleaner'
 

metadata

@@ -2,14 +2,14 @@
 name: association_observers
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-12-12 00:00:00.000000000 Z
+date: 2012-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -145,13 +145,30 @@ dependencies:
     none: false
   prerelease: false
   type: :development
-description: ! "This is an alternative implementation of the observer pattern. As\
-  \ you may know, Ruby (and Rails/ActiveRecord) already have an\n  implementation\
-  \ of it. This implementation is a variation of the pattern, so it is not supposed\
-  \ to supersede the existing\n  implementations, but \"complete\" them for the specific\
-  \ use-cases addressed."
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :runtime
+description: |-
+  This is an alternative implementation of the observer pattern. As you may know, Ruby (and Rails/ActiveRecord) already have an
+    implementation of it. This implementation is a variation of the pattern, so it is not supposed to supersede the existing
+    implementations, but "complete" them for the specific use-cases addressed.
 email:
-- tiago@restorm.com
+- cardoso_tiago@hotmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -168,6 +185,7 @@ files:
 - database.yml
 - lib/association_observers.rb
 - lib/association_observers/activerecord.rb
+- lib/association_observers/datamapper.rb
 - lib/association_observers/notifiers/base.rb
 - lib/association_observers/notifiers/propagation_notifier.rb
 - lib/association_observers/railtie.rb
@@ -175,8 +193,11 @@ files:
 - lib/association_observers/version.rb
 - lib/examples/notifiers/update_timestamp_notifier.rb
 - lib/examples/readme_example.rb
+- spec/active_record_helper.rb
 - spec/activerecord/association_observers_spec.rb
-- spec/examples/readme_example_spec.rb
+- spec/activerecord/readme_example_spec.rb
+- spec/datamapper/association_observers_spec.rb
+- spec/datamapper_helper.rb
 - spec/spec_helper.rb
 homepage: https://github.com/TiagoCardoso1983/association_observers
 licenses: []
@@ -217,7 +238,10 @@ summary: ! 'The Observer Pattern clearly defines two roles: the observer and the
   behaviour has to be copied from one place to the other. So, why not delegate this
   information (to whom, when, behaviour) to a third role, the notifier?'
 test_files:
+- spec/active_record_helper.rb
 - spec/activerecord/association_observers_spec.rb
-- spec/examples/readme_example_spec.rb
+- spec/activerecord/readme_example_spec.rb
+- spec/datamapper/association_observers_spec.rb
+- spec/datamapper_helper.rb
 - spec/spec_helper.rb
 has_rdoc: