tenacity 0.3.0 → 0.4.0

data/lib/tenacity/orm_ext/sequel.rb

@@ -1,134 +1,161 @@
 module Tenacity
-  # Tenacity relationships on Sequel objects require that certain columns
-  # exist on the associated table, and that join tables exist for one-to-many
-  # relationships.  Take the following class for example:
-  #
-  #   class Car < Sequel::Model
-  #     include Tenacity
-  #
-  #     t_has_many    :wheels
-  #     t_has_one     :dashboard
-  #     t_belongs_to  :driver
-  #   end
-  #
-  #
-  # == t_belongs_to
-  #
-  # The +t_belongs_to+ association requires that a property exist in the table
-  # to hold the id of the assoicated object.
-  #
-  #   DB.create_table :cars do
-  #     primary_key :id
-  #     String :driver_id
-  #   end
-  #
-  #
-  # == t_has_one
-  #
-  # The +t_has_one+ association requires no special column in the table, since
-  # the associated object holds the foreign key.
-  #
-  #
-  # == t_has_many
-  #
-  # The +t_has_many+ association requires that a join table exist to store the
-  # associations.  The name of the join table follows ActiveRecord conventions.
-  # The name of the join table in this example would be cars_wheels, since cars
-  # comes before wheels when shorted alphabetically.
-  #
-  #   DB.create_table :cars_wheels do
-  #     Integer :car_id
-  #     String :wheel_id
-  #   end
-  #
-  module Sequel
-
-    def self.setup(model)
-      require 'sequel'
-      if model.ancestors.include?(::Sequel::Model)
-        model.send :include, Sequel::InstanceMethods
-        model.extend Sequel::ClassMethods
+  module OrmExt
+    # Tenacity relationships on Sequel objects require that certain columns
+    # exist on the associated table, and that join tables exist for one-to-many
+    # relationships.  Take the following class for example:
+    #
+    #   class Car < Sequel::Model
+    #     include Tenacity
+    #
+    #     t_has_many    :wheels
+    #     t_has_one     :dashboard
+    #     t_belongs_to  :driver
+    #   end
+    #
+    #
+    # == t_belongs_to
+    #
+    # The +t_belongs_to+ association requires that a property exist in the table
+    # to hold the id of the assoicated object.
+    #
+    #   DB.create_table :cars do
+    #     primary_key :id
+    #     String :driver_id
+    #   end
+    #
+    #
+    # == t_has_one
+    #
+    # The +t_has_one+ association requires no special column in the table, since
+    # the associated object holds the foreign key.
+    #
+    #
+    # == t_has_many
+    #
+    # The +t_has_many+ association requires that a join table exist to store the
+    # associations.  The name of the join table follows ActiveRecord conventions.
+    # The name of the join table in this example would be cars_wheels, since cars
+    # comes before wheels when shorted alphabetically.
+    #
+    #   DB.create_table :cars_wheels do
+    #     Integer :car_id
+    #     String :wheel_id
+    #   end
+    #
+    module Sequel
+
+      def self.setup(model)
+        require 'sequel'
+        if model.ancestors.include?(::Sequel::Model)
+          model.send :include, Sequel::InstanceMethods
+          model.extend Sequel::ClassMethods
+        end
+      rescue LoadError
+        # Sequel not available
       end
-    rescue LoadError
-      # Sequel not available
-    end
 
-    module ClassMethods #:nodoc:
-      attr_accessor :_t_has_many_associations
-      attr_accessor :_t_belongs_to_associations
+      module ClassMethods #:nodoc:
+        include Tenacity::OrmExt::Helpers
 
-      def _t_find(id)
-        self[id]
-      end
+        attr_accessor :_t_has_one_associations
+        attr_accessor :_t_has_many_associations
+        attr_accessor :_t_belongs_to_associations
 
-      def _t_find_bulk(ids)
-        return [] if ids.nil? || ids.empty?
-        filter(:id => ids)
-      end
+        def _t_id_type
+          Integer
+        end
 
-      def _t_find_first_by_associate(property, id)
-        first(property.to_sym => id)
-      end
+        def _t_find(id)
+          self[_t_serialize(id)]
+        end
 
-      def _t_find_all_by_associate(property, id)
-        filter(property => id)
-      end
+        def _t_find_bulk(ids)
+          return [] if ids.nil? || ids.empty?
+          filter(:id => _t_serialize_ids(ids)).to_a
+        end
 
-      def _t_initialize_has_many_association(association)
-        @_t_has_many_associations ||= []
-        @_t_has_many_associations << association
-      end
+        def _t_find_first_by_associate(property, id)
+          first(property.to_sym => _t_serialize(id))
+        end
 
-      def _t_initialize_belongs_to_association(association)
-        @_t_belongs_to_associations ||= []
-        @_t_belongs_to_associations << association
-      end
+        def _t_find_all_by_associate(property, id)
+          filter(property => _t_serialize(id)).to_a
+        end
 
-      def _t_delete(ids, run_callbacks=true)
-        if run_callbacks
-          filter(:id => ids).destroy
-        else
-          filter(:id => ids).delete
+        def _t_initialize_tenacity
         end
-      end
-    end
 
-    module InstanceMethods #:nodoc:
-      def before_save
-        associations = self.class._t_belongs_to_associations || []
-        associations.each { |association| self.class._t_stringify_belongs_to_value(self, association) }
-        super
-      end
+        def _t_initialize_has_one_association(association)
+          @_t_has_one_associations ||= []
+          @_t_has_one_associations << association
+        end
 
-      def after_save
-        associations = self.class._t_has_many_associations || []
-        associations.each { |association| self.class._t_save_associates(self, association) }
-        super
-      end
+        def _t_initialize_has_many_association(association)
+          @_t_has_many_associations ||= []
+          @_t_has_many_associations << association
+        end
 
-      def _t_reload
-        reload
-      end
+        def _t_initialize_belongs_to_association(association)
+          @_t_belongs_to_associations ||= []
+          @_t_belongs_to_associations << association
+        end
 
-      def _t_clear_associates(association)
-        db["delete from #{association.join_table} where #{association.association_key} = #{self.id}"].delete
+        def _t_delete(ids, run_callbacks=true)
+          if run_callbacks
+            filter(:id => _t_serialize_ids(ids)).destroy
+          else
+            filter(:id => _t_serialize_ids(ids)).delete
+          end
+        end
       end
 
-      def _t_associate_many(association, associate_ids)
-        db.transaction do
-          _t_clear_associates(association)
-          associate_ids.each do |associate_id|
-            db["insert into #{association.join_table} (#{association.association_key}, #{association.association_foreign_key}) values (#{self.id}, '#{associate_id}')"].insert
+      module InstanceMethods #:nodoc:
+        include Tenacity::OrmExt::Helpers
+
+        def after_save
+          _t_save_autosave_associations
+
+          associations = self.class._t_has_many_associations || []
+          associations.each { |association| self.class._t_save_associates(self, association) }
+          super
+        end
+
+        def after_destroy
+          associations = self.class._t_belongs_to_associations || []
+          associations.each { |association| self._t_cleanup_belongs_to_association(association) }
+
+          associations = self.class._t_has_one_associations || []
+          associations.each { |association| self._t_cleanup_has_one_association(association) }
+
+          associations = self.class._t_has_many_associations || []
+          associations.each { |association| self._t_cleanup_has_many_association(association) }
+          super
+        end
+
+        def _t_reload
+          reload
+        end
+
+        def _t_clear_associates(association)
+          db["delete from #{association.join_table} where #{association.association_key} = #{_t_serialize_id_for_sql(self.id)}"].delete
+        end
+
+        def _t_associate_many(association, associate_ids)
+          db.transaction do
+            _t_clear_associates(association)
+            associate_ids.each do |associate_id|
+              db["insert into #{association.join_table} (#{association.association_key}, #{association.association_foreign_key}) values (#{_t_serialize_id_for_sql(self.id)}, #{_t_serialize_id_for_sql(associate_id)})"].insert
+            end
           end
         end
-      end
 
-      def _t_get_associate_ids(association)
-        return [] if self.id.nil?
-        rows = db["select #{association.association_foreign_key} from #{association.join_table} where #{association.association_key} = #{self.id}"].all
-        rows.map { |row| row[association.association_foreign_key.to_sym] }
+        def _t_get_associate_ids(association)
+          return [] if self.id.nil?
+          rows = db["select #{association.association_foreign_key} from #{association.join_table} where #{association.association_key} = #{_t_serialize_id_for_sql(self.id)}"].all
+          rows.map { |row| row[association.association_foreign_key.to_sym] }
+        end
       end
-    end
 
+    end
   end
 end

data/lib/tenacity/version.rb

@@ -1,3 +1,3 @@
 module Tenacity
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/tenacity.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rake", "~> 0.8.7"
   s.add_development_dependency "rcov", "~> 0.9.9"
   s.add_development_dependency "shoulda", "~> 2.11.3"
+  s.add_development_dependency "mocha", "~> 0.9.10"
   s.add_development_dependency "yard", "~> 0.6.4"
 
   # Relational DBs
@@ -33,7 +34,7 @@ Gem::Specification.new do |s|
 
   # MongoDB
   s.add_development_dependency "mongo_mapper", "~> 0.8.6"
-  s.add_development_dependency "bson_ext", "~> 1.1.3"
+  s.add_development_dependency "bson_ext", "~> 1.2.4"
   s.add_development_dependency "mongoid", "~> 2.0.0.beta"
 
   # CouchDB

data/test/association_features/belongs_to_test.rb

@@ -30,13 +30,58 @@ class BelongsToTest < Test::Unit::TestCase
     should "be able to specify the foreign key to use for the associated class" do
       car = ActiveRecordCar.create
       windshield = CouchRestWindshield.create(:active_record_car => car)
-      assert_equal car.id.to_s, windshield.car_id
+      assert_equal car.id, windshield.car_id
       assert !windshield.respond_to?(:active_record_car_id)
 
       engine = ActiveRecordEngine.create(:active_record_car => car)
       assert_equal car.id, engine.car_id
       assert !engine.respond_to?(:active_record_car_id)
     end
+
+    should "not be able to modify the associated object if the readonly option is set" do
+      engine = ActiveRecordEngine.create
+      air_filter = MongoMapperAirFilter.create(:active_record_engine => engine)
+      engine = air_filter.active_record_engine
+      engine.prop = "value"
+      assert_raises(Tenacity::ReadOnlyError) { engine.save }
+    end
+
+    should "save the associated object if autosave is true" do
+      source = MongoMapperAutosaveTrueHasOneTarget.create
+      target = ActiveRecordObject.create(:prop => 'abc')
+      source.active_record_object = target
+      source.save
+      assert_equal 'abc', source.active_record_object.prop
+
+      source.active_record_object.prop = 'xyz'
+      source.save
+      source.reload && source.active_record_object(true)
+      assert_equal 'xyz', source.active_record_object.prop
+    end
+
+    should "destroy the associated object if autosave is true and object is marked for destruction" do
+      source = MongoMapperAutosaveTrueHasOneTarget.create
+      target = ActiveRecordObject.create
+      source.active_record_object = target
+      source.save
+      assert_not_nil source.active_record_object(true)
+
+      source.active_record_object.mark_for_destruction
+      assert source.active_record_object.marked_for_destruction?
+      source.save
+      source.reload
+      assert_nil source.active_record_object(true)
+    end
+
+    should "be able to create a polymorphic association" do
+      circuit_board = MongoMapperCircuitBoard.create
+      alternator = MongoMapperAlternator.create
+      circuit_board.diagnosable = alternator
+      circuit_board.save
+
+      assert_equal alternator, MongoMapperCircuitBoard.find(circuit_board.id).diagnosable
+      assert_equal 'MongoMapperAlternator', circuit_board.diagnosable_type
+    end
   end
 
 end

data/test/association_features/has_many_test.rb

@@ -4,7 +4,7 @@ class HasManyTest < Test::Unit::TestCase
 
   context "A class with a belongs_to association to another class" do
     setup do
-      setup_fixtures
+      setup_all_fixtures
       @car = ActiveRecordCar.create
       @wheels = [MongoMapperWheel.create, MongoMapperWheel.create, MongoMapperWheel.create]
 
@@ -43,7 +43,7 @@ class HasManyTest < Test::Unit::TestCase
       car.save
 
       assert_set_equal [door_1, door_2, door_3], ActiveRecordCar.find(car.id).couch_rest_doors
-      assert_set_equal [door_1.id.to_s, door_2.id.to_s, door_3.id.to_s], ActiveRecordCar.find(car.id).couch_rest_door_ids
+      assert_set_equal [door_1.id, door_2.id, door_3.id], ActiveRecordCar.find(car.id).couch_rest_door_ids
     end
 
     should "save the associate object when it is added as an associate if the parent object is saved" do
@@ -79,6 +79,113 @@ class HasManyTest < Test::Unit::TestCase
       assert_set_equal [door_1], ActiveRecordCar.find(car.id).couch_rest_doors
     end
 
+    should "not be able to modify an associated object if the readonly option is set" do
+      car = ActiveRecordCar.create
+      wheel_1 = MongoMapperWheel.create
+      wheel_2 = MongoMapperWheel.create
+      wheel_3 = MongoMapperWheel.create
+      car.mongo_mapper_wheels = [wheel_1, wheel_2, wheel_3]
+      car.save
+
+      wheel = car.mongo_mapper_wheels.first
+      wheel.prop = "value"
+      assert_raises(Tenacity::ReadOnlyError) { wheel.save }
+    end
+
+    should "only return the number of results specified by the :limit option" do
+      car = ActiveRecordCar.create
+      wheel_1 = MongoMapperWheel.create
+      wheel_2 = MongoMapperWheel.create
+      wheel_3 = MongoMapperWheel.create
+      wheel_4 = MongoMapperWheel.create
+      wheel_5 = MongoMapperWheel.create
+      wheel_6 = MongoMapperWheel.create
+      wheel_7 = MongoMapperWheel.create
+      wheel_8 = MongoMapperWheel.create
+      car.mongo_mapper_wheels = [wheel_1, wheel_2, wheel_3, wheel_4, wheel_5, wheel_6, wheel_7, wheel_8]
+      car.save
+
+      sorted_wheels = car.mongo_mapper_wheels.sort { |a,b| a.id.to_s <=> b.id.to_s }
+      sorted_wheel_ids = sorted_wheels.map { |wheel| wheel.id.to_s }
+
+      assert_set_equal [sorted_wheels[0], sorted_wheels[1], sorted_wheels[2], sorted_wheels[3], sorted_wheels[4]],
+        ActiveRecordCar.find(car.id).mongo_mapper_wheels
+      assert_set_equal [sorted_wheel_ids[0], sorted_wheel_ids[1], sorted_wheel_ids[2], sorted_wheel_ids[3], sorted_wheel_ids[4]],
+        ActiveRecordCar.find(car.id).mongo_mapper_wheel_ids
+    end
+
+    should "skip over the first group of results, as specified by the :offset option" do
+      car = ActiveRecordCar.create
+      window_1 = MongoMapperWindow.create
+      window_2 = MongoMapperWindow.create
+      window_3 = MongoMapperWindow.create
+      window_4 = MongoMapperWindow.create
+      window_5 = MongoMapperWindow.create
+      window_6 = MongoMapperWindow.create
+      window_7 = MongoMapperWindow.create
+      window_8 = MongoMapperWindow.create
+      window_9 = MongoMapperWindow.create
+      car.mongo_mapper_windows = [window_1, window_2, window_3, window_4, window_5, window_6, window_7, window_8, window_9]
+      car.save
+
+      sorted_windows = car.mongo_mapper_windows.sort { |a,b| a.id.to_s <=> b.id.to_s }
+      sorted_window_ids = sorted_windows.map { |window| window.id.to_s }
+
+      assert_set_equal [sorted_windows[3], sorted_windows[4], sorted_windows[5], sorted_windows[6], sorted_windows[7]],
+        ActiveRecordCar.find(car.id).mongo_mapper_windows
+      assert_set_equal [sorted_window_ids[3], sorted_window_ids[4], sorted_window_ids[5], sorted_window_ids[6], sorted_window_ids[7]],
+        ActiveRecordCar.find(car.id).mongo_mapper_window_ids
+    end
+
+    should "be able to store objects via their polymorphic interface" do
+      circuit_board_1 = MongoMapperCircuitBoard.create
+      circuit_board_2 = MongoMapperCircuitBoard.create
+      circuit_board_3 = MongoMapperCircuitBoard.create
+      engine = ActiveRecordEngine.create
+      engine.diagnosable = [circuit_board_1, circuit_board_2, circuit_board_3]
+      engine.save
+
+      components = ActiveRecordEngine.find(engine.id).diagnosable
+      assert_set_equal [circuit_board_1, circuit_board_2, circuit_board_3], components
+      assert_set_equal ['ActiveRecordEngine', 'ActiveRecordEngine', 'ActiveRecordEngine'], components.map {|c| c.diagnosable_type}
+    end
+
+    context "with an autosave association" do
+      setup do
+        @source = ActiveRecordObject.create
+        @targets = [MongoMapperAutosaveTrueHasManyTarget.create(:prop => 'abc'), MongoMapperAutosaveTrueHasManyTarget.create(:prop => 'def')]
+        @source.mongo_mapper_autosave_true_has_many_targets = @targets
+        @source.save
+        assert_equal 'abc', @source.mongo_mapper_autosave_true_has_many_targets(true).first.prop
+      end
+
+      should "save the associated object if autosave is true" do
+        @source.mongo_mapper_autosave_true_has_many_targets.first.prop = 'xyz'
+        @source.save
+        @source.reload && @source.mongo_mapper_autosave_true_has_many_targets(true)
+        assert_equal 'xyz', @source.mongo_mapper_autosave_true_has_many_targets.first.prop
+      end
+
+      should "destroy the associated object stored in a local variable if autosave is true and object is marked for destruction" do
+        object = @source.mongo_mapper_autosave_true_has_many_targets.first
+        object.mark_for_destruction
+        assert object.marked_for_destruction?
+        @source.save
+        @source.reload && @source.mongo_mapper_autosave_true_has_many_targets(true)
+        assert_equal 1, @source.mongo_mapper_autosave_true_has_many_targets.size
+        assert_equal 'def', @source.mongo_mapper_autosave_true_has_many_targets.first.prop
+      end
+
+      should "destroy the associated object if autosave is true and object is marked for destruction" do
+        @source.mongo_mapper_autosave_true_has_many_targets.first.mark_for_destruction
+        assert @source.mongo_mapper_autosave_true_has_many_targets.first.marked_for_destruction?
+        @source.save
+        @source.reload && @source.mongo_mapper_autosave_true_has_many_targets(true)
+        assert_equal 1, @source.mongo_mapper_autosave_true_has_many_targets.size
+        assert_equal 'def', @source.mongo_mapper_autosave_true_has_many_targets.first.prop
+      end
+    end
+
     context "with a set of associates that need to be deleted" do
       setup do
         @new_car = ActiveRecordCar.create
@@ -104,6 +211,84 @@ class HasManyTest < Test::Unit::TestCase
         assert_equal old_count - 3, CouchRestDoor.count
         assert_set_equal [], ActiveRecordCar.find(@new_car.id).couch_rest_doors
       end
+
+      context "the delete method" do
+        should "not delete the object from the database if no dependent option is specified" do
+          dashboard = MongoMapperDashboard.create
+          vent_1 = MongoMapperVent.create
+          vent_2 = MongoMapperVent.create
+          vent_3 = MongoMapperVent.create
+          dashboard.vents = [vent_1, vent_2, vent_3]
+          dashboard.save
+          assert_set_equal [vent_1, vent_2, vent_3], MongoMapperDashboard.find(dashboard.id).vents
+
+          dashboard.vents.delete(vent_1)
+          dashboard.save
+          assert_set_equal [vent_2, vent_3], MongoMapperDashboard.find(dashboard.id).vents
+          assert_not_nil MongoMapperVent.find(vent_1.id)
+        end
+
+        should "delete the associated object and issue callbacks if association is configured to :destroy dependents" do
+          wheel_1 = MongoMapperWheel.create
+          wheel_2 = MongoMapperWheel.create
+          wheel_3 = MongoMapperWheel.create
+          @new_car.mongo_mapper_wheels = [wheel_1, wheel_2, wheel_3]
+          @new_car.save
+          assert_set_equal [wheel_1, wheel_2, wheel_3], ActiveRecordCar.find(@new_car.id).mongo_mapper_wheels
+
+          @new_car.mongo_mapper_wheels.delete(wheel_1)
+          @new_car.save
+          assert_set_equal [wheel_2, wheel_3], ActiveRecordCar.find(@new_car.id).mongo_mapper_wheels
+          assert_nil MongoMapperWheel._t_find(wheel_1.id)
+        end
+
+        should "delete the associated object without issuing callbacks if association is configured to :delete_all dependents" do
+          @new_car.couch_rest_doors.delete(@door_1)
+          @new_car.save
+          assert_set_equal [@door_2, @door_3], ActiveRecordCar.find(@new_car.id).couch_rest_doors
+          assert_nil CouchRestDoor._t_find(@door_1.id)
+        end
+      end
+
+      context "the clear method" do
+        should "not delete the object from the database if no dependent option is specified" do
+          dashboard = MongoMapperDashboard.create
+          vent_1 = MongoMapperVent.create
+          vent_2 = MongoMapperVent.create
+          dashboard.vents = [vent_1, vent_2]
+          dashboard.save
+          assert_set_equal [vent_1, vent_2], MongoMapperDashboard.find(dashboard.id).vents
+
+          dashboard.vents.clear
+          dashboard.save
+          assert_set_equal [], MongoMapperDashboard.find(dashboard.id).vents
+          assert_not_nil MongoMapperVent.find(vent_1.id)
+          assert_not_nil MongoMapperVent.find(vent_2.id)
+        end
+
+        should "delete the associated object and issue callbacks if association is configured to :destroy dependents" do
+          wheel_1 = MongoMapperWheel.create
+          wheel_2 = MongoMapperWheel.create
+          @new_car.mongo_mapper_wheels = [wheel_1, wheel_2]
+          @new_car.save
+          assert_set_equal [wheel_1, wheel_2], ActiveRecordCar.find(@new_car.id).mongo_mapper_wheels
+
+          @new_car.mongo_mapper_wheels.clear
+          @new_car.save
+          assert_set_equal [], ActiveRecordCar.find(@new_car.id).mongo_mapper_wheels
+          assert_nil MongoMapperWheel._t_find(wheel_1.id)
+          assert_nil MongoMapperWheel._t_find(wheel_2.id)
+        end
+
+        should "delete the associated object without issuing callbacks if association is configured to :delete_all dependents" do
+          @new_car.couch_rest_doors.clear
+          @new_car.save
+          assert_set_equal [], ActiveRecordCar.find(@new_car.id).couch_rest_doors
+          assert_nil CouchRestDoor._t_find(@door_1.id)
+          assert_nil CouchRestDoor._t_find(@door_2.id)
+          assert_nil CouchRestDoor._t_find(@door_3.id)
+        end
+      end
     end
   end