dm-constraints 0.10.2 → 1.0.0.rc1

data/lib/dm-constraints/migrations.rb

@@ -1,265 +1,48 @@
+require 'dm-migrations/auto_migration'
+
 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
-
-          select(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
+      module SingletonMethods
 
-        ##
-        # 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
+        def auto_migrate!(repository_name = nil)
+          repository_execute(:auto_migrate_down_constraints!, repository_name)
+          descendants = super
+          repository_execute(:auto_migrate_up_constraints!, repository_name)
+          descendants
         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
+      private
 
-          ##
-          # 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
+        def auto_migrate_down!(repository_name = nil)
+          repository_execute(:auto_migrate_down_constraints!, repository_name)
+          super
         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
+        def auto_migrate_up!(repository_name = nil)
+          descendants = super
+          repository_execute(:auto_migrate_up_constraints!, repository_name)
+          descendants
         end
 
-        include SQL
       end
 
-      module Sqlite3Adapter
-        def constraint_exists?(*)
-          false
-        end
-
-        def create_relationship_constraint(*)
-          false
-        end
+      module Model
 
-        def destroy_relationship_constraint(*)
-          false
-        end
-      end
+      private
 
-      module Model
-        def auto_migrate_down_with_constraints!(repository_name = self.repository_name)
+        def auto_migrate_down_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)
+        def auto_migrate_up_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)
@@ -268,7 +51,10 @@ module DataMapper
             adapter.send(method, relationship)
           end
         end
+
       end
-    end
-  end
-end
+
+    end # module Migrations
+
+  end # module Constraints
+end # module DataMapper

data/lib/dm-constraints/relationships.rb

@@ -0,0 +1,41 @@
+require 'dm-core'
+require 'dm-constraints/delete_constraint'
+
+module DataMapper
+  module Associations
+
+    class OneToMany::Relationship
+
+      include DataMapper::Hook
+      include Constraints::DeleteConstraint
+
+      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_constraint_option
+      end
+
+    end
+
+    class ManyToMany::Relationship
+
+      OPTIONS << :constraint
+
+      private
+
+      # TODO: document
+      # @api semipublic
+      chainable do
+        def one_to_many_options
+          super.merge(:constraint => @constraint)
+        end
+      end
+    end
+
+  end
+end

data/lib/dm-constraints.rb

@@ -1,41 +1,21 @@
-require 'dm-constraints/delete_constraint'
+require 'dm-core'
+
 require 'dm-constraints/migrations'
+require 'dm-constraints/delete_constraint'
+require 'dm-constraints/relationships'
+require 'dm-constraints/adapters/dm-abstract-adapter'
 
 module DataMapper
-  module Associations
-    class OneToMany::Relationship
-      include Extlib::Hook
-      include Constraints::DeleteConstraint
-
-      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_constraint_option
-      end
-    end
-
-    class ManyToMany::Relationship
-
-      OPTIONS << :constraint
 
-      private
+  extend Constraints::Migrations::SingletonMethods
 
-      # TODO: document
-      # @api semipublic
-      chainable do
-        def one_to_many_options
-          super.merge(:constraint => @constraint)
-        end
-      end
-    end
+  module Model
+    extend DataMapper::Constraints::Migrations::Model
+    append_extensions DataMapper::Constraints::Migrations::Model
   end
 
   module Constraints
+
     include DeleteConstraint
 
     module ClassMethods
@@ -57,15 +37,61 @@ module DataMapper
       RUBY
     end
 
+    def self.include_constraint_api
+      DataMapper::Repository.adapters.values.each do |adapter|
+        DataMapper::Adapters.include_constraint_api(ActiveSupport::Inflector.demodulize(adapter.class.name))
+      end
+    end
+
     Model.append_inclusions self
-  end
 
-  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 # module Constraints
+
+  module Adapters
+
+    class AbstractAdapter
+      include DataMapper::Constraints::Adapters::AbstractAdapter
+    end
+
+    extend Chainable
+
+    class << self
+
+      def include_constraint_api(const_name)
+        require constraint_extensions(const_name)
+        if Constraints::Adapters.const_defined?(const_name)
+          adapter = const_get(const_name)
+          adapter.send(:include, constraint_module(const_name))
+        end
+      rescue LoadError
+        # do nothing
+      end
+
+      def constraint_module(const_name)
+        Constraints::Adapters.const_get(const_name)
       end
+
+    private
+
+      # @api private
+      def constraint_extensions(const_name)
+        name = adapter_name(const_name)
+        name = 'do' if name == 'dataobjects'
+        "dm-constraints/adapters/dm-#{name}-adapter"
+      end
+
     end
-  end
-end
+
+    extendable do
+      # @api private
+      def const_added(const_name)
+        include_constraint_api(const_name)
+        super
+      end
+    end
+
+  end # module Adapters
+
+  Constraints.include_constraint_api
+
+end # module DataMapper

data/spec/integration/constraints_spec.rb

@@ -1,11 +1,15 @@
 require 'spec_helper'
 
-ADAPTERS.each do |name, connection_uri|
-  describe 'DataMapper::Constraints', "(with #{name})" do
+describe 'DataMapper::Constraints', "(with #{DataMapper::Spec.adapter_name})" do
+  supported_by :all do
     before :all do
-      @adapter    = DataMapper.setup(:default, connection_uri)
-      @repository = DataMapper.repository(@adapter.name)
+      @in_memory = defined?(DataMapper::Adapters::InMemoryAdapter) && @adapter.kind_of?(DataMapper::Adapters::InMemoryAdapter)
+      @yaml      = defined?(DataMapper::Adapters::YamlAdapter)     && @adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
 
+      @skip = @in_memory || @yaml
+    end
+
+    before :all do
       class ::Article
         include DataMapper::Resource
 
@@ -72,9 +76,11 @@ ADAPTERS.each do |name, connection_uri|
         @comment = @author.comments.create(:body => 'So true!')
       end
 
-      it 'should not be able to create related objects with a failing foreign key constraint' do
-        article = Article.create(:title => 'Man on the Moon')
-        lambda { Comment.create(:body => 'So true!', :article_id => article_id.id + 1) }.should raise_error
+      supported_by :postgres, :mysql do
+        it 'should not be able to create related objects with a failing foreign key constraint' do
+          article = Article.create(:title => 'Man on the Moon')
+          lambda { Comment.create(:body => 'So true!', :article_id => article.id + 1) }.should raise_error(DataObjects::IntegrityError)
+        end
       end
     end
 
@@ -180,6 +186,10 @@ ADAPTERS.each do |name, connection_uri|
         end
 
         describe 'many-to-many associations' do
+          before do
+            pending 'The adapter does not support m:m associations yet' if @skip
+          end
+
           before do
             @author         = Author.create(:first_name => 'John', :last_name => 'Doe')
             @another_author = Author.create(:first_name => 'Joe',  :last_name => 'Smith')
@@ -275,6 +285,10 @@ ADAPTERS.each do |name, connection_uri|
         end
 
         describe 'many-to-many associations' do
+          before do
+            pending 'The adapter does not support m:m associations yet' if @skip
+          end
+
           before do
             @article       = Article.create(:title => 'Man on the Moon')
             @other_article = Article.create(:title => 'Dolly cloned')
@@ -370,6 +384,10 @@ ADAPTERS.each do |name, connection_uri|
         end
 
         describe 'many-to-many associations' do
+          before do
+            pending 'The adapter does not support m:m associations yet' if @skip
+          end
+
           before do
             @article       = Article.create(:title => 'Man on the Moon')
             @other_article = Article.create(:title => 'Dolly cloned')
@@ -538,6 +556,10 @@ ADAPTERS.each do |name, connection_uri|
         end
 
         describe 'many-to-many associations' do
+          before do
+            pending 'The adapter does not support m:m associations yet' if @skip
+          end
+
           before do
             @article       = Article.create(:title => 'Man on the Moon')
             @other_article = Article.create(:title => 'Dolly cloned')

data/spec/isolated/require_after_setup_spec.rb

@@ -0,0 +1,36 @@
+require 'spec'
+require 'isolated/require_spec'
+require 'dm-core/spec/setup'
+require 'dm-core/spec/lib/adapter_helpers'
+
+# To really test this behavior, this spec needs to be run in isolation and not
+# as part of the typical rake spec run, which requires dm-transactions upfront
+
+Spec::Runner.configure do |config|
+  config.extend(DataMapper::Spec::Adapters::Helpers)
+end
+
+describe "require 'dm-constraints' after calling DataMapper.setup" do
+
+  before(:all) do
+
+    @adapter = DataMapper::Spec.adapter
+    require 'dm-constraints'
+
+    class ::Person
+      include DataMapper::Resource
+      property :id, Serial
+      has n, :tasks
+    end
+
+    class ::Task
+      include DataMapper::Resource
+      property :id, Serial
+      belongs_to :person
+    end
+
+  end
+
+  it_should_behave_like "require 'dm-constraints'"
+
+end

data/spec/isolated/require_before_setup_spec.rb

@@ -0,0 +1,36 @@
+require 'spec'
+require 'isolated/require_spec'
+require 'dm-core/spec/setup'
+require 'dm-core/spec/lib/adapter_helpers'
+
+# To really test this behavior, this spec needs to be run in isolation and not
+# as part of the typical rake spec run, which requires dm-transactions upfront
+
+Spec::Runner.configure do |config|
+  config.extend(DataMapper::Spec::Adapters::Helpers)
+end
+
+describe "require 'dm-constraints' before calling DataMapper.setup" do
+
+  before(:all) do
+
+    require 'dm-constraints'
+    @adapter = DataMapper::Spec.adapter
+
+    class ::Person
+      include DataMapper::Resource
+      property :id, Serial
+      has n, :tasks
+    end
+
+    class ::Task
+      include DataMapper::Resource
+      property :id, Serial
+      belongs_to :person
+    end
+
+  end
+
+  it_should_behave_like "require 'dm-constraints'"
+
+end

data/spec/isolated/require_spec.rb

@@ -0,0 +1,14 @@
+shared_examples_for "require 'dm-constraints'" do
+
+  it "should include the constraint api in the DataMapper namespace" do
+    DataMapper::Model.respond_to?(:auto_migrate_down_constraints!, true).should be_true
+    DataMapper::Model.respond_to?(:auto_migrate_up_constraints!,   true).should be_true
+  end
+  
+  it "should include the constraint api into the adapter" do
+    @adapter.respond_to?(:constraint_exists?             ).should be_true
+    @adapter.respond_to?(:create_relationship_constraint ).should be_true
+    @adapter.respond_to?(:destroy_relationship_constraint).should be_true
+  end
+
+end