tenacity 0.2.0 → 0.3.0

data/lib/tenacity/orm_ext/mongoid.rb

@@ -0,0 +1,108 @@
+module Tenacity
+  # Tenacity relationships on Mongoid objects require no special keys
+  # defined on the object.  Tenacity will define the keys that it needs
+  # to support the relationships.  Take the following class for example:
+  #
+  #   class Car
+  #     include Mongoid::Document
+  #     include Tenacity
+  #
+  #     t_has_many    :wheels
+  #     t_has_one     :dashboard
+  #     t_belongs_to  :driver
+  #   end
+  #
+  # == t_belongs_to
+  #
+  # The +t_belongs_to+ association will define a key named after the association.
+  # The example above will create a key named <tt>:driver_id</tt>
+  #
+  #
+  # == t_has_one
+  #
+  # The +t_has_one+ association will not define any new keys on the object, since
+  # the associated object holds the foreign key.
+  #
+  #
+  # == t_has_many
+  #
+  # The +t_has_many+ association will define a key named after the association.
+  # The example above will create a key named <tt>:wheels_ids</tt>
+  #
+  module Mongoid
+
+    def self.setup(model) #:nodoc:
+      require 'mongoid'
+      if model.included_modules.include?(::Mongoid::Document)
+        model.send :include, Mongoid::InstanceMethods
+        model.extend Mongoid::ClassMethods
+      end
+    rescue LoadError
+      # Mongoid not available
+    end
+
+    module ClassMethods #:nodoc:
+      def _t_find(id)
+        (id.nil? || id.to_s.strip == "") ? nil : find(id)
+      rescue ::Mongoid::Errors::DocumentNotFound
+        nil
+      end
+
+      def _t_find_bulk(ids)
+        find(ids)
+      rescue ::Mongoid::Errors::DocumentNotFound
+        []
+      end
+
+      def _t_find_first_by_associate(property, id)
+        find(:first, :conditions => { property => id })
+      end
+
+      def _t_find_all_by_associate(property, id)
+        find(:all, :conditions => { property => id })
+      end
+
+      def _t_initialize_has_many_association(association)
+        unless self.respond_to?(association.foreign_keys_property)
+          field association.foreign_keys_property, :type => Array
+          after_save { |record| self.class._t_save_associates(record, association) }
+        end
+      end
+
+      def _t_initialize_belongs_to_association(association)
+        unless self.respond_to?(association.foreign_key)
+          field association.foreign_key, :type => String
+          before_save { |record| self.class._t_stringify_belongs_to_value(record, association) }
+        end
+      end
+
+      def _t_delete(ids, run_callbacks=true)
+        docs = _t_find_bulk(ids)
+        if run_callbacks
+          docs.each { |doc| doc.destroy }
+        else
+          docs.each { |doc| doc.delete }
+        end
+      end
+    end
+
+    module InstanceMethods #:nodoc:
+      def _t_reload
+        reload
+      end
+
+      def _t_associate_many(association, associate_ids)
+        self.send(association.foreign_keys_property + '=', associate_ids.map { |associate_id| associate_id.to_s })
+      end
+
+      def _t_get_associate_ids(association)
+        self.send(association.foreign_keys_property)
+      end
+
+      def _t_clear_associates(association)
+        self.send(association.foreign_keys_property + '=', [])
+      end
+    end
+
+  end
+end

data/lib/tenacity/orm_ext/sequel.rb

@@ -0,0 +1,134 @@
+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
+      end
+    rescue LoadError
+      # Sequel not available
+    end
+
+    module ClassMethods #:nodoc:
+      attr_accessor :_t_has_many_associations
+      attr_accessor :_t_belongs_to_associations
+
+      def _t_find(id)
+        self[id]
+      end
+
+      def _t_find_bulk(ids)
+        return [] if ids.nil? || ids.empty?
+        filter(:id => ids)
+      end
+
+      def _t_find_first_by_associate(property, id)
+        first(property.to_sym => id)
+      end
+
+      def _t_find_all_by_associate(property, id)
+        filter(property => id)
+      end
+
+      def _t_initialize_has_many_association(association)
+        @_t_has_many_associations ||= []
+        @_t_has_many_associations << association
+      end
+
+      def _t_initialize_belongs_to_association(association)
+        @_t_belongs_to_associations ||= []
+        @_t_belongs_to_associations << association
+      end
+
+      def _t_delete(ids, run_callbacks=true)
+        if run_callbacks
+          filter(:id => ids).destroy
+        else
+          filter(:id => ids).delete
+        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 after_save
+        associations = self.class._t_has_many_associations || []
+        associations.each { |association| self.class._t_save_associates(self, association) }
+        super
+      end
+
+      def _t_reload
+        reload
+      end
+
+      def _t_clear_associates(association)
+        db["delete from #{association.join_table} where #{association.association_key} = #{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 (#{self.id}, '#{associate_id}')"].insert
+          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] }
+      end
+    end
+
+  end
+end

data/lib/tenacity/version.rb

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

data/tenacity.gemspec

@@ -22,12 +22,23 @@ 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 "yard", "~> 0.6.4"
+
+  # Relational DBs
+  s.add_development_dependency "sqlite3-ruby", "~> 1.3.1"
+  s.add_development_dependency "activerecord", "~> 3.0.0"
+  s.add_development_dependency "datamapper", "~> 1.0.2"
+  s.add_development_dependency "dm-sqlite-adapter", "~> 1.0.2"
+  s.add_development_dependency "sequel", "~> 3.19.0"
+
+  # MongoDB
   s.add_development_dependency "mongo_mapper", "~> 0.8.6"
   s.add_development_dependency "bson_ext", "~> 1.1.3"
-  s.add_development_dependency "activerecord", "~> 3.0.0"
-  s.add_development_dependency "sqlite3-ruby", "~> 1.3.1"
+  s.add_development_dependency "mongoid", "~> 2.0.0.beta"
+
+  # CouchDB
   s.add_development_dependency "couchrest", "~> 1.0.0"
-  s.add_development_dependency "couchrest_model"
+  s.add_development_dependency "couchrest_model", "~> 1.0.0.beta"
 
   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

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class BelongsToTest < Test::Unit::TestCase
+
+  context "A class with a belongs_to association to another class" do
+    setup do
+      setup_fixtures
+      @car = ActiveRecordCar.create
+      @wheel = MongoMapperWheel.create(:active_record_car => @car)
+    end
+
+    should "memoize the association" do
+      assert_equal @car, @wheel.active_record_car
+
+      other_car = ActiveRecordCar.create
+      assert_equal @car, MongoMapperWheel.find(@wheel.id).active_record_car
+      MongoMapperWheel.update(@wheel.id, :active_record_car => other_car)
+      assert_equal other_car, MongoMapperWheel.find(@wheel.id).active_record_car
+
+      assert_equal @car, @wheel.active_record_car
+      assert_equal other_car, @wheel.active_record_car(true)
+    end
+
+    should "be able to specify the class name of the associated class" do
+      dashboard = MongoMapperDashboard.create
+      ash_tray = MongoMapperAshTray.create(:dashboard => dashboard)
+      assert_equal dashboard, ash_tray.dashboard
+    end
+
+    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 !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
+  end
+
+end

data/test/association_features/has_many_test.rb

@@ -0,0 +1,110 @@
+require 'test_helper'
+
+class HasManyTest < Test::Unit::TestCase
+
+  context "A class with a belongs_to association to another class" do
+    setup do
+      setup_fixtures
+      @car = ActiveRecordCar.create
+      @wheels = [MongoMapperWheel.create, MongoMapperWheel.create, MongoMapperWheel.create]
+
+      @car.mongo_mapper_wheels = @wheels
+      @car.save
+    end
+
+    should "memoize the association" do
+      assert_equal @wheels, @car.mongo_mapper_wheels
+
+      other_wheels = [MongoMapperWheel.create, MongoMapperWheel.create, MongoMapperWheel.create]
+      assert_equal @wheels, ActiveRecordCar.find(@car.id).mongo_mapper_wheels
+      ActiveRecordCar.find(@car.id).update_attribute(:mongo_mapper_wheels, other_wheels)
+      assert_equal other_wheels, ActiveRecordCar.find(@car.id).mongo_mapper_wheels
+
+      assert_equal @wheels, @car.mongo_mapper_wheels
+      assert_equal other_wheels, @car.mongo_mapper_wheels(true)
+    end
+
+    should "be able to specify the class name of the associated class" do
+      vent_1 = MongoMapperVent.create
+      vent_2 = MongoMapperVent.create
+      vent_3 = MongoMapperVent.create
+      dashboard = MongoMapperDashboard.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
+    end
+
+    should "be able to specify the foreign key to use for the class" do
+      car = ActiveRecordCar.create
+      door_1 = CouchRestDoor.create({})
+      door_2 = CouchRestDoor.create({})
+      door_3 = CouchRestDoor.create({})
+      car.couch_rest_doors = [door_1, door_2, door_3]
+      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
+    end
+
+    should "save the associate object when it is added as an associate if the parent object is saved" do
+      car = ActiveRecordCar.create
+      door_1 = CouchRestDoor.new({})
+      assert_nil door_1.id
+
+      old_count = CouchRestDoor.count
+      car.couch_rest_doors << door_1
+      assert_equal old_count + 1, CouchRestDoor.count
+    end
+
+    should "not save the associate object when it is added as an associate if the parent object is not saved" do
+      car = ActiveRecordCar.new
+      door_1 = CouchRestDoor.new({})
+      assert_nil door_1.id
+
+      old_count = CouchRestDoor.count
+      car.couch_rest_doors << door_1
+      assert_equal old_count, CouchRestDoor.count
+    end
+
+    should "save all unsaved associates when the parent object is saved" do
+      car = ActiveRecordCar.new
+      door_1 = CouchRestDoor.new({})
+      assert_nil door_1.id
+
+      old_count = CouchRestDoor.count
+      car.couch_rest_doors << door_1
+      assert_equal old_count, CouchRestDoor.count
+      car.save
+      assert_equal old_count + 1, CouchRestDoor.count
+      assert_set_equal [door_1], ActiveRecordCar.find(car.id).couch_rest_doors
+    end
+
+    context "with a set of associates that need to be deleted" do
+      setup do
+        @new_car = ActiveRecordCar.create
+        @door_1 = CouchRestDoor.create({})
+        @door_2 = CouchRestDoor.create({})
+        @door_3 = CouchRestDoor.create({})
+        @new_car.couch_rest_doors = [@door_1, @door_2, @door_3]
+        @new_car.save
+      end
+
+      should "be able to delete all associates" do
+        assert_set_equal [@door_1, @door_2, @door_3], ActiveRecordCar.find(@new_car.id).couch_rest_doors
+        old_count = CouchRestDoor.count
+        @new_car.couch_rest_doors.delete_all
+        assert_equal old_count - 3, CouchRestDoor.count
+        assert_set_equal [], ActiveRecordCar.find(@new_car.id).couch_rest_doors
+      end
+
+      should "be able to destroy all associates" do
+        assert_set_equal [@door_1, @door_2, @door_3], ActiveRecordCar.find(@new_car.id).couch_rest_doors
+        old_count = CouchRestDoor.count
+        @new_car.couch_rest_doors.destroy_all
+        assert_equal old_count - 3, CouchRestDoor.count
+        assert_set_equal [], ActiveRecordCar.find(@new_car.id).couch_rest_doors
+      end
+    end
+  end
+
+end

data/test/association_features/has_one_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+class HasOneTest < Test::Unit::TestCase
+
+  context "A class with a has_one association to another class" do
+    setup do
+      setup_fixtures
+      @climate_control_unit = ActiveRecordClimateControlUnit.create
+      @dashboard = MongoMapperDashboard.create(:active_record_climate_control_unit => @climate_control_unit)
+    end
+
+    should "memoize the association" do
+      assert_equal @climate_control_unit, @dashboard.active_record_climate_control_unit
+
+      other_climate_control_unit = ActiveRecordClimateControlUnit.create
+      assert_equal @climate_control_unit, MongoMapperDashboard.find(@dashboard.id).active_record_climate_control_unit
+      ActiveRecordClimateControlUnit.update(@climate_control_unit.id, :mongo_mapper_dashboard_id => nil)
+      ActiveRecordClimateControlUnit.update(other_climate_control_unit.id, :mongo_mapper_dashboard_id => @dashboard.id)
+      assert_equal other_climate_control_unit, MongoMapperDashboard.find(@dashboard.id).active_record_climate_control_unit
+
+      assert_equal @climate_control_unit, @dashboard.active_record_climate_control_unit
+      assert_equal other_climate_control_unit, @dashboard.active_record_climate_control_unit(true)
+    end
+
+    should "be able to specify the class name of the associated class" do
+      ash_tray = MongoMapperAshTray.create
+      dashboard = MongoMapperDashboard.create(:ash_tray => ash_tray)
+      assert_equal ash_tray, dashboard.ash_tray
+    end
+
+    should "be able to specify the foreign key to use for the class" do
+      car = ActiveRecordCar.create
+      windshield = CouchRestWindshield.create(:active_record_car => car)
+      assert_equal windshield, car.couch_rest_windshield
+
+      engine = ActiveRecordEngine.create(:active_record_car => car)
+      assert_equal engine, car.active_record_engine
+    end
+  end
+
+end