radiant 0.5.2 → 0.6.0

data/vendor/rails/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -0,0 +1,169 @@
+module ActiveRecord
+  module Associations
+    class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
+      def initialize(owner, reflection)
+        super
+        construct_sql
+      end
+ 
+      def build(attributes = {})
+        load_target
+        record = @reflection.klass.new(attributes)
+        @target << record
+        record
+      end
+
+      def create(attributes = {})
+        # Can't use Base.create since the foreign key may be a protected attribute.
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr) }
+        else
+          record = build(attributes)
+          insert_record(record) unless @owner.new_record?
+          record
+        end
+      end
+
+      def find_first
+        load_target.first
+      end
+      
+      def find(*args)
+        options = Base.send(:extract_options_from_args!, args)
+
+        # If using a custom finder_sql, scan the entire collection.
+        if @reflection.options[:finder_sql]
+          expects_array = args.first.kind_of?(Array)
+          ids = args.flatten.compact.uniq
+
+          if ids.size == 1
+            id = ids.first.to_i
+            record = load_target.detect { |record| id == record.id }
+            expects_array ? [record] : record
+          else
+            load_target.select { |record| ids.include?(record.id) }
+          end
+        else
+          conditions = "#{@finder_sql}"
+
+          if sanitized_conditions = sanitize_sql(options[:conditions])
+            conditions << " AND (#{sanitized_conditions})"
+          end
+
+          options[:conditions] = conditions
+          options[:joins]      = @join_sql
+          options[:readonly]   = finding_with_ambigious_select?(options[:select])
+
+          if options[:order] && @reflection.options[:order]
+            options[:order] = "#{options[:order]}, #{@reflection.options[:order]}"
+          elsif @reflection.options[:order]
+            options[:order] = @reflection.options[:order]
+          end
+
+          merge_options_from_reflection!(options)
+
+          # Pass through args exactly as we received them.
+          args << options
+          @reflection.klass.find(*args)
+        end
+      end      
+      
+      # Deprecated as of Rails 1.2.   If your associations require attributes
+      # you should be using has_many :through
+      def push_with_attributes(record, join_attributes = {})
+        raise_on_type_mismatch(record)
+        join_attributes.each { |key, value| record[key.to_s] = value }
+
+        callback(:before_add, record)
+        insert_record(record) unless @owner.new_record?
+        @target << record
+        callback(:after_add, record)
+
+        self
+      end
+      deprecate :push_with_attributes => "consider using has_many :through instead"
+
+      alias :concat_with_attributes :push_with_attributes
+
+      protected
+        def method_missing(method, *args, &block)
+          if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
+            super
+          else
+            @reflection.klass.with_scope(:find => { :conditions => @finder_sql, :joins => @join_sql, :readonly => false }) do
+              @reflection.klass.send(method, *args, &block)
+            end
+          end
+        end
+
+        def count_records
+          load_target.size
+        end
+
+        def insert_record(record)
+          if record.new_record?
+            return false unless record.save
+          end
+
+          if @reflection.options[:insert_sql]
+            @owner.connection.execute(interpolate_sql(@reflection.options[:insert_sql], record))
+          else
+            columns = @owner.connection.columns(@reflection.options[:join_table], "#{@reflection.options[:join_table]} Columns")
+
+            attributes = columns.inject({}) do |attributes, column|
+              case column.name
+                when @reflection.primary_key_name
+                  attributes[column.name] = @owner.quoted_id
+                when @reflection.association_foreign_key
+                  attributes[column.name] = record.quoted_id
+                else
+                  if record.attributes.has_key?(column.name)
+                    value = @owner.send(:quote_value, record[column.name], column)
+                    attributes[column.name] = value unless value.nil?
+                  end
+              end
+              attributes
+            end
+
+            sql =
+              "INSERT INTO #{@reflection.options[:join_table]} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
+              "VALUES (#{attributes.values.join(', ')})"
+
+            @owner.connection.execute(sql)
+          end
+          
+          return true
+        end
+        
+        def delete_records(records)
+          if sql = @reflection.options[:delete_sql]
+            records.each { |record| @owner.connection.execute(interpolate_sql(sql, record)) }
+          else
+            ids = quoted_record_ids(records)
+            sql = "DELETE FROM #{@reflection.options[:join_table]} WHERE #{@reflection.primary_key_name} = #{@owner.quoted_id} AND #{@reflection.association_foreign_key} IN (#{ids})"
+            @owner.connection.execute(sql)
+          end
+        end
+        
+        def construct_sql
+          interpolate_sql_options!(@reflection.options, :finder_sql)
+
+          if @reflection.options[:finder_sql]
+            @finder_sql = @reflection.options[:finder_sql]
+          else
+            @finder_sql = "#{@reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{@owner.quoted_id} "
+            @finder_sql << " AND (#{conditions})" if conditions
+          end
+
+          @join_sql = "INNER JOIN #{@reflection.options[:join_table]} ON #{@reflection.klass.table_name}.#{@reflection.klass.primary_key} = #{@reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
+        end
+
+        # Join tables with additional columns on top of the two foreign keys must be considered ambigious unless a select
+        # clause has been explicitly defined. Otherwise you can get broken records back, if, say, the join column also has
+        # and id column, which will then overwrite the id column of the records coming back.
+        def finding_with_ambigious_select?(select_clause)
+          !select_clause && @owner.connection.columns(@reflection.options[:join_table], "Join Table Columns").size != 2
+        end
+    end
+  end
+end

data/vendor/rails/activerecord/lib/active_record/associations/has_many_association.rb

@@ -0,0 +1,210 @@
+module ActiveRecord
+  module Associations
+    class HasManyAssociation < AssociationCollection #:nodoc:
+      def initialize(owner, reflection)
+        super
+        construct_sql
+      end
+
+      def build(attributes = {})
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| build(attr) }
+        else
+          record = @reflection.klass.new(attributes)
+          set_belongs_to_association_for(record)
+          
+          @target ||= [] unless loaded?
+          @target << record
+          
+          record
+        end
+      end
+
+      # DEPRECATED.
+      def find_all(runtime_conditions = nil, orderings = nil, limit = nil, joins = nil)
+        if @reflection.options[:finder_sql]
+          @reflection.klass.find_by_sql(@finder_sql)
+        else
+          conditions = @finder_sql
+          conditions += " AND (#{sanitize_sql(runtime_conditions)})" if runtime_conditions
+          orderings ||= @reflection.options[:order]
+          @reflection.klass.find_all(conditions, orderings, limit, joins)
+        end
+      end
+      deprecate :find_all => "use find(:all, ...) instead"
+
+      # DEPRECATED. Find the first associated record.  All arguments are optional.
+      def find_first(conditions = nil, orderings = nil)
+        find_all(conditions, orderings, 1).first
+      end
+      deprecate :find_first => "use find(:first, ...) instead"
+
+      # Count the number of associated records. All arguments are optional.
+      def count(*args)
+        if @reflection.options[:counter_sql]
+          @reflection.klass.count_by_sql(@counter_sql)
+        elsif @reflection.options[:finder_sql]
+          @reflection.klass.count_by_sql(@finder_sql)
+        else
+          column_name, options = @reflection.klass.send(:construct_count_options_from_legacy_args, *args)          
+          options[:conditions] = options[:conditions].nil? ?
+            @finder_sql :
+            @finder_sql + " AND (#{sanitize_sql(options[:conditions])})"
+          options[:include] = @reflection.options[:include]
+
+          @reflection.klass.count(column_name, options)
+        end
+      end
+
+      def find(*args)
+        options = Base.send(:extract_options_from_args!, args)
+
+        # If using a custom finder_sql, scan the entire collection.
+        if @reflection.options[:finder_sql]
+          expects_array = args.first.kind_of?(Array)
+          ids = args.flatten.compact.uniq
+
+          if ids.size == 1
+            id = ids.first
+            record = load_target.detect { |record| id == record.id }
+            expects_array ? [ record ] : record
+          else
+            load_target.select { |record| ids.include?(record.id) }
+          end
+        else
+          conditions = "#{@finder_sql}"
+          if sanitized_conditions = sanitize_sql(options[:conditions])
+            conditions << " AND (#{sanitized_conditions})"
+          end
+          options[:conditions] = conditions
+
+          if options[:order] && @reflection.options[:order]
+            options[:order] = "#{options[:order]}, #{@reflection.options[:order]}"
+          elsif @reflection.options[:order]
+            options[:order] = @reflection.options[:order]
+          end
+
+          merge_options_from_reflection!(options)
+
+          # Pass through args exactly as we received them.
+          args << options
+          @reflection.klass.find(*args)
+        end
+      end
+
+      protected
+        def method_missing(method, *args, &block)
+          if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
+            super
+          else
+            create_scoping = {}
+            set_belongs_to_association_for(create_scoping)
+
+            @reflection.klass.with_scope(
+              :create => create_scoping,
+              :find => {
+                :conditions => @finder_sql, 
+                :joins      => @join_sql, 
+                :readonly   => false
+              }
+            ) do
+              @reflection.klass.send(method, *args, &block)
+            end
+          end
+        end
+
+        def load_target
+          if !@owner.new_record? || foreign_key_present
+            begin
+              if !loaded?
+                if @target.is_a?(Array) && @target.any?
+                  @target = (find_target + @target).uniq
+                else
+                  @target = find_target
+                end
+              end
+            rescue ActiveRecord::RecordNotFound
+              reset
+            end
+          end
+
+          loaded if target
+          target
+        end
+
+        def count_records
+          count = if has_cached_counter?
+            @owner.send(:read_attribute, cached_counter_attribute_name)
+          elsif @reflection.options[:counter_sql]
+            @reflection.klass.count_by_sql(@counter_sql)
+          else
+            @reflection.klass.count(:conditions => @counter_sql)
+          end
+          
+          @target = [] and loaded if count == 0
+          
+          if @reflection.options[:limit]
+            count = [ @reflection.options[:limit], count ].min
+          end
+          
+          return count
+        end
+
+        def has_cached_counter?
+          @owner.attribute_present?(cached_counter_attribute_name)
+        end
+
+        def cached_counter_attribute_name
+          "#{@reflection.name}_count"
+        end
+
+        def insert_record(record)
+          set_belongs_to_association_for(record)
+          record.save
+        end
+
+        def delete_records(records)
+          if @reflection.options[:dependent]
+            records.each { |r| r.destroy }
+          else
+            ids = quoted_record_ids(records)
+            @reflection.klass.update_all(
+              "#{@reflection.primary_key_name} = NULL", 
+              "#{@reflection.primary_key_name} = #{@owner.quoted_id} AND #{@reflection.klass.primary_key} IN (#{ids})"
+            )
+          end
+        end
+
+        def target_obsolete?
+          false
+        end
+
+        def construct_sql
+          case
+            when @reflection.options[:finder_sql]
+              @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+
+            when @reflection.options[:as]
+              @finder_sql = 
+                "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
+                "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
+              @finder_sql << " AND (#{conditions})" if conditions
+            
+            else
+              @finder_sql = "#{@reflection.klass.table_name}.#{@reflection.primary_key_name} = #{@owner.quoted_id}"
+              @finder_sql << " AND (#{conditions})" if conditions
+          end
+
+          if @reflection.options[:counter_sql]
+            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+          elsif @reflection.options[:finder_sql]
+            # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
+            @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT (\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
+            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+          else
+            @counter_sql = @finder_sql
+          end
+        end
+    end
+  end
+end

data/vendor/rails/activerecord/lib/active_record/associations/has_many_through_association.rb

@@ -0,0 +1,247 @@
+module ActiveRecord
+  module Associations
+    class HasManyThroughAssociation < AssociationProxy #:nodoc:
+      def initialize(owner, reflection)
+        super
+        reflection.check_validity!
+        @finder_sql = construct_conditions
+        construct_sql
+      end
+
+      def find(*args)
+        options = Base.send(:extract_options_from_args!, args)
+
+        conditions = "#{@finder_sql}"
+        if sanitized_conditions = sanitize_sql(options[:conditions])
+          conditions << " AND (#{sanitized_conditions})"
+        end
+        options[:conditions] = conditions
+
+        if options[:order] && @reflection.options[:order]
+          options[:order] = "#{options[:order]}, #{@reflection.options[:order]}"
+        elsif @reflection.options[:order]
+          options[:order] = @reflection.options[:order]
+        end
+
+        options[:select]  = construct_select(options[:select])
+        options[:from]  ||= construct_from
+        options[:joins]   = construct_joins(options[:joins])
+        options[:include] = @reflection.source_reflection.options[:include] if options[:include].nil?
+
+        merge_options_from_reflection!(options)
+
+        # Pass through args exactly as we received them.
+        args << options
+        @reflection.klass.find(*args)
+      end
+
+      def reset
+        @target = []
+        @loaded = false
+      end
+
+      # Adds records to the association. The source record and its associates
+      # must have ids in order to create records associating them, so this
+      # will raise ActiveRecord::HasManyThroughCantAssociateNewRecords if
+      # either is a new record.  Calls create! so you can rescue errors.
+      #
+      # The :before_add and :after_add callbacks are not yet supported.
+      def <<(*records)
+        return if records.empty?
+        through = @reflection.through_reflection
+        raise ActiveRecord::HasManyThroughCantAssociateNewRecords.new(@owner, through) if @owner.new_record?
+
+        load_target
+
+        klass = through.klass
+        klass.transaction do
+          flatten_deeper(records).each do |associate|
+            raise_on_type_mismatch(associate)
+            raise ActiveRecord::HasManyThroughCantAssociateNewRecords.new(@owner, through) unless associate.respond_to?(:new_record?) && !associate.new_record?
+
+            @owner.send(@reflection.through_reflection.name).proxy_target << klass.with_scope(:create => construct_join_attributes(associate)) { klass.create! }
+            @target << associate
+          end
+        end
+
+        self
+      end
+
+      [:push, :concat].each { |method| alias_method method, :<< }
+
+      # Remove +records+ from this association.  Does not destroy +records+.
+      def delete(*records)
+        records = flatten_deeper(records)
+        records.each { |associate| raise_on_type_mismatch(associate) }
+        records.reject! { |associate| @target.delete(associate) if associate.new_record? }
+        return if records.empty?
+        
+        @delete_join_finder ||= "find_all_by_#{@reflection.source_reflection.association_foreign_key}"
+        through = @reflection.through_reflection
+        through.klass.transaction do
+          records.each do |associate|
+            joins = @owner.send(through.name).send(@delete_join_finder, associate.id)
+            @owner.send(through.name).delete(joins)
+            @target.delete(associate)
+          end
+        end
+      end
+
+      def build(attrs = nil)
+        raise ActiveRecord::HasManyThroughCantAssociateNewRecords.new(@owner, @reflection.through_reflection)
+      end
+
+      def create!(attrs = nil)
+        @reflection.klass.transaction do
+          self << @reflection.klass.with_scope(:create => attrs) { @reflection.klass.create! }
+        end
+      end
+
+      # Calculate sum using SQL, not Enumerable
+      def sum(*args, &block)
+        calculate(:sum, *args, &block)
+      end
+
+      protected
+        def method_missing(method, *args, &block)
+          if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
+            super
+          else
+            @reflection.klass.with_scope(construct_scope) { @reflection.klass.send(method, *args, &block) }
+          end
+        end
+
+        def find_target
+          records = @reflection.klass.find(:all,
+            :select     => construct_select,
+            :conditions => construct_conditions,
+            :from       => construct_from,
+            :joins      => construct_joins,
+            :order      => @reflection.options[:order],
+            :limit      => @reflection.options[:limit],
+            :group      => @reflection.options[:group],
+            :include    => @reflection.options[:include] || @reflection.source_reflection.options[:include]
+          )
+
+          @reflection.options[:uniq] ? records.to_set.to_a : records
+        end
+
+        # Construct attributes for associate pointing to owner.
+        def construct_owner_attributes(reflection)
+          if as = reflection.options[:as]
+            { "#{as}_id" => @owner.id,
+              "#{as}_type" => @owner.class.base_class.name.to_s }
+          else
+            { reflection.primary_key_name => @owner.id }
+          end
+        end
+
+        # Construct attributes for :through pointing to owner and associate.
+        def construct_join_attributes(associate)
+          returning construct_owner_attributes(@reflection.through_reflection).merge(@reflection.source_reflection.primary_key_name => associate.id) do |join_attributes|
+            if @reflection.options[:source_type]
+              join_attributes.merge!(@reflection.source_reflection.options[:foreign_type] => associate.class.base_class.name.to_s)
+            end
+          end
+        end
+
+        # Associate attributes pointing to owner, quoted.
+        def construct_quoted_owner_attributes(reflection)
+          if as = reflection.options[:as]
+            { "#{as}_id" => @owner.quoted_id,
+              "#{as}_type" => reflection.klass.quote_value(
+                @owner.class.base_class.name.to_s,
+                reflection.klass.columns_hash["#{as}_type"]) }
+          else
+            { reflection.primary_key_name => @owner.quoted_id }
+          end
+        end
+
+        # Build SQL conditions from attributes, qualified by table name.
+        def construct_conditions
+          table_name = @reflection.through_reflection.table_name
+          conditions = construct_quoted_owner_attributes(@reflection.through_reflection).map do |attr, value|
+            "#{table_name}.#{attr} = #{value}"
+          end
+          conditions << sql_conditions if sql_conditions
+          "(" + conditions.join(') AND (') + ")"
+        end
+
+        def construct_from
+          @reflection.table_name
+        end
+
+        def construct_select(custom_select = nil)
+          selected = custom_select || @reflection.options[:select] || "#{@reflection.table_name}.*"
+        end
+
+        def construct_joins(custom_joins = nil)
+          polymorphic_join = nil
+          if @reflection.through_reflection.options[:as] || @reflection.source_reflection.macro == :belongs_to
+            reflection_primary_key = @reflection.klass.primary_key
+            source_primary_key     = @reflection.source_reflection.primary_key_name
+            if @reflection.options[:source_type]
+              polymorphic_join = "AND %s.%s = %s" % [
+                @reflection.through_reflection.table_name, "#{@reflection.source_reflection.options[:foreign_type]}",
+                @owner.class.quote_value(@reflection.options[:source_type])
+              ]
+            end
+          else
+            reflection_primary_key = @reflection.source_reflection.primary_key_name
+            source_primary_key     = @reflection.klass.primary_key
+            if @reflection.source_reflection.options[:as]
+              polymorphic_join = "AND %s.%s = %s" % [
+                @reflection.table_name, "#{@reflection.source_reflection.options[:as]}_type",
+                @owner.class.quote_value(@reflection.through_reflection.klass.name)
+              ]
+            end
+          end
+
+          "INNER JOIN %s ON %s.%s = %s.%s %s #{@reflection.options[:joins]} #{custom_joins}" % [
+            @reflection.through_reflection.table_name,
+            @reflection.table_name, reflection_primary_key,
+            @reflection.through_reflection.table_name, source_primary_key,
+            polymorphic_join
+          ]
+        end
+
+        def construct_scope
+          { :create => construct_owner_attributes(@reflection),
+            :find   => { :from        => construct_from,
+                         :conditions  => construct_conditions,
+                         :joins       => construct_joins,
+                         :select      => construct_select } }
+        end
+
+        def construct_sql
+          case
+            when @reflection.options[:finder_sql]
+              @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+
+              @finder_sql = "#{@reflection.klass.table_name}.#{@reflection.primary_key_name} = #{@owner.quoted_id}"
+              @finder_sql << " AND (#{conditions})" if conditions
+          end
+
+          if @reflection.options[:counter_sql]
+            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+          elsif @reflection.options[:finder_sql]
+            # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
+            @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT (\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
+            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+          else
+            @counter_sql = @finder_sql
+          end
+        end
+
+        def conditions
+          @conditions ||= [
+            (interpolate_sql(@reflection.klass.send(:sanitize_sql, @reflection.options[:conditions])) if @reflection.options[:conditions]),
+            (interpolate_sql(@reflection.active_record.send(:sanitize_sql, @reflection.through_reflection.options[:conditions])) if @reflection.through_reflection.options[:conditions]),
+            ("#{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.klass.inheritance_column} = #{@reflection.klass.quote_value(@reflection.through_reflection.klass.name.demodulize)}" unless @reflection.through_reflection.klass.descends_from_active_record?)
+          ].compact.collect { |condition| "(#{condition})" }.join(' AND ') unless (!@reflection.options[:conditions] && !@reflection.through_reflection.options[:conditions] && @reflection.through_reflection.klass.descends_from_active_record?)
+        end
+
+        alias_method :sql_conditions, :conditions
+    end
+  end
+end