tenacity 0.4.1 → 0.5.0

data/lib/tenacity/orm_ext/sequel.rb

@@ -32,15 +32,8 @@ module Tenacity
     #
     # == 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
+    # The +t_has_many+ association requires nothing special, as the associates
+    # are looked up using the associate class.
     #
     module Sequel
 
@@ -79,7 +72,12 @@ module Tenacity
         end
 
         def _t_find_all_by_associate(property, id)
-          filter(property => _t_serialize(id)).to_a
+          filter(property.to_sym => _t_serialize(id)).to_a
+        end
+
+        def _t_find_all_ids_by_associate(property, id)
+          results = db["SELECT id FROM #{table_name} WHERE #{property} = #{_t_serialize_id_for_sql(id)}"].all
+          results.map { |r| r[:id] }
         end
 
         def _t_initialize_tenacity
@@ -112,6 +110,11 @@ module Tenacity
       module InstanceMethods #:nodoc:
         include Tenacity::OrmExt::Helpers
 
+        def before_save
+          _t_verify_associates_exist
+          super
+        end
+
         def after_save
           _t_save_autosave_associations
 
@@ -120,10 +123,7 @@ module Tenacity
           super
         end
 
-        def after_destroy
-          associations = self.class._t_belongs_to_associations || []
-          associations.each { |association| self._t_cleanup_belongs_to_association(association) }
-
+        def before_destroy
           associations = self.class._t_has_one_associations || []
           associations.each { |association| self._t_cleanup_has_one_association(association) }
 
@@ -132,27 +132,15 @@ module Tenacity
           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
+        def after_destroy
+          associations = self.class._t_belongs_to_associations || []
+          associations.each { |association| self._t_cleanup_belongs_to_association(association) }
+          super
         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} = #{_t_serialize_id_for_sql(self.id)}"].all
-          rows.map { |row| row[association.association_foreign_key.to_sym] }
+        def _t_reload
+          reload
+          self
         end
       end
 

data/lib/tenacity/orm_ext/toystore.rb

@@ -0,0 +1,114 @@
+module Tenacity
+  module OrmExt
+    #
+    # Tenacity relationships on Toystore objects require no special attributes
+    # defined on the object.  Tenacity will define the attributes that it needs
+    # to support the relationships.  Take the following class for example:
+    #
+    #   class Car
+    #     include Toy::Store
+    #     store :mongo, Mongo::Connection.new.db('tenacity')['toystore']
+    #     include Tenacity
+    #
+    #     t_has_many    :wheels
+    #     t_has_one     :dashboard
+    #     t_belongs_to  :driver
+    #   end
+    #
+    # <b>Please note that the data store must be established before including the Tenacity module.</b>
+    #
+    # == t_belongs_to
+    #
+    # The +t_belongs_to+ association will define an attribute named after the association.
+    # The example above will create an attribute named <tt>:driver_id</tt>
+    #
+    #
+    # == t_has_one
+    #
+    # The +t_has_one+ association will not define any new attributes on the object, since
+    # the associated object holds the foreign key.
+    #
+    #
+    # == t_has_many
+    #
+    # The +t_has_many+ association will define an attribute named after the association.
+    # The example above will create attribute named <tt>:wheels_ids</tt>
+    #
+    module Toystore
+
+      def self.setup(model) #:nodoc:
+        require 'toystore'
+        if model.included_modules.include?(::Toy::Store)
+          model.send :include, Toystore::InstanceMethods
+          model.extend Toystore::ClassMethods
+        end
+      rescue LoadError
+        # Toystore not available
+      end
+
+      module ClassMethods #:nodoc:
+        include Tenacity::OrmExt::Helpers
+
+        def _t_id_type
+          String
+        end
+
+        def _t_find(id)
+          (id.nil? || id.to_s.strip == "") ? nil : get(_t_serialize(id))
+        end
+
+        def _t_find_bulk(ids)
+          get_multi(_t_serialize_ids(ids)).compact
+        end
+
+        def _t_find_first_by_associate(property, id)
+          send("first_by_#{property}", id)
+        end
+
+        def _t_find_all_by_associate(property, id)
+          get_multi(_t_find_all_ids_by_associate(property, id))
+        end
+
+        def _t_find_all_ids_by_associate(property, id)
+          get_index(property.to_sym, id)
+        end
+
+        def _t_initialize_tenacity
+          before_save { |record| record._t_verify_associates_exist }
+          after_save { |record| record._t_save_autosave_associations }
+        end
+
+        def _t_initialize_has_one_association(association)
+          before_destroy { |record| record._t_cleanup_has_one_association(association) }
+        end
+
+        def _t_initialize_has_many_association(association)
+          after_save { |record| self.class._t_save_associates(record, association) }
+          before_destroy { |record| record._t_cleanup_has_many_association(association) }
+        end
+
+        def _t_initialize_belongs_to_association(association)
+          attribute association.foreign_key, id_class_for(association)
+          attribute association.polymorphic_type, String if association.polymorphic?
+          index(association.foreign_key.to_sym)
+          after_destroy { |record| record._t_cleanup_belongs_to_association(association) }
+        end
+
+        def _t_delete(ids, run_callbacks=true)
+          if run_callbacks
+            destroy(*ids)
+          else
+            delete(*ids)
+          end
+        end
+      end
+
+      module InstanceMethods #:nodoc:
+        def _t_reload
+          reload
+          self
+        end
+      end
+    end
+  end
+end

data/lib/tenacity/version.rb

@@ -1,3 +1,3 @@
 module Tenacity
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/tenacity.gemspec

@@ -33,13 +33,20 @@ Gem::Specification.new do |s|
   s.add_development_dependency "sequel", "~> 3.19.0"
 
   # MongoDB
-  # mongo_mapper dependency defined in Gemfile
+  s.add_development_dependency "mongo_mapper", "~> 0.9.0"
   s.add_development_dependency "bson_ext", "~> 1.3.0"
-  s.add_development_dependency "mongoid", "~> 2.0.0.beta"
+  s.add_development_dependency "mongoid", "~> 2.0.0"
 
   # CouchDB
   s.add_development_dependency "couchrest", "~> 1.0.0"
-  s.add_development_dependency "couchrest_model", "~> 1.0.0.beta"
+  s.add_development_dependency "couchrest_model", "~> 1.0.0"
+
+  # Riak
+  s.add_development_dependency "ripple", "~> 0.9.2"
+
+  # Multiple
+  s.add_development_dependency "toystore", "~> 0.8.0"
+  s.add_development_dependency "adapter-mongo", "~> 0.5.2"
 
   s.files        = `git ls-files`.split("\n")
   s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact

data/test/association_features/belongs_to_test.rb

@@ -82,6 +82,18 @@ class BelongsToTest < Test::Unit::TestCase
       assert_equal alternator, MongoMapperCircuitBoard.find(circuit_board.id).diagnosable
       assert_equal 'MongoMapperAlternator', circuit_board.diagnosable_type
     end
+
+    should "not be able to create the relationship if the target object does not exist" do
+      ash_tray = MongoMapperAshTray.new(:mongo_mapper_dashboard_id => 'abc123')
+      assert_raises(Tenacity::ObjectDoesNotExistError) { ash_tray.save }
+    end
+
+    should "be able to create the relationship if the target object does not exist and foreign key constraints are disabled" do
+      Tenacity::Association.any_instance.stubs(:foreign_key_constraints_enabled?).returns(false)
+      ash_tray = MongoMapperAshTray.new(:mongo_mapper_dashboard_id => 'abc123')
+      ash_tray.save
+      assert_equal 'abc123', MongoMapperAshTray.find(ash_tray.id).mongo_mapper_dashboard_id
+    end
   end
 
 end

data/test/association_features/has_many_test.rb

@@ -2,9 +2,11 @@ require 'test_helper'
 
 class HasManyTest < Test::Unit::TestCase
 
-  context "A class with a belongs_to association to another class" do
+  context "A class with a has_many association to another class" do
     setup do
-      setup_all_fixtures
+      setup_fixtures
+      setup_couchdb_fixtures
+
       @car = ActiveRecordCar.create
       @wheels = [MongoMapperWheel.create, MongoMapperWheel.create, MongoMapperWheel.create]
 
@@ -150,6 +152,34 @@ class HasManyTest < Test::Unit::TestCase
       assert_set_equal ['ActiveRecordEngine', 'ActiveRecordEngine', 'ActiveRecordEngine'], components.map {|c| c.diagnosable_type}
     end
 
+    context "with an a active t_belongs_to association that is not auto destroyed" do
+      setup 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
+      end
+
+      should "should not eligible for deletion" do
+        assert_raises(Tenacity::ObjectIdInUseError) { ActiveRecordCar._t_delete(@car.id) }
+        assert_not_nil ActiveRecordCar._t_find(@car.id)
+      end
+
+      should "should be eligible for deletion if foreign key constraints are disabled" do
+        Tenacity::Association.any_instance.stubs(:foreign_key_constraints_enabled?).returns(false)
+        ActiveRecordCar._t_delete(@car.id)
+        assert_nil ActiveRecordCar._t_find(@car.id)
+      end
+    end
+
     context "with an autosave association" do
       setup do
         @source = ActiveRecordObject.create

data/test/association_features/has_one_test.rb

@@ -4,9 +4,11 @@ class HasOneTest < Test::Unit::TestCase
 
   context "A class with a has_one association to another class" do
     setup do
-      setup_all_fixtures
-      @climate_control_unit = ActiveRecordClimateControlUnit.create
-      @dashboard = MongoMapperDashboard.create(:active_record_climate_control_unit => @climate_control_unit)
+      setup_fixtures
+      setup_couchdb_fixtures
+
+      @dashboard = MongoMapperDashboard.create
+      @climate_control_unit = ActiveRecordClimateControlUnit.create(:mongo_mapper_dashboard => @dashboard)
     end
 
     should "memoize the association" do
@@ -23,8 +25,9 @@ class HasOneTest < Test::Unit::TestCase
     end
 
     should "be able to specify the class name of the associated class" do
+      dashboard = MongoMapperDashboard.create
       ash_tray = MongoMapperAshTray.create
-      dashboard = MongoMapperDashboard.create(:ash_tray => ash_tray)
+      dashboard.ash_tray = ash_tray
       assert_equal ash_tray, dashboard.ash_tray
     end
 
@@ -91,6 +94,17 @@ class HasOneTest < Test::Unit::TestCase
       assert_equal circuit_board, component
       assert_equal 'MongoMapperAlternator', component.diagnosable_type
     end
+
+    should "not be able to delete an object with an active t_belongs_to association" do
+      assert_raises(Tenacity::ObjectIdInUseError) { MongoMapperDashboard._t_delete(@dashboard.id) }
+      assert_not_nil MongoMapperDashboard._t_find(@dashboard.id)
+    end
+
+    should "be able to delete an object with an active t_belongs_to association if foreign key constraints are disabled" do
+      Tenacity::Association.any_instance.stubs(:foreign_key_constraints_enabled?).returns(false)
+      MongoMapperDashboard._t_delete(@dashboard.id)
+      assert_nil MongoMapperDashboard._t_find(@dashboard.id)
+    end
   end
 
 end

data/test/associations/has_one_test.rb

@@ -26,7 +26,6 @@ class HasOneTest < Test::Unit::TestCase
       end
 
       should "be able to invoke the post delete callback" do
-        @source.send("#{@foreign_key}=", @target)
         @source_class._t_delete([serialize_id(@source)])
       end
 

data/test/core/classmethods_test.rb

@@ -35,6 +35,13 @@ class ClassmethodsTest < Test::Unit::TestCase
     should("respond to mongo_mapper_has_many_target_ids=") { assert @object.respond_to?(:mongo_mapper_has_many_target_ids=) }
   end
 
+  context "A class including Tenacity with no associations" do
+    should "be able to be saved successfully" do
+      object = NoAssociations.new(:name => "Daniel")
+      assert object.save
+    end
+  end
+
   context "The object returned by a has_many association" do
     setup do
       setup_fixtures

data/test/fixtures/active_record_has_many_target.rb

@@ -6,12 +6,16 @@ class ActiveRecordHasManyTarget < ActiveRecord::Base
   t_belongs_to :data_mapper_object
   t_belongs_to :mongo_mapper_object
   require_mongoid { t_belongs_to :mongoid_object }
+  require_ripple { t_belongs_to :ripple_object }
   t_belongs_to :sequel_object
+  require_toystore { t_belongs_to :toystore_object }
 
   t_belongs_to :active_record_has_many_target_testable, :polymorphic => true
   t_belongs_to :couch_rest_has_many_target_testable, :polymorphic => true
   t_belongs_to :data_mapper_has_many_target_testable, :polymorphic => true
   t_belongs_to :mongo_mapper_has_many_target_testable, :polymorphic => true
   require_mongoid { t_belongs_to :mongoid_has_many_target_testable, :polymorphic => true }
+  require_ripple { t_belongs_to :ripple_has_many_target_testable, :polymorphic => true }
   t_belongs_to :sequel_has_many_target_testable, :polymorphic => true
+  require_toystore { t_belongs_to :toystore_has_many_target_testable, :polymorphic => true }
 end

data/test/fixtures/active_record_has_one_target.rb

@@ -6,12 +6,16 @@ class ActiveRecordHasOneTarget < ActiveRecord::Base
   t_belongs_to :data_mapper_object
   t_belongs_to :mongo_mapper_object
   require_mongoid { t_belongs_to :mongoid_object }
+  require_ripple { t_belongs_to :ripple_object }
   t_belongs_to :sequel_object
+  require_toystore { t_belongs_to :toystore_object }
 
   t_belongs_to :active_record_has_one_target_testable, :polymorphic => true
   t_belongs_to :couch_rest_has_one_target_testable, :polymorphic => true
   t_belongs_to :data_mapper_has_one_target_testable, :polymorphic => true
   t_belongs_to :mongo_mapper_has_one_target_testable, :polymorphic => true
   require_mongoid { t_belongs_to :mongoid_has_one_target_testable, :polymorphic => true }
+  require_ripple { t_belongs_to :ripple_has_one_target_testable, :polymorphic => true }
   t_belongs_to :sequel_has_one_target_testable, :polymorphic => true
+  require_toystore { t_belongs_to :toystore_has_one_target_testable, :polymorphic => true }
 end

data/test/fixtures/active_record_object.rb

@@ -6,28 +6,36 @@ class ActiveRecordObject < ActiveRecord::Base
   t_has_one :data_mapper_has_one_target
   t_has_one :mongo_mapper_has_one_target
   require_mongoid { t_has_one :mongoid_has_one_target }
+  require_ripple { t_has_one :ripple_has_one_target }
   t_has_one :sequel_has_one_target
+  require_toystore { t_has_one :toystore_has_one_target }
 
   t_has_one :active_record_has_one_target, :as => :active_record_has_one_target_testable
   t_has_one :couch_rest_has_one_target, :as => :couch_rest_has_one_target_testable
   t_has_one :data_mapper_has_one_target, :as => :data_mapper_has_one_target_testable
   t_has_one :mongo_mapper_has_one_target, :as => :mongo_mapper_has_one_target_testable
   require_mongoid { t_has_one :mongoid_has_one_target, :as => :mongoid_has_one_target_testable }
+  require_ripple { t_has_one :ripple_has_one_target, :as => :ripple_has_one_target_testable }
   t_has_one :sequel_has_one_target, :as => :sequel_has_one_target_testable
+  require_toystore { t_has_one :toystore_has_one_target, :as => :toystore_has_one_target_testable }
 
   t_has_many :active_record_has_many_targets
   t_has_many :couch_rest_has_many_targets
   t_has_many :data_mapper_has_many_targets
   t_has_many :mongo_mapper_has_many_targets
   require_mongoid { t_has_many :mongoid_has_many_targets }
+  require_ripple { t_has_many :ripple_has_many_targets }
   t_has_many :sequel_has_many_targets
+  require_toystore { t_has_many :toystore_has_many_targets }
 
   t_has_many :active_record_has_many_targets, :as => :active_record_has_many_target_testable
   t_has_many :couch_rest_has_many_targets, :as => :couch_rest_has_many_target_testable
   t_has_many :data_mapper_has_many_targets, :as => :data_mapper_has_many_target_testable
   t_has_many :mongo_mapper_has_many_targets, :as => :mongo_mapper_has_many_target_testable
   require_mongoid { t_has_many :mongoid_has_many_targets, :as => :mongoid_has_many_target_testable }
+  require_ripple { t_has_many :ripple_has_many_targets, :as => :ripple_has_many_target_testable }
   t_has_many :sequel_has_many_targets, :as => :sequel_has_many_target_testable
+  require_toystore { t_has_many :toystore_has_many_targets, :as => :toystore_has_many_target_testable }
 
   t_has_one :mongo_mapper_autosave_true_has_one_target, :autosave => true
   t_has_one :mongo_mapper_autosave_false_has_one_target, :autosave => false

data/test/fixtures/couch_rest_has_many_target.rb

@@ -7,13 +7,17 @@ class CouchRestHasManyTarget < CouchRest::Model::Base
   t_belongs_to :data_mapper_object
   t_belongs_to :mongo_mapper_object
   require_mongoid { t_belongs_to :mongoid_object }
+  require_ripple { t_belongs_to :ripple_object }
   t_belongs_to :sequel_object
+  require_toystore { t_belongs_to :toystore_object }
 
   t_belongs_to :active_record_has_many_target_testable, :polymorphic => true
   t_belongs_to :couch_rest_has_many_target_testable, :polymorphic => true
   t_belongs_to :data_mapper_has_many_target_testable, :polymorphic => true
   t_belongs_to :mongo_mapper_has_many_target_testable, :polymorphic => true
   require_mongoid { t_belongs_to :mongoid_has_many_target_testable, :polymorphic => true }
+  require_ripple { t_belongs_to :ripple_has_many_target_testable, :polymorphic => true }
   t_belongs_to :sequel_has_many_target_testable, :polymorphic => true
+  require_toystore { t_belongs_to :toystore_has_many_target_testable, :polymorphic => true }
 end