mongodb 0.0.5 → 0.0.6

data/lib/mongo/object/object.rb

@@ -4,13 +4,12 @@ module Mongo::Object
   def valid? opts = {}
     opts = ::Mongo::Object.parse_options opts
     begin
-      return false unless errors.empty?
-
-      return false if opts[:callbacks] and !::Mongo::Object.run_callbacks(self, :before, :validate)
+      return false if opts[:callbacks] and !::Mongo::Object.run_before_callbacks(self, :validate)
 
       child_opts = opts.merge internal: true
-      if child_objects.all?{|group| group.all?{|obj| obj.valid?(child_opts)}} and errors.empty?
-        ::Mongo::Object.run_callbacks(self, :after, :validate) if opts[:callbacks]
+      children_valid = child_objects.all?{|group| group.all?{|obj| obj.valid?(child_opts)}}
+      if children_valid and ::Mongo::Object.run_validations(self) and errors.empty?
+        ::Mongo::Object.run_after_callbacks(self, :validate) if opts[:callbacks]
         true
       else
         false
@@ -136,12 +135,30 @@ module Mongo::Object
     def build doc
       return unless doc
       obj = _build doc
-      obj.send :update_internal_state! if obj.is_a? ::Mongo::Object
+      obj.send :update_original_children! if obj.is_a? ::Mongo::Object
       obj
     end
 
-    def run_callbacks obj, type, method_name
-      obj.respond_to?(:run_callbacks) ? obj.run_callbacks(type, method_name) : true
+    def run_before_callbacks obj, method
+      if obj.respond_to?(:run_before_callbacks)
+        obj.run_before_callbacks(:save, method: :save) if method == :update or method == :create
+        obj.run_before_callbacks(method, method: method)
+      else
+        true
+      end
+    end
+
+    def run_after_callbacks obj, method
+      if obj.respond_to?(:run_before_callbacks)
+        obj.run_after_callbacks(method, method: method)
+        obj.run_after_callbacks(:save, method: :save) if method == :update or method == :create
+      else
+        true
+      end
+    end
+
+    def run_validations obj
+      obj.respond_to?(:run_validations) ? obj.run_validations : true
     end
 
     protected
@@ -183,17 +200,15 @@ module Mongo::Object
   end
 
   protected
-    attr_writer :_original_children
-    def _original_children
-      @_original_children ||= []
-    end
+    attr_writer :original_children
+    def original_children; @_original_children ||= [] end
 
-    def update_internal_state!
+    def update_original_children!
       return unless ::Mongo.defaults[:callbacks]
 
-      _original_children.clear
+      original_children.clear
       ::Mongo::Object.each_object self, false do |obj|
-        _original_children << obj
+        original_children << obj
       end
     end
 
@@ -210,34 +225,34 @@ module Mongo::Object
       unless @_child_objects
         created_children, updated_children, destroyed_children = [], [], []
 
-        original_children_ids = Set.new; _original_children.each{|obj| original_children_ids << obj.object_id}
+        original_children_ids = Set.new; original_children.each{|obj| original_children_ids << obj.object_id}
         ::Mongo::Object.each_object self, false do |obj|
           (original_children_ids.include?(obj.object_id) ? updated_children : created_children) << obj
         end
 
         children_ids = Set.new; ::Mongo::Object.each_object(self, false){|obj| children_ids << obj.object_id}
-        destroyed_children = _original_children.select{|obj| !children_ids.include?(obj.object_id)}
+        destroyed_children = original_children.select{|obj| !children_ids.include?(obj.object_id)}
 
         @_child_objects = [created_children, updated_children, destroyed_children]
       end
       @_child_objects
     end
 
-    def with_object_callbacks method_name, opts, &block
+    def with_object_callbacks method, opts, &block
       opts = ::Mongo::Object.parse_options opts
 
       # validation
       return false if opts[:validate] and !valid?(opts.merge(internal: true))
 
       # before callbacks
-      return false if opts[:callbacks] and !run_all_callbacks(:before, method_name)
+      return false if opts[:callbacks] and !run_all_callbacks(:before, method)
 
       # saving
       block.call ::Mongo::Object.to_mongo_options(opts)
-      update_internal_state!
+      update_original_children!
 
       # after callbacks
-      run_all_callbacks :after, method_name if opts[:callbacks]
+      run_all_callbacks :after, method if opts[:callbacks]
 
       true
     ensure
@@ -245,36 +260,36 @@ module Mongo::Object
     end
 
     # TODO1 move to static method
-    def run_all_callbacks type, method_name
+    def run_all_callbacks type, method
       result = if type == :before
-        ::Mongo::Object.run_callbacks self, type, method_name
+        ::Mongo::Object.run_before_callbacks self, method
       else
         true
       end
 
-      result &= if method_name == :create
+      result &= if method == :create
         child_objects.all? do |group|
           group.all? do |obj|
-            obj.run_all_callbacks type, method_name
+            obj.run_all_callbacks type, method
           end
         end
-      elsif method_name == :update
+      elsif method == :update
         created_children, updated_children, destroyed_children = child_objects
         created_children.all?{|obj| obj.run_all_callbacks type, :create} and
           updated_children.all?{|obj| obj.run_all_callbacks type, :update} and
           destroyed_children.all?{|obj| obj.run_all_callbacks type, :destroy}
-      elsif method_name == :destroy
+      elsif method == :destroy
         child_objects.all? do |group|
           group.all? do |obj|
-            obj.run_all_callbacks type, method_name
+            obj.run_all_callbacks type, method
           end
         end
       else
-        raise_error "unknown callback method (#{method_name})!"
+        raise_error "unknown callback method (#{method})!"
       end
 
       result &= if type == :after
-        ::Mongo::Object.run_callbacks self, type, method_name
+        ::Mongo::Object.run_after_callbacks self, method
       else
         true
       end

data/spec/object/callbacks_spec.rb

@@ -22,7 +22,7 @@ describe 'Object callbacks' do
   end
 
   it 'create' do
-    %w(before_validate after_validate before_create after_create).each do |name|
+    %w(before_validate after_validate before_save before_create after_create after_save).each do |name|
       @player.should_receive(name).once.ordered.and_return(true)
       @mission.should_receive(name).once.ordered.and_return(true)
     end
@@ -33,7 +33,7 @@ describe 'Object callbacks' do
   it 'update' do
     db.players.save(@player).should be_true
 
-    %w(before_validate after_validate before_update after_update).each do |name|
+    %w(before_validate after_validate before_save before_update after_update after_save).each do |name|
       @player.should_receive(name).once.ordered.and_return(true)
       @mission.should_receive(name).once.ordered.and_return(true)
     end
@@ -63,8 +63,8 @@ describe 'Object callbacks' do
   end
 
   it 'should be able interrupt CRUD' do
-    @mission.stub! :run_callbacks do |type, method_name|
-      false if type == :before and method_name == :create
+    @mission.stub! :run_before_callbacks do |method_name|
+      false if method_name == :create
     end
     db.players.save(@player).should be_false
     db.players.count.should == 0

data/spec/object/spec_helper.rb

@@ -7,8 +7,13 @@ require 'driver/spec_helper'
 
 # To simplify callback expectations
 module RSpec::CallbackHelper
-  def run_callbacks type, method_name
-    callback_method_name = :"#{type}_#{method_name}"
+  def run_before_callbacks method_name, opts = {}
+    callback_method_name = :"before_#{method_name}"
+    respond_to?(callback_method_name) ? send(callback_method_name) : true
+  end
+
+  def run_after_callbacks method_name, opts = {}
+    callback_method_name = :"after_#{method_name}"
     respond_to?(callback_method_name) ? send(callback_method_name) : true
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongodb
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors: