meta_where 0.9.9.2 → 0.9.10

data/CHANGELOG

@@ -1,3 +1,14 @@
+Changes since 0.9.9 (2010-11-15):
+  * Multiple conditions on the same column with the same predicate will be "OR"ed
+    instead of dropping all but the last one. This tracks the same behavior in
+    Rails 3-0-stable.
+  * You can specify a polymorphic belongs_to join via something like:
+    Model.joins(:joinable.type(PolymorphicClass))
+  * You can specify ActiveRecord objects as values:
+    Developer.joins(:projects).where(:projects => Project.first) is the same as
+    Developer.joins(:projects).where(:projects => {:id => Project.first.id}), but
+    less hashy.
+
 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

data/VERSION

@@ -1 +1 @@
-0.9.9.2
+0.9.10

data/lib/core_ext/symbol.rb

@@ -25,6 +25,10 @@ class Symbol
     MetaWhere::JoinType.new(self, Arel::Nodes::OuterJoin)
   end
 
+  def type(klass)
+    MetaWhere::JoinType.new(self, Arel::Nodes::InnerJoin, klass)
+  end
+
   def asc
     MetaWhere::Column.new(self, :asc)
   end

data/lib/meta_where/belongs_to_polymorphic_association.rb

@@ -0,0 +1,16 @@
+module MetaWhere
+  module BelongsToPolymorphicAssociation
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :conditions, :metawhere
+        alias :sql_conditions :conditions_with_metawhere
+      end
+    end
+
+    # How does this even work in core? Oh, nevermind, it doesn't. Patch submitted. :)
+    def conditions_with_metawhere
+      @conditions ||= interpolate_sql(association_class.send(:sanitize_sql, @reflection.options[:conditions])) if @reflection.options[:conditions]
+    end
+
+  end
+end

data/lib/meta_where/join_dependency.rb

@@ -4,6 +4,7 @@ module MetaWhere
     def self.included(base)
       base.class_eval do
         alias_method_chain :build, :metawhere
+        alias_method_chain :find_join_association, :metawhere
       end
     end
 
@@ -12,14 +13,26 @@ module MetaWhere
     class AssociationNotFoundError < StandardError; end
 
     def build_with_metawhere(associations, parent = nil, join_type = Arel::Nodes::InnerJoin)
+      parent ||= @joins.last
       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)
+        klass = associations.klass
+        join_type = associations.join_type
+        associations = associations.name
+      end
+
+      case associations
+      when Symbol, String
+        reflection = parent.reflections[associations.to_s.intern] or
+          raise ConfigurationError, "Association named '#{ association }' was not found; perhaps you misspelled it?"
+        unless (association = find_join_association(reflection, parent)) && (!klass || association.active_record == klass)
           @reflections << reflection
-          association = build_join_association(reflection, parent)
-          association.join_type = associations.join_type
+          if reflection.options[:polymorphic]
+            raise ArgumentError, "You can't create a polymorphic belongs_to join without specifying the polymorphic class!" unless klass
+            association = build_polymorphic_join_association(reflection, parent, klass)
+          else
+            association = build_join_association(reflection, parent)
+          end
+          association.join_type = join_type
           @joins << association
         end
         association
@@ -27,5 +40,65 @@ module MetaWhere
         build_without_metawhere(associations, parent, join_type)
       end
     end
+
+    def find_join_association_with_metawhere(name_or_reflection, parent)
+      case name_or_reflection
+      when MetaWhere::JoinType
+        join_associations.detect do |j|
+          (j.reflection.name == name_or_reflection.name) &&
+          (j.reflection.klass == name_or_reflection.klass) &&
+          (j.parent == parent)
+        end
+      else
+        find_join_association_without_metawhere(name_or_reflection, parent)
+      end
+    end
+
+    def build_polymorphic_join_association(reflection, parent, klass)
+      PolymorphicJoinAssociation.new(reflection, self, klass, parent)
+    end
+  end
+
+  class PolymorphicJoinAssociation < ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation
+
+    def initialize(reflection, join_dependency, polymorphic_class, parent = nil)
+      reflection.check_validity!
+      @active_record = polymorphic_class
+      @cached_record = {}
+      @join_dependency    = join_dependency
+      @parent             = parent || join_dependency.join_base
+      @reflection         = reflection.clone
+      @reflection.instance_variable_set :"@klass", polymorphic_class
+      @aliased_prefix     = "t#{ join_dependency.joins.size }"
+      @parent_table_name  = @parent.active_record.table_name
+      @aliased_table_name = aliased_table_name_for(table_name)
+      @join               = nil
+      @join_type          = Arel::Nodes::InnerJoin
+    end
+
+    def ==(other)
+      other.class == self.class &&
+      other.reflection == reflection &&
+      other.active_record == active_record &&
+      other.parent == parent
+    end
+
+    def association_join
+      return @join if @join
+
+      aliased_table = Arel::Table.new(table_name, :as => @aliased_table_name, :engine => arel_engine)
+      parent_table = Arel::Table.new(parent.table_name, :as => parent.aliased_table_name, :engine => arel_engine)
+
+      @join = [
+        aliased_table[options[:primary_key] || reflection.klass.primary_key].eq(parent_table[options[:foreign_key] || reflection.primary_key_name]),
+        parent_table[options[:foreign_type]].eq(active_record.name)
+      ]
+
+      if options[:conditions]
+        @join << interpolate_sql(sanitize_sql(options[:conditions], aliased_table_name))
+      end
+
+      @join
+    end
   end
 end

data/lib/meta_where/join_type.rb

@@ -1,22 +1,43 @@
 module MetaWhere
   class JoinType
-    attr_reader :name, :join_type
+    attr_reader :name, :join_type, :klass
 
-    def initialize(name, join_type = Arel::Nodes::InnerJoin)
+    def initialize(name, join_type = Arel::Nodes::InnerJoin, klass = nil)
       @name = name
       @join_type = join_type
+      @klass = klass
     end
 
     def ==(other)
       self.class == other.class &&
       name == other.name &&
-      join_type == other.join_type
+      join_type == other.join_type &&
+      klass == other.klass
     end
 
     alias_method :eql?, :==
 
     def hash
-      [name, join_type].hash
+      [name, join_type, klass].hash
+    end
+
+    def outer
+      @join_type = Arel::Nodes::OuterJoin
+      self
+    end
+
+    def inner
+      @join_type = Arel::Nodes::InnerJoin
+      self
+    end
+
+    def type(klass)
+      @klass = klass
+      self
+    end
+
+    def to_sym
+      self
     end
   end
 end

data/lib/meta_where/relation.rb

@@ -34,7 +34,7 @@ module MetaWhere
 
     def scope_for_create_with_metawhere
       @scope_for_create ||= begin
-        @create_with_value || predicate_wheres.inject({}) do |hash, where|
+        @create_with_value || predicates_without_conflicting_equality.inject({}) do |hash, where|
           if is_equality_predicate?(where)
             hash[where.left.name] = where.right.respond_to?(:value) ? where.right.value : where.right
           end
@@ -108,7 +108,7 @@ module MetaWhere
       arel.joins(arel)
     end unless defined?(:custom_join_sql)
 
-    def predicate_wheres
+    def predicates_without_conflicting_equality
       remove_conflicting_equality_predicates(flatten_predicates(@where_values, predicate_visitor))
     end
 
@@ -155,19 +155,9 @@ module MetaWhere
 
       arel = build_intelligent_joins(arel, visitor) if @joins_values.present?
 
-      predicate_wheres = remove_conflicting_equality_predicates(flatten_predicates(@where_values, visitor))
+      predicate_wheres = flatten_predicates(@where_values.uniq, visitor)
 
-      predicate_wheres.each do |where|
-        next if where.blank?
-
-        case where
-        when Arel::Nodes::SqlLiteral
-          arel = arel.where(where)
-        else
-          sql = where.is_a?(String) ? where : where.to_sql
-          arel = arel.where(Arel::Nodes::SqlLiteral.new("(#{sql})"))
-        end
-      end
+      arel = collapse_wheres(arel, (predicate_wheres - ['']).uniq)
 
       arel = arel.having(*flatten_predicates(@having_values, visitor).reject {|h| h.blank?}) unless @having_values.empty?
 
@@ -244,6 +234,27 @@ module MetaWhere
       }.reverse
     end
 
+    def collapse_wheres(arel, wheres)
+      binaries = wheres.grep(Arel::Nodes::Binary)
+
+      groups = binaries.group_by do |binary|
+        [binary.class, binary.left]
+      end
+
+      groups.each do |_, bins|
+        test = bins.inject(bins.shift) do |memo, expr|
+          memo.or(expr)
+        end
+        arel = arel.where(test)
+      end
+
+      (wheres - binaries).each do |where|
+        where = Arel.sql(where) if String === where
+        arel = arel.where(Arel::Nodes::Grouping.new(where))
+      end
+      arel
+    end
+
     def flatten_predicates(predicates, visitor)
       predicates.map {|p|
         predicate = visitor.can_accept?(p) ? visitor.accept(p) : p
@@ -266,7 +277,7 @@ module MetaWhere
     end
 
     def stashed_association_joins
-      @mw_stashed_association_joins ||= unique_joins.select {|j| j.is_a?(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)}
+      @mw_stashed_association_joins ||= unique_joins.grep(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)
     end
 
     def non_association_joins

data/lib/meta_where/utility.rb

@@ -2,6 +2,10 @@ module MetaWhere
   module Utility
     private
 
+    def array_of_activerecords(val)
+      val.is_a?(Array) && !val.empty? && val.all? {|v| v.is_a?(ActiveRecord::Base)}
+    end
+
     def association_from_parent_and_column(parent, column)
       parent.is_a?(Symbol) ? nil : @join_dependency.send(:find_join_association, column, parent)
     end

data/lib/meta_where/visitors/attribute.rb

@@ -9,7 +9,8 @@ module MetaWhere
       end
 
       def visit_Hash(o, parent)
-        table = build_table(parent)
+        parent = parent.name if parent.is_a? MetaWhere::JoinType
+        table = tables[parent]
         built_attributes = o.map do |column, value|
           if value.is_a?(Hash)
             association = association_from_parent_and_column(parent, column)
@@ -27,7 +28,7 @@ module MetaWhere
       end
 
       def visit_Symbol(o, parent)
-        table = self.build_table(parent)
+        table = tables[parent]
 
         unless attribute = table[o]
           raise ::ActiveRecord::StatementInvalid, "No attribute named `#{o}` exists for table `#{table.name}`"
@@ -42,7 +43,7 @@ module MetaWhere
           table_name, column_name = column_name.split('.', 2)
           table = Arel::Table.new(table_name, :engine => parent.arel_engine)
         else
-          table = self.build_table(parent)
+          table = tables[parent]
         end
 
         unless attribute = table[column_name]

data/lib/meta_where/visitors/predicate.rb

@@ -5,12 +5,13 @@ module MetaWhere
     class Predicate < Visitor
 
       def self.visitables
-        [Hash, MetaWhere::Or, MetaWhere::And, MetaWhere::Condition, MetaWhere::Function]
+        [Hash, Array, MetaWhere::Or, MetaWhere::And, MetaWhere::Condition, MetaWhere::Function]
       end
 
       def visit_Hash(o, parent)
         parent ||= join_dependency.join_base
-        table = build_table(parent)
+        parent = parent.name if parent.is_a? MetaWhere::JoinType
+        table = tables[parent]
         predicates = o.map do |column, value|
           if value.is_a?(Hash)
             association = association_from_parent_and_column(parent, column)
@@ -21,6 +22,9 @@ module MetaWhere
           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)}
+          elsif (value.is_a?(ActiveRecord::Base) || array_of_activerecords(value)) &&
+              reflection = parent.active_record.reflect_on_association(column.is_a?(MetaWhere::JoinType) ? column.name : column)
+            accept_activerecord_values(column, value, parent, reflection)
           else
             if column.is_a?(MetaWhere::Column)
               method = column.method
@@ -34,15 +38,16 @@ module MetaWhere
               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))
+            if attribute = attribute_from_column_and_table(column, table)
+              attribute.send(method, args_for_predicate(value))
+            else
+              raise ::ActiveRecord::StatementInvalid, "No attribute named `#{column}` exists for table `#{table.name}`"
+            end
+
           end
         end
 
@@ -56,6 +61,14 @@ module MetaWhere
         end
       end
 
+      def visit_Array(o, parent)
+        if o.first.is_a? String
+          join_dependency.join_base.send(:sanitize_sql, o)
+        else
+          o.map {|e| accept(e, parent)}.flatten
+        end
+      end
+
       def visit_MetaWhere_Or(o, parent)
         accept(o.condition1, parent).or(accept(o.condition2, parent))
       end
@@ -65,7 +78,7 @@ module MetaWhere
       end
 
       def visit_MetaWhere_Condition(o, parent)
-        table = self.build_table(parent)
+        table = tables[parent]
 
         unless attribute = attribute_from_column_and_table(o.column, table)
           raise ::ActiveRecord::StatementInvalid, "No attribute named `#{o.column}` exists for table `#{table.name}`"
@@ -78,11 +91,55 @@ module MetaWhere
       end
 
       def visit_MetaWhere_Function(o, parent)
-        self.table = self.build_table(parent)
+        self.table = tables[parent]
 
         o.to_sqlliteral
       end
 
+      private
+
+      def accept_activerecord_values(column, value, parent, reflection)
+        groups = Array.wrap(value).group_by {|v| v.class.base_class}
+        unless reflection.options[:polymorphic] || groups.keys.all? {|k| reflection.klass == k}
+          raise ArgumentError, "An object you supplied to :#{reflection.name} is not a #{reflection.klass}!"
+        end
+        case reflection.macro
+        when :has_many, :has_one, :has_and_belongs_to_many
+          conditions = nil
+          groups.each do |klass, values|
+            condition = {
+              (reflection.options[:foreign_key] || reflection.klass.primary_key).to_sym => values.size == 1 ? values.first.id : values.map(&:id)
+            }
+            conditions = conditions ? conditions | condition : condition
+          end
+
+          accept(conditions, association_from_parent_and_column(parent, column) || column)
+        when :belongs_to
+          conditions = nil
+          groups.each do |klass, values|
+            condition = if reflection.options[:polymorphic]
+              {
+                (reflection.options[:foreign_key] || reflection.primary_key_name).to_sym => values.size == 1 ? values.first.id : values.map(&:id),
+                reflection.options[:foreign_type].to_sym => klass.name
+              }
+            else
+              {(reflection.options[:foreign_key] || reflection.primary_key_name).to_sym => values.size == 1 ? values.first.id : values.map(&:id)}
+            end
+            conditions = conditions ? conditions | condition : condition
+          end
+
+          accept(conditions, parent)
+        end
+      end
+
+      def sanitize_or_accept_reflection_conditions(reflection, parent, column)
+        if !can_accept?(reflection.options[:conditions])
+          reflection.sanitized_conditions
+        else
+          accept(reflection.options[:conditions], association_from_parent_and_column(parent, column) || column)
+        end
+      end
+
     end
   end
 end

data/lib/meta_where/visitors/visitor.rb

@@ -5,16 +5,17 @@ module MetaWhere
     class Visitor
       include MetaWhere::Utility
 
-      attr_reader :join_dependency
+      attr_reader :join_dependency, :tables
 
       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)
+        @tables = Hash.new {|hash, key| hash[key] = get_table(key)}
       end
 
-      def build_table(parent_or_table_name = nil)
+      def get_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)

data/lib/meta_where.rb

@@ -39,8 +39,10 @@ require 'core_ext/hash'
 require 'meta_where/visitors/attribute'
 require 'meta_where/visitors/predicate'
 require 'meta_where/association_reflection'
+require 'meta_where/belongs_to_polymorphic_association'
 require 'meta_where/relation'
 require 'meta_where/join_dependency'
 ActiveRecord::Relation.send(:include, MetaWhere::Relation)
 ActiveRecord::Reflection::AssociationReflection.send(:include, MetaWhere::AssociationReflection)
-ActiveRecord::Associations::ClassMethods::JoinDependency.send(:include, MetaWhere::JoinDependency)
+ActiveRecord::Associations::ClassMethods::JoinDependency.send(:include, MetaWhere::JoinDependency)
+ActiveRecord::Associations::BelongsToPolymorphicAssociation.send(:include, MetaWhere::BelongsToPolymorphicAssociation)

data/meta_where.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{meta_where}
-  s.version = "0.9.9.2"
+  s.version = "0.9.10"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ernie Miller"]
-  s.date = %q{2010-11-17}
+  s.date = %q{2011-01-06}
   s.description = %q{
       MetaWhere offers the ability to call any Arel predicate methods
       (with a few convenient aliases) on your Model's attributes instead
@@ -37,6 +37,7 @@ Gem::Specification.new do |s|
     "lib/core_ext/symbol_operators.rb",
     "lib/meta_where.rb",
     "lib/meta_where/association_reflection.rb",
+    "lib/meta_where/belongs_to_polymorphic_association.rb",
     "lib/meta_where/column.rb",
     "lib/meta_where/compound.rb",
     "lib/meta_where/condition.rb",

data/test/fixtures/note.rb

@@ -1,3 +1,3 @@
 class Note < ActiveRecord::Base
-  belongs_to :notable, :polymorphic => true
+  belongs_to :notable, :polymorphic => true, :conditions => '1=1'
 end

data/test/fixtures/notes.yml

@@ -1,79 +1,95 @@
 peter:
+  id          : 1
   notable_type: Developer
   notable_id  : 1
   note        : A straight shooter with upper management written all over him.
-  
+
 michael:
+  id          : 2
   notable_type: Developer
   notable_id  : 2
   note        : Doesn't like the singer of the same name. The nerve!
 
 samir:
+  id          : 3
   notable_type: Developer
   notable_id  : 3
   note        : Naga.... Naga..... Not gonna work here anymore anyway.
 
 herb:
+  id          : 4
   notable_type: Developer
   notable_id  : 4
   note        : Will show you what he's doing.
 
 dude:
+  id          : 5
   notable_type: Developer
   notable_id  : 5
   note        : Nothing of note.
 
 ernie:
+  id          : 6
   notable_type: Developer
   notable_id  : 6
   note        : Complete slacker. Should probably be fired.
 
 someone:
+  id          : 7
   notable_type: Developer
   notable_id  : 7
   note        : Just another developer.
 
 another:
+  id          : 8
   notable_type: Developer
   notable_id  : 8
   note        : Placing a note in this guy's file for insubordination.
 
 initech:
+  id          : 9
   notable_type: Company
   notable_id  : 1
   note        : Innovation + Technology!
 
 aos:
+  id          : 10
   notable_type: Company
   notable_id  : 2
   note        : Advanced solutions of an optical nature.
 
 mission_data:
+  id          : 11
   notable_type: Company
   notable_id  : 3
   note        : Best design + development shop in the 'ville.
 
 y2k:
+  id          : 12
   notable_type: Project
   notable_id  : 1
   note        : It may have already passed but that's no excuse to be unprepared!
 
 virus:
+  id          : 13
   notable_type: Project
   notable_id  : 2
   note        : It could bring the company to its knees.
 
 awesome:
+  id          : 14
   notable_type: Project
   notable_id  : 3
   note        : This note is AWESOME!!!
 
 metasearch:
+  id          : 15
   notable_type: Project
   notable_id  : 4
   note        : A complete waste of the developer's time.
 
 another:
+  id          : 16
   notable_type: Project
   notable_id  : 5
   note        : This is another project note.

data/test/test_relations.rb

@@ -314,5 +314,99 @@ class TestRelations < Test::Unit::TestCase
       assert_match /IN \(1, 2, 3\)/, query.to_sql
       assert_same_elements Developer.all, query.all
     end
+
+    should "merge multiple conditions on the same column and predicate with ORs" do
+      assert_match /"developers"."name" = 'blah' OR "developers"."name" = 'blah2'/,
+                   @r.where(:name => 'blah').where(:name => 'blah2').to_sql
+      assert_match /"developers"."name" LIKE '%blah%' OR "developers"."name" LIKE '%blah2%'/,
+                   @r.where(:name.matches => '%blah%').where(:name.matches => '%blah2%').to_sql
+    end
+
+    should "erge multiple conditions on the same column but different predicate with ANDs" do
+      assert_match /"developers"."name" = 'blah' AND "developers"."name" LIKE '%blah2%'/,
+                   @r.where(:name => 'blah').where(:name.matches => '%blah2%').to_sql
+    end
+  end
+
+  context "A relation" do
+    should "allow conditions on a belongs_to polymorphic association with an object" do
+      dev = Developer.first
+      assert_equal dev, Note.where(:notable.type(Developer) => dev).first.notable
+    end
+
+    should "allow conditions on a belongs_to association with an object" do
+      company = Company.first
+      assert_same_elements Developer.where(:company_id => company.id),
+                           Developer.where(:company => company).all
+    end
+
+    should "allow conditions on a has_and_belongs_to_many association with an object" do
+      project = Project.first
+      assert_same_elements Developer.joins(:projects).where(:projects => {:id => project.id}),
+                           Developer.joins(:projects).where(:projects => project)
+    end
+
+    should "not allow an object of the wrong class to be passed to a non-polymorphic association" do
+      company = Company.first
+      assert_raise ArgumentError do
+        Project.where(:developers => company).all
+      end
+    end
+
+    should "allow multiple AR objects on the value side of an association condition" do
+      projects = [Project.first, Project.last]
+      assert_same_elements Developer.joins(:projects).where(:projects => {:id => projects.map(&:id)}),
+                           Developer.joins(:projects).where(:projects => projects)
+    end
+
+    should "allow multiple different kinds of AR objects on the value side of a polymorphic belongs_to" do
+      dev1 = Developer.first
+      dev2 = Developer.last
+      project = Project.first
+      company = Company.first
+      assert_same_elements Note.where(
+                                       {:notable_type => project.class.base_class.name, :notable_id => project.id} |
+                                       {:notable_type => dev1.class.base_class.name, :notable_id => [dev1.id, dev2.id]} |
+                                       {:notable_type => company.class.base_class.name, :notable_id => company.id}
+                                     ),
+                           Note.where(:notable => [dev1, dev2, project, company]).all
+    end
+
+    should "allow an AR object on the value side of a polymorphic has_many condition" do
+      note = Note.first
+      peter = Developer.first
+      assert_equal [peter],
+                   Developer.joins(:notes).where(:notes => note).all
+    end
+
+    should "allow a join of a polymorphic belongs_to relation with a type specified" do
+      dev = Developer.first
+      company = Company.first
+      assert_equal [company.notes.first],
+                   Note.joins(:notable.type(Company) => :developers).where(:notable => {:developers => dev}).all
+    end
+
+    should "allow selection of a specific polymorphic join by name in the where clause" do
+      dev = Developer.first
+      company = Company.first
+      project = Project.first
+      dev_note = dev.notes.first
+      company_note = company.notes.first
+      project_note = project.notes.first
+      # Have to use outer joins since one inner join will cause remaining rows to be missing
+      # This is pretty convoluted, and way beyond the normal use case for polymorphic belongs_to
+      # joins anyway.
+      @r = Note.joins(:notable.type(Company).outer => :notes.outer, :notable.type(Developer).outer => :notes.outer, :notable.type(Project).outer => :notes.outer)
+      assert_equal [dev_note],
+                    @r.where(:notable.type(Developer) => {:notes => dev_note}).all
+      assert_equal [company_note],
+                    @r.where(:notable.type(Company) => {:notes => company_note}).all
+      assert_equal [project_note],
+                    @r.where(:notable.type(Project) => {:notes => project_note}).all
+    end
+
+    should "maintain belongs_to conditions in a polymorphic join" do
+      assert_match /1=1/, Note.joins(:notable.type(Company)).to_sql
+    end
   end
 end

metadata

@@ -5,9 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 9
-  - 2
-  version: 0.9.9.2
+  - 10
+  version: 0.9.10
 platform: ruby
 authors: 
 - Ernie Miller
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-17 00:00:00 -05:00
+date: 2011-01-06 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -98,6 +97,7 @@ files:
 - lib/core_ext/symbol_operators.rb
 - lib/meta_where.rb
 - lib/meta_where/association_reflection.rb
+- lib/meta_where/belongs_to_polymorphic_association.rb
 - lib/meta_where/column.rb
 - lib/meta_where/compound.rb
 - lib/meta_where/condition.rb