datamapper 0.2.5 → 0.3.0

data/lib/data_mapper/adapters/sqlite3_adapter.rb

@@ -24,11 +24,13 @@ module DataMapper
 
       TABLE_QUOTING_CHARACTER = '"'.freeze
       COLUMN_QUOTING_CHARACTER = '"'.freeze
+      TRUE_ALIASES << 't'.freeze
+      FALSE_ALIASES << 'f'.freeze
       
       def create_connection
         conn = DataObject::Sqlite3::Connection.new("dbname=#{@configuration.database}")
         conn.logger = self.logger
-        conn.open
+        conn.open if conn.respond_to?(:open)
         return conn
       end
       
@@ -65,6 +67,11 @@ module DataMapper
               PRAGMA TABLE_INFO(?)
             EOS
           end
+          
+          def to_truncate_sql
+            "DELETE FROM #{to_sql}"
+          end
+          
           alias_method :to_columns_sql, :to_column_exists_sql
           
           def unquote_default(default)
@@ -148,4 +155,4 @@ module DataMapper
     end # class Sqlite3Adapter
     
   end # module Adapters
-end # module DataMapper
+end # module DataMapper

data/lib/data_mapper/associations.rb

@@ -5,25 +5,97 @@ require 'data_mapper/associations/has_and_belongs_to_many_association'
 
 module DataMapper
   module Associations
-  
+    
+    # Extends +base+ with methods for setting up associations between different models.
     def self.included(base)
       base.extend(ClassMethods)
     end
     
     module ClassMethods
-      
+      # Adds the following methods for query of a single associated object:
+      # * <tt>collection(</tt> - returns a set containing the associated objects. Returns
+      #   an empty set if no objects are found.
+      # * <tt>collection << object</tt> - adds an object to the collection.
+      # * <tt>collection = [objects]</tt> - replaces the collections content by deleting and
+      #   adding objects as appropriate.
+      # * <tt>collection.empty?</tt> - returns +true+ if there is no associated objects.
+      # * <tt>collection.size</tt> - returns the number of associated objects.
+      #
+      # Options are:
+      # * <tt>:class</tt> - specify the class name of the association. So has_many :animals will by
+      #   default be linked to the Animal class, but if you want the association to use a
+      #   different class, you'll have to specify it with this option. DM also lets you specify
+      #   this with <tt>:class_name</tt>, for AR compability.
+      # * <tt>:foreign_key</tt> - specify the foreign key used for the association. By default
+      #   this is guessed to be the name of this class in lower-case and _id suffixed.
+      # * <tt>:dependent</tt> - if set to :destroy, the associated objects have their destroy! methods
+      #   called in a chain meaning all callbacks are also called for each object.
+      #   if set to :delete, the associated objects are deleted from the database
+      #   without their callbacks being triggered.
+      #   if set to :protect and the collection is not empty an AssociatedProtectedError will be raised.
+      #   if set to :nullify, the associated objects foreign key is set to NULL.
+      #   default is :nullify
+      #
+      # Option examples:
+      #   has_many :favourite_fruits, :class => 'Fruit', :dependent => :destroy
       def has_many(association_name, options = {})
         database.schema[self].associations << HasManyAssociation.new(self, association_name, options)
       end
       
+      # Adds the following methods for query of a single associated object:
+      # * <tt>association(</tt> - returns the associated object. Returns an empty set if no
+      #   object is found.
+      # * <tt>association=(associate)</tt> - assigns the associate object, extracts the
+      #   primary key, and sets it as the foreign key.
+      # * <tt>association.nil?</tt> - returns +true+ if there is no associated object.
+      #
+      # The declaration can also include an options hash to specialize the behavior of the
+      # association.
+      #
+      # Options are:
+      # * <tt>:class</tt> - specify the class name of the association. So has_one :animal will by
+      #   default be linked to the Animal class, but if you want the association to use a
+      #   different class, you'll have to specify it with this option. DM also lets you specify
+      #   this with <tt>:class_name</tt>, for AR compability.
+      # * <tt>:foreign_key</tt> - specify the foreign key used for the association. By default
+      #   this is guessed to be the name of this class in lower-case and _id suffixed.
+      # * <tt>:dependent</tt> - has_one is secretly a has_many so this option performs the same
+      #   as the has_many
+      #
+      # Option examples:
+      #   has_one :favourite_fruit, :class => 'Fruit', :foreign_key => 'devourer_id'
       def has_one(association_name, options = {})
         database.schema[self].associations << HasManyAssociation.new(self, association_name, options)
       end
       
+      # Adds the following methods for query of a single associated object:
+      # * <tt>association(</tt> - returns the associated object. Returns an empty set if no
+      #   object is found.
+      # * <tt>association=(associate)</tt> - assigns the associate object, extracts the
+      #   primary key, and sets it as the foreign key.
+      # * <tt>association.nil?</tt> - returns +true+ if there is no associated object.
+      # * <tt>build_association</tt> - builds a new object of the associated type, without
+      #   saving it to the database.
+      # * <tt>create_association</tt> - creates and saves a new object of the associated type.
       def belongs_to(association_name, options = {})
         database.schema[self].associations << BelongsToAssociation.new(self, association_name, options)
       end
       
+      # Associates two classes via an intermediate join table.
+      #
+      # Options are:
+      # * <tt>:dependent</tt> - if set to :destroy, the associated objects have their destroy! methods
+      #   called in a chain meaning all callbacks are also called for each object.  Beware that this
+      #   is a cascading delete and will affect all records that have a remote relationship with the
+      #   record being destroyed!
+      #   if set to :delete, the associated objects are deleted from the database without their
+      #   callbacks being triggered.  This does NOT cascade the deletes.  All associated objects will
+      #   have their relationships removed from other records before being deleted.  The record calling
+      #   destroy will only delete those records directly associated to it.
+      #   if set to :protect and the collection is not empty an AssociatedProtectedError will be raised.
+      #   if set to :nullify, the join table will have the relationship records removed which is
+      #   effectively nullifying the foreign key.
+      #   default is :nullify
       def has_and_belongs_to_many(association_name, options = {})
         database.schema[self].associations << HasAndBelongsToManyAssociation.new(self, association_name, options)
       end
@@ -31,4 +103,4 @@ module DataMapper
     end
     
   end
-end
+end

data/lib/data_mapper/associations/belongs_to_association.rb

@@ -2,90 +2,108 @@ require 'data_mapper/associations/has_n_association'
 
 module DataMapper
   module Associations
-    
+
     class BelongsToAssociation < HasNAssociation
 
-      def define_accessor(klass)        
+      def define_accessor(klass)
         klass.class_eval <<-EOS
-          
+
           def create_#{@association_name}(options = {})
             #{@association_name}_association.create(options)
           end
-          
+
           def build_#{@association_name}(options = {})
             #{@association_name}_association.build(options)
           end
-          
+
           def #{@association_name}
             #{@association_name}_association.instance
           end
-          
+
           def #{@association_name}=(value)
             #{@association_name}_association.set(value)
           end
-          
+
           private
             def #{@association_name}_association
               @#{@association_name} || (@#{@association_name} = DataMapper::Associations::BelongsToAssociation::Instance.new(self, #{@association_name.inspect}))
             end
         EOS
       end
-      
+
       # Reverse the natural order for BelongsToAssociations
       alias constant associated_constant
       def associated_constant
         @constant
       end
-      
+
       def foreign_key_name
         @foreign_key_name || @foreign_key_name = (@options[:foreign_key] || "#{name}_#{key_table.key.name}".to_sym)
       end
-      
-      def to_sql
+
+      def complementary_association
+        @complementary_association || begin
+          @complementary_association = key_table.associations.find do |mapping|
+            mapping.is_a?(HasManyAssociation) &&
+            mapping.foreign_key_column.name == foreign_key_column.name &&
+            mapping.associated_table.name == associated_table.name
+          end
+
+          if @complementary_association
+            class << self
+              attr_accessor :complementary_association
+            end
+          end
+
+          return @complementary_association
+        end
+      end
+
+      def to_sql # :nodoc:
         "JOIN #{key_table.to_sql} ON #{foreign_key_column.to_sql(true)} = #{primary_key_column.to_sql(true)}"
       end
-      
+
       class Instance < Associations::Reference
-        
-        def dirty?
-          @associated && @new_member
+
+        def dirty?(cleared = ::Set.new)
+          @associated && (@new_member || @key_not_set)
         end
-        
+
         def validate_recursively(event, cleared)
           @associated.nil? || cleared.include?(@associated) || @associated.validate_recursively(event, cleared)
         end
-        
-        def save_without_validation(database_context)
+
+        def save_without_validation(database_context, cleared)
           @new_member = false
           unless @associated.nil?
             @instance.instance_variable_set(
               association.foreign_key_column.instance_variable_name,
               @associated.key
             )
-            @instance.database_context.adapter.save_without_validation(database_context, @instance)
+            @instance.database_context.adapter.save_without_validation(database_context, @instance, cleared)
           end
         end
-        
+
         def reload!
           @new_member = false
           @associated = nil
           instance
         end
-        
+
         def instance
-          @associated || @associated = begin                    
+          @associated || @associated = begin
             if @instance.loaded_set.nil?
               nil
             else
-              
+
               # Temp variable for the instance variable name.
               fk = association.foreign_key_column.to_sym
-              
+
               set = @instance.loaded_set.group_by { |instance| instance.send(fk) }
 
               @instance.database_context.all(association.constant, association.associated_table.key.to_sym => set.keys).each do |assoc|
                 set[assoc.key].each do |primary_instance|
-                  primary_instance.send(setter_method, assoc)
+                  primary_instance.send("#{@association_name}_association").shallow_append(assoc)
                 end
               end
 
@@ -93,34 +111,50 @@ module DataMapper
             end
           end
         end
-      
+
         def create(options)
           @associated = association.associated_constant.create(options)
         end
-      
+
         def build(options)
           @associated = association.associated_constant.new(options)
         end
-      
+
         def setter_method
           "#{@association_name}=".to_sym
         end
-        
-        def set(val)
-          raise "RecursionError" if val == @instance
-          @new_member = true
+
+        def set(member)
+          shallow_append(member)
+
+          if complement = association.complementary_association
+            member.send(complement.name).shallow_append(@instance)
+          end
+
+          return self
+        end
+
+        def shallow_append(val)
+          raise RecursionError.new if val == @instance
           @instance.instance_variable_set(association.foreign_key_column.instance_variable_name, val.key)
           @associated = val
+          @key_not_set = true if val.key.nil?
+          return self
+        end
+
+        def deactivate
         end
-        
+
+        private
+
         def ensure_foreign_key!
           if @associated
             @instance.instance_variable_set(association.foreign_key.instance_variable_name, @associated.key)
           end
         end
-            
+
       end # class Instance
     end
-    
+
   end
-end
+end

data/lib/data_mapper/associations/has_and_belongs_to_many_association.rb

@@ -1,34 +1,43 @@
 module DataMapper
   module Associations
-    
+
     class HasAndBelongsToManyAssociation
-      
+
       attr_reader :adapter
-      
+
       def initialize(klass, association_name, options)
         @adapter = database.adapter
         @key_table = adapter.table(klass)
+        @self_referential = (association_name.to_s == @key_table.name)
         @association_name = association_name.to_sym
         @options = options
-        
+
         define_accessor(klass)
       end
-      
+
       # def key_table
       #   @key_table
       # end
-      
+
       def name
         @association_name
       end
 
+      def dependency
+        @options[:dependent]
+      end
+
       def foreign_name
         @foreign_name || (@foreign_name = (@options[:foreign_name] || @key_table.name).to_sym)
       end
-      
+
+      def self_referential?
+        @self_referential
+      end
+
       def constant
         @associated_class || @associated_class = begin
-        
+
           if @options.has_key?(:class) || @options.has_key?(:class_name)
             associated_class_name = (@options[:class] || @options[:class_name])
             if associated_class_name.kind_of?(String)
@@ -39,51 +48,56 @@ module DataMapper
           else
             Kernel.const_get(Inflector.classify(@association_name))
           end
-          
+
         end
       end
-      
-      def activate!
-        join_table.create!
+
+      def activate!(force = false)
+        join_columns.each {|column| column unless join_table.mapped_column_exists?(column.name)}
+        join_table.create!(force)
       end
 
       def associated_columns
         associated_table.columns.reject { |column| column.lazy? } + join_columns
       end
-      
+
       def join_columns
         [ left_foreign_key, right_foreign_key ]
       end
-      
+
       def associated_table
         @associated_table || (@associated_table = adapter.table(constant))
       end
-      
+
       def join_table
-        @join_table || @join_table = begin 
-          join_table_name = @options[:join_table] || 
+        @join_table || @join_table = begin
+          join_table_name = @options[:join_table] ||
             [ @key_table.name.to_s, database.schema[constant].name.to_s ].sort.join('_')
-            
+
           adapter.table(join_table_name)
-        end        
+        end
       end
-      
+
       def left_foreign_key
         @left_foreign_key || @left_foreign_key = begin
           join_table.add_column(
             (@options[:left_foreign_key] || @key_table.default_foreign_key),
-            :integer, :key => true)
+            :integer, :nullable => true, :key => true)
         end
       end
 
       def right_foreign_key
+        if self_referential?
+          @options[:right_foreign_key] ||= ["related_", associated_table.default_foreign_key].to_s
+        end
+
         @right_foreign_key || @right_foreign_key = begin
           join_table.add_column(
             (@options[:right_foreign_key] || associated_table.default_foreign_key),
-            :integer, :key => true)
+            :integer, :nullable => true, :key => true)
         end
       end
-      
+
       def to_sql
         <<-EOS.compress_lines
           JOIN #{join_table.to_sql} ON
@@ -92,14 +106,21 @@ module DataMapper
             #{associated_table.key.to_sql(true)} = #{right_foreign_key.to_sql(true)}
         EOS
       end
-      
+
       def to_shallow_sql
+        if self_referential?
+          <<-EOS.compress_lines
+            JOIN #{join_table.to_sql} ON
+              #{right_foreign_key.to_sql(true)} = #{@key_table.key.to_sql(true)}
+          EOS
+        else
         <<-EOS.compress_lines
           JOIN #{join_table.to_sql} ON
             #{left_foreign_key.to_sql(true)} = #{@key_table.key.to_sql(true)}
         EOS
+        end
       end
-      
+
       def to_insert_sql
         <<-EOS.compress_lines
           INSERT INTO #{join_table.to_sql}
@@ -107,14 +128,29 @@ module DataMapper
           VALUES
         EOS
       end
-      
+
       def to_delete_sql
-        <<-EOS
+        <<-EOS.compress_lines
           DELETE FROM #{join_table.to_sql}
           WHERE #{left_foreign_key.to_sql} = ?
         EOS
       end
-      
+
+      def to_delete_set_sql
+        <<-EOS.compress_lines
+          DELETE FROM #{join_table.to_sql}
+          WHERE #{left_foreign_key.to_sql} IN ?
+            OR #{right_foreign_key.to_sql} IN ?
+        EOS
+      end
+
+      def to_delete_members_sql
+        <<-EOS.compress_lines
+          DELETE FROM #{associated_table.to_sql}
+          WHERE #{associated_table.key.to_sql} IN ?
+        EOS
+      end
+
       def to_delete_member_sql
         <<-EOS
           DELETE FROM #{join_table.to_sql}
@@ -122,29 +158,43 @@ module DataMapper
             AND #{right_foreign_key.to_sql} = ?
         EOS
       end
-      
+
+      def to_disassociate_sql
+        <<-EOS
+          UPDATE #{join_table.to_sql}
+          SET #{left_foreign_key.to_sql} = NULL
+          WHERE #{left_foreign_key.to_sql} = ?
+        EOS
+      end
+
       # Define the association instance method (i.e. Project#tasks)
       def define_accessor(klass)
         klass.class_eval <<-EOS
           def #{@association_name}
             @#{@association_name} || (@#{@association_name} = HasAndBelongsToManyAssociation::Set.new(self, #{@association_name.inspect}))
           end
-          
+
           def #{@association_name}=(value)
             #{@association_name}.set(value)
           end
+
+          private
+          def #{@association_name}_keys=(value)
+            #{@association_name}.clear
+
+            associated_constant = #{@association_name}.association.constant
+            associated_table = #{@association_name}.association.associated_table
+            associated_constant.all(associated_table.key => [*value]).each do |entry|
+              #{@association_name} << entry
+            end
+          end
         EOS
       end
-      
+
       class Set < Associations::Reference
-        
+
         include Enumerable
-        
-        def initialize(*args)
-          super
-          @new_members = false
-        end
-        
+
         def each
           entries.each { |item| yield item }
         end
@@ -153,11 +203,11 @@ module DataMapper
           entries.size
         end
         alias length size
-        
+
         def count
           entries.size
         end
-        
+
         def [](key)
           entries[key]
         end
@@ -165,48 +215,49 @@ module DataMapper
         def empty?
           entries.empty?
         end
-        
-        def dirty?
-          @new_members || (@entries && @entries.any? { |item| item != @instance && item.dirty? })
+
+        def dirty?(cleared = ::Set.new)
+          return false unless @entries
+          @entries.any? {|item| cleared.include?(item) || item.dirty?(cleared) } || @associated_keys != @entries.map { |entry| entry.keys }
         end
-        
+
         def validate_recursively(event, cleared)
           @entries.blank? || @entries.all? { |item| cleared.include?(item) || item.validate_recursively(event, cleared) }
         end
-        
-        def save_without_validation(database_context)
+
+        def save_without_validation(database_context, cleared)
           unless @entries.nil?
-            
-            if @new_members || dirty?
+
+            if dirty?(cleared)
               adapter = @instance.database_context.adapter
-              
+
               adapter.connection do |db|
                 command = db.create_command(association.to_delete_sql)
                 command.execute_non_query(@instance.key)
               end
-              
+
               unless @entries.empty?
                 if adapter.batch_insertable?
                   sql = association.to_insert_sql
                   values = []
                   keys = []
-              
+
                   @entries.each do |member|
-                    adapter.save_without_validation(database_context, member)
+                    adapter.save_without_validation(database_context, member, cleared)
                     values << "(?, ?)"
                     keys << @instance.key << member.key
                   end
-            
+
                   adapter.connection do |db|
                     command = db.create_command(sql << ' ' << values.join(', '))
                     command.execute_non_query(*keys)
                   end
-              
+
                 else # adapter doesn't support batch inserts...
                   @entries.each do |member|
-                    adapter.save_without_validation(database_context, member)          
+                    adapter.save_without_validation(database_context, member, cleared)
                   end
-              
+
                   # Just to keep the same flow as the batch-insert mode.
                   @entries.each do |member|
                     adapter.connection do |db|
@@ -216,30 +267,31 @@ module DataMapper
                   end
                 end # if adapter.batch_insertable?
               end # unless @entries.empty?
-              
-              @new_members = false
-            end # if @new_members || dirty?
+            end # if dirty?
           end
         end
-        
+
         def <<(member)
-          @new_members = true
-          entries << member unless member.nil?
+          return nil unless member
+
+          if member.is_a?(Enumerable)
+            member.each { |entry| entries << entry }
+          else
+            entries << member
+          end
         end
-        
+
         def clear
-          @new_members = true
-          @entries = []
+          @entries = Support::TypedSet.new(association.constant)
         end
-        
+
         def reload!
-          @new_members = false
           @entries = nil
         end
-        
+
         def delete(member)
-          @new_members = true
-          if entries.delete(member)
+          if found_member = entries.detect { |entry| entry == member }
+            entries.delete?(found_member)
             @instance.database_context.adapter.connection do |db|
               command = db.create_command(association.to_delete_member_sql)
               command.execute_non_query(@instance.key, member.key)
@@ -249,7 +301,7 @@ module DataMapper
             nil
           end
         end
-        
+
         def method_missing(symbol, *args, &block)
           if entries.respond_to?(symbol)
             entries.send(symbol, *args, &block)
@@ -265,21 +317,21 @@ module DataMapper
             super
           end
         end
-        
+
         def entries
           @entries || @entries = begin
 
             if @instance.loaded_set.nil?
-              []
+              Support::TypedSet.new(association.constant)
             else
-              
+
               associated_items = Hash.new { |h,k| h[k] = [] }
               left_key_index = nil
               association_constant = association.constant
               left_foreign_key = association.left_foreign_key
-              
+
               matcher = lambda do |instance,columns,row|
-                
+
                 # Locate the column for the left-key.
                 unless left_key_index
                   columns.each_with_index do |column, index|
@@ -289,40 +341,97 @@ module DataMapper
                     end
                   end
                 end
-                
+
                 if instance.kind_of?(association_constant)
                   associated_items[left_foreign_key.type_cast_value(row[left_key_index])] << instance
                 end
               end
-                
+
               @instance.database_context.all(association.constant,
                 left_foreign_key => @instance.loaded_set.map(&:key),
                 :shallow_include => association.foreign_name,
                 :intercept_load => matcher
               )
-              
+
               # do stsuff with associated_items hash.
               setter_method = "#{@association_name}=".to_sym
-              
+
               @instance.loaded_set.each do |entry|
                 entry.send(setter_method, associated_items[entry.key])
               end # @instance.loaded_set.each
-              
-              @entries              
+
+              @entries
             end
           end
         end
 
         def set(results)
-          @entries = results
+          if results.is_a?(Support::TypedSet)
+            @entries = results
+          else
+            @entries = Support::TypedSet.new(association.constant)
+            [*results].each { |item| @entries << item }
+          end
+          @associated_keys = @entries.map { |entry| entry.key }
+          return @entries
         end
 
         def inspect
           entries.inspect
         end
+
+        def first
+          entries.entries.first
+        end
+
+        def last
+          entries.entries.last
+        end
+
+        def deactivate
+          case association.dependency
+          when :destroy
+            entries.each do |member|
+              member.destroy! unless member.new_record?
+            end
+          when :delete
+            delete_association
+          when :protect
+            unless entries.empty?
+              raise AssociationProtectedError.new("You cannot delete this model while it has items associated with it.")
+            end
+          when :nullify
+            nullify_association
+          else
+            nullify_association
+          end
+        end
+
+        def delete_association
+          @instance.database_context.adapter.connection do |db|
+            associated_keys = entries.collect do |item|
+              item.key unless item.new_record?
+            end.compact
+            parameters = [@instance.key] + associated_keys
+
+            sql = association.to_delete_set_sql
+            db.create_command(sql).execute_non_query(*[parameters, parameters])
+
+            sql = association.to_delete_members_sql
+            db.create_command(sql).execute_non_query(associated_keys)
+          end
+        end
+
+        def nullify_association
+          @instance.database_context.adapter.connection do |db|
+            sql = association.to_delete_sql
+            parameters = [@instance.key]
+            db.create_command(sql).execute_non_query(*parameters)
+          end
+        end
       end
-    
+
     end # class HasAndBelongsToManyAssociation
-    
+
   end # module Associations
-end # module DataMapper
+end # module DataMapper