squeel 1.0.18 → 1.1.0

data/lib/generators/templates/squeel.rb

@@ -5,7 +5,7 @@ Squeel.configure do |config|
   # config.load_core_extensions :hash
 
   # To load symbol extensions (for a subset of the old MetaWhere functionality,
-  # via ARel predicate methods on Symbols: :name.matches, etc):
+  # via Arel predicate methods on Symbols: :name.matches, etc):
   #
   # NOTE: Not recommended. Learn the new DSL. Use it. Love it.
   #

data/lib/squeel/adapters/active_record.rb

@@ -1,5 +1,5 @@
 case ActiveRecord::VERSION::MAJOR
-when 3
+when 3, 4
   ActiveRecord::Relation.send :include, Squeel::Nodes::Aliasing
   require 'squeel/adapters/active_record/join_dependency_extensions'
   require 'squeel/adapters/active_record/base_extensions'

data/lib/squeel/adapters/active_record/4.0/compat.rb

@@ -0,0 +1,17 @@
+require 'squeel/adapters/active_record/compat'
+
+module ActiveRecord
+  module Associations
+    class AssociationScope
+      # 4.0's eval_scope doesn't play nicely with different bases. Need to do
+      # a similar workaround to the one for AR::Relation#merge, visiting it
+      def eval_scope(klass, scope)
+        if scope.is_a?(Relation)
+          scope
+        else
+          klass.unscoped.instance_exec(owner, &scope).visited
+        end
+      end
+    end
+  end
+end

data/lib/squeel/adapters/active_record/4.0/context.rb

@@ -0,0 +1 @@
+require 'squeel/adapters/active_record/context'

data/lib/squeel/adapters/active_record/4.0/preloader_extensions.rb

@@ -0,0 +1 @@
+require 'squeel/adapters/active_record/preloader_extensions'

data/lib/squeel/adapters/active_record/4.0/relation_extensions.rb

@@ -0,0 +1,126 @@
+require 'squeel/adapters/active_record/relation_extensions'
+
+module Squeel
+  module Adapters
+    module ActiveRecord
+      module RelationExtensions
+
+        # where.not is a pain. It calls the private `build_where` method on its
+        # scope, and since ActiveRecord::Relation already includes the original
+        # ActiveRecord::QueryMethods module, we have to find a way to trick the
+        # scope passed to the WhereChain initializer into having the original
+        # behavior. This is a way to do it that avoids using alias_method_chain.
+        module WhereChainCompatibility
+          include ::ActiveRecord::QueryMethods
+          define_method :build_where,
+            ::ActiveRecord::QueryMethods.instance_method(:build_where)
+        end
+
+        def where(opts = :chain, *rest)
+          if block_given?
+            super(DSL.eval &Proc.new)
+          else
+            if opts == :chain
+              scope = spawn
+              scope.extend(WhereChainCompatibility)
+              ::ActiveRecord::QueryMethods::WhereChain.new(scope)
+            else
+              super
+            end
+          end
+        end
+
+        def build_arel
+          arel = Arel::SelectManager.new(table.engine, table)
+
+          build_joins(arel, joins_values) unless joins_values.empty?
+
+          collapse_wheres(arel, where_visit((where_values - ['']).uniq))
+
+          arel.having(*having_visit(having_values.uniq.reject{|h| h.blank?})) unless having_values.empty?
+
+          arel.take(connection.sanitize_limit(limit_value)) if limit_value
+          arel.skip(offset_value.to_i) if offset_value
+
+          arel.group(*group_visit(group_values.uniq.reject{|g| g.blank?})) unless group_values.empty?
+
+          build_order(arel)
+
+          build_select(arel, select_visit(select_values.uniq))
+
+          arel.distinct(distinct_value)
+          arel.from(from_visit(from_value)) if from_value
+          arel.lock(lock_value) if lock_value
+
+          arel
+        end
+
+        def build_order(arel)
+          orders = order_visit(dehashified_order_values)
+          orders = reverse_sql_order(attrs_to_orderings(orders)) if reverse_order_value
+
+          orders = orders.uniq.reject(&:blank?).flat_map do |order|
+            case order
+            when Symbol
+              table[order].asc
+            when Hash
+              order.map { |field, dir| table[field].send(dir) }
+            else
+              order
+            end
+          end
+
+          arel.order(*orders) unless orders.empty?
+        end
+
+        def build_from
+          opts, name = from_value
+          case opts
+          when Relation
+            name ||= 'subquery'
+            opts.arel.as(name.to_s)
+          else
+            opts
+          end
+        end
+
+        # This is copied directly from 4.0.0's implementation, but adds an extra
+        # exclusion for Squeel::Nodes::Node to fix #248. Can be removed if/when
+        # rails/rails#11439 is merged.
+        def order!(*args)
+          args.flatten!
+          validate_order_args args
+
+          references = args.reject { |arg|
+            Arel::Node === arg || Squeel::Nodes::Node === arg
+          }
+          references.map! { |arg| arg =~ /^([a-zA-Z]\w*)\.(\w+)/ && $1 }.compact!
+          references!(references) if references.any?
+
+          # if a symbol is given we prepend the quoted table name
+          args = args.map { |arg|
+            arg.is_a?(Symbol) ? "#{quoted_table_name}.#{arg} ASC" : arg
+          }
+
+          self.order_values = args + self.order_values
+          self
+        end
+
+        private
+
+        def dehashified_order_values
+          order_values.map { |o|
+            if Hash === o && o.values.all? { |v| [:asc, :desc].include?(v) }
+              o.map { |field, dir| table[field].send(dir) }
+            else
+              o
+            end
+          }
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.send :include, Squeel::Adapters::ActiveRecord::RelationExtensions

data/lib/squeel/adapters/active_record/base_extensions.rb

@@ -9,7 +9,7 @@ module Squeel
 
         def sifter(name = nil)
           if Symbol === name && block_given?
-            singleton_class.send :define_method, name,
+            singleton_class.send :define_method, "sifter_#{name}",
                                   lambda {|*args| DSL.exec(*args, &Proc.new)}
           else
             raise ArgumentError, "A name and block are required"

data/lib/squeel/adapters/active_record/context.rb

@@ -44,6 +44,16 @@ module Squeel
           parent
         end
 
+        def classify(object)
+          if Class === object
+            object
+          elsif object.respond_to? :base_klass
+            object.base_klass
+          else
+            raise ArgumentError, "#{object} can't be converted to a class"
+          end
+        end
+
         private
 
         def get_table(object)
@@ -58,16 +68,6 @@ module Squeel
           end
         end
 
-        def classify(object)
-          if Class === object
-            object
-          elsif object.respond_to? :active_record
-            object.active_record
-          else
-            raise ArgumentError, "#{object} can't be converted to a class"
-          end
-        end
-
         def get_arel_visitor
           @engine.connection.visitor
         end

data/lib/squeel/adapters/active_record/relation_extensions.rb

@@ -14,7 +14,12 @@ module Squeel
         # because the default #reset already does this, despite never setting
         # it anywhere that I can find. Serendipity, I say!
         def join_dependency
-          @join_dependency ||= (build_join_dependency(table.from(table), @joins_values) && @join_dependency)
+          @join_dependency ||= (
+            build_join_dependency(
+              Arel::SelectManager.new(table.engine, table),
+              joins_values
+            ) && @join_dependency
+          )
         end
 
         %w(where having group order select from).each do |visitor|
@@ -40,6 +45,7 @@ module Squeel
               merge_resolving_duplicate_squeel_equalities(r)
             end
           else
+            puts r.inspect if r.is_a?(Proc)
             super(r)
           end
         end
@@ -49,12 +55,12 @@ module Squeel
         end
 
         def visit!
-          @where_values = where_visit((@where_values - ['']).uniq)
-          @having_values = having_visit(@having_values.uniq.reject{|h| h.blank?})
-          # FIXME: AR barfs on ARel attributes in group_values. Workaround?
-          # @group_values = group_visit(@group_values.uniq.reject{|g| g.blank?})
-          @order_values = order_visit(@order_values.uniq.reject{|o| o.blank?})
-          @select_values = select_visit(@select_values.uniq)
+          self.where_values = where_visit((where_values - ['']).uniq)
+          self.having_values = having_visit(having_values.uniq.reject{|h| h.blank?})
+          # FIXME: AR barfs on Arel attributes in group_values. Workaround?
+          # self.group_values = group_visit(group_values.uniq.reject{|g| g.blank?})
+          self.order_values = order_visit(order_values.uniq.reject{|o| o.blank?})
+          self.select_values = select_visit(select_values.uniq)
 
           self
         end
@@ -100,22 +106,22 @@ module Squeel
           buckets = joins.group_by do |join|
             case join
             when String
-              'string_join'
+              :string_join
             when Hash, Symbol, Array, Nodes::Stub, Nodes::Join, Nodes::KeyPath
-              'association_join'
+              :association_join
             when JoinAssociation
-              'stashed_join'
+              :stashed_join
             when Arel::Nodes::Join
-              'join_node'
+              :join_node
             else
               raise 'unknown class: %s' % join.class.name
             end
           end
 
-          association_joins         = buckets['association_join'] || []
-          stashed_association_joins = buckets['stashed_join'] || []
-          join_nodes                = (buckets['join_node'] || []).uniq
-          string_joins              = (buckets['string_join'] || []).map { |x|
+          association_joins         = buckets[:association_join] || []
+          stashed_association_joins = buckets[:stashed_join] || []
+          join_nodes                = (buckets[:join_node] || []).uniq
+          string_joins              = (buckets[:string_join] || []).map { |x|
             x.strip
           }.uniq
 
@@ -140,6 +146,8 @@ module Squeel
 
           manager
         end
+        # For 4.x adapters
+        alias :build_joins :build_join_dependency
 
         def includes(*args)
           if block_given? && args.empty?
@@ -335,7 +343,7 @@ module Squeel
         # DB for debug purposes without actually running the query.
         def debug_sql
           if eager_loading?
-            including = (@eager_load_values + @includes_values).uniq
+            including = (eager_load_values + includes_values).uniq
             join_dependency = JoinDependency.new(@klass, including, [])
             construct_relation_for_association_find(join_dependency).to_sql
           else

data/lib/squeel/configuration.rb

@@ -33,6 +33,7 @@ module Squeel
     #   @param [Symbol] sym1 :hash or :symbol
     #   @param [Symbol] sym2 :hash or :symbol
     def load_core_extensions(*exts)
+      deprecate 'Core extensions are deprecated and will be removed in Squeel 2.0.'
       exts.each do |ext|
         require "squeel/core_ext/#{ext}"
       end

data/lib/squeel/constants.rb

@@ -1,5 +1,5 @@
 module Squeel
-  # Defines the default list of ARel predicates and predicate aliases
+  # Defines the default list of Arel predicates and predicate aliases
   module Constants
     PREDICATES = [
        :eq, :eq_any, :eq_all,
@@ -21,4 +21,4 @@ module Squeel
        :gteq           => [:gte]
      }.freeze
   end
-end
+end

data/lib/squeel/context.rb

@@ -42,7 +42,7 @@ module Squeel
     end
 
     # This method, as implemented, just makes use of the table cache, which will
-    # call get_table, where the real work of getting the ARel Table occurs.
+    # call get_table, where the real work of getting the Arel Table occurs.
     #
     # @param object A contextualizable object (this will depend on the subclass's implementation)
     # @return [Arel::Table] A table corresponding to the object param
@@ -72,4 +72,4 @@ module Squeel
     end
 
   end
-end
+end

data/lib/squeel/dsl.rb

@@ -63,7 +63,7 @@ module Squeel
       @caller.instance_eval &block
     end
 
-    # Shorthand for creating ARel SqlLiteral nodes.
+    # Shorthand for creating Arel SqlLiteral nodes.
     #
     # @param [String] string The string to convert to an SQL literal.
     # @return [Arel::Nodes::SqlLiteral] The SQL literal.

data/lib/squeel/nodes.rb

@@ -5,6 +5,8 @@ module Squeel
   end
 end
 
+require 'squeel/nodes/node'
+
 require 'squeel/nodes/predicate_methods'
 require 'squeel/nodes/operators'
 require 'squeel/nodes/predicate_operators'

data/lib/squeel/nodes/binary.rb

@@ -1,7 +1,7 @@
 module Squeel
   module Nodes
     # A node that represents an operation with two operands.
-    class Binary
+    class Binary < Node
 
       include PredicateOperators
 

data/lib/squeel/nodes/function.rb

@@ -1,7 +1,7 @@
 module Squeel
   module Nodes
     # A node that represents an SQL function call
-    class Function
+    class Function < Node
 
       include PredicateMethods
       include PredicateOperators
@@ -22,7 +22,7 @@ module Squeel
       alias :<= :lteq
 
       # @return [Symbol] The name of the SQL function to be called
-      attr_reader :name
+      attr_reader :function_name
 
       # @return [Array] The arguments to be passed to the SQL function
       attr_reader :args
@@ -30,8 +30,8 @@ module Squeel
       # Create a node representing an SQL Function with the given name and arguments
       # @param [Symbol] name The function name
       # @param [Array] args The array of arguments to pass to the function.
-      def initialize(name, args)
-        @name, @args = name, args
+      def initialize(function_name, args)
+        @function_name, @args = function_name, args
       end
 
       # expand_hash_conditions_for_aggregates assumes our hash keys can be
@@ -48,7 +48,7 @@ module Squeel
 
       def eql?(other)
         self.class == other.class &&
-          self.name.eql?(other.name) &&
+          self.function_name.eql?(other.function_name) &&
           self.args.eql?(other.args)
       end
 

data/lib/squeel/nodes/join.rb

@@ -3,7 +3,7 @@ require 'active_support/core_ext/module'
 module Squeel
   module Nodes
     # A node representing a joined association
-    class Join
+    class Join < Node
       undef_method :id if method_defined?(:id)
 
       attr_reader :_join
@@ -12,7 +12,7 @@ module Squeel
 
       # Create a new Join node
       # @param [Symbol] name The association name
-      # @param [Arel::InnerJoin, Arel::OuterJoin] type The ARel join class
+      # @param [Arel::InnerJoin, Arel::OuterJoin] type The Arel join class
       # @param [Class, String, Symbol] klass The polymorphic belongs_to class or class name
       def initialize(name, type = Arel::InnerJoin, klass = nil)
         @_join = Polyamorous::Join.new(name, type, klass)

data/lib/squeel/nodes/key_path.rb

@@ -4,7 +4,7 @@ module Squeel
   module Nodes
     # A node that stores a path of keys (of Symbol, Stub, or Join values) and
     # an endpoint. Used similarly to a nested hash.
-    class KeyPath
+    class KeyPath < Node
       include PredicateOperators
       include Operators
 
@@ -179,12 +179,17 @@ module Squeel
 
       # Appends to the KeyPath or delegates to the endpoint, as appropriate
       # @return [KeyPath] The updated KeyPath
-      def method_missing(method_id, *args)
+      def method_missing(method_id, *args, &block)
         super if method_id == :to_ary
 
-        if endpoint.respond_to? method_id
-          self.endpoint = endpoint.send(method_id, *args)
-          self
+        if endpoint.respond_to?(method_id)
+          if Predicate === endpoint && method_id == :==
+            false
+          else
+            # TODO: We really should not mutate here.
+            self.endpoint = endpoint.send(method_id, *args)
+            self
+          end
         elsif Stub === endpoint || Join === endpoint
           if args.empty?
             @path << Stub.new(method_id)