dm-constraints 1.1.0 → 1.2.0.rc1

data/Gemfile

@@ -5,26 +5,26 @@ source 'http://rubygems.org'
 SOURCE         = ENV.fetch('SOURCE', :git).to_sym
 REPO_POSTFIX   = SOURCE == :path ? ''                                : '.git'
 DATAMAPPER     = SOURCE == :path ? Pathname(__FILE__).dirname.parent : 'http://github.com/datamapper'
-DM_VERSION     = '~> 1.1.0'
-DO_VERSION     = '~> 0.10.2'
+DM_VERSION     = '~> 1.2.0.rc1'
+DO_VERSION     = '~> 0.10.6'
 DM_DO_ADAPTERS = %w[ sqlite postgres mysql oracle sqlserver ]
 
 gem 'dm-core', DM_VERSION, SOURCE => "#{DATAMAPPER}/dm-core#{REPO_POSTFIX}"
 
 group :development do
 
-  gem 'jeweler', '~> 1.5.2'
-  gem 'rake',    '~> 0.8.7'
-  gem 'rspec',   '~> 1.3.1'
+  gem 'jeweler', '~> 1.6.4'
+  gem 'rake',    '~> 0.9.2'
+  gem 'rspec',   '~> 1.3.2'
 
 end
 
 platforms :mri_18 do
   group :quality do
 
-    gem 'rcov',      '~> 0.9.9'
-    gem 'yard',      '~> 0.6'
-    gem 'yardstick', '~> 0.2'
+    gem 'rcov',      '~> 0.9.10'
+    gem 'yard',      '~> 0.7.2'
+    gem 'yardstick', '~> 0.4'
 
   end
 end

data/README.rdoc

@@ -33,24 +33,26 @@ By default a relationship will PROTECT its children.
 
 === 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
-
-# Intermediary constraints for relationships using :through => Resource
-# are automatically inherited from the M:M relationship.
-
-# 1:1 Example
-class Farmer
-  has 1, :beloved_sheep, :constraint => :protect
-end
+  # 1:M Example
+  class Post
+    has n, :comments
+    # equivalent to:
+    # has n, :comments, :constraint => :protect
+  end
+
+  # M:M Example
+  class Article
+    has n, :tags, :through => Resource, :constraint => :destroy
+  end
+
+  class Tags
+    has n, :articles, :through => Resource, :constraint => :destroy
+  end
+
+  # Intermediary constraints for relationships using :through => Resource
+  # are automatically inherited from the M:M relationship.
+
+  # 1:1 Example
+  class User
+    has 1, :address, :constraint => :protect
+  end

data/Rakefile

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'rake'
 
 begin
-  gem 'jeweler', '~> 1.5.2'
+  gem 'jeweler', '~> 1.6.4'
   require 'jeweler'
 
   Jeweler::Tasks.new do |gem|

data/VERSION

@@ -1 +1 @@
-1.1.0
+1.2.0.rc1

data/dm-constraints.gemspec

@@ -4,14 +4,14 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{dm-constraints}
-  s.version = "1.1.0"
+  s.name = "dm-constraints"
+  s.version = "1.2.0.rc1"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Dirkjan Bussink"]
-  s.date = %q{2011-03-16}
-  s.description = %q{DataMapper plugin constraining relationships}
-  s.email = %q{d.bussink [a] gmail [d] com}
+  s.date = "2011-09-09"
+  s.description = "DataMapper plugin constraining relationships"
+  s.email = "d.bussink [a] gmail [d] com"
   s.extra_rdoc_files = [
     "LICENSE",
     "README.rdoc"
@@ -23,17 +23,21 @@ Gem::Specification.new do |s|
     "Rakefile",
     "VERSION",
     "dm-constraints.gemspec",
+    "lib/data_mapper/constraints/adapters/abstract_adapter.rb",
+    "lib/data_mapper/constraints/adapters/do_adapter.rb",
+    "lib/data_mapper/constraints/adapters/extension.rb",
+    "lib/data_mapper/constraints/adapters/mysql_adapter.rb",
+    "lib/data_mapper/constraints/adapters/oracle_adapter.rb",
+    "lib/data_mapper/constraints/adapters/postgres_adapter.rb",
+    "lib/data_mapper/constraints/adapters/sqlite_adapter.rb",
+    "lib/data_mapper/constraints/adapters/sqlserver_adapter.rb",
+    "lib/data_mapper/constraints/migrations/model.rb",
+    "lib/data_mapper/constraints/migrations/relationship.rb",
+    "lib/data_mapper/constraints/migrations/singleton_methods.rb",
+    "lib/data_mapper/constraints/relationship/many_to_many.rb",
+    "lib/data_mapper/constraints/relationship/one_to_many.rb",
+    "lib/data_mapper/constraints/resource.rb",
     "lib/dm-constraints.rb",
-    "lib/dm-constraints/adapters/dm-abstract-adapter.rb",
-    "lib/dm-constraints/adapters/dm-do-adapter.rb",
-    "lib/dm-constraints/adapters/dm-mysql-adapter.rb",
-    "lib/dm-constraints/adapters/dm-oracle-adapter.rb",
-    "lib/dm-constraints/adapters/dm-postgres-adapter.rb",
-    "lib/dm-constraints/adapters/dm-sqlite-adapter.rb",
-    "lib/dm-constraints/adapters/dm-sqlserver-adapter.rb",
-    "lib/dm-constraints/delete_constraint.rb",
-    "lib/dm-constraints/migrations.rb",
-    "lib/dm-constraints/relationships.rb",
     "spec/integration/constraints_spec.rb",
     "spec/isolated/require_after_setup_spec.rb",
     "spec/isolated/require_before_setup_spec.rb",
@@ -45,38 +49,31 @@ Gem::Specification.new do |s|
     "tasks/yard.rake",
     "tasks/yardstick.rake"
   ]
-  s.homepage = %q{http://github.com/datamapper/dm-constraints}
+  s.homepage = "http://github.com/datamapper/dm-constraints"
   s.require_paths = ["lib"]
-  s.rubyforge_project = %q{datamapper}
-  s.rubygems_version = %q{1.6.2}
-  s.summary = %q{DataMapper plugin constraining relationships}
-  s.test_files = [
-    "spec/integration/constraints_spec.rb",
-    "spec/isolated/require_after_setup_spec.rb",
-    "spec/isolated/require_before_setup_spec.rb",
-    "spec/isolated/require_spec.rb",
-    "spec/spec_helper.rb"
-  ]
+  s.rubyforge_project = "datamapper"
+  s.rubygems_version = "1.8.10"
+  s.summary = "DataMapper plugin constraining relationships"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<dm-core>, ["~> 1.1.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
-      s.add_development_dependency(%q<rake>, ["~> 0.8.7"])
-      s.add_development_dependency(%q<rspec>, ["~> 1.3.1"])
+      s.add_runtime_dependency(%q<dm-core>, ["~> 1.2.0.rc1"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rake>, ["~> 0.9.2"])
+      s.add_development_dependency(%q<rspec>, ["~> 1.3.2"])
     else
-      s.add_dependency(%q<dm-core>, ["~> 1.1.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
-      s.add_dependency(%q<rake>, ["~> 0.8.7"])
-      s.add_dependency(%q<rspec>, ["~> 1.3.1"])
+      s.add_dependency(%q<dm-core>, ["~> 1.2.0.rc1"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rake>, ["~> 0.9.2"])
+      s.add_dependency(%q<rspec>, ["~> 1.3.2"])
     end
   else
-    s.add_dependency(%q<dm-core>, ["~> 1.1.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
-    s.add_dependency(%q<rake>, ["~> 0.8.7"])
-    s.add_dependency(%q<rspec>, ["~> 1.3.1"])
+    s.add_dependency(%q<dm-core>, ["~> 1.2.0.rc1"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rake>, ["~> 0.9.2"])
+    s.add_dependency(%q<rspec>, ["~> 1.3.2"])
   end
 end
 

data/lib/data_mapper/constraints/adapters/abstract_adapter.rb

@@ -0,0 +1,36 @@
+require "data_mapper/constraints/adapters/extension"
+
+module DataMapper
+  module Constraints
+    module Adapters
+      module AbstractAdapter
+
+        # @api private
+        def constraint_exists?(*)
+          false
+        end
+
+        # @api private
+        def create_relationship_constraint(*)
+          false
+        end
+
+        # @api private
+        def destroy_relationship_constraint(*)
+          false
+        end
+
+      end # module AbstractAdapter
+    end # module Adapters
+  end # module Constraints
+
+  Adapters::AbstractAdapter.class_eval do
+    include Constraints::Adapters::AbstractAdapter
+  end
+
+  Adapters::AbstractAdapter.descendants.each do |adapter_class|
+    const_name = DataMapper::Inflector.demodulize(adapter_class.name)
+    Adapters.include_constraint_api(const_name)
+  end
+
+end # module DataMapper

data/lib/{dm-constraints/adapters/dm-do-adapter.rb → data_mapper/constraints/adapters/do_adapter.rb}

@@ -40,28 +40,35 @@ module DataMapper
         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
+          source_storage_name = relationship.source_model.storage_name(name)
+          target_storage_name = relationship.target_model.storage_name(name)
+          constraint_name     = constraint_name(source_storage_name, relationship.name)
 
-          constraint_name = constraint_name(source_table, relationship.name)
-          return false if constraint_exists?(source_table, constraint_name)
+          return false if constraint_exists?(source_storage_name, constraint_name)
 
-          constraint_type = case relationship.inverse.constraint
+          constraint_type =
+            case relationship.inverse.constraint
             when :protect            then 'NO ACTION'
+            # TODO: support :cascade as an option:
+            #   (destroy doesn't communicate the UPDATE constraint)
             when :destroy, :destroy! then 'CASCADE'
             when :set_nil            then 'SET NULL'
-          end
+            end
 
           return false if constraint_type.nil?
 
-          storage_name           = relationship.source_model.storage_name(name)
-          reference_storage_name = relationship.target_model.storage_name(name)
+          source_keys = relationship.source_key.map { |p| property_to_column_name(p, false) }
+          target_keys = relationship.target_key.map { |p| property_to_column_name(p, false) }
 
-          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) }
+          create_constraints_statement = create_constraints_statement(
+            constraint_name,
+            constraint_type,
+            source_storage_name,
+            source_keys,
+            target_storage_name,
+            target_keys)
 
-          execute(create_constraints_statement(storage_name, constraint_name, constraint_type, foreign_keys, reference_storage_name, reference_keys))
+          execute(create_constraints_statement)
         end
 
         ##
@@ -77,16 +84,18 @@ module DataMapper
         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)
+          storage_name    = relationship.source_model.storage_name(name)
+          constraint_name = constraint_name(storage_name, relationship.name)
+
+          return false unless constraint_exists?(storage_name, constraint_name)
 
-          constraint_name = constraint_name(source_table, relationship.name)
-          return false unless constraint_exists?(source_table, constraint_name)
+          destroy_constraints_statement =
+            destroy_constraints_statement(storage_name, constraint_name)
 
-          execute(destroy_constraints_statement(source_table, constraint_name))
+          execute(destroy_constraints_statement)
         end
 
-        private
+      private
 
         ##
         # Check to see if the relationship's constraints can be used
@@ -110,34 +119,34 @@ module DataMapper
         end
 
         module SQL
-          private
 
-          ##
+        private
+
           # Generates the SQL statement to create a constraint
           #
-          # @param constraint_name [String]
+          # @param [String] constraint_name
           #   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
+          # @param [String] constraint_type
+          #   type of constraint to ALTER source_storage_name with
+          # @param [String] source_storage_name
+          #   name of table to ALTER with constraint
+          # @param [Array(String)] source_keys
+          #   columns in source_storage_name that refer to foreign table
+          # @param [String] target_storage_name
+          #   target table of the constraint
+          # @param [Array(String)] target_keys
+          #   columns the target 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)
+          def create_constraints_statement(constraint_name, constraint_type, source_storage_name, source_keys, target_storage_name, target_keys)
             DataMapper::Ext::String.compress_lines(<<-SQL)
-              ALTER TABLE #{quote_name(storage_name)}
+              ALTER TABLE #{quote_name(source_storage_name)}
               ADD CONSTRAINT #{quote_name(constraint_name)}
-              FOREIGN KEY (#{foreign_keys.join(', ')})
-              REFERENCES #{quote_name(reference_storage_name)} (#{reference_keys.join(', ')})
+              FOREIGN KEY (#{source_keys.join(', ')})
+              REFERENCES #{quote_name(target_storage_name)} (#{target_keys.join(', ')})
               ON DELETE #{constraint_type}
               ON UPDATE #{constraint_type}
             SQL
@@ -146,9 +155,9 @@ module DataMapper
           ##
           # Generates the SQL statement to destroy a constraint
           #
-          # @param storage_name [String]
+          # @param [String] storage_name
           #   name of table to constrain
-          # @param constraint_name [String]
+          # @param [String] constraint_name
           #   name of foreign key constraint
           #
           # @return [String]
@@ -165,9 +174,9 @@ module DataMapper
           ##
           # generates a unique constraint name given a table and a relationships
           #
-          # @param storage_name [String]
+          # @param [String] storage_name
           #   name of table to constrain
-          # @param relationships_name [String]
+          # @param [String] relationship_name
           #   name of the relationship to constrain
           #
           # @return [String]

data/lib/data_mapper/constraints/adapters/extension.rb

@@ -0,0 +1,49 @@
+module DataMapper
+  module Constraints
+    module Adapters
+      module Extension
+        # Include the corresponding Constraints module into a adapter class
+        #
+        # @param [Symbol] const_name
+        #   demodulized name of the adapter class to include corresponding
+        #   constraints module into
+        #
+        # TODO: come up with a better way to include modules
+        # into all currently loaded and subsequently loaded Adapters
+        #
+        # @api private
+        def include_constraint_api(const_name)
+          require constraint_extensions(const_name)
+
+          if Constraints::Adapters.const_defined?(const_name)
+            adapter = const_get(const_name)
+            constraint_module = Constraints::Adapters.const_get(const_name)
+            adapter.class_eval { include constraint_module }
+          end
+        rescue LoadError
+          # Silently ignore the fact that no adapter extensions could be required
+          # This means that the adapter in use doesn't support constraints
+        end
+
+      private
+
+        # @api private
+        def constraint_extensions(const_name)
+          name = adapter_name(const_name)
+          name = 'do' if name == 'dataobjects'
+          "data_mapper/constraints/adapters/#{name}_adapter"
+        end
+
+        # @api private
+        def const_added(const_name)
+          include_constraint_api(const_name)
+          super
+        end
+
+      end # module Extension
+    end # module Adapters
+  end # module Constraints
+
+  Adapters.extend Constraints::Adapters::Extension
+
+end # module DataMapper

data/lib/{dm-constraints/adapters/dm-mysql-adapter.rb → data_mapper/constraints/adapters/mysql_adapter.rb}

@@ -1,4 +1,4 @@
-require 'dm-constraints/adapters/dm-do-adapter'
+require 'data_mapper/constraints/adapters/do_adapter'
 
 module DataMapper
   module Constraints
@@ -14,13 +14,7 @@ module DataMapper
           ##
           # 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
+          # @see DataMapper::Constraints::Adapters::DataObjectsAdapter#destroy_constraints_statement
           #
           # @api private
           def destroy_constraints_statement(storage_name, constraint_name)