dm-constraints 1.1.0 → 1.2.0.rc1

data/lib/{dm-constraints/adapters/dm-oracle-adapter.rb → data_mapper/constraints/adapters/oracle_adapter.rb}

@@ -1,4 +1,4 @@
-require 'dm-constraints/adapters/dm-do-adapter'
+require 'data_mapper/constraints/adapters/do_adapter'
 
 module DataMapper
   module Constraints
@@ -8,8 +8,10 @@ module DataMapper
         include DataObjectsAdapter
 
         # oracle does not provide the information_schema table
-        # To question intenal state like postgres or mysql
+        # To question internal state like postgres or mysql
+        #
         # @see DataMapper::Constraints::Adapters::DataObjectsAdapter
+        #
         # @api private
         def constraint_exists?(storage_name, constraint_name)
           statement = DataMapper::Ext::String.compress_lines(<<-SQL)
@@ -24,6 +26,10 @@ module DataMapper
 
 
         # @see DataMapper::Constraints::Adapters::DataObjectsAdapter#create_constraints_statement
+        #
+        # @api private
+        #
+        # TODO: is it desirable to always set `INITIALLY DEFERRED DEFERRABLE`?
         def create_constraints_statement(storage_name, constraint_name, constraint_type, foreign_keys, reference_storage_name, reference_keys)
           DataMapper::Ext::String.compress_lines(<<-SQL)
             ALTER TABLE #{quote_name(storage_name)}
@@ -34,6 +40,7 @@ module DataMapper
           SQL
         end
 
+        # @api private
         def destroy_constraints_statement(storage_name, constraint_name)
           DataMapper::Ext::String.compress_lines(<<-SQL)
             ALTER TABLE #{quote_name(storage_name)}

data/lib/{dm-constraints/adapters/dm-postgres-adapter.rb → data_mapper/constraints/adapters/postgres_adapter.rb}

@@ -1,4 +1,4 @@
-require 'dm-constraints/adapters/dm-do-adapter'
+require 'data_mapper/constraints/adapters/do_adapter'
 
 module DataMapper
   module Constraints

data/lib/{dm-constraints/adapters/dm-sqlite-adapter.rb → data_mapper/constraints/adapters/sqlite_adapter.rb}

@@ -4,17 +4,21 @@ module DataMapper
 
       module SqliteAdapter
 
+        # @api private
         def constraint_exists?(*)
           false
         end
 
+        # @api private
         def create_relationship_constraint(*)
           false
         end
 
+        # @api private
         def destroy_relationship_constraint(*)
           false
         end
+
       end
 
     end

data/lib/{dm-constraints/adapters/dm-sqlserver-adapter.rb → data_mapper/constraints/adapters/sqlserver_adapter.rb}

@@ -1,4 +1,4 @@
-require 'dm-constraints/adapters/dm-do-adapter'
+require 'data_mapper/constraints/adapters/do_adapter'
 
 module DataMapper
   module Constraints

data/lib/data_mapper/constraints/migrations/model.rb

@@ -0,0 +1,36 @@
+# TODO: figure out some other (less tightly coupled) way to ensure that
+# dm-migrations' method implementations are loaded before this file
+require "dm-migrations/auto_migration"
+
+module DataMapper
+  module Constraints
+    module Migrations
+      module Model
+
+        # @api private
+        def auto_migrate_constraints_up(repository_name = self.repository_name)
+          # TODO: this check should not be here
+          return if self.respond_to?(:is_remixable?) && self.is_remixable?
+
+          relationships(repository_name).each do |relationship|
+            relationship.auto_migrate_constraints_up(repository_name)
+          end
+        end
+
+        # @api private
+        def auto_migrate_constraints_down(repository_name = self.repository_name)
+          return unless storage_exists?(repository_name)
+          # TODO: this check should not be here
+          return if self.respond_to?(:is_remixable?) && self.is_remixable?
+
+          relationships(repository_name).each do |relationship|
+            relationship.auto_migrate_constraints_down(repository_name)
+          end
+        end
+
+      end # module Model
+    end # module Migrations
+  end # module Constraints
+
+  Model.append_extensions Constraints::Migrations::Model
+end # module DataMapper

data/lib/data_mapper/constraints/migrations/relationship.rb

@@ -0,0 +1,42 @@
+module DataMapper
+  module Constraints
+    module Migrations
+      module Relationship
+        # @api private
+        def auto_migrate_constraints_up(repository_name)
+          # no-op
+        end
+
+        # @api private
+        def auto_migrate_constraints_down(repository_name)
+          # no-op
+        end
+
+        module ManyToOne
+          # @api private
+          def auto_migrate_constraints_up(repository_name)
+            adapter = DataMapper.repository(repository_name).adapter
+            adapter.create_relationship_constraint(self)
+            self
+          end
+
+          # @api private
+          def auto_migrate_constraints_down(repository_name)
+            adapter = DataMapper.repository(repository_name).adapter
+            adapter.destroy_relationship_constraint(self)
+            self
+          end
+        end
+
+      end # module Relationship
+    end # module Migrations
+  end # module Constraints
+
+  Associations::Relationship.class_eval do
+    include Constraints::Migrations::Relationship
+  end
+
+  Associations::ManyToOne::Relationship.class_eval do
+    include Constraints::Migrations::Relationship::ManyToOne
+  end
+end # module DataMapper

data/lib/data_mapper/constraints/migrations/singleton_methods.rb

@@ -0,0 +1,48 @@
+module DataMapper
+  module Constraints
+    module Migrations
+      module SingletonMethods
+
+        def auto_migrate!(repository_name = nil)
+          auto_migrate_constraints_down(repository_name)
+          # TODO: Model#auto_migrate! drops and adds constraints, as well.
+          #   is that an avoidable duplication?
+          super
+          auto_migrate_constraints_up(repository_name)
+          self
+        end
+
+      private
+
+        def auto_migrate_down!(repository_name = nil)
+          auto_migrate_constraints_down(repository_name)
+          super
+          self
+        end
+
+        def auto_migrate_up!(repository_name = nil)
+          super
+          auto_migrate_constraints_up(repository_name)
+          self
+        end
+
+        # @api private
+        def auto_migrate_constraints_up(repository_name = nil)
+          DataMapper::Model.descendants.each do |model|
+            model.auto_migrate_constraints_up(repository_name || model.default_repository_name)
+          end
+        end
+
+        # @api private
+        def auto_migrate_constraints_down(repository_name = nil)
+          DataMapper::Model.descendants.each do |model|
+            model.auto_migrate_constraints_down(repository_name || model.default_repository_name)
+          end
+        end
+
+      end # module SingletonMethods
+    end # module Migrations
+  end # module Constraints
+
+  extend Constraints::Migrations::SingletonMethods
+end # module DataMapper

data/lib/data_mapper/constraints/relationship/many_to_many.rb

@@ -0,0 +1,50 @@
+require 'data_mapper/constraints/relationship/one_to_many'
+
+module DataMapper
+  module Constraints
+    module Relationship
+      module ManyToMany
+
+      private
+
+        def one_to_many_options
+          super.merge(:constraint => @constraint)
+        end
+
+        # Checks that the constraint type is appropriate to the relationship
+        #
+        # @param [Fixnum] cardinality
+        #   cardinality of relationship
+        # @param [Symbol] name
+        #   name of relationship to evaluate constraint of
+        # @param [Hash] options
+        #   options hash
+        #
+        # @option *args :constraint[Symbol]
+        #   one of VALID_CONSTRAINT_VALUES
+        #
+        # @raise ArgumentError
+        #   if @option :constraint is not one of VALID_CONSTRAINT_TYPES
+        #
+        # @return [Undefined]
+        #
+        # @api private
+        def assert_valid_constraint
+          super
+
+          # TODO: is any constraint valid for a m:m relationship?
+          if @constraint == :set_nil
+            raise ArgumentError, "#{@constraint} is not a valid constraint type for #{self.class}"
+          end
+        end
+
+      end # module ManyToMany
+    end # module Relationship
+  end # module Constraints
+
+  Associations::ManyToMany::Relationship::OPTIONS << :constraint
+
+  Associations::ManyToMany::Relationship.class_eval do
+    include Constraints::Relationship::ManyToMany
+  end
+end # module DataMapper

data/lib/data_mapper/constraints/relationship/one_to_many.rb

@@ -0,0 +1,83 @@
+module DataMapper
+  module Constraints
+    module Relationship
+      module OneToMany
+
+        attr_reader :constraint
+
+        # @api private
+        def enforce_destroy_constraint(resource)
+          return true unless association = get(resource)
+
+          constraint = self.constraint
+
+          case constraint
+          when :protect
+            Array(association).empty?
+          when :destroy, :destroy!
+            association.__send__(constraint)
+          when :set_nil
+            Array(association).all? do |resource|
+              resource.update(inverse => nil)
+            end
+          when :skip
+            true  # do nothing
+          end
+        end
+
+      private
+
+        ##
+        # Adds the delete constraint options to a relationship
+        #
+        # @param params [*ARGS] Arguments passed to Relationship#initialize
+        #
+        # @return [nil]
+        #
+        # @api private
+        def initialize(*args)
+          super
+          set_constraint
+          assert_valid_constraint
+        end
+
+        def set_constraint
+          @constraint = @options.fetch(:constraint, :protect) || :skip
+        end
+
+        # Checks that the constraint type is appropriate to the relationship
+        #
+        # @param [Fixnum] cardinality
+        #   cardinality of relationship
+        # @param [Symbol] name
+        #   name of relationship to evaluate constraint of
+        # @param [Hash] options
+        #   options hash
+        #
+        # @option *args :constraint[Symbol]
+        #   one of VALID_CONSTRAINT_VALUES
+        #
+        # @raise ArgumentError
+        #   if @option :constraint is not one of VALID_CONSTRAINT_VALUES
+        #
+        # @return [Undefined]
+        #
+        # @api semipublic
+        def assert_valid_constraint
+          return unless @constraint
+
+          unless VALID_CONSTRAINT_VALUES.include?(@constraint)
+            raise ArgumentError, ":constraint option must be one of #{VALID_CONSTRAINT_VALUES.to_a.join(', ')}"
+          end
+        end
+
+      end # module OneToMany
+    end # module Relationship
+  end # module Constraints
+
+  Associations::OneToMany::Relationship::OPTIONS << :constraint
+
+  Associations::OneToMany::Relationship.class_eval do
+    include Constraints::Relationship::OneToMany
+  end
+end # module DataMapper

data/lib/data_mapper/constraints/resource.rb

@@ -0,0 +1,34 @@
+module DataMapper
+  module Constraints
+    module Resource
+      def before_destroy_hook
+        enforce_destroy_constraints
+        super
+      end
+
+    private
+
+      # Check delete constraints prior to destroying a dm resource or collection
+      #
+      # @note
+      #   - It only considers a relationship's constraints if this is the parent model (ie a child shouldn't delete a parent)
+      #   - Many to Many Relationships are skipped, as they are evaluated by their underlying 1:M relationships
+      #
+      # @return [nil]
+      #
+      # @api semi-public
+      def enforce_destroy_constraints
+        relationships.each do |relationship|
+          next unless relationship.respond_to?(:enforce_destroy_constraint)
+
+          constraint_satisfied = relationship.enforce_destroy_constraint(self)
+
+          throw(:halt, false) unless constraint_satisfied
+        end
+      end
+
+    end # module Resource
+  end # module Constraints
+
+  Model.append_inclusions Constraints::Resource
+end # module DataMapper

data/lib/dm-constraints.rb

@@ -1,95 +1,19 @@
 require 'dm-core'
 
-require 'dm-constraints/migrations'
-require 'dm-constraints/delete_constraint'
-require 'dm-constraints/relationships'
-require 'dm-constraints/adapters/dm-abstract-adapter'
+require 'data_mapper/constraints/resource'
 
-module DataMapper
+require 'data_mapper/constraints/migrations/model'
+require 'data_mapper/constraints/migrations/relationship'
+require 'data_mapper/constraints/migrations/singleton_methods'
 
-  extend Constraints::Migrations::SingletonMethods
+require 'data_mapper/constraints/relationship/one_to_many'
+require 'data_mapper/constraints/relationship/many_to_many'
 
-  module Model
-    extend DataMapper::Constraints::Migrations::Model
-    append_extensions DataMapper::Constraints::Migrations::Model
-  end
+require 'data_mapper/constraints/adapters/extension'
+require 'data_mapper/constraints/adapters/abstract_adapter'
 
+module DataMapper
   module Constraints
-
-    include DeleteConstraint
-
-    module ClassMethods
-      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 <<-RUBY, __FILE__, __LINE__ + 1
-        before_class_method :has, :check_delete_constraint_type
-
-        if instance_methods.any? { |m| m.to_sym == :destroy }
-          before :destroy, :check_delete_constraints
-        end
-      RUBY
-    end
-
-    def self.include_constraint_api
-      DataMapper::Adapters::AbstractAdapter.descendants.each do |adapter_class|
-        DataMapper::Adapters.include_constraint_api(DataMapper::Inflector.demodulize(adapter_class.name))
-      end
-    end
-
-    Model.append_inclusions self
-
-  end # module Constraints
-
-  module Adapters
-
-    class AbstractAdapter
-      include DataMapper::Constraints::Adapters::AbstractAdapter
-    end
-
-    def self.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
-      # Silently ignore the fact that no adapter extensions could be required
-      # This means that the adapter in use doesn't support constraints
-    end
-
-    def self.constraint_module(const_name)
-      Constraints::Adapters.const_get(const_name)
-    end
-
-    class << self
-    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
-
-    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
+    VALID_CONSTRAINT_VALUES = [ :protect, :destroy, :destroy!, :set_nil, :skip ].to_set.freeze
+  end
+end