datamapper 0.1.1 → 0.2.0

data/lib/data_mapper/associations/has_and_belongs_to_many_association.rb

@@ -2,99 +2,190 @@ module DataMapper
   module Associations
     
     class HasAndBelongsToManyAssociation
-      include Enumerable
       
-      def initialize(instance, association_name, options)
-        @instance = instance
+      attr_reader :adapter, :table
+      
+      def initialize(klass, association_name, options)
+        @adapter = database.adapter
+        @table = adapter.table(klass)
         @association_name = association_name.to_sym
         @options = options
         
-        @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))
-          else
-            associated_class_name
-          end
-        else            
-          Kernel.const_get(Inflector.classify(association_name))
-        end
-        
-        @join_table_name = @options.has_key?(:join_table_name) ? @options[:join_table_name] : [Inflector.tableize(@instance.class.name), Inflector.tableize(@associated_class.name)].sort.join('_')
+        define_accessor(klass)
       end
       
-      def self.setup(klass, association_name, options)
+      def name
+        @association_name
+      end
+
+      def foreign_name
+        @foreign_name || (@foreign_name = (@options[:foreign_name] || @table.name).to_sym)
+      end
+      
+      def constant
+        @associated_class || @associated_class = begin
         
-        # Define the association instance method (i.e. Project#tasks)
-        klass.class_eval <<-EOS
-          def #{association_name}
-            @#{association_name} || (@#{association_name} = HasAndBelongsToManyAssociation.new(self, "#{association_name}", #{options.inspect}))
+          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))
+            else
+              associated_class_name
+            end
+          else
+            Kernel.const_get(Inflector.classify(@association_name))
           end
-        EOS
-        
+          
+        end
       end
-      
-      def each
-        find.each { |item| yield item }
+
+      def association_columns
+        association_table.columns.reject { |column| column.lazy? } + join_columns
       end
       
-      def size
-        entries.size
+      def join_columns
+        [ left_foreign_key, right_foreign_key ]
       end
-      alias length size
       
-      def [](key)
-        entries[key]
+      def association_table
+        @association_table || (@association_table = adapter.table(constant))
       end
       
-      def empty?
-        entries.empty?
+      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('_')
+            
+          adapter.table(join_table_name)
+        end        
       end
       
-      def find
-        return @results unless @results.nil?
-        
-        unless @instance.loaded_set.nil?
-          
-          # Temp variable for the instance variable name.
-          instance_variable_name = "@#{foreign_key}".to_sym
-          
-          @results = @instance.session.find(@associated_class, :all,
-            :id.select => { :table => @join_table_name, foreign_key.to_sym => @instance.key }
-          ) do |animal_id, ref|
-            @instance.load_set.find { |x| x.id == animal_id }.exhibits << ref
-          end
-          
+      def left_foreign_key
+        @left_foreign_key || @left_foreign_key = begin
+          join_table.add_column(
+            (@options[:left_foreign_key] || table.default_foreign_key),
+            :integer, {})
         end
-        
-        return @results || (@results = [])
       end
-      
-      def set(results)
-        @results = results
+
+      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, {})
+        end
       end
       
-      def inspect
-        @results.inspect
+      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)}
+        EOS
       end
       
-      def foreign_key
-        @foreign_key || (@foreign_key = (@options[:foreign_key] || @instance.session.mappings[@instance.class].default_foreign_key))
+      def to_shallow_sql
+        <<-EOS.compress_lines
+          JOIN #{join_table.to_sql} ON
+            #{left_foreign_key.to_sql(true)} = #{table.key.to_sql(true)}
+        EOS
       end
-
-    end
-    
-    module HasAndBelongsToMany
-      def self.included(base)
-        base.extend(ClassMethods)
+      
+      # 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
+        EOS
       end
       
-      module ClassMethods
-        def has_and_belongs_to_many(association_name, options = {})
-          HasAndBelongsToManyAssociation.setup(self, association_name, options)
+      class Set
+        
+        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])
+        end
+        
+        def each
+          entries.each { |item| yield item }
+        end
+
+        def size
+          entries.size
+        end
+        alias length size
+
+        def [](key)
+          entries[key]
+        end
+
+        def empty?
+          entries.empty?
+        end
+        
+        def entries
+          @entries || @entries = begin
+
+            if @instance.loaded_set.nil?
+              []
+            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
+                  left_key_index = columns.index(association.left_foreign_key)
+                end
+                
+                if instance.kind_of?(association_constant)
+                  associated_items[left_foreign_key.type_cast_value(row[left_key_index])] << instance
+                end
+              end
+                
+              @instance.session.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              
+            end
+          end
+        end
+
+        def set(results)
+          @entries = results
+        end
+
+        def inspect
+          entries.inspect
         end
       end
-    end
     
-  end
-end
+    end # class HasAndBelongsToManyAssociation
+    
+  end # module Associations
+end # module DataMapper

data/lib/data_mapper/associations/has_many_association.rb

@@ -1,100 +1,118 @@
+require 'data_mapper/associations/has_n_association'
+
 module DataMapper
   module Associations
     
-    class HasManyAssociation
-      include Enumerable
-      
-      def initialize(instance, association_name, options)
-        @instance = instance
-        @association_name = association_name.to_sym
-        @options = options
-        
-        @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))
-          else
-            associated_class_name
-          end
-        else            
-          Kernel.const_get(Inflector.classify(association_name))
-        end
-      end
+    class HasManyAssociation < HasNAssociation
       
-      def self.setup(klass, association_name, options)
-
-        # Define the association instance method (i.e. Project#tasks)
+      # Define the association instance method (i.e. Project#tasks)
+      def define_accessor(klass)
         klass.class_eval <<-EOS
-          def #{association_name}
-            @#{association_name} || (@#{association_name} = HasManyAssociation.new(self, "#{association_name}", #{options.inspect}))
+          def #{@association_name}
+            @#{@association_name} || (@#{@association_name} = DataMapper::Associations::HasManyAssociation::Set.new(self, #{@association_name.inspect}))
+          end
+          
+          def #{@association_name}=(value)
+            #{@association_name}.set(value)
           end
         EOS
-        
-      end
-      
-      def each
-        find.each { |item| yield item }
       end
       
-      def size
-        entries.size
-      end
-      alias length size
-      
-      def [](key)
-        entries[key]
-      end
-      
-      def empty?
-        entries.empty?
-      end
-      
-      def find
-        return @results unless @results.nil?
+      class Set < Associations::Reference
+        
+        include Enumerable
+        
+        def dirty?
+          @items && @items.any? { |item| item != @instance && item.dirty? }
+        end
+        
+        def validate_excluding_association(associated, context)
+          @items.blank? || @items.all? { |item| item.validate_excluding_association(associated, context) }
+        end
+        
+        def save
+          unless @items.nil? || @items.empty?
+            setter_method = "#{@association_name}=".to_sym
+            ivar_name = association.foreign_key.instance_variable_name
+            @items.each do |item|
+              item.instance_variable_set(ivar_name, @instance.key)
+              item.save
+            end
+          end
+        end
+        
+        def each
+          items.each { |item| yield item }
+        end
         
-        unless @instance.loaded_set.nil?
+        def <<(associated_item)
+          items << associated_item
           
-          # Temp variable for the instance variable name.
-          instance_variable_name = "@#{foreign_key}".to_sym
+          # TODO: Optimize!
+          fk = association.foreign_key
+          foreign_association = association.association_table.associations.find do |mapping|
+            mapping.is_a?(BelongsToAssociation) && mapping.foreign_key == fk
+          end
           
-          set = @instance.loaded_set.group_by { |instance| instance.key }
+          associated_item.send("#{foreign_association.name}=", @instance) if foreign_association
           
-          # Fetch the foreign objects for all instances in the current object's loaded-set.
-          @instance.session.all(@associated_class, foreign_key.to_sym => set.keys).group_by do |association|
-            association.instance_variable_get(instance_variable_name)
-          end.each_pair do |id, results|
-            set[id].first.send(@association_name).set(results)
+          return @items
+        end
+        
+        def set(items)
+          @items = items
+        end
+        
+        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 }
+            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
         
-        return @results ||= []
-      end
-      
-      def set(results)
-        @results = results
-      end
-      
-      def inspect
-        @results.inspect
-      end
-      
-      def foreign_key
-        @foreign_key || (@foreign_key = (@options[:foreign_key] || @instance.session.schema[@instance.class].default_foreign_key))
-      end
+        def respond_to?(symbol)
+          items.respond_to?(symbol) || super
+        end
 
-    end
-    
-    module HasMany
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      module ClassMethods
-        def has_many(association_name, options = {})
-          HasManyAssociation.setup(self, association_name, options)
+        def items
+          @items || begin
+            if @instance.loaded_set.nil?
+              @items = []
+            else
+              fk = association.foreign_key.to_sym
+              
+              finder_options = { association.foreign_key.to_sym => @instance.loaded_set.map { |item| item.key } }
+              finder_options.merge!(association.finder_options)
+              
+              associated_items = @instance.session.all(
+                association.constant,
+                finder_options
+              ).group_by { |entry| entry.send(fk) }
+              
+              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
+              
+              return @items
+            end # if @instance.loaded_set.nil?
+          end # begin
+        end # def items
+        
+        def inspect
+          @entries.inspect
         end
       end
+
     end
     
   end