squeel 0.5.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+gemspec
+
+gem 'arel',  :git => 'git://github.com/rails/arel.git'
+git 'git://github.com/rails/rails.git' do
+  gem 'activesupport'
+  gem 'activerecord'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2011 Ernie Miller
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,41 @@
+=Squeel
+
+This is a complete rewrite of the library formerly called MetaWhere. It's Rails 3.1-only
+for now.
+
+It's not really suitable for actual use yet, but you're welcome to test it and send
+me feedback.
+
+==What's new?
+
+A lot.
+
+* Symbol and hash methods aren't loaded by default. To enable them, do this in
+  your Squeel.configure block: <tt>config.load_core_extensions :hash, :symbol</tt>
+* Speaking of, you can call Squeel.configure do |config| ... end and do
+  another bit of configuration, setting up your own aliases.
+  <tt>config.alias_predicate :new_name, :old_name</tt>
+* The preferred way to use the various enhancements is now by passing a block to
+  the relation method you're calling. For example:
+
+    Person.select{max(id).as(max_id)} # Call SQL functions
+    Person.where{(name == 'bob') & (salary == 100000)} # Compounds & and | work
+
+* Operators have changed. As before, operators starting with ! are only available
+  on Ruby 1.9. Upgrade, for the love of all that is good and holy.
+
+  * == - Equality
+  * != - Inequality
+  * ^ - Inequality, for those poor souls on 1.8.x
+  * >> - In, (mnemonic: value >> [1,2,3], the value is running INTO the array)
+  * << - Not in, (mnemonic: value << [1,2,3], the value is running OUT of the array)
+  * =~ - Matches (SQL LIKE)
+  * !~ - Not matches (SQL NOT LIKE) Again, only in Ruby 1.9
+  * > - Greater than
+  * >= - Greater than or equal to
+  * < - Less than
+  * <= - Less than or equal to
+  * [] - Alternative function syntax. Just use parentheses, not sure I'm gonna keep [].
+
+There's more -- have a read through the specs for a better idea of what you can do,
+or clone the repo, run <tt>bundle install</tt> and play around in <tt>rake console</tt>.

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new(:spec) do |rspec|
+  rspec.rspec_opts = ['--backtrace']
+end
+
+task :default => :spec
+
+desc "Open an irb session with Squeel and the sample data used in specs"
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'console'
+  ARGV.clear
+  IRB.start
+end

data/lib/core_ext/hash.rb

@@ -0,0 +1,13 @@
+require 'squeel/nodes/predicate_operators'
+
+class Hash
+  # Hashes are "acceptable" by PredicateVisitor, so they
+  # can be treated like nodes for the purposes of and/or/not
+  # if you load core extensions with:
+  #
+  #   Squeel.configure do |config|
+  #     config.load_core_extensions :hash
+  #   end
+
+  include Squeel::Nodes::PredicateOperators
+end

data/lib/core_ext/symbol.rb

@@ -0,0 +1,36 @@
+require 'squeel/predicate_methods'
+
+class Symbol
+  # These extensions to Symbol are loaded optionally, with:
+  #
+  #   Squeel.configure do |config|
+  #     config.load_core_extensions :symbol
+  #   end
+
+  include Squeel::PredicateMethods
+
+  def asc
+    Squeel::Nodes::Order.new self, 1
+  end
+
+  def desc
+    Squeel::Nodes::Order.new self, -1
+  end
+
+  def func(*args)
+    Squeel::Nodes::Function.new(self, args)
+  end
+
+  def inner
+    Squeel::Nodes::Join.new(self, Arel::InnerJoin)
+  end
+
+  def outer
+    Squeel::Nodes::Join.new(self, Arel::OuterJoin)
+  end
+
+  def of_class(klass)
+    Squeel::Nodes::Join.new(self, Arel::InnerJoin, klass)
+  end
+
+end

data/lib/squeel.rb

@@ -0,0 +1,26 @@
+require 'squeel/configuration'
+
+module Squeel
+
+  extend Configuration
+
+  def self.evil_things
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = original_verbosity
+  end
+
+  Constants::PREDICATE_ALIASES.each do |original, aliases|
+    aliases.each do |aliaz|
+      alias_predicate aliaz, original
+    end
+  end
+
+end
+
+require 'squeel/nodes'
+require 'squeel/dsl'
+require 'squeel/visitors'
+require 'squeel/adapters/active_record'

data/lib/squeel/adapters/active_record.rb

@@ -0,0 +1,6 @@
+require 'squeel/adapters/active_record/relation'
+require 'squeel/adapters/active_record/join_dependency'
+require 'squeel/adapters/active_record/join_association'
+
+ActiveRecord::Relation.send :include, Squeel::Adapters::ActiveRecord::Relation
+ActiveRecord::Associations::JoinDependency.send :include, Squeel::Adapters::ActiveRecord::JoinDependency

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

@@ -0,0 +1,90 @@
+require 'active_record'
+
+module Squeel
+  module Adapters
+    module ActiveRecord
+
+      class JoinAssociation < ::ActiveRecord::Associations::JoinDependency::JoinAssociation
+
+        def initialize(reflection, join_dependency, parent = nil, polymorphic_class = nil)
+          if polymorphic_class && ::ActiveRecord::Base > polymorphic_class
+            swapping_reflection_klass(reflection, polymorphic_class) do |reflection|
+              super(reflection, join_dependency, parent)
+            end
+          else
+            super(reflection, join_dependency, parent)
+          end
+        end
+
+        def swapping_reflection_klass(reflection, klass)
+          reflection = reflection.clone
+          original_polymorphic = reflection.options.delete(:polymorphic)
+          reflection.instance_variable_set(:@klass, klass)
+          yield reflection
+        ensure
+          reflection.options[:polymorphic] = original_polymorphic
+        end
+
+        def join_to(relation)
+          tables        = @tables.dup
+          foreign_table = parent_table
+
+          # The chain starts with the target table, but we want to end with it here (makes
+          # more sense in this context), so we reverse
+          chain.reverse.each_with_index do |reflection, i|
+            table = tables.shift
+
+            case reflection.source_macro
+            when :belongs_to
+              key         = reflection.association_primary_key
+              foreign_key = reflection.foreign_key
+            when :has_and_belongs_to_many
+              # Join the join table first...
+              relation.from(join(
+                table,
+                table[reflection.foreign_key].
+                  eq(foreign_table[reflection.active_record_primary_key])
+              ))
+
+              foreign_table, table = table, tables.shift
+
+              key         = reflection.association_primary_key
+              foreign_key = reflection.association_foreign_key
+            else
+              key         = reflection.foreign_key
+              foreign_key = reflection.active_record_primary_key
+            end
+
+            constraint = table[key].eq(foreign_table[foreign_key])
+
+            if reflection.options[:polymorphic]
+              constraint = constraint.and(
+                foreign_table[reflection.foreign_type].eq(reflection.klass.name)
+              )
+            end
+
+            if reflection.klass.finder_needs_type_condition?
+              constraint = table.create_and([
+                constraint,
+                reflection.klass.send(:type_condition, table)
+              ])
+            end
+
+            relation.from(join(table, constraint))
+
+            unless conditions[i].empty?
+              relation.where(sanitize(conditions[i], table))
+            end
+
+            # The current table in this iteration becomes the foreign table in the next
+            foreign_table = table
+          end
+
+          relation
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+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
+          end
+        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)
+              @reflections << reflection
+              join_association = build_join_association_respecting_polymorphism(reflection, parent, associations)
+              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, join)
+          if association = find_join_association(reflection, parent)
+            unless reflection.options[:polymorphic]
+              association
+            else
+              association if association.active_record == join.klass
+            end
+          end
+        end
+
+        def build_join_association_respecting_polymorphism(reflection, parent, join)
+          if reflection.options[:polymorphic] && join.polymorphic?
+            JoinAssociation.new(reflection, self, parent, join.klass)
+          else
+            JoinAssociation.new(reflection, self, parent)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,292 @@
+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=
+
+        def join_dependency
+          @join_dependency ||= (build_join_dependency(table.from(table), @joins_values) && @join_dependency)
+        end
+
+        def select_visitor
+          Visitors::SelectVisitor.new(
+            Contexts::JoinDependencyContext.new(join_dependency)
+          )
+        end
+
+        def predicate_visitor
+          Visitors::PredicateVisitor.new(
+            Contexts::JoinDependencyContext.new(join_dependency)
+          )
+        end
+
+        def order_visitor
+          Visitors::OrderVisitor.new(
+            Contexts::JoinDependencyContext.new(join_dependency)
+          )
+        end
+
+        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)
+            self.joins_values += [association_name] if reflect_on_association(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.joins_values.map! {|j| [Symbol, Hash, Nodes::Stub, Nodes::Join].include?(j.class) ? {association_name => j} : j}
+        end
+
+        def build_arel
+          arel = table.from table
+
+          build_join_dependency(arel, @joins_values) unless @joins_values.empty?
+
+          predicate_viz = predicate_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(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
+
+          unless @order_values.empty?
+            order_viz = order_visitor
+            arel.order(*order_viz.accept(@order_values.uniq.reject{|o| o.blank?}))
+          end
+
+          build_select(arel, select_visitor.accept(@select_values.uniq))
+
+          arel.from(@from_value) if @from_value
+          arel.lock(@lock_value) if @lock_value
+
+          arel
+        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 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.evaluate &value)
+              relation
+            end
+          else
+            super
+          end
+        end
+
+        def where(opts = Proc.new, *rest)
+          if block_given? && Proc === opts
+            super(DSL.evaluate &opts)
+          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 order(*args)
+          if block_given? && args.empty?
+            super(DSL.evaluate &Proc.new)
+          else
+            super
+          end
+        end
+
+        def joins(*args)
+          if block_given? && args.empty?
+            super(DSL.evaluate &Proc.new)
+          else
+            super
+          end
+        end
+
+        def having(*args)
+          if block_given? && args.empty?
+            super(DSL.evaluate &Proc.new)
+          else
+            super
+          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
+            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