squeel_rbg 0.8.2

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

@@ -0,0 +1,83 @@
+require 'active_record'
+
+module Squeel
+  module Adapters
+    module ActiveRecord
+      module JoinDependency
+
+        # Yes, I'm using alias_method_chain here. No, I don't feel too
+        # bad about it. JoinDependency, or, to call it by its full proper
+        # name, ::ActiveRecord::Associations::JoinDependency, is one of the
+        # most "for internal use only" chunks of ActiveRecord.
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :build, :squeel
+            alias_method_chain :graft, :squeel
+          end
+        end
+
+        def graft_with_squeel(*associations)
+          associations.each do |association|
+            unless join_associations.detect {|a| association == a}
+              if association.reflection.options[:polymorphic]
+                build(Nodes::Join.new(association.reflection.name, association.join_type, association.reflection.klass),
+                      association.find_parent_in(self) || join_base, association.join_type)
+              else
+                build(association.reflection.name, association.find_parent_in(self) || join_base, association.join_type)
+              end
+            end
+          end
+          self
+        end
+
+        def build_with_squeel(associations, parent = nil, join_type = Arel::InnerJoin)
+          associations = associations.symbol if Nodes::Stub === associations
+
+          case associations
+          when Nodes::Join
+            parent ||= join_parts.last
+            reflection = parent.reflections[associations._name] or
+              raise ::ActiveRecord::ConfigurationError, "Association named '#{ associations._name }' was not found; perhaps you misspelled it?"
+
+            unless join_association = find_join_association_respecting_polymorphism(reflection, parent, associations._klass)
+              @reflections << reflection
+              join_association = build_join_association_respecting_polymorphism(reflection, parent, associations._klass)
+              join_association.join_type = associations._type
+              @join_parts << join_association
+              cache_joined_association(join_association)
+            end
+
+            join_association
+          when Nodes::KeyPath
+            parent ||= join_parts.last
+            associations.path_with_endpoint.each do |key|
+              parent = build(key, parent, join_type)
+            end
+            parent
+          else
+            build_without_squeel(associations, parent, join_type)
+          end
+        end
+
+        def find_join_association_respecting_polymorphism(reflection, parent, klass)
+          if association = find_join_association(reflection, parent)
+            unless reflection.options[:polymorphic]
+              association
+            else
+              association if association.active_record == klass
+            end
+          end
+        end
+
+        def build_join_association_respecting_polymorphism(reflection, parent, klass)
+          if reflection.options[:polymorphic] && klass
+            JoinAssociation.new(reflection, self, parent, klass)
+          else
+            JoinAssociation.new(reflection, self, parent)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Squeel
+  module Adapters
+    module ActiveRecord
+      module Preloader
+
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :run, :squeel
+          end
+        end
+
+        def run_with_squeel
+          unless records.empty?
+            Visitors::SymbolVisitor.new.accept(associations).each { |association| preload(association) }
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,351 @@
+require 'active_record'
+
+module Squeel
+  module Adapters
+    module ActiveRecord
+      module Relation
+
+        JoinAssociation = ::ActiveRecord::Associations::JoinDependency::JoinAssociation
+        JoinDependency = ::ActiveRecord::Associations::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, 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)
+        end
+
+        def predicate_visitor
+          Visitors::PredicateVisitor.new(
+            Context.new(join_dependency)
+          )
+        end
+
+        def attribute_visitor
+          Visitors::AttributeVisitor.new(
+            Context.new(join_dependency)
+          )
+        end
+
+        # We need to be able to support merging two relations that have a different
+        # base class. Stock ActiveRecord doesn't have to do anything too special, because
+        # it's already created predicates out of the where_values by now, and they're
+        # already bound to the proper table.
+        #
+        # Squeel, on the other hand, needs to do its best to ensure the predicates are still
+        # winding up against the proper table. Merging relations is a really nifty shortcut
+        # but another little corner of ActiveRecord where the magic quickly fades. :(
+        def merge(r, association_name = nil)
+          if association_name || relation_with_different_base?(r)
+            r = r.clone
+            association_name ||= infer_association_for_relation_merge(r)
+            prepare_relation_for_association_merge!(r, association_name)
+          end
+
+          super(r)
+        end
+
+        def relation_with_different_base?(r)
+          ::ActiveRecord::Relation === r &&
+          base_class.name != r.klass.base_class.name
+        end
+
+        def infer_association_for_relation_merge(r)
+          default_association = reflect_on_all_associations.detect {|a| a.class_name == r.klass.name}
+          default_association ? default_association.name : r.table_name.to_sym
+        end
+
+        def prepare_relation_for_association_merge!(r, association_name)
+          r.where_values.map! {|w| Squeel::Visitors::PredicateVisitor.can_accept?(w) ? {association_name => w} : w}
+          r.having_values.map! {|h| Squeel::Visitors::PredicateVisitor.can_accept?(h) ? {association_name => h} : h}
+          r.group_values.map! {|g| Squeel::Visitors::AttributeVisitor.can_accept?(g) ? {association_name => g} : g}
+          r.order_values.map! {|o| Squeel::Visitors::AttributeVisitor.can_accept?(o) ? {association_name => o} : o}
+          r.select_values.map! {|s| Squeel::Visitors::AttributeVisitor.can_accept?(s) ? {association_name => s} : s}
+          r.joins_values.map! {|j| [Symbol, Hash, Nodes::Stub, Nodes::Join, Nodes::KeyPath].include?(j.class) ? {association_name => j} : j}
+          r.includes_values.map! {|i| [Symbol, Hash, Nodes::Stub, Nodes::Join, Nodes::KeyPath].include?(i.class) ? {association_name => i} : i}
+        end
+
+        def build_arel
+          arel = table.from table
+
+          build_join_dependency(arel, @joins_values) unless @joins_values.empty?
+
+          predicate_viz = predicate_visitor
+          attribute_viz = attribute_visitor
+
+          collapse_wheres(arel, predicate_viz.accept((@where_values - ['']).uniq))
+
+          arel.having(*predicate_viz.accept(@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) if @offset_value
+
+          arel.group(*attribute_viz.accept(@group_values.uniq.reject{|g| g.blank?})) unless @group_values.empty?
+
+          order = @reorder_value ? @reorder_value : @order_values
+          order = attribute_viz.accept(order.uniq.reject{|o| o.blank?})
+          order = reverse_sql_order(sqlify_order(order)) if @reverse_order_value
+          arel.order(*order) unless order.empty?
+
+          build_select(arel, attribute_viz.accept(@select_values.uniq))
+
+          arel.from(@from_value) if @from_value
+          arel.lock(@lock_value) if @lock_value
+
+          arel
+        end
+
+        # reverse_sql_order doesn't understand ARel ordering nodes, so we
+        # need to convert them to their corresponding SQL
+        def sqlify_order(order)
+          order.map do |o|
+            o.respond_to?(:to_sql) ? o.to_sql : o
+          end
+        end
+
+        def build_join_dependency(manager, joins)
+          buckets = joins.group_by do |join|
+            case join
+            when String
+              'string_join'
+            when Hash, Symbol, Array, Nodes::Stub, Nodes::Join, Nodes::KeyPath
+              'association_join'
+            when JoinAssociation
+              'stashed_join'
+            when Arel::Nodes::Join
+              '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'] || []
+          string_joins              = (buckets['string_join'] || []).map { |x|
+            x.strip
+          }.uniq
+
+          join_list = custom_join_ast(manager, string_joins)
+
+          # All of this duplication just to add
+          self.join_dependency = JoinDependency.new(
+            @klass,
+            association_joins,
+            join_list
+          )
+
+          join_nodes.each do |join|
+            join_dependency.alias_tracker.aliased_name_for(join.left.name.downcase)
+          end
+
+          join_dependency.graft(*stashed_association_joins)
+
+          @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
+
+          join_dependency.join_associations.each do |association|
+            association.join_to(manager)
+          end
+
+          manager.join_sources.concat join_nodes.uniq
+          manager.join_sources.concat join_list
+
+          manager
+        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 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
+          binaries = wheres.grep(Arel::Nodes::Binary)
+
+          groups = binaries.group_by {|b| [b.class, b.left]}
+
+          groups.each do |_, bins|
+            arel.where(Arel::Nodes::And.new(bins))
+          end
+
+          (wheres - binaries).each do |where|
+            where = Arel.sql(where) if String === where
+            arel.where(Arel::Nodes::Grouping.new(where))
+          end
+        end
+
+        def find_equality_predicates(nodes)
+          nodes.map { |node|
+            case node
+            when Arel::Nodes::Equality
+              node if node.left.relation.name == table_name
+            when Arel::Nodes::Grouping
+              find_equality_predicates([node.expr])
+            when Arel::Nodes::And
+              find_equality_predicates(node.children)
+            else
+              nil
+            end
+          }.compact.flatten
+        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, [])
+            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. 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.
+
+        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(predicate_visitor.accept(@where_values))
+
+          Hash[equalities.map { |where| [where.left.name, where.right] }]
+        end
+
+      end
+    end
+  end
+end

data/lib/squeel/adapters/active_record.rb

@@ -0,0 +1,28 @@
+case ActiveRecord::VERSION::MAJOR
+when 3
+  case ActiveRecord::VERSION::MINOR
+  when 0
+    require 'squeel/adapters/active_record/3.0/compat'
+    require 'squeel/adapters/active_record/3.0/relation'
+    require 'squeel/adapters/active_record/3.0/join_dependency'
+    require 'squeel/adapters/active_record/3.0/join_association'
+    require 'squeel/adapters/active_record/3.0/association_preload'
+    require 'squeel/adapters/active_record/3.0/context'
+
+    ActiveRecord::Relation.send :include, Squeel::Adapters::ActiveRecord::Relation
+    ActiveRecord::Associations::ClassMethods::JoinDependency.send :include, Squeel::Adapters::ActiveRecord::JoinDependency
+    ActiveRecord::Base.extend Squeel::Adapters::ActiveRecord::AssociationPreload
+  else
+    require 'squeel/adapters/active_record/relation'
+    require 'squeel/adapters/active_record/join_dependency'
+    require 'squeel/adapters/active_record/join_association'
+    require 'squeel/adapters/active_record/preloader'
+    require 'squeel/adapters/active_record/context'
+
+    ActiveRecord::Relation.send :include, Squeel::Adapters::ActiveRecord::Relation
+    ActiveRecord::Associations::JoinDependency.send :include, Squeel::Adapters::ActiveRecord::JoinDependency
+    ActiveRecord::Associations::Preloader.send :include, Squeel::Adapters::ActiveRecord::Preloader
+  end
+else
+  raise NotImplementedError, "Squeel does not support ActiveRecord version #{ActiveRecord::VERSION::STRING}"
+end

data/lib/squeel/configuration.rb

@@ -0,0 +1,54 @@
+require 'squeel/constants'
+require 'squeel/predicate_methods'
+
+module Squeel
+  # The Squeel configuration module. The Squeel module extends this to provide its
+  # configuration capability.
+  module Configuration
+
+    # Start a Squeel configuration block in an initializer.
+    #
+    # @yield [config] A configuration block
+    #
+    # @example Load hash and symbol extensions
+    #   Squeel.configure do |config|
+    #     config.load_core_extensions :hash, :symbol
+    #   end
+    #
+    # @example Alias a predicate
+    #   Squeel.configure do |config|
+    #     config.alias_ptedicate :is_less_than, :lt
+    #   end
+    def configure
+      yield self
+    end
+
+    # Load core extensions for Hash, Symbol, or both
+    #
+    # @overload load_core_extensions(sym)
+    #   Load a single extension
+    #   @param [Symbol] sym :hash or :symbol
+    # @overload load_core_extensions(sym1, sym2)
+    #   Load both extensions
+    #   @param [Symbol] sym1 :hash or :symbol
+    #   @param [Symbol] sym2 :hash or :symbol
+    def load_core_extensions(*exts)
+      exts.each do |ext|
+        require "core_ext/#{ext}"
+      end
+    end
+
+    # Create an alias to an existing predication method. The _any/_all variations will
+    # be created automatically.
+    # @param [Symbol] new_name The alias name
+    # @param [Symbol] existing_name The existing predicate name
+    # @raise [ArgumentError] The existing name is an _any/_all variation, and not the original predicate name
+    def alias_predicate(new_name, existing_name)
+      raise ArgumentError, 'the existing name should be the base name, not an _any/_all variation' if existing_name.to_s =~ /(_any|_all)$/
+      ['', '_any', '_all'].each do |suffix|
+        PredicateMethods.class_eval "alias :#{new_name}#{suffix} :#{existing_name}#{suffix} unless defined?(#{new_name}#{suffix})"
+      end
+    end
+
+  end
+end

data/lib/squeel/constants.rb

@@ -0,0 +1,24 @@
+module Squeel
+  # Defines the default list of ARel predicates and predicate aliases
+  module Constants
+    PREDICATES = [
+       :eq, :eq_any, :eq_all,
+       :not_eq, :not_eq_any, :not_eq_all,
+       :matches, :matches_any, :matches_all,
+       :does_not_match, :does_not_match_any, :does_not_match_all,
+       :lt, :lt_any, :lt_all,
+       :lteq, :lteq_any, :lteq_all,
+       :gt, :gt_any, :gt_all,
+       :gteq, :gteq_any, :gteq_all,
+       :in, :in_any, :in_all,
+       :not_in, :not_in_any, :not_in_all
+     ].freeze
+
+     PREDICATE_ALIASES = {
+       :matches        => [:like],
+       :does_not_match => [:not_like],
+       :lteq           => [:lte],
+       :gteq           => [:gte]
+     }.freeze
+  end
+end

data/lib/squeel/context.rb

@@ -0,0 +1,67 @@
+require 'arel'
+
+module Squeel
+  # @abstract Subclass and implement {#traverse}, #{find} and {#get_table}
+  #   to create a Context that supports a given ORM.
+  class Context
+    attr_reader :base, :engine, :arel_visitor
+
+    # The Squeel context expects some kind of context object that is
+    # representative of the current joins in a query in order to return
+    # appropriate tables. Again, in the case of an ActiveRecord context,
+    # this will be a JoinDependency. Subclasses are expected to set the
+    # <tt>@base</tt>, <tt>@engine</tt>, and <tt>@arel_visitor</tt>
+    # instance variables to appropriate values for use in their implementations
+    # of other required methods.
+    #
+    # @param object The object the context will use for contextualization
+    def initialize(object)
+      @object = object
+      @tables = Hash.new {|hash, key| hash[key] = get_table(key)}
+    end
+
+    # This method should find a given object inside the context.
+    #
+    # @param object The object to find
+    # @param parent The parent object, if applicable
+    # @return a valid "parent" or contextualizable object
+    def find(object, parent = @base)
+      raise NotImplementedError, "Subclasses must implement public method find"
+    end
+
+    # This method should traverse a keypath and return an object for use
+    # in future calls to #traverse, #find, or #contextualize.
+    #
+    # @param [Nodes::KeyPath] keypath The keypath to traverse
+    # @param parent The parent object from which traversal should start.
+    # @param [Boolean] include_endpoint Whether or not the KeyPath's
+    #   endpoint should be treated as a traversable key
+    # @return a valid "parent" or contextualizable object
+    def traverse(keypath, parent = @base, include_endpoint = false)
+      raise NotImplementedError, "Subclasses must implement public method traverse"
+    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.
+    #
+    # @param object A contextualizable object (this will depend on the subclass's implementation)
+    # @return [Arel::Table] A table corresponding to the object param
+    def contextualize(object)
+      @tables[object]
+    end
+
+    private
+
+    # Returns an Arel::Table that's appropriate for the object it's been sent.
+    # What's "appropriate"? Well, that's up to the implementation to decide, but
+    # it should probably generate a table that is least likely to result in invalid
+    # SQL.
+    #
+    # @param object A contextualizable object (this will depend on the subclass's implementation)
+    # @return [Arel::Table] A table corresponding to the object param.
+    def get_table(object)
+      raise NotImplementedError, "Subclasses must implement private method get_table"
+    end
+
+  end
+end