activerecord 3.0.0

data/lib/active_record/relation/predicate_builder.rb

@@ -0,0 +1,41 @@
+module ActiveRecord
+  class PredicateBuilder
+
+    def initialize(engine)
+      @engine = engine
+    end
+
+    def build_from_hash(attributes, default_table)
+      predicates = attributes.map do |column, value|
+        table = default_table
+
+        if value.is_a?(Hash)
+          table = Arel::Table.new(column, :engine => @engine)
+          build_from_hash(value, table)
+        else
+          column = column.to_s
+
+          if column.include?('.')
+            table_name, column = column.split('.', 2)
+            table = Arel::Table.new(table_name, :engine => @engine)
+          end
+
+          attribute = table[column] || Arel::Attribute.new(table, column)
+
+          case value
+          when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation
+            values = value.to_a
+            attribute.in(values)
+          when Range, Arel::Relation
+            attribute.in(value)
+          else
+            attribute.eq(value)
+          end
+        end
+      end
+
+      predicates.flatten
+    end
+
+  end
+end

data/lib/active_record/relation/query_methods.rb

@@ -0,0 +1,261 @@
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/object/blank'
+
+module ActiveRecord
+  module QueryMethods
+    extend ActiveSupport::Concern
+
+    attr_accessor :includes_values, :eager_load_values, :preload_values,
+                  :select_values, :group_values, :order_values, :joins_values, :where_values, :having_values,
+                  :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value, :from_value
+
+    def includes(*args)
+      args.reject! { |a| a.blank? }
+      clone.tap {|r| r.includes_values = (r.includes_values + args).flatten.uniq if args.present? }
+    end
+
+    def eager_load(*args)
+      clone.tap {|r| r.eager_load_values += args if args.present? }
+    end
+
+    def preload(*args)
+      clone.tap {|r| r.preload_values += args if args.present? }
+    end
+
+    def select(*args)
+      if block_given?
+        to_a.select {|*block_args| yield(*block_args) }
+      else
+        clone.tap {|r| r.select_values += args if args.present? }
+      end
+    end
+
+    def group(*args)
+      clone.tap {|r| r.group_values += args.flatten if args.present? }
+    end
+
+    def order(*args)
+      clone.tap {|r| r.order_values += args if args.present? }
+    end
+
+    def reorder(*args)
+      clone.tap {|r| r.order_values = args if args.present? }
+    end
+
+    def joins(*args)
+      args.flatten!
+      clone.tap {|r| r.joins_values += args if args.present? }
+    end
+
+    def where(opts, *rest)
+      value = build_where(opts, rest)
+      copy = clone
+      copy.where_values += Array.wrap(value) if value
+      copy
+    end
+
+    def having(*args)
+      value = build_where(*args)
+      clone.tap {|r| r.having_values += Array.wrap(value) if value.present? }
+    end
+
+    def limit(value = true)
+      copy = clone
+      copy.limit_value = value
+      copy
+    end
+
+    def offset(value = true)
+      clone.tap {|r| r.offset_value = value }
+    end
+
+    def lock(locks = true)
+      case locks
+      when String, TrueClass, NilClass
+        clone.tap {|r| r.lock_value = locks || true }
+      else
+        clone.tap {|r| r.lock_value = false }
+      end
+    end
+
+    def readonly(value = true)
+      clone.tap {|r| r.readonly_value = value }
+    end
+
+    def create_with(value = true)
+      clone.tap {|r| r.create_with_value = value }
+    end
+
+    def from(value = true)
+      clone.tap {|r| r.from_value = value }
+    end
+
+    def extending(*modules, &block)
+      modules << Module.new(&block) if block_given?
+      clone.tap {|r| r.send(:apply_modules, *modules) }
+    end
+
+    def reverse_order
+      order_clause = arel.order_clauses.join(', ')
+      relation = except(:order)
+
+      order = order_clause.blank? ?
+        "#{@klass.table_name}.#{@klass.primary_key} DESC" :
+        reverse_sql_order(order_clause)
+
+      relation.order Arel::SqlLiteral.new order
+    end
+
+    def arel
+      @arel ||= build_arel
+    end
+
+    def custom_join_sql(*joins)
+      arel = table
+      joins.each do |join|
+        next if join.blank?
+
+        @implicit_readonly = true
+
+        case join
+        when Hash, Array, Symbol
+          if array_of_strings?(join)
+            join_string = join.join(' ')
+            arel = arel.join(Arel::SqlLiteral.new(join_string))
+          end
+        when String
+          arel = arel.join(Arel::SqlLiteral.new(join))
+        else
+          arel = arel.join(join)
+        end
+      end
+      arel.joins(arel)
+    end
+
+    def build_arel
+      arel = table
+
+      arel = build_joins(arel, @joins_values) unless @joins_values.empty?
+
+      (@where_values - ['']).uniq.each do |where|
+        case where
+        when Arel::SqlLiteral
+          arel = arel.where(where)
+        else
+          sql = where.is_a?(String) ? where : where.to_sql
+          arel = arel.where(Arel::SqlLiteral.new("(#{sql})"))
+        end
+      end
+
+      arel = arel.having(*@having_values.uniq.select{|h| h.present?}) unless @having_values.empty?
+
+      arel = arel.take(@limit_value) if @limit_value
+      arel = arel.skip(@offset_value) if @offset_value
+
+      arel = arel.group(*@group_values.uniq.select{|g| g.present?}) unless @group_values.empty?
+
+      arel = arel.order(*@order_values.uniq.select{|o| o.present?}) unless @order_values.empty?
+
+      arel = build_select(arel, @select_values.uniq)
+
+      arel = arel.from(@from_value) if @from_value
+      arel = arel.lock(@lock_value) if @lock_value
+
+      arel
+    end
+
+    def build_where(opts, other = [])
+      case opts
+      when String, Array
+        @klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))
+      when Hash
+        attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)
+        PredicateBuilder.new(table.engine).build_from_hash(attributes, table)
+      else
+        opts
+      end
+    end
+
+    private
+
+    def build_joins(relation, joins)
+      joined_associations = []
+      association_joins = []
+
+      joins = @joins_values.map {|j| j.respond_to?(:strip) ? j.strip : j}.uniq
+
+      joins.each do |join|
+        association_joins << join if [Hash, Array, Symbol].include?(join.class) && !array_of_strings?(join)
+      end
+
+      stashed_association_joins = joins.grep(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)
+
+      non_association_joins = (joins - association_joins - stashed_association_joins)
+      custom_joins = custom_join_sql(*non_association_joins)
+
+      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins, custom_joins)
+
+      join_dependency.graft(*stashed_association_joins)
+
+      @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
+
+      to_join = []
+
+      join_dependency.join_associations.each do |association|
+        if (association_relation = association.relation).is_a?(Array)
+          to_join << [association_relation.first, association.join_class, association.association_join.first]
+          to_join << [association_relation.last, association.join_class, association.association_join.last]
+        else
+          to_join << [association_relation, association.join_class, association.association_join]
+        end
+      end
+
+      to_join.each do |tj|
+        unless joined_associations.detect {|ja| ja[0] == tj[0] && ja[1] == tj[1] && ja[2] == tj[2] }
+          joined_associations << tj
+          relation = relation.join(tj[0], tj[1]).on(*tj[2])
+        end
+      end
+
+      relation.join(custom_joins)
+    end
+
+    def build_select(arel, selects)
+      unless selects.empty?
+        @implicit_readonly = false
+        # TODO: fix this ugly hack, we should refactor the callers to get an ARel compatible array.
+        # Before this change we were passing to ARel the last element only, and ARel is capable of handling an array
+        if selects.all? {|s| s.is_a?(String) || !s.is_a?(Arel::Expression) } && !(selects.last =~ /^COUNT\(/)
+          arel.project(*selects)
+        else
+          arel.project(selects.last)
+        end
+      else
+        arel.project(Arel::SqlLiteral.new(@klass.quoted_table_name + '.*'))
+      end
+    end
+
+    def apply_modules(modules)
+      values = Array.wrap(modules)
+      @extensions += values if values.present?
+      values.each {|extension| extend(extension) }
+    end
+
+    def reverse_sql_order(order_query)
+      order_query.to_s.split(/,/).each { |s|
+        if s.match(/\s(asc|ASC)$/)
+          s.gsub!(/\s(asc|ASC)$/, ' DESC')
+        elsif s.match(/\s(desc|DESC)$/)
+          s.gsub!(/\s(desc|DESC)$/, ' ASC')
+        else
+          s.concat(' DESC')
+        end
+      }.join(',')
+    end
+
+    def array_of_strings?(o)
+      o.is_a?(Array) && o.all?{|obj| obj.is_a?(String)}
+    end
+
+  end
+end

data/lib/active_record/relation/spawn_methods.rb

@@ -0,0 +1,112 @@
+require 'active_support/core_ext/object/blank'
+
+module ActiveRecord
+  module SpawnMethods
+    def merge(r)
+      merged_relation = clone
+      return merged_relation unless r
+
+      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) - [:joins, :where]).each do |method|
+        value = r.send(:"#{method}_values")
+        unless value.empty?
+          if method == :includes
+            merged_relation = merged_relation.includes(value)
+          else
+            merged_relation.send(:"#{method}_values=", value)
+          end
+        end
+      end
+
+      merged_relation = merged_relation.joins(r.joins_values)
+
+      merged_wheres = @where_values
+
+      r.where_values.each do |w|
+        if w.respond_to?(:operator) && w.operator == :==
+          merged_wheres = merged_wheres.reject { |p|
+            p.respond_to?(:operator) && p.operator == :== && p.operand1.name == w.operand1.name
+          }
+        end
+
+        merged_wheres += [w]
+      end
+
+      merged_relation.where_values = merged_wheres
+
+      Relation::SINGLE_VALUE_METHODS.reject {|m| m == :lock}.each do |method|
+        unless (value = r.send(:"#{method}_value")).nil?
+          merged_relation.send(:"#{method}_value=", value)
+        end
+      end
+
+      merged_relation.lock_value = r.lock_value unless merged_relation.lock_value
+
+      # Apply scope extension modules
+      merged_relation.send :apply_modules, r.extensions
+
+      merged_relation
+    end
+
+    alias :& :merge
+
+    def except(*skips)
+      result = self.class.new(@klass, table)
+
+      (Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS).each do |method|
+        result.send(:"#{method}_values=", send(:"#{method}_values")) unless skips.include?(method)
+      end
+
+      Relation::SINGLE_VALUE_METHODS.each do |method|
+        result.send(:"#{method}_value=", send(:"#{method}_value")) unless skips.include?(method)
+      end
+
+      result
+    end
+
+    def only(*onlies)
+      result = self.class.new(@klass, table)
+
+      onlies.each do |only|
+        if (Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS).include?(only)
+          result.send(:"#{only}_values=", send(:"#{only}_values"))
+        elsif Relation::SINGLE_VALUE_METHODS.include?(only)
+          result.send(:"#{only}_value=", send(:"#{only}_value"))
+        else
+          raise "Invalid argument : #{only}"
+        end
+      end
+
+      result
+    end
+
+    VALID_FIND_OPTIONS = [ :conditions, :include, :joins, :limit, :offset, :extend,
+                           :order, :select, :readonly, :group, :having, :from, :lock ]
+
+    def apply_finder_options(options)
+      relation = clone
+      return relation unless options
+
+      options.assert_valid_keys(VALID_FIND_OPTIONS)
+
+      [:joins, :select, :group, :having, :limit, :offset, :from, :lock].each do |finder|
+        if value = options[finder]
+          relation = relation.send(finder, value)
+        end
+      end
+
+      relation = relation.readonly(options[:readonly]) if options.key? :readonly
+
+      # Give precedence to newly-applied orders and groups to play nicely with with_scope
+      [:group, :order].each do |finder|
+        relation.send("#{finder}_values=", Array.wrap(options[finder]) + relation.send("#{finder}_values")) if options.has_key?(finder)
+      end
+
+      relation = relation.where(options[:conditions]) if options.has_key?(:conditions)
+      relation = relation.includes(options[:include]) if options.has_key?(:include)
+      relation = relation.extending(options[:extend]) if options.has_key?(:extend)
+
+      relation
+    end
+
+  end
+end

data/lib/active_record/schema.rb

@@ -0,0 +1,59 @@
+require 'active_support/core_ext/object/blank'
+
+module ActiveRecord
+  # = Active Record Schema
+  #
+  # Allows programmers to programmatically define a schema in a portable
+  # DSL. This means you can define tables, indexes, etc. without using SQL
+  # directly, so your applications can more easily support multiple
+  # databases.
+  #
+  # Usage:
+  #
+  #   ActiveRecord::Schema.define do
+  #     create_table :authors do |t|
+  #       t.string :name, :null => false
+  #     end
+  #
+  #     add_index :authors, :name, :unique
+  #
+  #     create_table :posts do |t|
+  #       t.integer :author_id, :null => false
+  #       t.string :subject
+  #       t.text :body
+  #       t.boolean :private, :default => false
+  #     end
+  #
+  #     add_index :posts, :author_id
+  #   end
+  #
+  # ActiveRecord::Schema is only supported by database adapters that also
+  # support migrations, the two features being very similar.
+  class Schema < Migration
+    private_class_method :new
+
+    def self.migrations_path
+      ActiveRecord::Migrator.migrations_path
+    end
+
+    # Eval the given block. All methods available to the current connection
+    # adapter are available within the block, so you can easily use the
+    # database definition DSL to build up your schema (+create_table+,
+    # +add_index+, etc.).
+    #
+    # The +info+ hash is optional, and if given is used to define metadata
+    # about the current schema (currently, only the schema's version):
+    #
+    #   ActiveRecord::Schema.define(:version => 20380119000001) do
+    #     ...
+    #   end
+    def self.define(info={}, &block)
+      instance_eval(&block)
+
+      unless info[:version].blank?
+        initialize_schema_migrations_table
+        assume_migrated_upto_version(info[:version], migrations_path)
+      end
+    end
+  end
+end