dm-constraints 0.9.10 → 0.9.11

data/History.txt

@@ -1,3 +1,13 @@
+=== 0.9.11 / 2009-03-29
+
+* 5 major enhancements:
+
+  * Added :destroy! constraints
+  * Added support for 1:1 constraints
+  * Added support for M:M constraints
+  * Add'l rspecs
+  * Updated readme.txt
+
 === 0.9.10 / 2009-01-19
 
 * 1 major enhancement:

data/README.txt

@@ -2,3 +2,51 @@
 
 Plugin that adds foreign key constraints to associations.
 Currently supports only PostgreSQL and MySQL
+
+All constraints are added to the underlying database, but constraining is implemented in
+pure ruby.
+
+
+=== Constraints
+
+ - :protect     returns false on destroy if there are child records
+ - :destroy     deletes children if present
+ - :destroy!    deletes children directly without instantiating the resource, bypassing any hooks
+                Does not support 1:1 Relationships as #destroy! is not supported on Resource in dm-master
+ - :set_nil     sets parent id to nil in child associations
+                Not valid for M:M relationships as duplicate records could be created (see explanation in specs)
+ - :skip        Does nothing with children, results in orphaned records
+
+By default a relationship will PROTECT its children.
+
+
+=== Cardinality Notes
+ * 1:1
+  * Applicable constraints: [:set_nil, :skip, :protect, :destroy]
+
+ * 1:M
+  * Applicable constraints: [:set_nil, :skip, :protect, :destroy, :destroy!]
+
+ * M:M
+  * Applicable constraints: [:skip, :protect, :destroy, :destroy!]
+
+
+=== Examples
+
+# 1:M Example
+class Farmer
+  has n, :pigs #equivalent to: has n, :pigs, :constraint => :protect
+end
+
+# M:M Example
+class Articles
+  has n, :tags, :through => Resource, :constraint => :destroy
+end
+class Tags
+  has n, :articles, :through => Resource, :constraint => :destroy
+end
+
+# 1:1 Example
+class Farmer
+  has 1, :beloved_sheep, :constraint => :protect
+end

data/Rakefile

@@ -12,7 +12,7 @@ AUTHOR = 'Dirkjan Bussink'
 EMAIL  = 'd.bussink [a] gmail [d] com'
 GEM_NAME = 'dm-constraints'
 GEM_VERSION = DataMapper::Constraints::VERSION
-GEM_DEPENDENCIES = [['dm-core', "~>#{GEM_VERSION}"]]
+GEM_DEPENDENCIES = [['dm-core', GEM_VERSION]]
 GEM_CLEAN = %w[ log pkg coverage ]
 GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.txt LICENSE TODO History.txt ] }
 

data/lib/dm-constraints/data_objects_adapter.rb

@@ -2,8 +2,26 @@ module DataMapper
   module Constraints
     module DataObjectsAdapter
       module SQL
+
+        ##
+        # generates all foreign key create constraint statements for valid relationships
+        #   given repository and a model
+        #
+        # This wraps calls to create_constraints_statement
+        #
+        # @see #create_constraints_statement
+        #
+        # @param repository_name [Symbol] Name of the repository to constrain
+        #
+        # @param model [DataMapper::Model] Model to constrain
+        #
+        # @return [Array[String]] List of statements to create constraints
+        #
+        #
+        # @api public
         def create_constraints_statements(repository_name, model)
           model.many_to_one_relationships.map do |relationship|
+
             table_name      = model.storage_name(repository_name)
             constraint_name = constraint_name(table_name, relationship.name)
             next if constraint_exists?(table_name, constraint_name)
@@ -13,8 +31,16 @@ module DataMapper
             foreign_table = parent.storage_name(repository_name)
             foreign_keys  = parent.key.map { |key| property_to_column_name(parent.repository(repository_name), key, false) }
 
-            one_to_many_relationship = parent.relationships.values.select { |rel| rel.child_model == model }.first
-            delete_constraint_type = case one_to_many_relationship.delete_constraint
+            #Anonymous relationshps for :through => Resource
+            one_to_many_relationship = parent.relationships.values.select { |rel|
+              rel.options[:near_relationship_name] == Extlib::Inflection.tableize(model.name).to_sym
+            }.first
+
+            one_to_many_relationship ||= parent.relationships.values.select { |rel|
+              rel.child_model == model
+            }.first
+
+            delete_constraint_type = case one_to_many_relationship.nil? ? :protect : one_to_many_relationship.delete_constraint
             when :protect, nil
               "NO ACTION"
             when :destroy, :destroy!
@@ -24,10 +50,27 @@ module DataMapper
             when :skip
               nil
             end
+
             create_constraints_statement(table_name, constraint_name, keys, foreign_table, foreign_keys, delete_constraint_type) if delete_constraint_type
           end.compact
         end
 
+        ##
+        # generates all foreign key destroy constraint statements for valid relationships
+        #   given repository and a model
+        #
+        # This wraps calls to destroy_constraints_statement
+        #
+        # @see #destroy_constraints_statement
+        #
+        # @param repository_name [Symbol] Name of the repository to constrain
+        #
+        # @param model [DataMapper::Model] Model to constrain
+        #
+        # @return [Array[String]] List of statements to destroy constraints
+        #
+        #
+        # @api public
         def destroy_constraints_statements(repository_name, model)
           model.many_to_one_relationships.map do |relationship|
             table_name      = model.storage_name(repository_name)
@@ -35,11 +78,30 @@ module DataMapper
             next unless constraint_exists?(table_name, constraint_name)
 
             destroy_constraints_statement(table_name, constraint_name)
+
           end.compact
         end
 
         private
 
+        ##
+        # Generates the SQL statement to create a constraint
+        #
+        # @param table_name [String] name of table to constrain
+        #
+        # @param constraint_name [String] name of foreign key constraint
+        #
+        # @param keys [Array[String]] keys that refer to another table
+        #
+        # @param foreign_table [String] table fk refers to
+        #
+        # @param foreign_keys [Array[String]] keys on foreign table that constraint refers to
+        #
+        # @param delete_constraint_type [String] the constraint to add to the table
+        #
+        # @return [String] SQL DDL Statement to create a constraint
+        #
+        # @api private
         def create_constraints_statement(table_name, constraint_name, keys, foreign_table, foreign_keys, delete_constraint_type)
           <<-EOS.compress_lines
             ALTER TABLE #{quote_table_name(table_name)}
@@ -51,6 +113,16 @@ module DataMapper
           EOS
         end
 
+        ##
+        # Generates the SQL statement to destroy a constraint
+        #
+        # @param table_name [String] name of table to constrain
+        #
+        # @param constraint_name [String] name of foreign key constraint
+        #
+        # @return [String] SQL DDL Statement to destroy a constraint
+        #
+        # @api private
         def destroy_constraints_statement(table_name, constraint_name)
           <<-EOS.compress_lines
             ALTER TABLE #{quote_table_name(table_name)}
@@ -58,10 +130,30 @@ module DataMapper
           EOS
         end
 
+        ##
+        # generates a unique constraint name given a table and a relationships
+        #
+        # @param table_name [String] name of table to constrain
+        #
+        # @param relationships_name [String] name of the relationship to constrain
+        #
+        # @return [String] name of the constraint
+        #
+        # @api private
         def constraint_name(table_name, relationship_name)
           "#{table_name}_#{relationship_name}_fk"
         end
 
+        ##
+        # SQL quotes a foreign key constraint name
+        #
+        # @see #quote_table_name
+        #
+        # @param foreign_key [String] SQL quotes a foreign key name
+        #
+        # @return [String] quoted constraint name
+        #
+        # @api private
         def quote_constraint_name(foreign_key)
           quote_table_name(foreign_key)
         end
@@ -78,6 +170,7 @@ module DataMapper
           def auto_migrate_constraints_down(repository_name, *descendants)
             descendants = DataMapper::Resource.descendants.to_a if descendants.empty?
             descendants.each do |model|
+              repository_name ||= model.repository(repository_name).name
               if model.storage_exists?(repository_name)
                 adapter = model.repository(repository_name).adapter
                 next unless adapter.respond_to?(:destroy_constraints_statements)
@@ -90,6 +183,7 @@ module DataMapper
           def auto_migrate_constraints_up(retval, repository_name, *descendants)
             descendants = DataMapper::Resource.descendants.to_a if descendants.empty?
             descendants.each do |model|
+              repository_name ||= model.repository(repository_name).name
               adapter = model.repository(repository_name).adapter
               next unless adapter.respond_to?(:create_constraints_statements)
               statements = adapter.create_constraints_statements(repository_name, model)

data/lib/dm-constraints/delete_constraint.rb

@@ -8,16 +8,57 @@ module DataMapper
 
       module ClassMethods
         DELETE_CONSTRAINT_OPTIONS = [:protect, :destroy, :destroy!, :set_nil, :skip]
+
+        ##
+        # Checks that the constraint type is appropriate to the relationship
+        #
+        # @param cardinality [Fixnum] cardinality of relationship
+        #
+        # @param name [Symbol] name of relationship to evaluate constraint of
+        #
+        # @param options [Hash] options hash
+        #
+        # @raises ArgumentError
+        #
+        # @return [nil]
+        #
+        # @api semi-public
         def check_delete_constraint_type(cardinality, name, options = {})
+          #Make sure options contains :constraint key, whether nil or not
+          options[:constraint] ||= nil
           constraint_type = options[:constraint]
           return if constraint_type.nil?
+
           delete_constraint_options = DELETE_CONSTRAINT_OPTIONS.map { |o| ":#{o}" }
           if !DELETE_CONSTRAINT_OPTIONS.include?(constraint_type)
             raise ArgumentError, ":constraint option must be one of #{delete_constraint_options * ', '}"
           end
+
+          if constraint_type == :set_nil && self.relationships[name].is_a?(DataMapper::Associations::RelationshipChain)
+            raise ArgumentError, "Constraint type :set_nil is not valid for M:M relationships"
+          end
+
+          if cardinality == 1 && constraint_type == :destroy!
+            raise ArgumentError, "Constraint type :destroy! is not valid for 1:1 relationships"
+          end
         end
 
-        # TODO: that should be moved to a 'util-like' module
+        ##
+        # Temporarily changes the visibility of a method so a block can be evaluated against it
+        #
+        # @param method [Symobl] method to change visibility of
+        #
+        # @param from_visibility [Symbol] original visibility
+        #
+        # @param to_visibility [Symbol] temporary visibility
+        #
+        # @param block [Proc] proc to run
+        #
+        # @notes  TODO: this should be moved to a 'util-like' module
+        #
+        # @return [nil]
+        #
+        # @api semi-public
         def with_changed_method_visibility(method, from_visibility, to_visibility, &block)
           send(to_visibility, method)
           yield
@@ -26,33 +67,119 @@ module DataMapper
 
       end
 
-      def add_delete_constraint_option(name, repository_name, child_model, parent_model, options = {})
-        @delete_constraint = options[:constraint]
+      ##
+      # Addes the delete constraint options to a relationship
+      #
+      # @param params [*ARGS] Arguments passed to Relationship#initialize or RelationshipChain#initialize
+      #
+      # @notes This takes *params because it runs before the initializer for Relationships and RelationshipChains
+      #   which have different method signatures
+      #
+      # @return [nil]
+      #
+      # @api semi-public
+      def add_delete_constraint_option(*params)
+        opts = params.last
+
+        if opts.is_a?(Hash)
+          #if it is a chain, set the constraint on the 1:M near relationship(anonymous)
+          if self.is_a?(DataMapper::Associations::RelationshipChain)
+            opts = params.last
+            near_rel = opts[:parent_model].relationships[opts[:near_relationship_name]]
+            near_rel.options[:constraint] = opts[:constraint]
+            near_rel.instance_variable_set "@delete_constraint", opts[:constraint]
+          end
+
+          @delete_constraint = params.last[:constraint]
+        end
       end
 
+      ##
+      # Checks delete constraints prior to destroying a dm resource or collection
+      #
+      # @throws :halt
+      #
+      # @notes
+      #   - It only considers a relationship's constraints if this is the parent model (ie a child shouldn't delete a parent)
+      #   - RelationshipChains are skipped, as they are evaluated by their underlying 1:M relationships
+      #
+      # @returns [nil]
+      #
+      # @api semi-public
       def check_delete_constraints
         model.relationships.each do |rel_name, rel|
+          #Only look at relationships where this model is the parent
+          next if rel.parent_model != model
+
+          #Don't delete across M:M relationships, instead use their anonymous 1:M Relationships
+          next if rel.is_a?(DataMapper::Associations::RelationshipChain)
+
           children = self.send(rel_name)
-          case rel.delete_constraint
-          when nil, :protect
-            # only prevent deletion if the resource is a parent in a relationship and has children
-            throw(:halt, false) if children && children.respond_to?(:empty?) && !children.empty?
-          when :destroy
-            if children && children.respond_to?(:each)
-              children.each { |child| child.destroy }
-            end
-          when :set_nil
-            if children && children.respond_to?(:each)
-              children.each do |child|
-                child.class.many_to_one_relationships.each do |mto_rel|
-                  child.send("#{mto_rel.name}=", nil) if child.send(mto_rel.name).eql?(self)
-                end
-              end
-            end
-          end # case
+          if children.kind_of?(DataMapper::Collection)
+            check_collection_delete_constraints(rel,children)
+          elsif children
+            check_resource_delete_constraints(rel,children)
+          end
         end # relationships
       end # check_delete_constraints
 
+      ##
+      # Performs the meat of the check_delete_constraints method for a collection of resources
+      #
+      # @param rel [DataMapper::Associations::Relationship] relationship being evaluated
+      #
+      # @param children [~DataMapper::Collection] child records to constrain
+      #
+      # @see #check_delete_constraints
+      #
+      # @api semi-public
+      def check_collection_delete_constraints(rel, children)
+        case rel.delete_constraint
+        when nil, :protect
+          unless children.empty?
+            DataMapper.logger.error("Could not delete #{self.class} a child #{children.first.class} exists")
+            throw(:halt,false)
+          end
+        when :destroy
+          children.each{|child| child.destroy}
+        when :destroy!
+          children.destroy!
+        when :set_nil
+          children.each do |child|
+            child.class.many_to_one_relationships.each do |mto_rel|
+              child.send("#{mto_rel.name}=", nil) if child.send(mto_rel.name).eql?(self)
+            end
+          end
+        end
+      end
+
+      ##
+      # Performs the meat of check_delete_constraints method for a single resource
+      #
+      # @param rel [DataMapper::Associations::Relationship] the relationship to evaluate
+      #
+      # @param child [~DataMapper::Model] the model to constrain
+      #
+      # @see #check_delete_constraints
+      #
+      # @api semi-public
+      def check_resource_delete_constraints(rel, child)
+        case rel.delete_constraint
+        when nil, :protect
+          unless child.nil?
+            DataMapper.logger.error("Could not delete #{self.class} a child #{child.class} exists")
+            throw(:halt,false)
+          end
+        when :destroy
+          child.destroy
+        when :destroy!
+          #not supported in dm-master, an exception should have been raised on class load
+        when :set_nil
+          child.class.many_to_one_relationships.each do |mto_rel|
+            child.send("#{mto_rel.name}=", nil) if child.send(mto_rel.name).eql?(self)
+          end
+        end
+      end
 
     end # DeleteConstraint
   end # Constraints

data/lib/dm-constraints/mysql_adapter.rb

@@ -6,6 +6,16 @@ module DataMapper
 
         private
 
+        ##
+        # MySQL specific query to determine to drop a foreign key
+        #
+        # @param table_name [Symbol] name of table to check constraint on
+        #
+        # @param constraint_name [~String] name of constraint to check for
+        #
+        # @return [String] SQL DDL to destroy a constraint
+        #
+        # @api private
         def destroy_constraints_statement(table_name, constraint_name)
           <<-EOS.compress_lines
             ALTER TABLE #{quote_table_name(table_name)}
@@ -13,7 +23,17 @@ module DataMapper
           EOS
         end
 
-        def constraint_exists?(storage_name, constraint_name)
+        ##
+        # MySQL specific query to determine if a constraint exists
+        #
+        # @param table_name [Symbol] name of table to check constraint on
+        #
+        # @param constraint_name [~String] name of constraint to check for
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def constraint_exists?(table_name, constraint_name)
           statement = <<-EOS.compress_lines
             SELECT COUNT(*)
             FROM `information_schema`.`table_constraints`
@@ -22,7 +42,7 @@ module DataMapper
             AND `table_name` = ?
             AND `constraint_name` = ?
           EOS
-          query(statement, db_name, storage_name, constraint_name).first > 0
+          query(statement, db_name, table_name, constraint_name).first > 0
         end
       end
     end

data/lib/dm-constraints/postgres_adapter.rb

@@ -6,7 +6,17 @@ module DataMapper
 
         private
 
-        def constraint_exists?(storage_name, constraint_name)
+        ##
+        # Postgres specific query to determine if a constraint exists
+        #
+        # @param table_name [Symbol] name of table to check constraint on
+        #
+        # @param constraint_name [~String] name of constraint to check for
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def constraint_exists?(table_name, constraint_name)
           statement = <<-EOS.compress_lines
             SELECT COUNT(*)
             FROM "information_schema"."table_constraints"
@@ -14,7 +24,7 @@ module DataMapper
             AND "table_name" = ?
             AND "constraint_name" = ?
           EOS
-          query(statement, storage_name, constraint_name).first > 0
+          query(statement, table_name, constraint_name).first > 0
         end
       end
     end

data/lib/dm-constraints/version.rb

@@ -1,5 +1,5 @@
 module DataMapper
   module Constraints
-    VERSION = '0.9.10'
+    VERSION = '0.9.11'
   end
 end

data/lib/dm-constraints.rb

@@ -3,7 +3,7 @@ require 'rubygems'
 require 'pathname'
 
 # Add all external dependencies for the plugin here
-gem 'dm-core', '~>0.9.10'
+gem 'dm-core', '0.9.11'
 require 'dm-core'
 
 # Require plugin-files
@@ -12,6 +12,25 @@ require Pathname(__FILE__).dirname.expand_path / 'dm-constraints' / 'postgres_ad
 require Pathname(__FILE__).dirname.expand_path / 'dm-constraints' / 'mysql_adapter'
 require Pathname(__FILE__).dirname.expand_path / 'dm-constraints' / 'delete_constraint'
 
+module DataMapper
+  module Associations
+    class RelationshipChain
+      include Extlib::Hook
+      include DataMapper::Constraints::DeleteConstraint
+
+      attr_reader :delete_constraint
+      OPTIONS << :constraint
+
+      # initialize is a private method in Relationship
+      # and private methods can not be "advised" (hooked into)
+      # in extlib.
+      with_changed_method_visibility(:initialize, :private, :public) do
+        before :initialize, :add_delete_constraint_option
+      end
+    end
+  end
+end
+
 module DataMapper
   module Associations
     class Relationship
@@ -40,6 +59,10 @@ module DataMapper
       include DeleteConstraint::ClassMethods
     end
 
+    ##
+    # Add before hooks to #has to check for proper constraint definitions
+    # Add before hooks to #destroy to properly constrain children
+    #
     def self.included(model)
       model.extend(ClassMethods)
       model.class_eval do

data/spec/integration/constraints_spec.rb

@@ -2,11 +2,7 @@ require 'pathname'
 require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
 
 ADAPTERS.each do |adapter|
-
   describe 'DataMapper::Constraints' do
-
-    # load_models_for_metaphor :stable, :farmer, :cow
-
     before do
       DataMapper::Repository.adapters[:default] =  DataMapper::Repository.adapters[adapter]
 
@@ -43,10 +39,43 @@ ADAPTERS.each do |adapter|
         belongs_to :farmer
       end
 
+      #Used to test a belongs_to association with no has() association
+      #on the other end
+      class ::Pig
+        include DataMapper::Resource
+        include DataMapper::Constraints
+
+        property :id,   Serial
+        property :name, String
+
+        belongs_to :farmer
+      end
+
+      #Used to test M:M :through => Resource relationships
+      class ::Chicken
+        include DataMapper::Resource
+        include DataMapper::Constraints
+
+        property :id,   Serial
+        property :name, String
+
+        has n, :tags, :through => Resource
+      end
+
+      class ::Tag
+        include DataMapper::Resource
+        include DataMapper::Constraints
+
+        property :id,     Serial
+        property :phrase, String
+
+        has n, :chickens, :through => Resource
+      end
+
       DataMapper.auto_migrate!
-    end
+    end # before
 
-    it "is included when DataMapper::Searchable is loaded" do
+    it "is included when DataMapper::Constraints is loaded" do
       Cow.new.should be_kind_of(DataMapper::Constraints)
     end
 
@@ -65,16 +94,24 @@ ADAPTERS.each do |adapter|
       lambda { @c1 = Cow.create(:name => "Bea", :stable_id => s.id + 1) }.should raise_error
     end
 
-    # :constraint associations
-    # value  | on deletion of parent...
-    # ---------------------------------
-    # :protect | raises exception if there are child records
-    # :destroy | deletes children
-    # :destroy! | deletes children directly without instantiating the resource, bypassing any hooks
-    # :set_nil | sets parent id to nil in child associations
-    # :skip | does not do anything with children (they'll become orphan records)
+    describe "belongs_to without matching has association" do
+      before do
+        @f1 = Farmer.create(:first_name => "John", :last_name => "Doe")
+        @f2 = Farmer.create(:first_name => "Some", :last_name => "Body")
+        @p = Pig.create(:name => "Bea", :farmer => @f2)
+      end
+      it "should destroy the parent if there are no children in the association" do
+        @f1.destroy.should == true
+      end
+
+      it "the child should be destroyable" do
+        @p.destroy.should == true
+      end
+
+    end
 
     describe "constraint options" do
+
       describe "when no constraint options are given" do
 
         it "should destroy the parent if there are no children in the association" do
@@ -96,128 +133,424 @@ ADAPTERS.each do |adapter|
         before do
           class ::Farmer
             has n, :cows, :constraint => :protect
+            has 1, :pig, :constraint => :protect
+          end
+          class ::Pig
+            belongs_to :farmer
           end
           class ::Cow
             belongs_to :farmer
           end
+          class ::Chicken
+            has n, :tags, :through => Resource, :constraint => :protect
+          end
+          class ::Tag
+            has n, :chickens, :through => Resource, :constraint => :protect
+          end
         end
 
-        it "should destroy the parent if there are no children in the association" do
-          @f1 = Farmer.create(:first_name => "John", :last_name => "Doe")
-          @f2 = Farmer.create(:first_name => "Some", :last_name => "Body")
-          @c1 = Cow.create(:name => "Bea", :farmer => @f2)
-          @f1.destroy.should == true
+        describe "one-to-one associations" do
+          before do
+            @f1 = Farmer.create(:first_name => "Mary", :last_name => "Smith")
+            @p1 = Pig.create(:name => "Morton",:farmer => @f1)
+          end
+
+          it "should not destroy the parent if there are children in the association" do
+            @f1.destroy.should == false
+          end
+
+          it "the child should be destroyable" do
+            @p1.destroy.should == true
+          end
         end
 
-        it "should not destroy the parent if there are children in the association" do
-          @f = Farmer.create(:first_name => "John", :last_name => "Doe")
-          @c1 = Cow.create(:name => "Bea", :farmer => @f)
-          @f.destroy.should == false
+        describe "one-to-many associations" do
+          before do
+            @f1 = Farmer.create(:first_name => "John", :last_name => "Doe")
+            @f2 = Farmer.create(:first_name => "Some", :last_name => "Body")
+            @c1 = Cow.create(:name => "Bea", :farmer => @f2)
+          end
+
+          it "should destroy the parent if there are no children in the association" do
+            @f1.destroy.should == true
+          end
+
+          it "should not destroy the parent if there are children in the association" do
+            @f2.destroy.should == false
+          end
+
+          it "the child should be destroyable" do
+            @c1.destroy.should == true
+          end
         end
 
-        it "the child should be destroyable" do
-          @f = Farmer.create(:first_name => "John", :last_name => "Doe")
-          @c = Cow.create(:name => "Bea", :farmer => @f)
-          @c.destroy.should == true
+        describe "many-to-many associations" do
+          before do
+            @t1   = Tag.create(:phrase => "silly chicken")
+            @t2   = Tag.create(:phrase => "serious chicken")
+            @chk1 = Chicken.create(:name =>"Frank the Chicken", :tags => [@t2])
+          end
+
+          it "should destroy the parent if there are no children in the association" do
+            @t1.destroy.should == true
+          end
+
+          it "should not destroy the parent if there are children in the association" do
+            @t2.destroy.should == false
+          end
+
+          it "the child should be destroyable" do
+            @chk1.tags.clear
+            @chk1.save.should == true
+            @chk1.tags.should be_empty
+          end
         end
 
-      end
+      end # when constraint protect is given
+
+      describe "when :constraint => :destroy! is given" do
+        before do
+          class ::Farmer
+            has n, :cows, :constraint => :destroy!
+          end
+          class ::Cow
+            belongs_to :farmer
+          end
+          class ::Chicken
+            has n, :tags, :through => Resource, :constraint => :destroy!
+          end
+          class ::Tag
+            has n, :chickens, :through => Resource, :constraint => :destroy!
+          end
+
+          DataMapper.auto_migrate!
+        end
+
+        describe "one-to-many associations" do
+          before(:each) do
+            @f = Farmer.create(:first_name => "John", :last_name => "Doe")
+            @c1 = Cow.create(:name => "Bea", :farmer => @f)
+            @c2 = Cow.create(:name => "Riksa", :farmer => @f)
+          end
+
+          it "should let the parent to be destroyed" do
+            @f.destroy.should == true
+            @f.should be_new_record
+          end
+
+          it "should destroy the children" do
+            @f.destroy
+            @f.cows.all? { |c| c.should be_new_record }
+          end
+
+          it "the child should be destroyable" do
+            @c1.destroy.should == true
+          end
+
+        end
+
+        describe "many-to-many associations" do
+          before do
+            @t1   = Tag.create(:phrase => "floozy")
+            @t2   = Tag.create(:phrase => "dirty")
+            @chk1 = Chicken.create(:name => "Nancy Chicken", :tags => [@t1, @t2])
+          end
+
+          it "should destroy! the parent and the children, too" do
+            @chk1.destroy.should == true
+            @chk1.should be_new_record
+
+            # @t1 & @t2 should still exist, the chicken_tags should have been deleted
+            ChickenTag.all.should be_empty
+            @t1.should_not be_new_record
+            @t2.should_not be_new_record
+          end
+
+          it "the child should be destroyable" do
+            @chk1.destroy.should == true
+          end
+        end
+
+      end # when :constraint => :destroy! is given
 
       describe "when :constraint => :destroy is given" do
         before do
           class ::Farmer
             has n, :cows, :constraint => :destroy
+            has 1, :pig, :constraint => :destroy
           end
           class ::Cow
             belongs_to :farmer
           end
+          class ::Chicken
+            has n, :tags, :through => Resource, :constraint => :destroy
+          end
+          class ::Tag
+            has n, :chickens, :through => Resource, :constraint => :destroy
+          end
+
           DataMapper.auto_migrate!
         end
 
-        it "should destroy the parent and the children, too" do
-          #NOTE: the repository wrapper is needed in order for
-          # the identity map to work (otherwise @c1 in the below two calls
-          # would refer to different instances)
-          repository do
+        describe "one-to-one associations" do
+          before do
+            @f = Farmer.create(:first_name => "Ted", :last_name => "Cornhusker")
+            @p = Pig.create(:name => "BaconBits", :farmer => @f)
+          end
+
+          it "should let the parent to be destroyed" do
+            @f.destroy.should == true
+            @f.should be_new_record
+          end
+
+          it "should destroy the children" do
+            pig = @f.pig
+            @f.destroy
+            pig.should be_new_record
+          end
+
+          it "the child should be destroyable" do
+            @p.destroy.should == true
+          end
+        end
+
+        describe "one-to-many associations" do
+          before(:each) do
             @f = Farmer.create(:first_name => "John", :last_name => "Doe")
             @c1 = Cow.create(:name => "Bea", :farmer => @f)
             @c2 = Cow.create(:name => "Riksa", :farmer => @f)
+          end
+
+          it "should let the parent to be destroyed" do
             @f.destroy.should == true
             @f.should be_new_record
-            @c1.should be_new_record
-            @c2.should be_new_record
           end
+
+          it "should destroy the children" do
+            @f.destroy
+            @f.cows.all? { |c| c.should be_new_record }
+            @f.should be_new_record
+          end
+
+          it "the child should be destroyable" do
+            @c1.destroy.should == true
+          end
+
         end
 
-        it "the child should be destroyable" do
-          @f = Farmer.create(:first_name => "John", :last_name => "Doe")
-          @c = Cow.create(:name => "Bea", :farmer => @f)
-          @c.destroy.should == true
+        describe "many-to-many associations" do
+          before do
+            @t1   = Tag.create :phrase => "floozy"
+            @t2   = Tag.create :phrase => "dirty"
+            @chk1 = Chicken.create :name => "Nancy Chicken", :tags => [@t1,@t2]
+          end
+
+          it "should destroy the parent and the children, too" do
+            @chk1.destroy.should == true
+            @chk1.should be_new_record
+
+            #@t1 & @t2 should still exist, the chicken_tags should have been deleted
+            ChickenTag.all.should be_empty
+            @t1.should_not be_new_record
+            @t2.should_not be_new_record
+          end
+
+          it "the child should be destroyable" do
+            @chk1.destroy.should == true
+          end
         end
 
-      end
+      end # when :constraint => :destroy is given
 
       describe "when :constraint => :set_nil is given" do
         before do
           class ::Farmer
             has n, :cows, :constraint => :set_nil
+            has 1, :pig, :constraint => :set_nil
           end
           class ::Cow
             belongs_to :farmer
           end
+          # NOTE: M:M Relationships are not supported,
+          # see "when checking constraint types" tests at bottom
           DataMapper.auto_migrate!
         end
 
-        it "destroying the parent should set children foreign keys to nil" do
-          @f = Farmer.create(:first_name => "John", :last_name => "Doe")
-          @c1 = Cow.create(:name => "Bea", :farmer => @f)
-          @c2 = Cow.create(:name => "Riksa", :farmer => @f)
-          cows = @f.cows
-          @f.destroy.should == true
-          cows.all? { |cow| cow.farmer.should be_nil }
+        describe "one-to-one associations" do
+          before do
+            @f = Farmer.create(:first_name => "Mr", :last_name => "Hands")
+            @p = Pig.create(:name => "Greasy", :farmer => @f)
+          end
+
+          it "should let the parent to be destroyed" do
+            @f.destroy.should == true
+          end
+
+          it "should set the child's foreign_key id to nil" do
+            pig = @f.pig
+            @f.destroy.should == true
+            pig.farmer.should be_nil
+          end
+
+          it "the child should be destroyable" do
+            @p.destroy.should == true
+          end
+
         end
 
-        it "the child should be destroyable" do
-          @f = Farmer.create(:first_name => "John", :last_name => "Doe")
-          @c = Cow.create(:name => "Bea", :farmer => @f)
-          @c.destroy.should == true
+        describe "one-to-many associations" do
+          before(:each) do
+            @f = Farmer.create(:first_name => "John", :last_name => "Doe")
+            @c1 = Cow.create(:name => "Bea", :farmer => @f)
+            @c2 = Cow.create(:name => "Riksa", :farmer => @f)
+          end
+
+          it "should let the parent to be destroyed" do
+            @f.destroy.should == true
+            @f.should be_new_record
+          end
+
+          it "should set the foreign_key ids of children to nil" do
+            @f.destroy
+            @f.cows.all? { |c| c.farmer.should be_nil }
+          end
+
+          it "the children should be destroyable" do
+            @c1.destroy.should == true
+            @c2.destroy.should == true
+          end
+
         end
 
-      end # describe
+      end # describe "when :constraint => :set_nil is given" do
 
       describe "when :constraint => :skip is given" do
         before do
           class ::Farmer
             has n, :cows, :constraint => :skip
+            has 1, :pig, :constraint => :skip
           end
           class ::Cow
             belongs_to :farmer
           end
+          class ::Chicken
+            has n, :tags, :through => Resource, :constraint => :skip
+          end
+          class ::Tag
+            has n, :chickens, :through => Resource, :constraint => :skip
+          end
           DataMapper.auto_migrate!
         end
 
-        it "destroying the parent should be allowed, children should become orphan records" do
-          @f = Farmer.create(:first_name => "John", :last_name => "Doe")
-          @c1 = Cow.create(:name => "Bea", :farmer => @f)
-          @c2 = Cow.create(:name => "Riksa", :farmer => @f)
-          @f.destroy.should == true
-          @c1.farmer.should be_new_record
-          @c2.farmer.should be_new_record
+        describe "one-to-one associations" do
+          before do
+            @f = Farmer.create(:first_name => "William", :last_name => "Shepard")
+            @p  = Pig.create(:name => "Jiggles The Pig", :farmer => @f)
+          end
+
+          it "should let the parent be destroyed" do
+            @f.destroy.should == true
+            @f.should be_new_record
+            # @p.farmer.should be_new_record
+          end
+
+          it "should let the children become orphan records" do
+            @f.destroy
+            @p.farmer.should be_new_record
+          end
+
+          it "the child should be destroyable" do
+            @p.destroy.should == true
+          end
+
         end
 
-        it "the child should be destroyable" do
-          @f = Farmer.create(:first_name => "John", :last_name => "Doe")
-          @c = Cow.create(:name => "Bea", :farmer => @f)
-          @c.destroy.should == true
+        describe "one-to-many associations" do
+          before do
+            @f = Farmer.create(:first_name => "John", :last_name => "Doe")
+            @c1 = Cow.create(:name => "Bea", :farmer => @f)
+            @c2 = Cow.create(:name => "Riksa", :farmer => @f)
+          end
+
+          it "should let the parent to be destroyed" do
+            @f.destroy.should == true
+            @f.should be_new_record
+          end
+
+          it "should let the children become orphan records" do
+            @f.destroy
+            @c1.farmer.should be_new_record
+            @c2.farmer.should be_new_record
+          end
+
+          it "the children should be destroyable" do
+            @c1.destroy.should == true
+            @c2.destroy.should == true
+          end
+
+        end
+
+        describe "many-to-many associations" do
+          before do
+            @t = Tag.create(:phrase => "Richard Pryor's Chicken")
+            @chk = Chicken.create(:name => "Delicious", :tags => [@t])
+          end
+
+          it "the children should be destroyable" do
+            @chk.destroy.should == true
+          end
         end
 
-      end # describe
+      end # describe "when :constraint => :skip is given"
+
+      describe "when checking constraint types" do
+
+        #M:M relationships results in a join table composed of a two part primary key
+        # setting a portion of the primary key is not possible for two reasons:
+        # 1. the columns are defined as :nullable => false
+        # 2. there could be duplicate rows if more than one of either of the types
+        #   was deleted while being associated to the same type on the other side of the relationshp
+        #   Given
+        #   Turkey(Name: Ted, ID: 1) =>
+        #       Tags[Tag(Phrase: awesome, ID: 1), Tag(Phrase: fat, ID: 2)]
+        #   Turkey(Name: Steve, ID: 2) =>
+        #       Tags[Tag(Phrase: awesome, ID: 1), Tag(Phrase: flamboyant, ID: 3)]
+        #
+        #   Table turkeys_tags would look like (turkey_id, tag_id)
+        #     (1, 1)
+        #     (1, 2)
+        #     (2, 1)
+        #     (2, 3)
+        #
+        #   If both turkeys were deleted and pk was set null
+        #     (null, 1)
+        #     (null, 2)
+        #     (null, 1) #at this time there would be a duplicate row error
+        #     (null, 3)
+        #
+        #   I would suggest setting :constraint to :skip in this scenario which will leave
+        #     you with orphaned rows.
+        it "should raise an error if :set_nil is given for a M:M relationship" do
+          lambda{
+            class ::Chicken
+              has n, :tags, :through => Resource, :constraint => :set_nil
+            end
+            class ::Tag
+              has n, :chickens, :through => Resource, :constraint => :set_nil
+            end
+          }.should raise_error(ArgumentError)
+        end
 
-      describe "when an invalid option is given" do
-        before do
+        # Resource#destroy! is not suppored in dm-core
+        it "should raise an error if :destroy! is given for a 1:1 relationship" do
+          lambda do
+            class ::Farmer
+              has 1, :pig, :constraint => :destroy!
+            end
+          end.should raise_error(ArgumentError)
         end
 
-        it "should raise an error" do
+        it "should raise an error if an unknown type is given" do
           lambda do
             class ::Farmer
               has n, :cows, :constraint => :chocolate

data/spec/spec_helper.rb

@@ -1,10 +1,10 @@
 require 'pathname'
 require 'rubygems'
 
-gem 'rspec', '~>1.1.11'
+gem 'rspec', '~>1.2'
 require 'spec'
 
-gem 'dm-core', '~>0.9.10'
+gem 'dm-core', '0.9.11'
 require 'dm-core'
 
 ADAPTERS = []

data/tasks/spec.rb

@@ -1,5 +1,5 @@
 begin
-  gem 'rspec', '~>1.1.11'
+  gem 'rspec', '~>1.2'
   require 'spec'
   require 'spec/rake/spectask'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dm-constraints
 version: !ruby/object:Gem::Version 
-  version: 0.9.10
+  version: 0.9.11
 platform: ruby
 authors: 
 - Dirkjan Bussink
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-19 00:00:00 -08:00
+date: 2009-03-29 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -18,9 +18,9 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ~>
+    - - "="
       - !ruby/object:Gem::Version 
-        version: 0.9.10
+        version: 0.9.11
     version: 
 description: DataMapper plugin constraining relationships
 email: