squeel 1.0.11 → 1.0.12

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 1.0.12 (2012-10-07)
+
+* Properly uniq order_values before visiting, to fix #163
+* Remove an unnecessary passthrough on String in visitor.rb. Fixes #162
+
 ## 1.0.11 (2012-09-03)
 
 * Fixed issue #157, resolving problems when joining the same table twice.
@@ -6,7 +11,7 @@
 
 ## 1.0.10 (2012-09-01)
 
-  * Yanked from RubyGems.org due to semantic versioning oversight
+* Yanked from RubyGems.org due to semantic versioning oversight
 
 ## 1.0.9 (2012-08-06)
 

data/lib/squeel/adapters/active_record.rb

@@ -3,36 +3,10 @@ when 3
   ActiveRecord::Relation.send :include, Squeel::Nodes::Aliasing
   require 'squeel/adapters/active_record/join_dependency_extensions'
   require 'squeel/adapters/active_record/base_extensions'
-  ActiveRecord::Base.extend Squeel::Adapters::ActiveRecord::BaseExtensions
 
-  case ActiveRecord::VERSION::MINOR
-  when 0
-    require 'squeel/adapters/active_record/3.0/compat'
-    require 'squeel/adapters/active_record/3.0/relation_extensions'
-    require 'squeel/adapters/active_record/3.0/association_preload_extensions'
-    require 'squeel/adapters/active_record/3.0/context'
-
-    ActiveRecord::Relation.send :include, Squeel::Adapters::ActiveRecord::RelationExtensions
-    ActiveRecord::Associations::ClassMethods::JoinDependency.send :include, Squeel::Adapters::ActiveRecord::JoinDependencyExtensions
-    ActiveRecord::Base.extend Squeel::Adapters::ActiveRecord::AssociationPreloadExtensions
-  when 1
-    require 'squeel/adapters/active_record/3.1/compat'
-    require 'squeel/adapters/active_record/3.1/relation_extensions'
-    require 'squeel/adapters/active_record/3.1/preloader_extensions'
-    require 'squeel/adapters/active_record/3.1/context'
-
-    ActiveRecord::Relation.send :include, Squeel::Adapters::ActiveRecord::RelationExtensions
-    ActiveRecord::Associations::JoinDependency.send :include, Squeel::Adapters::ActiveRecord::JoinDependencyExtensions
-    ActiveRecord::Associations::Preloader.send :include, Squeel::Adapters::ActiveRecord::PreloaderExtensions
-  else
-    require 'squeel/adapters/active_record/compat'
-    require 'squeel/adapters/active_record/relation_extensions'
-    require 'squeel/adapters/active_record/preloader_extensions'
-    require 'squeel/adapters/active_record/context'
-
-    ActiveRecord::Relation.send :include, Squeel::Adapters::ActiveRecord::RelationExtensions
-    ActiveRecord::Associations::JoinDependency.send :include, Squeel::Adapters::ActiveRecord::JoinDependencyExtensions
-    ActiveRecord::Associations::Preloader.send :include, Squeel::Adapters::ActiveRecord::PreloaderExtensions
+  adapter_directory = "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+  Dir[File.expand_path("../active_record/#{adapter_directory}/*.rb", __FILE__)].each do |f|
+    require f
   end
 else
   raise NotImplementedError, "Squeel does not support ActiveRecord version #{ActiveRecord::VERSION::STRING}"

data/lib/squeel/adapters/active_record/3.0/association_preload_extensions.rb

@@ -11,3 +11,5 @@ module Squeel
     end
   end
 end
+
+ActiveRecord::Base.extend Squeel::Adapters::ActiveRecord::AssociationPreloadExtensions

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

@@ -1,73 +1,14 @@
-require 'squeel/context'
+require 'squeel/adapters/active_record/context'
 
 module Squeel
   module Adapters
     module ActiveRecord
       class Context < ::Squeel::Context
-        # Because the AR::Associations namespace is insane
-        JoinBase = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinBase
-
-        def initialize(object)
-          super
-          @base = object.join_base
-          @engine = @base.arel_engine
-          @arel_visitor = Arel::Visitors.visitor_for @engine
-          @default_table = Arel::Table.new(@base.table_name, :as => @base.aliased_table_name, :engine => @engine)
-        end
-
-        def find(object, parent = @base)
-          if JoinBase === parent
-            case object
-            when String, Symbol, Nodes::Stub
-              assoc_name = object.to_s
-              @object.join_associations.detect { |j|
-                j.reflection.name.to_s == assoc_name && j.parent == parent
-              }
-            when Nodes::Join
-              @object.join_associations.detect { |j|
-                j.reflection.name == object.name && j.parent == parent &&
-                (object.polymorphic? ? j.reflection.klass == object._klass : true)
-              }
-            else
-              @object.join_associations.detect { |j|
-                j.reflection == object && j.parent == parent
-              }
-            end
-          end
-        end
-
-        def traverse(keypath, parent = @base, include_endpoint = false)
-          parent = @base if keypath.absolute?
-          keypath.path_without_endpoint.each do |key|
-            parent = find(key, parent) || key
-          end
-          parent = find(keypath.endpoint, parent) if include_endpoint
-
-          parent
-        end
 
         private
 
-        def get_table(object)
-          if [Symbol, String, Nodes::Stub].include?(object.class)
-            Arel::Table.new(object.to_s, :engine => @engine)
-          elsif Nodes::Join === object
-            object._klass ? object._klass.arel_table : Arel::Table.new(object._name, :engine => @engine)
-          elsif object.respond_to?(:aliased_table_name)
-            Arel::Table.new(object.table_name, :as => object.aliased_table_name, :engine => @engine)
-          else
-            raise ArgumentError, "Unable to get table for #{object}"
-          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
+        def get_arel_visitor
+          Arel::Visitors.visitor_for @engine
         end
 
       end

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

@@ -1,16 +1,10 @@
-require 'active_record'
+require 'squeel/adapters/active_record/relation_extensions'
 
 module Squeel
   module Adapters
     module ActiveRecord
       module RelationExtensions
 
-        JoinAssociation = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation
-        JoinDependency = ::ActiveRecord::Associations::ClassMethods::JoinDependency
-
-        attr_writer :join_dependency
-        private :join_dependency=
-
         # Returns a JoinDependency for the current relation.
         #
         # We don't need to clear out @join_dependency by overriding #reset,
@@ -20,48 +14,6 @@ module Squeel
           @join_dependency ||= (build_join_dependency(table, @joins_values) && @join_dependency)
         end
 
-        %w(where having group order select from).each do |visitor|
-          define_method "#{visitor}_visit" do |values|
-            Visitors.const_get("#{visitor.capitalize}Visitor").new(
-              Context.new(join_dependency)
-            ).accept(values)
-          end
-        end
-
-        # We need to be able to support merging two relations without having
-        # to get our hooks too deeply into ActiveRecord. That proves to be
-        # easier said than done. I hate Relation#merge. If Squeel has a
-        # nemesis, Relation#merge would be it.
-        #
-        # Whatever code you see here currently is my current best attempt at
-        # coexisting peacefully with said nemesis.
-        def merge(r, equalities_resolved = false)
-          if ::ActiveRecord::Relation === r && !equalities_resolved
-            if self.table_name != r.table_name
-              super(r.visited)
-            else
-              merge_resolving_duplicate_squeel_equalities(r)
-            end
-          else
-            super(r)
-          end
-        end
-
-        def visited
-          clone.visit!
-        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
-        end
-
         def build_arel
           arel = table
 
@@ -86,35 +38,6 @@ module Squeel
           arel
         end
 
-        # So, building a select for a count query in ActiveRecord is
-        # pretty heavily dependent on select_values containing strings.
-        # I'd initially expected that I could just hack together a fix
-        # to select_for_count and everything would fall in line, but
-        # unfortunately, pretty much everything from that point on
-        # in ActiveRecord::Calculations#perform_calculation expects
-        # the column to be a string, or at worst, a symbol.
-        #
-        # In the long term, I would like to refactor the code in
-        # Rails core, but for now, I'm going to settle for this hack
-        # that tries really hard to coerce things to a string.
-        def select_for_count
-          visited_values = select_visit(select_values.uniq)
-          if visited_values.size == 1
-            select = visited_values.first
-
-            str_select = case select
-            when String
-              select
-            when Symbol
-              select.to_s
-            else
-              select.to_sql if select.respond_to?(:to_sql)
-            end
-
-            str_select if str_select && str_select !~ /[,*]/
-          end
-        end
-
         def build_join_dependency(relation, joins)
           association_joins = []
 
@@ -153,126 +76,14 @@ module Squeel
           relation = relation.join(custom_joins)
         end
 
-        def includes(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def preload(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def eager_load(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def select(value = Proc.new)
-          if block_given? && Proc === value
-            if value.arity > 0
-              to_a.select {|*block_args| value.call(*block_args)}
-            else
-              relation = clone
-              relation.select_values += Array.wrap(DSL.eval &value)
-              relation
-            end
-          else
-            super
-          end
-        end
-
-        def group(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def order(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def reorder(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def joins(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def where(opts = Proc.new, *rest)
-          if block_given? && Proc === opts
-            super(DSL.eval &opts)
-          else
-            super
-          end
-        end
-
-        def having(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def from(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def build_where(opts, other = [])
-          case opts
-          when String, Array
-            super
-          else  # Let's prevent PredicateBuilder from doing its thing
-            [opts, *other].map do |arg|
-              case arg
-              when Array  # Just in case there's an array in there somewhere
-                @klass.send(:sanitize_sql, arg)
-              when Hash
-                @klass.send(:expand_hash_conditions_for_aggregates, arg)
-              else
-                arg
-              end
-            end
-          end
-        end
-
         def collapse_wheres(arel, wheres)
-          wheres = [wheres] unless Array === wheres
+          wheres = Array(wheres)
           binaries = wheres.grep(Arel::Nodes::Binary)
 
           groups = binaries.group_by {|b| [b.class, b.left]}
 
           groups.each do |_, bins|
-            arel = arel.where(bins.inject(&:and))
+            arel = arel.where(Arel::Nodes::And.new(bins))
           end
 
           (wheres - binaries).each do |where|
@@ -283,117 +94,6 @@ module Squeel
           arel
         end
 
-        def find_equality_predicates(nodes)
-          nodes.map { |node|
-            case node
-            when Arel::Nodes::Equality
-              if node.left.respond_to?(:relation) &&
-                node.left.relation.name == table_name
-                node
-              end
-            when Arel::Nodes::Grouping
-              find_equality_predicates([node.expr])
-            when Arel::Nodes::And
-              find_equality_predicates(node.children)
-            else
-              nil
-            end
-          }.compact.flatten
-        end
-
-        def flatten_nodes(nodes)
-          nodes.map { |node|
-            case node
-            when Array
-              flatten_nodes(node)
-            when Nodes::And
-              flatten_nodes(node.children)
-            when Nodes::Grouping
-              flatten_nodes(node.expr)
-            else
-              node
-            end
-          }.flatten
-        end
-
-        def merge_resolving_duplicate_squeel_equalities(r)
-          left = clone
-          right = r.clone
-          left.where_values = flatten_nodes(left.where_values)
-          right.where_values = flatten_nodes(right.where_values)
-          right_equalities = right.where_values.select do |obj|
-            Nodes::Predicate === obj && obj.method_name == :eq
-          end
-          right.where_values -= right_equalities
-          left.where_values = resolve_duplicate_squeel_equalities(
-            left.where_values + right_equalities
-          )
-          left.merge(right, true)
-        end
-
-        def resolve_duplicate_squeel_equalities(wheres)
-          seen = {}
-          wheres.reverse.reject { |n|
-            nuke = false
-            if Nodes::Predicate === n && n.method_name == :eq
-              nuke       = seen[n.expr]
-              seen[n.expr] = true
-            end
-            nuke
-          }.reverse
-        end
-
-        # Simulate the logic that occurs in #to_a
-        #
-        # This will let us get a dump of the SQL that will be run against the
-        # DB for debug purposes without actually running the query.
-        def debug_sql
-          if eager_loading?
-            including = (@eager_load_values + @includes_values).uniq
-            join_dependency = JoinDependency.new(@klass, including, nil)
-            construct_relation_for_association_find(join_dependency).to_sql
-          else
-            arel.to_sql
-          end
-        end
-
-        ### ZOMG ALIAS_METHOD_CHAIN IS BELOW. HIDE YOUR EYES!
-        # ...
-        # ...
-        # ...
-        # Since you're still looking, let me explain this horrible
-        # transgression you see before you.
-        #
-        # You see, Relation#where_values_hash is defined on the
-        # ActiveRecord::Relation class, itself.
-        #
-        # Since it's defined there, but I would very much like to modify its
-        # behavior, I have three choices:
-        #
-        # 1. Inherit from ActiveRecord::Relation in a Squeel::Relation
-        #    class, and make an attempt to usurp all of the various calls
-        #    to methods on ActiveRecord::Relation by doing some really
-        #    evil stuff with constant reassignment, all for the sake of
-        #    being able to use super().
-        #
-        # 2. Submit a patch to Rails core, breaking this method off into
-        #    another module, all for my own selfish desire to use super()
-        #    while mucking about in Rails internals.
-        #
-        # 3. Use alias_method_chain, and say 10 hail Hanssons as penance.
-        #
-        # I opted to go with #3. Except for the hail Hansson thing.
-        # Unless you're DHH, in which case, I totally said them.
-        #
-        # If you'd like to read more about alias_method_chain, see
-        # http://erniemiller.org/2011/02/03/when-to-use-alias_method_chain/
-
-        def self.included(base)
-          base.class_eval do
-            alias_method_chain :where_values_hash, :squeel
-          end
-        end
-
         def where_values_hash_with_squeel
           equalities = find_equality_predicates(where_visit(@where_values))
 
@@ -404,3 +104,5 @@ module Squeel
     end
   end
 end
+
+ActiveRecord::Relation.send :include, Squeel::Adapters::ActiveRecord::RelationExtensions