meta_where 0.9.6 → 0.9.9

data/CHANGELOG

@@ -1,3 +1,15 @@
+Changes since 0.9.6 (2010-09-30):
+  * ARel 2.x and Rails 3.0.2 compatibility
+  * Allow MetaWhere::And and MetaWhere::Or on the value side of a condition hash
+    to trigger treatment of key as an association.
+    ex: :comments => (:created_at.lt % 1.day.ago | :body.matches % '%hey%')
+  * Support for selecting join type: :association.outer / :association.inner results
+    in an outer or inner join.
+  * Having clauses are now fully MetaWhere-enabled.
+  * SQL functions are now supported. :concat.func(val1, val2) will result in an
+    SQL concat() call, with two parameters. If you've enabled Symbol operators, then
+    you can also just do :concat[val1, val2].
+
 Changes since 0.9.5 (2010-09-27):
   * Don't skip adding condition if an empty array is supplied
 

data/README.rdoc

@@ -68,7 +68,7 @@ to enclose other conditions in {}, you should place operator conditions before a
 
 Operators are:
 
-* [] (equal)
+* >> (equal)
 * ^ (not equal)
 * + (in array/range)
 * - (not in array/range)
@@ -78,6 +78,7 @@ Operators are:
 * >= (greater than or equal to)
 * < (less than)
 * <= (less than or equal to)
+* [] (SQL functions -- more on those below)
 
 === Compounds
 You can use the & and | operators to perform ands and ors within your queries.
@@ -148,6 +149,33 @@ parentheses around everything. So MetaWhere also supports a substitution-inspire
 
 (*) Formatting added for clarity. I said you could do this, not that you should. :)
 
+== Join type specification
+You can choose whether to use an inner join (the default) or a left outer join by tacking
+<tt>.outer</tt> or <tt>.inner</tt> to the symbols specified in your joins() call:
+
+  Article.joins(:comments => :moderations.outer).to_sql
+  => SELECT "articles".* FROM "articles"
+     INNER JOIN "comments" ON "comments"."article_id" = "articles"."id"
+     LEFT OUTER JOIN "moderations" ON "moderations"."comment_id" = "comments"."id"
+
+== SQL Functions
+You can use SQL functions in your queries:
+
+  Manager.joins(:employees.outer).group('managers.id').
+          having(:employees => (:count.func(:id) < 3))
+  => SELECT "managers".* FROM "managers"
+     LEFT OUTER JOIN "employees" ON "employees"."manager_id" = "managers"."id"
+     GROUP BY managers.id HAVING count("employees"."id") < 3
+
+If you enable Symbol operators, you can just use <tt>:count[:id]</tt>, instead of calling
+<tt>func</tt> as shown above. SQL functions work in the SELECT, WHERE, and HAVING clauses,
+and can be aliased with <tt>as</tt>:
+
+  Manager.select('managers.*').
+          select(:find_in_set[:id, '3,2,1'].as('position'))
+  => SELECT managers.*, find_in_set("managers"."id",'3,2,1') AS position
+     FROM "managers"
+
 === But wait, there's more!
 
 == Intelligent hash condition mapping
@@ -182,7 +210,7 @@ With MetaWhere:
   => SELECT "articles".* FROM "articles" INNER JOIN "comments"
      ON "comments"."article_id" = "articles"."id" WHERE (("comments"."body" = 'hey'))
 
-The general idea is that if an association with the name provided exists, MetaWhere::Builder
+The general idea is that if an association with the name provided exists, MetaWhere
 will build the conditions against that association's table as it's been aliased, before falling
 back to assuming you're specifying a table by name. It also handles nested associations:
 

data/Rakefile

@@ -19,9 +19,9 @@ begin
     gem.homepage = "http://metautonomo.us/projects/metawhere/"
     gem.authors = ["Ernie Miller"]
     gem.add_development_dependency "shoulda"
-    gem.add_dependency "activerecord", "~> 3.0.0"
-    gem.add_dependency "activesupport", "~> 3.0.0"
-    gem.add_dependency "arel", "~> 1.0.1"
+    gem.add_dependency "activerecord", "~> 3.0.2"
+    gem.add_dependency "activesupport", "~> 3.0.2"
+    gem.add_dependency "arel", "~> 2.0.2"
     gem.post_install_message = <<END
 
 *** Thanks for installing MetaWhere! ***

data/VERSION

@@ -1 +1 @@
-0.9.6
+0.9.9

data/lib/core_ext/hash.rb

@@ -1,16 +1,9 @@
 class Hash
-  def to_predicate(builder, parent = nil)
-    Arel::Predicates::All.new(*builder.build_predicates_from_hash(self, parent || builder.join_dependency.join_base))
-  end
-  
-  def to_attribute(builder, parent = nil)
-    builder.build_attributes_from_hash(self, parent)
-  end
-  
+
   def |(other)
     MetaWhere::Or.new(self, other)
   end
-  
+
   def &(other)
     MetaWhere::And.new(self, other)
   end

data/lib/core_ext/symbol.rb

@@ -1,30 +1,34 @@
 class Symbol
-  Arel::Attribute::PREDICATES.each do |predication|
+  MetaWhere::PREDICATES.each do |predication|
     define_method(predication) do
       MetaWhere::Column.new(self, predication)
     end
   end
-  
+
   MetaWhere::METHOD_ALIASES.each_pair do |aliased, predication|
     define_method(aliased) do
       MetaWhere::Column.new(self, predication)
     end
   end
-  
-  def to_attribute(builder, parent = nil)
-    table = builder.build_table(parent)
-    
-    unless attribute = table[self]
-      raise ::ActiveRecord::StatementInvalid, "No attribute named `#{self}` exists for table `#{table.name}`"
-    end
 
-    attribute
+  def mw_func(*args)
+    MetaWhere::Function.new(self, *args)
+  end
+
+  alias_method :func, :mw_func unless method_defined?(:func)
+
+  def inner
+    MetaWhere::JoinType.new(self, Arel::Nodes::InnerJoin)
   end
-  
+
+  def outer
+    MetaWhere::JoinType.new(self, Arel::Nodes::OuterJoin)
+  end
+
   def asc
     MetaWhere::Column.new(self, :asc)
   end
-  
+
   def desc
     MetaWhere::Column.new(self, :desc)
   end

data/lib/core_ext/symbol_operators.rb

@@ -1,5 +1,9 @@
 class Symbol
-  def [](value)
+  def [](*values)
+    MetaWhere::Function.new(self, *values)
+  end
+
+  def >>(value)
     MetaWhere::Condition.new(self, value, :eq)
   end
 
@@ -22,7 +26,7 @@ class Symbol
   # Won't work on Ruby 1.8.x so need to do this conditionally
   if respond_to?('!~')
     define_method('!~') do |value|
-      MetaWhere::Condition.new(self, value, :not_matches)
+      MetaWhere::Condition.new(self, value, :does_not_match)
     end
   end
 

data/lib/meta_where/association_reflection.rb

@@ -18,7 +18,7 @@ module MetaWhere
       when Hash
         if obj.keys.grep(MetaWhere::Column).any?
           raise MetaWhereInAssociationError, <<END
-The :#{name} association  has a MetaWhere::Column in its :conditions. \
+The :#{name} association has a MetaWhere::Column in its :conditions. \
 If you actually needed to access conditions other than equality, then you most \
 likely meant to set up a scope or method, instead. Associations only work with \
 standard equality conditions, since they can be used to create records as well.

data/lib/meta_where/column.rb

@@ -3,8 +3,8 @@ module MetaWhere
     attr_reader :column, :method
 
     def initialize(column, method)
-      @column = column.to_s
-      @method = method.to_s
+      @column = column
+      @method = method
     end
 
     def %(value)
@@ -19,22 +19,6 @@ module MetaWhere
 
     alias_method :eql?, :==
 
-    def to_attribute(builder, parent = nil)
-      column_name = column
-      if column_name.include?('.')
-        table_name, column_name = column_name.split('.', 2)
-        table = Arel::Table.new(table_name, :engine => parent.arel_engine)
-      else
-        table = builder.build_table(parent)
-      end
-
-      unless attribute = table[column_name]
-        raise ::ActiveRecord::StatementInvalid, "No attribute named `#{column_name}` exists for table `#{table.name}`"
-      end
-
-      attribute.send(method)
-    end
-
     def hash
       [column, method].hash
     end

data/lib/meta_where/compound.rb

@@ -1,30 +1,24 @@
 module MetaWhere
   class Compound
     attr_reader :condition1, :condition2
-    
+
     def initialize(condition1, condition2)
       @condition1 = condition1
       @condition2 = condition2
     end
-    
+
     def |(other)
       Or.new(self, other)
     end
-    
+
     def &(other)
       And.new(self, other)
     end
   end
-  
+
   class Or < Compound
-    def to_predicate(builder, parent = nil)
-      condition1.to_predicate(builder, parent).or(condition2.to_predicate(builder, parent))
-    end
   end
-  
+
   class And < Compound
-    def to_predicate(builder, parent = nil)
-      condition1.to_predicate(builder, parent).and(condition2.to_predicate(builder, parent))
-    end
   end
 end

data/lib/meta_where/condition.rb

@@ -3,49 +3,36 @@ require 'meta_where/utility'
 module MetaWhere
   class Condition
     include MetaWhere::Utility
-    
+
     attr_reader :column, :value, :method
-    
+
     def initialize(column, value, method)
-      @column = column.to_s
+      @column = column
       @value = value
       @method = (MetaWhere::METHOD_ALIASES[method.to_s] || method).to_s
     end
-    
-    def to_predicate(builder, parent = nil)
-      table = builder.build_table(parent)
-      
-      unless attribute = table[column]
-        raise ::ActiveRecord::StatementInvalid, "No attribute named `#{column}` exists for table `#{table.name}`"
-      end
-
-      unless valid_comparison_method?(method)
-        raise ::ActiveRecord::StatementInvalid, "No comparison method named `#{method}` exists for column `#{column}`"
-      end
-      attribute.send(method, *args_for_predicate(method.to_s, value))
-    end
-    
+
     def ==(other_condition)
       other_condition.is_a?(Condition) &&
       other_condition.column == column &&
-      other_condition.value = value    &&
+      other_condition.value == value    &&
       other_condition.method == method
     end
-    
+
     alias_method :eql?, :==
-    
+
     def |(other)
       Or.new(self, other)
     end
-    
+
     def &(other)
       And.new(self, other)
     end
-    
+
     # Play "nicely" with expand_hash_conditions_for_aggregates
     def to_sym
       self
     end
   end
-  
+
 end

data/lib/meta_where/function.rb

@@ -0,0 +1,108 @@
+module MetaWhere
+  class Function
+    attr_reader :name, :args
+    attr_accessor :table, :alias
+
+    def initialize(name, *args)
+      @name = name
+      @args = args
+    end
+
+    def as(val)
+      self.alias = val
+      self
+    end
+
+    def to_sqlliteral
+      Arel.sql(
+        ("#{name}(#{(['%s'] * args.size).join(',')})" % contextualize_args) +
+        (self.alias ? " AS #{self.alias}" : '')
+      )
+    end
+
+    alias_method :to_sql, :to_sqlliteral
+
+    MetaWhere::PREDICATES.each do |predication|
+      define_method(predication) do
+        MetaWhere::Column.new(self, predication)
+      end
+    end
+
+    MetaWhere::METHOD_ALIASES.each_pair do |aliased, predication|
+      define_method(aliased) do
+        MetaWhere::Column.new(self, predication)
+      end
+    end
+
+    def >>(value)
+      MetaWhere::Condition.new(self, value, :eq)
+    end
+
+    def ^(value)
+      MetaWhere::Condition.new(self, value, :not_eq)
+    end
+
+    def +(value)
+      MetaWhere::Condition.new(self, value, :in)
+    end
+
+    def -(value)
+      MetaWhere::Condition.new(self, value, :not_in)
+    end
+
+    def =~(value)
+      MetaWhere::Condition.new(self, value, :matches)
+    end
+
+    # Won't work on Ruby 1.8.x so need to do this conditionally
+    if respond_to?('!~')
+      define_method('!~') do |value|
+        MetaWhere::Condition.new(self, value, :does_not_match)
+      end
+    end
+
+    def >(value)
+      MetaWhere::Condition.new(self, value, :gt)
+    end
+
+    def >=(value)
+      MetaWhere::Condition.new(self, value, :gteq)
+    end
+
+    def <(value)
+      MetaWhere::Condition.new(self, value, :lt)
+    end
+
+    def <=(value)
+      MetaWhere::Condition.new(self, value, :lteq)
+    end
+
+    # Play "nicely" with expand_hash_conditions_for_aggregates
+    def to_sym
+      self
+    end
+
+    private
+
+    def contextualize_args
+      args.map do |arg|
+        if arg.is_a? Symbol
+          self.table && self.table[arg] ? Arel::Visitors.for(ActiveRecord::Base).accept(table[arg]) : arg
+        else
+          arg.table = self.table if arg.is_a? MetaWhere::Function
+          Arel::Visitors.for(ActiveRecord::Base).accept(arg)
+        end
+      end
+    end
+  end
+end
+
+module Arel
+  module Visitors
+    class ToSql
+      def visit_MetaWhere_Function o
+        o.to_sqlliteral
+      end
+    end
+  end
+end

data/lib/meta_where/join_dependency.rb

@@ -11,37 +11,20 @@ module MetaWhere
     class ConfigurationError < StandardError; end
     class AssociationNotFoundError < StandardError; end
 
-    def build_with_metawhere(associations, parent = nil, join_class = Arel::InnerJoin)
-      parent ||= @joins.last
-      case associations
-      when Symbol, String
-        reflection = parent.reflections[associations.to_s.intern] or
-        raise AssociationNotFoundError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
+    def build_with_metawhere(associations, parent = nil, join_type = Arel::Nodes::InnerJoin)
+      if MetaWhere::JoinType === associations
+        parent||= @joins.last
+        reflection = parent.reflections[associations.name] or
+          raise AssociationNotFoundError, "Association named '#{ associations.name }' was not found; perhaps you misspelled it?"
         unless association = find_join_association(reflection, parent)
           @reflections << reflection
-          association = (@joins << build_join_association(reflection, parent).with_join_class(join_class)).last
+          association = build_join_association(reflection, parent)
+          association.join_type = associations.join_type
+          @joins << association
         end
         association
-      when Array
-        associations.each do |association|
-          build(association, parent, join_class)
-        end
-      when Hash
-        associations.keys.sort{|a,b|a.to_s<=>b.to_s}.each do |name|
-          association = build(name, parent, join_class)
-          build(associations[name], association, join_class)
-        end
-      else
-        raise ConfigurationError, associations.inspect
-      end
-    end
-
-    def find_join_association(name_or_reflection, parent)
-      case name_or_reflection
-      when Symbol, String
-        join_associations.detect {|j| (j.reflection.name == name_or_reflection.to_s.intern) && (j.parent == parent)}
       else
-        join_associations.detect {|j| (j.reflection == name_or_reflection) && (j.parent == parent)}
+        build_without_metawhere(associations, parent, join_type)
       end
     end
   end

data/lib/meta_where/join_type.rb

@@ -0,0 +1,22 @@
+module MetaWhere
+  class JoinType
+    attr_reader :name, :join_type
+
+    def initialize(name, join_type = Arel::Nodes::InnerJoin)
+      @name = name
+      @join_type = join_type
+    end
+
+    def ==(other)
+      self.class == other.class &&
+      name == other.name &&
+      join_type == other.join_type
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      [name, join_type].hash
+    end
+  end
+end

data/lib/meta_where/relation.rb

@@ -15,12 +15,12 @@ module MetaWhere
 
     def merge(r, association_name = nil)
       if (r && (association_name || base_class.name != r.klass.base_class.name)) # Merging relations with different base.
-        association_name ||= (default_association = reflect_on_all_associations.detect {|a| a.klass.name == r.klass.name}) ?
+        association_name ||= (default_association = reflect_on_all_associations.detect {|a| a.class_name == r.klass.name}) ?
                              default_association.name : r.table_name.to_sym
         r = r.clone
-        r.where_values.map! {|w| w.respond_to?(:to_predicate) ? {association_name => w} : w}
-        r.joins_values.map! {|j| [Symbol, Hash].include?(j.class) ? {association_name => j} : j}
-        self.joins_values += [association_name]
+        r.where_values.map! {|w| MetaWhere::Visitors::Predicate.visitables.include?(w.class) ? {association_name => w} : w}
+        r.joins_values.map! {|j| [Symbol, Hash, MetaWhere::JoinType].include?(j.class) ? {association_name => j} : j}
+        self.joins_values += [association_name] if reflect_on_association(association_name)
       end
 
       super(r)
@@ -36,7 +36,7 @@ module MetaWhere
       @scope_for_create ||= begin
         @create_with_value || predicate_wheres.inject({}) do |hash, where|
           if is_equality_predicate?(where)
-            hash[where.operand1.name] = where.operand2.respond_to?(:value) ? where.operand2.value : where.operand2
+            hash[where.left.name] = where.right.respond_to?(:value) ? where.right.value : where.right
           end
 
           hash
@@ -74,7 +74,7 @@ module MetaWhere
 
         case join
         when ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation
-          arel = arel.join(join.relation, Arel::OuterJoin).on(*join.on)
+          arel = arel.join(join.relation, Arel::Nodes::OuterJoin).on(*join.on)
         when Hash, Array, Symbol
           if array_of_strings?(join)
             join_string = join.join(' ')
@@ -109,14 +109,19 @@ module MetaWhere
     end unless defined?(:custom_join_sql)
 
     def predicate_wheres
-      remove_conflicting_equality_predicates(flatten_predicates(@where_values, metawhere_builder))
+      remove_conflicting_equality_predicates(flatten_predicates(@where_values, predicate_visitor))
     end
 
-    # Very occasionally, we need to get a builder for another relation, so it makes sense to factor
-    # this out into a public method despite only being two lines long.
-    def metawhere_builder
+    # Very occasionally, we need to get a visitor for another relation, so it makes sense to factor
+    # these out into a public method despite only being two lines long.
+    def predicate_visitor
       join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins, custom_joins)
-      MetaWhere::Builder.new(join_dependency)
+      MetaWhere::Visitors::Predicate.new(join_dependency)
+    end
+
+    def attribute_visitor
+      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins, custom_joins)
+      MetaWhere::Visitors::Attribute.new(join_dependency)
     end
 
     # Simulate the logic that occurs in ActiveRecord::Relation.to_a
@@ -136,9 +141,9 @@ module MetaWhere
     end
 
     def construct_limited_ids_condition(relation)
-      builder = relation.metawhere_builder
+      visitor = relation.attribute_visitor
 
-      relation.order_values.map! {|o| o.respond_to?(:to_attribute) ? o.to_attribute(builder).to_sql : o}
+      relation.order_values.map! {|o| visitor.can_accept?(o) ? visitor.accept(o).to_sql : o}
 
       super
     end
@@ -146,68 +151,70 @@ module MetaWhere
     def build_arel
       arel = table
 
-      builder = metawhere_builder
+      visitor = predicate_visitor
 
-      arel = build_intelligent_joins(arel, builder) if @joins_values.present?
+      arel = build_intelligent_joins(arel, visitor) if @joins_values.present?
 
-      predicate_wheres = remove_conflicting_equality_predicates(flatten_predicates(@where_values, builder))
+      predicate_wheres = remove_conflicting_equality_predicates(flatten_predicates(@where_values, visitor))
 
       predicate_wheres.each do |where|
         next if where.blank?
 
         case where
-        when Arel::SqlLiteral
+        when Arel::Nodes::SqlLiteral
           arel = arel.where(where)
         else
           sql = where.is_a?(String) ? where : where.to_sql
-          arel = arel.where(Arel::SqlLiteral.new("(#{sql})"))
+          arel = arel.where(Arel::Nodes::SqlLiteral.new("(#{sql})"))
         end
       end
 
-      arel = arel.having(*@having_values.uniq.select{|h| h.present?}) if @having_values.present?
+      arel = arel.having(*flatten_predicates(@having_values, visitor).reject {|h| h.blank?}) unless @having_values.empty?
 
-      arel = arel.take(@limit_value) if @limit_value.present?
-      arel = arel.skip(@offset_value) if @offset_value.present?
+      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?}) if @group_values.present?
+      arel = arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
 
-      arel = build_order(arel, builder, @order_values) if @order_values.present?
+      arel = build_order(arel, attribute_visitor, @order_values) unless @order_values.empty?
 
       arel = build_select(arel, @select_values.uniq)
 
-      arel = arel.from(@from_value) if @from_value.present?
-
-      case @lock_value
-      when TrueClass
-        arel = arel.lock
-      when String
-        arel = arel.lock(@lock_value)
-      end if @lock_value.present?
+      arel = arel.from(@from_value) if @from_value
+      arel = arel.lock(@lock_value) if @lock_value
 
       arel
     end
 
+    def select(value = Proc.new)
+      if MetaWhere::Function === value
+        value.table = self.arel_table
+      end
+
+      super
+    end
+
     private
 
     def is_equality_predicate?(predicate)
-      predicate.respond_to?(:operator) && predicate.operator == :==
+      predicate.class == Arel::Nodes::Equality
     end
 
-    def build_intelligent_joins(arel, builder)
+    def build_intelligent_joins(arel, visitor)
       joined_associations = []
 
-      builder.join_dependency.graft(*stashed_association_joins)
+      visitor.join_dependency.graft(*stashed_association_joins)
 
       @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
 
       to_join = []
 
-      builder.join_dependency.join_associations.each do |association|
+      visitor.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]
+          to_join << [association_relation.first, association.join_type, association.association_join.first]
+          to_join << [association_relation.last, association.join_type, association.association_join.last]
         else
-          to_join << [association_relation, association.join_class, association.association_join]
+          to_join << [association_relation, association.join_type, association.association_join]
         end
       end
 
@@ -221,11 +228,10 @@ module MetaWhere
       arel = arel.join(custom_joins)
     end
 
-    def build_order(arel, builder, orders)
+    def build_order(arel, visitor, orders)
       order_attributes = orders.map {|o|
-        o.respond_to?(:to_attribute) ? o.to_attribute(builder, builder.join_dependency.join_base) : o
-      }.flatten.uniq.select {|o| o.present?}
-      order_attributes.map! {|a| Arel::SqlLiteral.new(a.is_a?(String) ? a : a.to_sql)}
+        visitor.can_accept?(o) ? visitor.accept(o, visitor.join_dependency.join_base) : o
+      }.flatten.uniq.reject {|o| o.blank?}
       order_attributes.present? ? arel.order(*order_attributes) : arel
     end
 
@@ -238,11 +244,11 @@ module MetaWhere
       }.reverse
     end
 
-    def flatten_predicates(predicates, builder)
+    def flatten_predicates(predicates, visitor)
       predicates.map {|p|
-        predicate = p.respond_to?(:to_predicate) ? p.to_predicate(builder) : p
-        if predicate.is_a?(Arel::Predicates::All)
-          flatten_predicates(predicate.predicates, builder)
+        predicate = visitor.can_accept?(p) ? visitor.accept(p) : p
+        if predicate.is_a?(Arel::Nodes::Grouping) && predicate.expr.is_a?(Arel::Nodes::And)
+          flatten_predicates([predicate.expr.left, predicate.expr.right], visitor)
         else
           predicate
         end
@@ -255,7 +261,7 @@ module MetaWhere
 
     def association_joins
       @mw_association_joins ||= unique_joins.select{|j|
-        [Hash, Array, Symbol].include?(j.class) && !array_of_strings?(j)
+        [Hash, Array, Symbol, MetaWhere::JoinType].include?(j.class) && !array_of_strings?(j)
       }
     end
 

data/lib/meta_where/utility.rb

@@ -2,12 +2,28 @@ module MetaWhere
   module Utility
     private
 
-    def args_for_predicate(method, value)
-      value = [Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation].include?(value.class) ? value.to_a : value
-      if method =~ /_(any|all)$/ && value.is_a?(Array)
-        value
+    def association_from_parent_and_column(parent, column)
+      parent.is_a?(Symbol) ? nil : @join_dependency.send(:find_join_association, column, parent)
+    end
+
+    def attribute_from_column_and_table(column, table)
+      case column
+      when String, Symbol
+        table[column]
+      when MetaWhere::Function
+        column.table = table
+        column.to_sqlliteral
       else
-        [value]
+        nil
+      end
+    end
+
+    def args_for_predicate(value)
+      case value
+      when ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation
+        value.to_a
+      else
+        value
       end
     end
 
@@ -21,7 +37,7 @@ module MetaWhere
     end
 
     def valid_comparison_method?(method)
-      Arel::Attribute::PREDICATES.map(&:to_s).include?(method.to_s)
+      MetaWhere::PREDICATES.map(&:to_s).include?(method.to_s)
     end
   end
 end

data/lib/meta_where/visitors/attribute.rb

@@ -0,0 +1,57 @@
+require 'meta_where/visitors/visitor'
+
+module MetaWhere
+  module Visitors
+    class Attribute < Visitor
+
+      def self.visitables
+        [Hash, Symbol, MetaWhere::Column]
+      end
+
+      def visit_Hash(o, parent)
+        table = build_table(parent)
+        built_attributes = o.map do |column, value|
+          if value.is_a?(Hash)
+            association = association_from_parent_and_column(parent, column)
+            accept(value, association || column)
+          elsif value.is_a?(Array) && value.all? {|v| can_accept?(v)}
+            association = association_from_parent_and_column(parent, column)
+            value.map {|val| self.accept(val, association || column)}
+          else
+            association = association_from_parent_and_column(parent, column)
+            can_accept?(value) ? self.accept(value, association || column) : value
+          end
+        end
+
+        built_attributes.flatten
+      end
+
+      def visit_Symbol(o, parent)
+        table = self.build_table(parent)
+
+        unless attribute = table[o]
+          raise ::ActiveRecord::StatementInvalid, "No attribute named `#{o}` exists for table `#{table.name}`"
+        end
+
+        attribute
+      end
+
+      def visit_MetaWhere_Column(o, parent)
+        column_name = o.column.to_s
+        if column_name.include?('.')
+          table_name, column_name = column_name.split('.', 2)
+          table = Arel::Table.new(table_name, :engine => parent.arel_engine)
+        else
+          table = self.build_table(parent)
+        end
+
+        unless attribute = table[column_name]
+          raise ::ActiveRecord::StatementInvalid, "No attribute named `#{column_name}` exists for table `#{table.name}`"
+        end
+
+        attribute.send(o.method)
+      end
+
+    end
+  end
+end

data/lib/meta_where/visitors/predicate.rb

@@ -0,0 +1,88 @@
+require 'meta_where/visitors/visitor'
+
+module MetaWhere
+  module Visitors
+    class Predicate < Visitor
+
+      def self.visitables
+        [Hash, MetaWhere::Or, MetaWhere::And, MetaWhere::Condition, MetaWhere::Function]
+      end
+
+      def visit_Hash(o, parent)
+        parent ||= join_dependency.join_base
+        table = build_table(parent)
+        predicates = o.map do |column, value|
+          if value.is_a?(Hash)
+            association = association_from_parent_and_column(parent, column)
+            accept(value, association || column)
+          elsif [MetaWhere::Condition, MetaWhere::And, MetaWhere::Or].include?(value.class)
+            association = association_from_parent_and_column(parent, column)
+            accept(value, association || column)
+          elsif value.is_a?(Array) && !value.empty? && value.all? {|v| can_accept?(v)}
+            association = association_from_parent_and_column(parent, column)
+            value.map {|val| accept(val, association || column)}
+          else
+            if column.is_a?(MetaWhere::Column)
+              method = column.method
+              column = column.column
+            else
+              method = method_from_value(value)
+            end
+
+            if [String, Symbol].include?(column.class) && column.to_s.include?('.')
+              table_name, column = column.to_s.split('.', 2)
+              table = Arel::Table.new(table_name, :engine => parent.arel_engine)
+            end
+
+            unless attribute = attribute_from_column_and_table(column, table)
+              raise ::ActiveRecord::StatementInvalid, "No attribute named `#{column}` exists for table `#{table.name}`"
+            end
+
+            unless valid_comparison_method?(method)
+              raise ::ActiveRecord::StatementInvalid, "No comparison method named `#{method}` exists for column `#{column}`"
+            end
+
+            attribute.send(method, args_for_predicate(value))
+          end
+        end
+
+        predicates.flatten!
+
+        if predicates.size > 1
+          first = predicates.shift
+          Arel::Nodes::Grouping.new(predicates.inject(first) {|memo, expr| Arel::Nodes::And.new(memo, expr)})
+        else
+          predicates.first
+        end
+      end
+
+      def visit_MetaWhere_Or(o, parent)
+        accept(o.condition1, parent).or(accept(o.condition2, parent))
+      end
+
+      def visit_MetaWhere_And(o, parent)
+        accept(o.condition1, parent).and(accept(o.condition2, parent))
+      end
+
+      def visit_MetaWhere_Condition(o, parent)
+        table = self.build_table(parent)
+
+        unless attribute = attribute_from_column_and_table(o.column, table)
+          raise ::ActiveRecord::StatementInvalid, "No attribute named `#{o.column}` exists for table `#{table.name}`"
+        end
+
+        unless valid_comparison_method?(o.method)
+          raise ::ActiveRecord::StatementInvalid, "No comparison method named `#{o.method}` exists for column `#{o.column}`"
+        end
+        attribute.send(o.method, args_for_predicate(o.value))
+      end
+
+      def visit_MetaWhere_Function(o, parent)
+        self.table = self.build_table(parent)
+
+        o.to_sqlliteral
+      end
+
+    end
+  end
+end

data/lib/meta_where/visitors/visitor.rb

@@ -0,0 +1,46 @@
+require 'meta_where/utility'
+
+module MetaWhere
+  module Visitors
+    class Visitor
+      include MetaWhere::Utility
+
+      attr_reader :join_dependency
+
+      def initialize(join_dependency)
+        @join_dependency = join_dependency
+        jb = join_dependency.join_base
+        @engine = jb.arel_engine
+        @default_table = Arel::Table.new(jb.table_name, :as => jb.aliased_table_name, :engine => @engine)
+      end
+
+      def build_table(parent_or_table_name = nil)
+        if parent_or_table_name.is_a?(Symbol)
+          Arel::Table.new(parent_or_table_name, :engine => @engine)
+        elsif parent_or_table_name.respond_to?(:aliased_table_name)
+          Arel::Table.new(parent_or_table_name.table_name, :as => parent_or_table_name.aliased_table_name, :engine => @engine)
+        else
+          @default_table
+        end
+      end
+
+      def accept(object, parent = nil)
+        visit(object, parent)
+      end
+
+      def can_accept?(object)
+        respond_to? DISPATCH[object.class]
+      end
+
+      private
+
+      DISPATCH = Hash.new do |hash, klass|
+        hash[klass] = "visit_#{klass.name.gsub('::', '_')}"
+      end
+
+      def visit(object, parent)
+        send(DISPATCH[object.class], object, parent)
+      end
+    end
+  end
+end

data/lib/meta_where.rb

@@ -2,12 +2,26 @@ module MetaWhere
   METHOD_ALIASES = {
     'ne' => :not_eq,
     'like' => :matches,
-    'nlike' => :not_matches,
+    'not_matches' => :does_not_match,
+    'nlike' => :does_not_match,
     'lte' => :lteq,
     'gte' => :gteq,
     'nin' => :not_in
   }
 
+  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
+  ]
+
   def self.operator_overload!
     require 'core_ext/symbol_operators'
   end
@@ -18,9 +32,12 @@ require 'active_support'
 require 'meta_where/column'
 require 'meta_where/condition'
 require 'meta_where/compound'
+require 'meta_where/function'
+require 'meta_where/join_type'
 require 'core_ext/symbol'
 require 'core_ext/hash'
-require 'meta_where/builder'
+require 'meta_where/visitors/attribute'
+require 'meta_where/visitors/predicate'
 require 'meta_where/association_reflection'
 require 'meta_where/relation'
 require 'meta_where/join_dependency'

data/meta_where.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{meta_where}
-  s.version = "0.9.6"
+  s.version = "0.9.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ernie Miller"]
-  s.date = %q{2010-09-30}
+  s.date = %q{2010-11-15}
   s.description = %q{
       MetaWhere offers the ability to call any Arel predicate methods
       (with a few convenient aliases) on your Model's attributes instead
@@ -39,13 +39,17 @@ Gem::Specification.new do |s|
      "lib/core_ext/symbol_operators.rb",
      "lib/meta_where.rb",
      "lib/meta_where/association_reflection.rb",
-     "lib/meta_where/builder.rb",
      "lib/meta_where/column.rb",
      "lib/meta_where/compound.rb",
      "lib/meta_where/condition.rb",
+     "lib/meta_where/function.rb",
      "lib/meta_where/join_dependency.rb",
+     "lib/meta_where/join_type.rb",
      "lib/meta_where/relation.rb",
      "lib/meta_where/utility.rb",
+     "lib/meta_where/visitors/attribute.rb",
+     "lib/meta_where/visitors/predicate.rb",
+     "lib/meta_where/visitors/visitor.rb",
      "meta_where.gemspec",
      "test/fixtures/companies.yml",
      "test/fixtures/company.rb",
@@ -105,20 +109,20 @@ you're feeling especially appreciative. It'd help me justify this
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<shoulda>, [">= 0"])
-      s.add_runtime_dependency(%q<activerecord>, ["~> 3.0.0"])
-      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0.0"])
-      s.add_runtime_dependency(%q<arel>, ["~> 1.0.1"])
+      s.add_runtime_dependency(%q<activerecord>, ["~> 3.0.2"])
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0.2"])
+      s.add_runtime_dependency(%q<arel>, ["~> 2.0.2"])
     else
       s.add_dependency(%q<shoulda>, [">= 0"])
-      s.add_dependency(%q<activerecord>, ["~> 3.0.0"])
-      s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
-      s.add_dependency(%q<arel>, ["~> 1.0.1"])
+      s.add_dependency(%q<activerecord>, ["~> 3.0.2"])
+      s.add_dependency(%q<activesupport>, ["~> 3.0.2"])
+      s.add_dependency(%q<arel>, ["~> 2.0.2"])
     end
   else
     s.add_dependency(%q<shoulda>, [">= 0"])
-    s.add_dependency(%q<activerecord>, ["~> 3.0.0"])
-    s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
-    s.add_dependency(%q<arel>, ["~> 1.0.1"])
+    s.add_dependency(%q<activerecord>, ["~> 3.0.2"])
+    s.add_dependency(%q<activesupport>, ["~> 3.0.2"])
+    s.add_dependency(%q<arel>, ["~> 2.0.2"])
   end
 end
 

data/test/test_relations.rb

@@ -29,6 +29,35 @@ class TestRelations < Test::Unit::TestCase
       assert_equal results.first, Company.find_by_name('Initech')
     end
 
+    should "allow selection of join type in association joins" do
+      assert_match /INNER JOIN/, @r.joins(:developers.inner).to_sql
+      assert_match /LEFT OUTER JOIN/, @r.joins(:developers.outer).to_sql
+    end
+
+    should "only join once even if two join types are used" do
+      assert_equal 1, @r.joins(:developers.inner, :developers.outer).to_sql.scan("JOIN").size
+    end
+
+    should "allow SQL functions via Symbol#func" do
+      assert_equal @r.where(:name.in => ['Initech', 'Mission Data']), @r.joins(:developers).group('companies.id').having(:developers => {:count.func(:id).gt => 2}).all
+    end
+
+    should "allow SQL functions via Symbol#[]" do
+      assert_equal @r.where(:name.in => ['Initech', 'Mission Data']), @r.joins(:developers).group('companies.id').having(:developers => {:count[:id].gt => 2}).all
+    end
+
+    should "allow SQL functions in select clause" do
+      assert_equal [3,2,3], @r.joins(:developers).group('companies.id').select(:count[Developer.arel_table[:id]].as(:developers_count)).map {|c| c.developers_count}
+    end
+
+    should "allow operators on MetaWhere::Function objects" do
+      assert_equal @r.where(:name.in => ['Initech', 'Mission Data']), @r.joins(:developers).group('companies.id').having(:developers => [:count[:id] > 2]).all
+    end
+
+    should "join multiple parameters to an SQL function with commas" do
+      assert_match /concat\("companies"."id","companies"."name"\) LIKE '%blah%'/, @r.where(:concat[:id,:name].matches => '%blah%').to_sql
+    end
+
     should "create new records with values from equality predicates" do
       assert_equal "New Company",
                    @r.where(:name => 'New Company').new.name
@@ -59,6 +88,12 @@ class TestRelations < Test::Unit::TestCase
       assert_equal results.first, Company.find_by_name('Initech')
     end
 
+    should "behave as expected with empty arrays" do
+      none = @r.where("3 = 1").all
+      assert_equal none, @r.where(:name => []).all
+      assert_equal none, @r.where(:name.in => []).all
+    end
+
     should "allow multiple condition params in a single where" do
       results = @r.where(['name like ?', '%tech'], :created_at => 100.years.ago..Time.now)
       assert_equal 1, results.size
@@ -92,6 +127,21 @@ class TestRelations < Test::Unit::TestCase
                    @r.joins(:data_types).where(:data_types => [:dec >= 2, :dec <= 5]).all
     end
 
+    should "allow nested conditions hashes to have MetaWhere::Condition values" do
+      assert_equal @r.joins(:data_types).where(:data_types => {:dec.gt => 2}).all,
+                   @r.joins(:data_types).where(:data_types => :dec > 2).all
+    end
+
+    should "allow nested conditions hashes to have MetaWhere::And values" do
+      assert_equal @r.joins(:data_types).where(:data_types => {:dec => 2..5}).all,
+                   @r.joins(:data_types).where(:data_types => ((:dec >= 2) & (:dec <= 5))).all
+    end
+
+    should "allow nested conditions hashes to have MetaWhere::Or values" do
+      assert_equal @r.joins(:data_types).where(:data_types => [:dec.gteq % 2 | :bln.eq % true]).all,
+                   @r.joins(:data_types).where(:data_types => ((:dec >= 2) | (:bln >> true))).all
+    end
+
     should "allow combinations of options that no sane developer would ever try to use" do
       assert_equal @r.find_all_by_name('Initech'),
                    @r.joins(:data_types, :developers => [:projects, :notes]).
@@ -165,7 +215,7 @@ class TestRelations < Test::Unit::TestCase
     end
   end
 
-  context "A merged relation" do
+  context "A merged relation with a different base class" do
     setup do
       @r = Developer.where(:salary.gteq % 70000) & Company.where(:name.matches % 'Initech')
     end
@@ -179,7 +229,18 @@ class TestRelations < Test::Unit::TestCase
     end
   end
 
-  context "A merged relation with an alternate association" do
+  context "A merged relation with a different base class and a MetaWhere::JoinType in joins" do
+    setup do
+      @r = Developer.where(:salary.gteq % 70000) & Company.where(:name.matches % 'Initech').joins(:data_types.outer)
+    end
+
+    should "merge the JoinType under the association for the merged relation" do
+      assert_match /LEFT OUTER JOIN #{DataType.quoted_table_name} ON #{DataType.quoted_table_name}."company_id" = #{Company.quoted_table_name}."id"/,
+                   @r.to_sql
+    end
+  end
+
+  context "A merged relation with with a different base class and an alternate association" do
     setup do
       @r = Company.scoped.merge(Developer.where(:salary.gt => 70000), :slackers)
     end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 6
-  version: 0.9.6
+  - 9
+  version: 0.9.9
 platform: ruby
 authors: 
 - Ernie Miller
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-30 00:00:00 -04:00
+date: 2010-11-15 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,8 +41,8 @@ dependencies:
         segments: 
         - 3
         - 0
-        - 0
-        version: 3.0.0
+        - 2
+        version: 3.0.2
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -56,8 +56,8 @@ dependencies:
         segments: 
         - 3
         - 0
-        - 0
-        version: 3.0.0
+        - 2
+        version: 3.0.2
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -69,10 +69,10 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version 
         segments: 
-        - 1
+        - 2
         - 0
-        - 1
-        version: 1.0.1
+        - 2
+        version: 2.0.2
   type: :runtime
   version_requirements: *id004
 description: "\n      MetaWhere offers the ability to call any Arel predicate methods\n      (with a few convenient aliases) on your Model's attributes instead\n      of the ones normally offered by ActiveRecord's hash parameters. It also\n      adds convenient syntax for order clauses, smarter mapping of nested hash\n      conditions, and a debug_sql method to see the real SQL your code is\n      generating without running it against the database. If you like the new\n      AR 3.0 query interface, you'll love it with MetaWhere.\n    "
@@ -99,13 +99,17 @@ files:
 - lib/core_ext/symbol_operators.rb
 - lib/meta_where.rb
 - lib/meta_where/association_reflection.rb
-- lib/meta_where/builder.rb
 - lib/meta_where/column.rb
 - lib/meta_where/compound.rb
 - lib/meta_where/condition.rb
+- lib/meta_where/function.rb
 - lib/meta_where/join_dependency.rb
+- lib/meta_where/join_type.rb
 - lib/meta_where/relation.rb
 - lib/meta_where/utility.rb
+- lib/meta_where/visitors/attribute.rb
+- lib/meta_where/visitors/predicate.rb
+- lib/meta_where/visitors/visitor.rb
 - meta_where.gemspec
 - test/fixtures/companies.yml
 - test/fixtures/company.rb

data/lib/meta_where/builder.rb

@@ -1,84 +0,0 @@
-require 'meta_where/utility'
-
-module MetaWhere
-  class Builder
-    include MetaWhere::Utility
-    attr_reader :join_dependency
-
-    def initialize(join_dependency)
-      @join_dependency = join_dependency
-      @engine = join_dependency.join_base.arel_engine
-      @default_table = Arel::Table.new(join_dependency.join_base.table_name, :engine => @engine)
-    end
-
-    def build_table(parent_or_table_name = nil)
-      if parent_or_table_name.is_a?(Symbol)
-        Arel::Table.new(parent_or_table_name, :engine => @engine)
-      elsif parent_or_table_name.respond_to?(:aliased_table_name)
-        Arel::Table.new(parent_or_table_name.table_name, :as => parent_or_table_name.aliased_table_name, :engine => @engine)
-      else
-        @default_table
-      end
-    end
-
-    def build_predicates_from_hash(attributes, parent = nil)
-      table = build_table(parent)
-      predicates = attributes.map do |column, value|
-        if value.is_a?(Hash)
-          association = parent.is_a?(Symbol) ? nil : @join_dependency.find_join_association(column, parent)
-          build_predicates_from_hash(value, association || column)
-        elsif value.is_a?(MetaWhere::Condition)
-          association = parent.is_a?(Symbol) ? nil : @join_dependency.find_join_association(column, parent)
-          value.to_predicate(self, association || column)
-        elsif value.is_a?(Array) && !value.empty? && value.all? {|v| v.respond_to?(:to_predicate)}
-          association = parent.is_a?(Symbol) ? nil : @join_dependency.find_join_association(column, parent)
-          value.map {|val| val.to_predicate(self, association || column)}
-        else
-          if column.is_a?(MetaWhere::Column)
-            method = column.method
-            column = column.column
-          else
-            column = column.to_s
-            method = method_from_value(value)
-          end
-
-          if column.include?('.')
-            table_name, column = column.split('.', 2)
-            table = Arel::Table.new(table_name, :engine => parent.arel_engine)
-          end
-
-          unless attribute = table[column]
-            raise ::ActiveRecord::StatementInvalid, "No attribute named `#{column}` exists for table `#{table.name}`"
-          end
-
-          unless valid_comparison_method?(method)
-            raise ::ActiveRecord::StatementInvalid, "No comparison method named `#{method}` exists for column `#{column}`"
-          end
-
-          attribute.send(method, *args_for_predicate(method.to_s, value))
-        end
-      end
-
-      predicates.flatten
-    end
-
-    def build_attributes_from_hash(attributes, parent = nil)
-      table = build_table(parent)
-      built_attributes = attributes.map do |column, value|
-        if value.is_a?(Hash)
-          association = parent.is_a?(Symbol) ? nil : @join_dependency.find_join_association(column, parent)
-          build_attributes_from_hash(value, association || column)
-        elsif value.is_a?(Array) && value.all? {|v| v.respond_to?(:to_attribute)}
-          association = parent.is_a?(Symbol) ? nil : @join_dependency.find_join_association(column, parent)
-          value.map {|val| val.to_attribute(self, association || column)}
-        else
-          association = parent.is_a?(Symbol) ? nil : @join_dependency.find_join_association(column, parent)
-          value.respond_to?(:to_attribute) ? value.to_attribute(self, association || column) : value
-        end
-      end
-
-      built_attributes.flatten
-    end
-
-  end
-end