datamapper 0.2.3 → 0.2.4

data/lib/data_mapper/associations/has_and_belongs_to_many_association.rb

@@ -3,23 +3,27 @@ module DataMapper
     
     class HasAndBelongsToManyAssociation
       
-      attr_reader :adapter, :table
+      attr_reader :adapter
       
       def initialize(klass, association_name, options)
         @adapter = database.adapter
-        @table = adapter.table(klass)
+        @key_table = adapter.table(klass)
         @association_name = association_name.to_sym
         @options = options
         
         define_accessor(klass)
       end
       
+      # def key_table
+      #   @key_table
+      # end
+      
       def name
         @association_name
       end
 
       def foreign_name
-        @foreign_name || (@foreign_name = (@options[:foreign_name] || @table.name).to_sym)
+        @foreign_name || (@foreign_name = (@options[:foreign_name] || @key_table.name).to_sym)
       end
       
       def constant
@@ -38,23 +42,27 @@ module DataMapper
           
         end
       end
+      
+      def activate!
+        join_table.create!
+      end
 
-      def association_columns
-        association_table.columns.reject { |column| column.lazy? } + join_columns
+      def associated_columns
+        associated_table.columns.reject { |column| column.lazy? } + join_columns
       end
       
       def join_columns
         [ left_foreign_key, right_foreign_key ]
       end
       
-      def association_table
-        @association_table || (@association_table = adapter.table(constant))
+      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] || 
-            [ table.name.to_s, database.schema[constant].name.to_s ].sort.join('_')
+            [ @key_table.name.to_s, database.schema[constant].name.to_s ].sort.join('_')
             
           adapter.table(join_table_name)
         end        
@@ -63,32 +71,55 @@ module DataMapper
       def left_foreign_key
         @left_foreign_key || @left_foreign_key = begin
           join_table.add_column(
-            (@options[:left_foreign_key] || table.default_foreign_key),
-            :integer, {})
+            (@options[:left_foreign_key] || @key_table.default_foreign_key),
+            :integer, :key => true)
         end
       end
 
       def right_foreign_key
         @right_foreign_key || @right_foreign_key = begin
           join_table.add_column(
-            (@options[:right_foreign_key] || association_table.default_foreign_key),
-            :integer, {})
+            (@options[:right_foreign_key] || associated_table.default_foreign_key),
+            :integer, :key => true)
         end
       end
       
       def to_sql
         <<-EOS.compress_lines
           JOIN #{join_table.to_sql} ON
-            #{left_foreign_key.to_sql(true)} = #{table.key.to_sql(true)}
-          JOIN #{association_table.to_sql} ON
-            #{association_table.key.to_sql(true)} = #{right_foreign_key.to_sql(true)}
+            #{left_foreign_key.to_sql(true)} = #{@key_table.key.to_sql(true)}
+          JOIN #{associated_table.to_sql} ON
+            #{associated_table.key.to_sql(true)} = #{right_foreign_key.to_sql(true)}
         EOS
       end
       
       def to_shallow_sql
         <<-EOS.compress_lines
           JOIN #{join_table.to_sql} ON
-            #{left_foreign_key.to_sql(true)} = #{table.key.to_sql(true)}
+            #{left_foreign_key.to_sql(true)} = #{@key_table.key.to_sql(true)}
+        EOS
+      end
+      
+      def to_insert_sql
+        <<-EOS.compress_lines
+          INSERT INTO #{join_table.to_sql}
+          (#{left_foreign_key.to_sql}, #{right_foreign_key.to_sql})
+          VALUES
+        EOS
+      end
+      
+      def to_delete_sql
+        <<-EOS
+          DELETE FROM #{join_table.to_sql}
+          WHERE #{left_foreign_key.to_sql} = ?
+        EOS
+      end
+      
+      def to_delete_member_sql
+        <<-EOS
+          DELETE FROM #{join_table.to_sql}
+          WHERE #{left_foreign_key.to_sql} = ?
+            AND #{right_foreign_key.to_sql} = ?
         EOS
       end
       
@@ -105,16 +136,13 @@ module DataMapper
         EOS
       end
       
-      class Set
+      class Set < Associations::Reference
         
         include Enumerable
         
-        def initialize(instance, association_name)
-          @instance, @association_name = instance, association_name
-        end
-        
-        def association
-          @association || (@association = @instance.session.schema[@instance.class].associations[@association_name])
+        def initialize(*args)
+          super
+          @new_members = false
         end
         
         def each
@@ -125,7 +153,11 @@ module DataMapper
           entries.size
         end
         alias length size
-
+        
+        def count
+          entries.size
+        end
+        
         def [](key)
           entries[key]
         end
@@ -134,6 +166,106 @@ module DataMapper
           entries.empty?
         end
         
+        def dirty?
+          @new_members || (@entries && @entries.any? { |item| item != @instance && item.dirty? })
+        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)
+          unless @entries.nil?
+            
+            if @new_members || dirty?
+              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)
+                    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)          
+                  end
+              
+                  # Just to keep the same flow as the batch-insert mode.
+                  @entries.each do |member|
+                    adapter.connection do |db|
+                      command = db.create_command("#{association.to_insert_sql} (?, ?)")
+                      command.execute_non_query(@instance.key, member.key)
+                    end
+                  end
+                end # if adapter.batch_insertable?
+              end # unless @entries.empty?
+              
+              @new_members = false
+            end # if @new_members || dirty?
+          end
+        end
+        
+        def <<(member)
+          @new_members = true
+          entries << member
+        end
+        
+        def clear
+          @new_members = true
+          @entries = []
+        end
+        
+        def reload!
+          @new_members = false
+          @entries = nil
+        end
+        
+        def delete(member)
+          @new_members = true
+          if entries.delete(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)
+            end
+            member
+          else
+            nil
+          end
+        end
+        
+        def method_missing(symbol, *args, &block)
+          if entries.respond_to?(symbol)
+            entries.send(symbol, *args, &block)
+          elsif association.associated_table.associations.any? { |assoc| assoc.name == symbol }
+            results = []
+            each do |item|
+              unless (val = item.send(symbol)).blank?
+                results << (val.is_a?(Enumerable) ? val.entries : val)
+              end
+            end
+            results.flatten
+          else
+            super
+          end
+        end
+        
         def entries
           @entries || @entries = begin
 
@@ -163,7 +295,7 @@ module DataMapper
                 end
               end
                 
-              @instance.session.all(association.constant,
+              @instance.database_context.all(association.constant,
                 left_foreign_key => @instance.loaded_set.map(&:key),
                 :shallow_include => association.foreign_name,
                 :intercept_load => matcher

data/lib/data_mapper/associations/has_many_association.rb

@@ -18,25 +18,39 @@ module DataMapper
         EOS
       end
       
+      def to_disassociate_sql
+        "UPDATE #{associated_table.to_sql} SET #{foreign_key_column.to_sql} = NULL WHERE #{foreign_key_column.to_sql} = ?"
+      end
+      
       class Set < Associations::Reference
         
         include Enumerable
         
         def dirty?
-          @items && @items.any? { |item| item != @instance && item.dirty? }
+          @items && @items.any? { |item| item.dirty? }
         end
         
-        def validate_excluding_association(associated, context)
-          @items.blank? || @items.all? { |item| item.validate_excluding_association(associated, context) }
+        def validate_recursively(event, cleared)
+          @items.blank? || @items.all? { |item| cleared.include?(item) || item.validate_recursively(event, cleared) }
         end
         
-        def save
+        def save_without_validation(database_context)
+          
+          adapter = @instance.database_context.adapter
+          
+          adapter.connection do |db|
+            command = db.create_command(association.to_disassociate_sql)
+            command.execute_non_query(@instance.key)
+          end
+          
           unless @items.nil? || @items.empty?
+            
+            
             setter_method = "#{@association_name}=".to_sym
-            ivar_name = association.foreign_key.instance_variable_name
+            ivar_name = association.foreign_key_column.instance_variable_name
             @items.each do |item|
               item.instance_variable_set(ivar_name, @instance.key)
-              item.save
+              @instance.database_context.adapter.save_without_validation(database_context, item)
             end
           end
         end
@@ -49,15 +63,27 @@ module DataMapper
           items << associated_item
           
           # TODO: Optimize!
-          fk = association.foreign_key
-          foreign_association = association.association_table.associations.find do |mapping|
-            mapping.is_a?(BelongsToAssociation) && mapping.foreign_key == fk
+          fk = association.foreign_key_column
+          foreign_association = association.associated_table.associations.find do |mapping|
+            mapping.is_a?(BelongsToAssociation) && mapping.foreign_key_column == fk
           end
           
           associated_item.send("#{foreign_association.name}=", @instance) if foreign_association
           
           return @items
         end
+
+        def build(options)
+          item = association.associated_constant.new(options)
+          self << item
+          item
+        end
+
+        def create(options)
+          item = build(options)
+          item.save
+          item
+        end
         
         def set(items)
           @items = items
@@ -66,7 +92,7 @@ module DataMapper
         def method_missing(symbol, *args, &block)
           if items.respond_to?(symbol)
             items.send(symbol, *args, &block)
-          elsif association.association_table.associations.any? { |assoc| assoc.name == symbol }
+          elsif association.associated_table.associations.any? { |assoc| assoc.name == symbol }
             results = []
             each do |item|
               unless (val = item.send(symbol)).blank?
@@ -82,19 +108,23 @@ module DataMapper
         def respond_to?(symbol)
           items.respond_to?(symbol) || super
         end
+        
+        def reload!
+          @items = nil
+        end
 
         def items
           @items || begin
             if @instance.loaded_set.nil?
               @items = []
             else
-              fk = association.foreign_key.to_sym
+              fk = association.foreign_key_column.to_sym
               
-              finder_options = { association.foreign_key.to_sym => @instance.loaded_set.map { |item| item.key } }
+              finder_options = { association.foreign_key_column.to_sym => @instance.loaded_set.map { |item| item.key } }
               finder_options.merge!(association.finder_options)
               
-              associated_items = @instance.session.all(
-                association.constant,
+              associated_items = @instance.database_context.all(
+                association.associated_constant,
                 finder_options
               ).group_by { |entry| entry.send(fk) }
               
@@ -116,4 +146,4 @@ module DataMapper
     end
     
   end
-end
+end

data/lib/data_mapper/associations/has_n_association.rb

@@ -1,9 +1,12 @@
-module DataMapper
+module DataMapper                        
+  
+  class ForeignKeyNotFoundError < StandardError; end
+    
   module Associations
     
     class HasNAssociation
       
-      attr_reader :adapter, :table, :options
+      attr_reader :options
       
       OPTIONS = [
         :class,
@@ -12,12 +15,35 @@ module DataMapper
       ]
       
       def initialize(klass, association_name, options)
+        @constant = klass
         @adapter = database.adapter
-        @table = adapter.table(klass)
+        @table = @adapter.table(klass)
         @association_name = association_name.to_sym
         @options = options || Hash.new
         
         define_accessor(klass)
+        
+        Base::dependencies.add(associated_constant_name) do |klass|
+          @foreign_key_column = associated_table[foreign_key_name]
+          
+          unless @foreign_key_column
+            associated_constant.property(foreign_key_name, foreign_key_type)
+          
+            @foreign_key_column = associated_table[foreign_key_name]
+          
+            if @foreign_key_column.nil?
+              raise ForeignKeyNotFoundError.new(<<-EOS.compress_lines)
+                key_table => #{key_table.inspect},
+                association_table => #{associated_table.inspect},
+                association_name => #{name},
+                foreign_key_name => #{foreign_key_name.inspect},
+                foreign_key_type => #{foreign_key_type.inspect},
+                constant => #{constant.inspect},
+                associated_constant => #{associated_constant.inspect}
+              EOS
+            end
+          end
+        end
       end
       
       def name
@@ -25,39 +51,72 @@ module DataMapper
       end
 
       def constant
-        @associated_class || @associated_class = 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)
-            Kernel.const_get(Inflector.classify(associated_class_name))
+        @constant
+      end
+      
+      def associated_constant
+        @associated_constant || @associated_constant = Kernel.const_get(associated_constant_name)
+      end
+      
+      def associated_constant_name
+        @associated_constant_name || begin
+          
+          if @options.has_key?(:class) || @options.has_key?(:class_name)
+            @associated_constant_name = (@options[:class] || @options[:class_name])
+            
+            if @associated_constant_name.kind_of?(String)
+              @associated_constant_name = Inflector.classify(@associated_constant_name)
+            elsif @associated_constant_name.kind_of?(Class)
+              @associated_constant_name = @associated_constant_name.name
+            end  
           else
-            associated_class_name
+            @associated_constant_name = Inflector.classify(@association_name)
           end
-        else            
-          Kernel.const_get(Inflector.classify(@association_name))
+          
+          @associated_constant_name
         end
+        
       end
       
-      def foreign_key
-        @foreign_key || @foreign_key = begin
-          association_table[@options[:foreign_key] || table.default_foreign_key]
-        end
+      def primary_key_column
+        @primary_key_column || @primary_key_column = key_table.key
       end
       
-      def association_table
-        @association_table || (@association_table = adapter.table(constant))
+      def foreign_key_column
+        @foreign_key_column
       end
       
-      def to_sql
-        "JOIN #{association_table.to_sql} ON #{foreign_key.to_sql(true)} = #{table.key.to_sql(true)}"
+      def foreign_key_name
+        @foreign_key_name || @foreign_key_name = (@options[:foreign_key] || key_table.default_foreign_key)
       end
       
-      def association_columns
-        association_table.columns.reject { |column| column.lazy? }
+      def foreign_key_type
+        @foreign_key_type || @foreign_key_type = key_table.key.type
+      end
+      
+      def key_table
+        @key_table || @key_table = @adapter.table(constant)
+      end
+      
+      def associated_table
+        @association_table || @association_table = @adapter.table(associated_constant)
+      end
+      
+      def associated_columns
+        associated_table.columns.reject { |column| column.lazy? }
       end
       
       def finder_options
         @finder_options || @finder_options = @options.reject { |k,v| self.class::OPTIONS.include?(k) }
       end
+      
+      def to_sql
+        "JOIN #{associated_table.to_sql} ON #{foreign_key_column.to_sql(true)} = #{primary_key_column.to_sql(true)}"
+      end
+      
+      def activate!
+        foreign_key_column
+      end
     end
     
   end

data/lib/data_mapper/associations/has_one_association.rb

@@ -40,12 +40,12 @@ module DataMapper
             else
               # Temp variable for the instance variable name.
               setter_method = "#{@association_name}=".to_sym
-              instance_variable_name = "@#{association.foreign_key}".to_sym
+              instance_variable_name = "@#{association.foreign_key_column}".to_sym
           
               set = @instance.loaded_set.group_by { |instance| instance.key }
           
               # Fetch the foreign objects for all instances in the current object's loaded-set.
-              @instance.session.all(association.constant, association.foreign_key => set.keys).each do |assoc|
+              @instance.database_context.all(association.associated_constant, association.foreign_key_column => set.keys).each do |assoc|
                 set[assoc.instance_variable_get(instance_variable_name)].first.send(setter_method, assoc)
               end
               

data/lib/data_mapper/associations/reference.rb

@@ -38,7 +38,7 @@ module DataMapper
       # #association provides lazily initialized access to the declared
       # Association.
       def association
-        @association || (@association = @instance.session.table(@instance.class).associations[@association_name])
+        @association || (@association = @instance.database_context.table(@instance.class).associations[@association_name])
       end
   
     end

data/lib/data_mapper/auto_migrations.rb

@@ -0,0 +1,40 @@
+module DataMapper
+  module AutoMigrations
+    def auto_migrate!
+      if self::subclasses.empty?
+        table = database.table(self)
+        table.associations.each do |association|
+          association.activate!
+        end
+        
+        table.create!(true)
+      else
+        schema = database.schema
+        columns = self::subclasses.inject(schema[self].columns) do |span, subclass|
+          span + schema[subclass].columns
+        end
+
+        table_name = schema[self].name.to_s
+        table = schema[table_name]
+        columns.each do |column|
+          table.add_column(column.name, column.type, column.options)
+        end
+        
+        table.associations.each do |association|
+          association.activate!
+        end
+        
+        return table.create!(true)
+      end
+    end
+    
+    private
+    def create_table(table)
+      raise NotImplementedError.new
+    end
+    
+    def modify_table(table, columns)
+      raise NotImplementedError.new
+    end
+  end
+end