dm-constraints 0.9.11 → 0.10.0

data/{History.txt → History.rdoc}

@@ -1,6 +1,8 @@
-=== 0.9.11 / 2009-03-29
+=== 0.10.0 / 2009-10-15
+
+* Updated to work with dm-core 0.10.0
 
-* 5 major enhancements:
+=== 0.9.11 / 2009-03-29
 
   * Added :destroy! constraints
   * Added support for 1:1 constraints

data/Manifest.txt

@@ -1,14 +1,12 @@
-History.txt
+History.rdoc
 LICENSE
 Manifest.txt
-README.txt
+README.rdoc
 Rakefile
 TODO
 lib/dm-constraints.rb
-lib/dm-constraints/data_objects_adapter.rb
 lib/dm-constraints/delete_constraint.rb
-lib/dm-constraints/mysql_adapter.rb
-lib/dm-constraints/postgres_adapter.rb
+lib/dm-constraints/migrations.rb
 lib/dm-constraints/version.rb
 spec/integration/constraints_spec.rb
 spec/spec.opts

data/Rakefile

@@ -1,5 +1,4 @@
 require 'pathname'
-require 'rubygems'
 
 ROOT    = Pathname(__FILE__).dirname.expand_path
 JRUBY   = RUBY_PLATFORM =~ /java/
@@ -14,10 +13,10 @@ GEM_NAME = 'dm-constraints'
 GEM_VERSION = DataMapper::Constraints::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 ] }
+GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.rdoc LICENSE TODO History.rdoc ] }
 
 PROJECT_NAME = 'datamapper'
-PROJECT_URL  = "http://github.com/sam/dm-more/tree/master/#{GEM_NAME}"
+PROJECT_URL  = "http://github.com/datamapper/dm-more/tree/master/#{GEM_NAME}"
 PROJECT_DESCRIPTION = PROJECT_SUMMARY = 'DataMapper plugin constraining relationships'
 
 [ ROOT, ROOT.parent ].each do |dir|

data/lib/dm-constraints/delete_constraint.rb

@@ -1,13 +1,12 @@
 module DataMapper
   module Constraints
     module DeleteConstraint
-
       def self.included(base)
         base.extend(ClassMethods)
       end
 
       module ClassMethods
-        DELETE_CONSTRAINT_OPTIONS = [:protect, :destroy, :destroy!, :set_nil, :skip]
+        CONSTRAINT_OPTIONS = [ :protect, :destroy, :destroy!, :set_nil, :skip ].to_set.freeze
 
         ##
         # Checks that the constraint type is appropriate to the relationship
@@ -23,26 +22,25 @@ module DataMapper
         # @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?
+        def check_delete_constraint_type(cardinality, name, *args)
+          options = extract_options(args)
 
-          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
+          return unless options.key?(:constraint)
+
+          constraint = options[:constraint]
 
-          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"
+          unless CONSTRAINT_OPTIONS.include?(constraint)
+            raise ArgumentError, ":constraint option must be one of #{CONSTRAINT_OPTIONS.to_a.join(', ')}"
           end
 
-          if cardinality == 1 && constraint_type == :destroy!
-            raise ArgumentError, "Constraint type :destroy! is not valid for 1:1 relationships"
+          # XXX: is any constraint valid with a :through relationship?
+          if constraint == :set_nil && options.key?(:through)
+            raise ArgumentError, 'Constraint type :set_nil is not valid for relationships using :through'
           end
         end
 
+        private
+
         ##
         # Temporarily changes the visibility of a method so a block can be evaluated against it
         #
@@ -62,38 +60,25 @@ module DataMapper
         def with_changed_method_visibility(method, from_visibility, to_visibility, &block)
           send(to_visibility, method)
           yield
+        ensure
           send(from_visibility, method)
         end
-
       end
 
       ##
-      # Addes the delete constraint options to a relationship
+      # Adds 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
+      # @param params [*ARGS] Arguments passed to Relationship#initialize
       #
       # @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
+      def add_constraint_option(name, child_model, parent_model, options = {})
+        @constraint = options.fetch(:constraint, :protect) || :skip
       end
 
+      private
+
       ##
       # Checks delete constraints prior to destroying a dm resource or collection
       #
@@ -101,86 +86,32 @@ module DataMapper
       #
       # @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
+      #   - Many to Many Relationships 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)
-          if children.kind_of?(DataMapper::Collection)
-            check_collection_delete_constraints(rel,children)
-          elsif children
-            check_resource_delete_constraints(rel,children)
+        relationships.each_value do |relationship|
+          next unless relationship.respond_to?(:constraint)
+          next unless association = relationship.get(self)
+
+          delete_allowed = case constraint = relationship.constraint
+            when :protect
+              Array(association).empty?
+            when :destroy, :destroy!
+              association.send(constraint)
+            when :set_nil
+              Array(association).all? do |resource|
+                resource.update(relationship.inverse => nil)
+              end
+            when :skip
+              true  # do nothing
           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
+          throw(:halt, false) unless delete_allowed
         end
       end
-
     end # DeleteConstraint
   end # Constraints
 end # DataMapper

data/lib/dm-constraints/migrations.rb

@@ -0,0 +1,274 @@
+module DataMapper
+  module Constraints
+    module Migrations
+      module SingletonMethods
+        def self.included(base)
+          # TODO: figure out how to make this work without AMC
+          base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            alias_method :auto_migrate_down_without_constraints!, :auto_migrate_down!
+            alias_method :auto_migrate_down!, :auto_migrate_down_with_constraints!
+
+            alias_method :auto_migrate_up_without_constraints!, :auto_migrate_up!
+            alias_method :auto_migrate_up!, :auto_migrate_up_with_constraints!
+          RUBY
+        end
+
+        def auto_migrate_down_with_constraints!(repository_name = nil)
+          repository_execute(:auto_migrate_down_with_constraints!, repository_name)
+          auto_migrate_down_without_constraints!(repository_name)
+        end
+
+        def auto_migrate_up_with_constraints!(repository_name = nil)
+          auto_migrate_up_without_constraints!(repository_name)
+          repository_execute(:auto_migrate_up_with_constraints!, repository_name)
+        end
+      end
+
+      module DataObjectsAdapter
+        ##
+        # Determine if a constraint exists for a table
+        #
+        # @param storage_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?(storage_name, constraint_name)
+          statement = <<-SQL.compress_lines
+            SELECT COUNT(*)
+            FROM "information_schema"."table_constraints"
+            WHERE "constraint_type" = 'FOREIGN KEY'
+            AND "table_schema" = ?
+            AND "table_name" = ?
+            AND "constraint_name" = ?
+          SQL
+
+          query(statement, schema_name, storage_name, constraint_name).first > 0
+        end
+
+        ##
+        # Create the constraint for a relationship
+        #
+        # @param relationship [Relationship]
+        #   the relationship to create the constraint for
+        #
+        # @return [true, false]
+        #   true if creating the constraints was successful
+        #
+        # @api semipublic
+        def create_relationship_constraint(relationship)
+          return false unless valid_relationship_for_constraint?(relationship)
+
+          source_model = relationship.source_model
+          source_table = source_model.storage_name(name)
+          source_key   = relationship.source_key
+
+          constraint_name = constraint_name(source_table, relationship.name)
+          return false if constraint_exists?(source_table, constraint_name)
+
+          constraint_type = case relationship.inverse.constraint
+            when :protect            then 'NO ACTION'
+            when :destroy, :destroy! then 'CASCADE'
+            when :set_nil            then 'SET NULL'
+          end
+
+          return false if constraint_type.nil?
+
+          storage_name           = relationship.source_model.storage_name(name)
+          reference_storage_name = relationship.target_model.storage_name(name)
+
+          foreign_keys   = relationship.source_key.map { |p| property_to_column_name(p, false) }
+          reference_keys = relationship.target_key.map { |p| property_to_column_name(p, false) }
+
+          execute(create_constraints_statement(storage_name, constraint_name, constraint_type, foreign_keys, reference_storage_name, reference_keys))
+        end
+
+        ##
+        # Remove the constraint for a relationship
+        #
+        # @param relationship [Relationship]
+        #   the relationship to remove the constraint for
+        #
+        # @return [true, false]
+        #   true if destroying the constraint was successful
+        #
+        # @api semipublic
+        def destroy_relationship_constraint(relationship)
+          return false unless valid_relationship_for_constraint?(relationship)
+
+          source_model = relationship.source_model
+          source_table = source_model.storage_name(name)
+
+          constraint_name = constraint_name(source_table, relationship.name)
+          return false unless constraint_exists?(source_table, constraint_name)
+
+          execute(destroy_constraints_statement(source_table, constraint_name))
+        end
+
+        private
+
+        ##
+        # Check to see if the relationship's constraints can be used
+        #
+        # Only one-to-one, one-to-many, and many-to-many relationships
+        # can be used for constraints.  They must also be in the same
+        # repository as the adapter is connected to.
+        #
+        # @param relationship [Relationship]
+        #   the relationship to check
+        #
+        # @return [true, false]
+        #   true if a constraint can be established for relationship
+        #
+        # @api private
+        def valid_relationship_for_constraint?(relationship)
+          return false unless relationship.source_repository_name == name || relationship.source_repository_name.nil?
+          return false unless relationship.target_repository_name == name || relationship.target_repository_name.nil?
+          return false unless relationship.kind_of?(Associations::ManyToOne::Relationship)
+          true
+        end
+
+        module SQL
+          private
+
+          ##
+          # Generates the SQL statement to create a constraint
+          #
+          # @param constraint_name [String]
+          #   name of the foreign key constraint
+          # @param constraint_type [String]
+          #   type of foreign key constraint to add to the table
+          # @param storage_name [String]
+          #   name of table to constrain
+          # @param foreign_keys [Array[String]]
+          #   columns in the table that refer to foreign table
+          # @param reference_storage_name [String]
+          #   table the foreign key refers to
+          # @param reference_storage_name [Array[String]]
+          #   columns the foreign table that are referred to
+          #
+          # @return [String]
+          #   SQL DDL Statement to create a constraint
+          #
+          # @api private
+          def create_constraints_statement(storage_name, constraint_name, constraint_type, foreign_keys, reference_storage_name, reference_keys)
+            <<-SQL.compress_lines
+              ALTER TABLE #{quote_name(storage_name)}
+              ADD CONSTRAINT #{quote_name(constraint_name)}
+              FOREIGN KEY (#{foreign_keys.join(', ')})
+              REFERENCES #{quote_name(reference_storage_name)} (#{reference_keys.join(', ')})
+              ON DELETE #{constraint_type}
+              ON UPDATE #{constraint_type}
+            SQL
+          end
+
+          ##
+          # Generates the SQL statement to destroy a constraint
+          #
+          # @param storage_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(storage_name, constraint_name)
+            <<-SQL.compress_lines
+              ALTER TABLE #{quote_name(storage_name)}
+              DROP CONSTRAINT #{quote_name(constraint_name)}
+            SQL
+          end
+
+          ##
+          # generates a unique constraint name given a table and a relationships
+          #
+          # @param storage_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(storage_name, relationship_name)
+            identifier = "#{storage_name}_#{relationship_name}"[0, self.class::IDENTIFIER_MAX_LENGTH - 3]
+            "#{identifier}_fk"
+          end
+        end
+
+        include SQL
+      end
+
+      module MysqlAdapter
+        module SQL
+          private
+
+          ##
+          # MySQL specific query to drop a foreign key
+          #
+          # @param storage_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(storage_name, constraint_name)
+            <<-SQL.compress_lines
+              ALTER TABLE #{quote_name(storage_name)}
+              DROP FOREIGN KEY #{quote_name(constraint_name)}
+            SQL
+          end
+        end
+
+        include SQL
+      end
+
+      module Sqlite3Adapter
+        def constraint_exists?(*)
+          false
+        end
+
+        def create_relationship_constraint(*)
+          false
+        end
+
+        def destroy_relationship_constraint(*)
+          false
+        end
+      end
+
+      module Model
+        def auto_migrate_down_with_constraints!(repository_name = self.repository_name)
+          return unless storage_exists?(repository_name)
+          return if self.respond_to?(:is_remixable?) && self.is_remixable?
+          execute_each_relationship(:destroy_relationship_constraint, repository_name)
+        end
+
+        def auto_migrate_up_with_constraints!(repository_name = self.repository_name)
+          return if self.respond_to?(:is_remixable?) && self.is_remixable?
+          execute_each_relationship(:create_relationship_constraint, repository_name)
+        end
+
+        private
+
+        def execute_each_relationship(method, repository_name)
+          adapter = DataMapper.repository(repository_name).adapter
+          return unless adapter.respond_to?(method)
+
+          relationships(repository_name).each_value do |relationship|
+            adapter.send(method, relationship)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dm-constraints/version.rb

@@ -1,5 +1,5 @@
 module DataMapper
   module Constraints
-    VERSION = '0.9.11'
+    VERSION = '0.10.0'.freeze
   end
 end

data/lib/dm-constraints.rb

@@ -1,58 +1,42 @@
-# Needed to import datamapper and other gems
-require 'rubygems'
-require 'pathname'
-
-# Add all external dependencies for the plugin here
-gem 'dm-core', '0.9.11'
-require 'dm-core'
-
-# Require plugin-files
-require Pathname(__FILE__).dirname.expand_path / 'dm-constraints' / 'data_objects_adapter'
-require Pathname(__FILE__).dirname.expand_path / 'dm-constraints' / 'postgres_adapter'
-require Pathname(__FILE__).dirname.expand_path / 'dm-constraints' / 'mysql_adapter'
-require Pathname(__FILE__).dirname.expand_path / 'dm-constraints' / 'delete_constraint'
+require 'dm-constraints/delete_constraint'
+require 'dm-constraints/migrations'
+require 'dm-constraints/version'
 
 module DataMapper
   module Associations
-    class RelationshipChain
+    class OneToMany::Relationship
       include Extlib::Hook
-      include DataMapper::Constraints::DeleteConstraint
+      include Constraints::DeleteConstraint
 
-      attr_reader :delete_constraint
       OPTIONS << :constraint
 
+      attr_reader :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
+        before :initialize, :add_constraint_option
       end
     end
-  end
-end
 
-module DataMapper
-  module Associations
-    class Relationship
-      include Extlib::Hook
-      include DataMapper::Constraints::DeleteConstraint
+    class ManyToMany::Relationship
 
-      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
+      private
+
+      # TODO: document
+      # @api semipublic
+      chainable do
+        def one_to_many_options
+          super.merge(:constraint => @constraint)
+        end
       end
     end
   end
-end
 
-module DataMapper
   module Constraints
-
     include DeleteConstraint
 
     module ClassMethods
@@ -65,28 +49,22 @@ module DataMapper
     #
     def self.included(model)
       model.extend(ClassMethods)
-      model.class_eval do
+      model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
         before_class_method :has, :check_delete_constraint_type
-        if method_defined?(:destroy)
+
+        if instance_methods.any? { |m| m.to_sym == :destroy }
           before :destroy, :check_delete_constraints
         end
-      end
+      RUBY
     end
-
-  end
-
-  class AutoMigrator
-    include Extlib::Hook
-    include DataMapper::Constraints::DataObjectsAdapter::Migration
   end
 
-  module Adapters
-    if defined?(MysqlAdapter)
-      MysqlAdapter.send :include, DataMapper::Constraints::MysqlAdapter::SQL
-    end
-
-    if defined?(PostgresAdapter)
-      PostgresAdapter.send :include, DataMapper::Constraints::PostgresAdapter::SQL
+  module Migrations
+    constants.each do |const_name|
+      if Constraints::Migrations.const_defined?(const_name)
+        mod = const_get(const_name)
+        mod.send(:include, Constraints::Migrations.const_get(const_name))
+      end
     end
   end
 end