searchlogic-heroku 2.4.19

data/lib/searchlogic/search.rb

@@ -0,0 +1,251 @@
+module Searchlogic
+  # A class that acts like a model, creates attr_accessors for named_scopes, and then
+  # chains together everything when an "action" method is called. It basically makes
+  # implementing search forms in your application effortless:
+  #
+  #   search = User.search
+  #   search.username_like = "bjohnson"
+  #   search.all
+  #
+  # Is equivalent to:
+  #
+  #   User.search(:username_like => "bjohnson").all
+  #
+  # Is equivalent to:
+  #
+  #   User.username_like("bjohnson").all
+  class Search
+    # Responsible for adding a "search" method into your models.
+    module Implementation
+      # Additional method, gets aliased as "search" if that method
+      # is available. A lot of other libraries like to use "search"
+      # as well, so if you have a conflict like this, you can use
+      # this method directly.
+      def searchlogic(conditions = {})
+        Search.new(self, scope(:find), conditions)
+      end
+    end
+    
+    # Is an invalid condition is used this error will be raised. Ex:
+    #
+    #   User.search(:unkown => true)
+    #
+    # Where unknown is not a valid named scope for the User model.
+    class UnknownConditionError < StandardError
+      def initialize(condition)
+        msg = "The #{condition} is not a valid condition. You may only use conditions that map to a named scope"
+        super(msg)
+      end
+    end
+    
+    attr_accessor :klass, :current_scope, :conditions
+    undef :id if respond_to?(:id)
+    
+    # Creates a new search object for the given class. Ex:
+    #
+    #   Searchlogic::Search.new(User, {}, {:username_like => "bjohnson"})
+    def initialize(klass, current_scope, conditions = {})
+      self.klass = klass
+      self.current_scope = current_scope
+      @conditions ||= {}
+      self.conditions = conditions if conditions.is_a?(Hash)
+    end
+    
+    def clone
+      self.class.new(klass, current_scope && current_scope.clone, conditions.clone)
+    end
+    
+    # Returns a hash of the current conditions set.
+    def conditions
+      mass_conditions.clone.merge(@conditions)
+    end
+    
+    # Accepts a hash of conditions.
+    def conditions=(values)
+      values.each do |condition, value|
+        # if a condition name ends with "(1i)", assume it's date / datetime
+        if condition =~ /(.*)\(1i\)$/
+          date_scope_name = $1
+          date_parts = (1..6).to_a.map do |idx|
+            values.delete("#{ date_scope_name }(#{ idx }i)")
+          end.reject{|s| s.blank? }.map{|s| s.to_i }
+
+          # did we get enough info to build a time?
+          if date_parts.length >= 3
+            values[date_scope_name] = Time.zone.local(*date_parts)
+          end
+        end
+      end
+
+      values.each do |condition, value|
+        mass_conditions[condition.to_sym] = value
+        value.delete_if { |v| ignore_value?(v) } if value.is_a?(Array)
+        next if ignore_value?(value)
+        send("#{condition}=", value)
+      end
+    end
+    
+    # Delete a condition from the search. Since conditions map to named scopes,
+    # if a named scope accepts a parameter there is no way to actually delete
+    # the scope if you do not want it anymore. A nil value might be meaningful
+    # to that scope.
+    def delete(*names)
+      names.each do |name|
+        @conditions.delete(name.to_sym)
+        mass_conditions.delete(name)
+      end
+      self
+    end
+    
+    # Returns the column we are currently ordering by
+    def ordering_by
+      order && order.to_s.gsub(/^(ascend|descend)_by_/, '')
+    end
+    
+    private
+      def method_missing(name, *args, &block)
+        condition_name = condition_name(name)
+        scope_name = scope_name(condition_name)
+        
+        if setter?(name)
+          if scope?(scope_name)
+            if args.size == 1
+              write_condition(
+                condition_name,
+                type_cast(
+                  args.first,
+                  cast_type(scope_name),
+                  scope_options(scope_name).respond_to?(:searchlogic_options) ? scope_options(scope_name).searchlogic_options : {}
+                )
+              )
+            else
+              write_condition(condition_name, args)
+            end
+          else
+            raise UnknownConditionError.new(condition_name)
+          end
+        elsif scope?(scope_name) && args.size <= 1
+          if args.size == 0
+            read_condition(condition_name)
+          else
+            send("#{condition_name}=", *args)
+            self
+          end
+        else
+          scope = conditions_array.inject(klass.scoped(current_scope) || {}) do |scope, condition|
+            scope_name, value = condition
+            scope_name = normalize_scope_name(scope_name)
+            klass.send(scope_name, value) if !klass.respond_to?(scope_name)
+            arity = klass.named_scope_arity(scope_name)
+            
+            if !arity || arity == 0
+              if value == true
+                scope.send(scope_name)
+              else
+                scope
+              end
+            elsif arity == -1
+              scope.send(scope_name, *(value.is_a?(Array) ? value : [value]))
+            else
+              scope.send(scope_name, value)
+            end
+          end
+          scope.send(name, *args, &block)
+        end
+      end
+      
+      # This is here as a hook to allow people to modify the order in which the conditions are called, for whatever reason.
+      def conditions_array
+        @conditions.to_a
+      end
+      
+      def normalize_scope_name(scope_name)
+        case
+        when klass.scopes.key?(scope_name.to_sym) then scope_name.to_sym
+        when klass.column_names.include?(scope_name.to_s) then "#{scope_name}_equals".to_sym
+        else scope_name.to_sym
+        end
+      end
+      
+      def setter?(name)
+        !(name.to_s =~ /=$/).nil?
+      end
+      
+      def condition_name(name)
+        condition = name.to_s.match(/(\w+)=?$/)
+        condition ? condition[1].to_sym : nil
+      end
+      
+      def write_condition(name, value)
+        @conditions[name] = value
+      end
+      
+      def read_condition(name)
+        @conditions[name]
+      end
+      
+      def mass_conditions
+        @mass_conditions ||= {}
+      end
+      
+      def scope_name(condition_name)
+        condition_name && normalize_scope_name(condition_name)
+      end
+      
+      def scope?(scope_name)
+        klass.scopes.key?(scope_name) || klass.condition?(scope_name)
+      end
+      
+      def scope_options(name)
+        klass.send(name, nil) if !klass.respond_to?(name) # We need to set up the named scope if it doesn't exist, so we can get a value for named_scope_options
+        klass.named_scope_options(name)
+      end
+      
+      def cast_type(name)
+        named_scope_options = scope_options(name)
+        arity = klass.named_scope_arity(name)
+        if !arity || arity == 0
+          :boolean
+        else
+          named_scope_options.respond_to?(:searchlogic_options) ? named_scope_options.searchlogic_options[:type] : :string
+        end
+      end
+      
+      def type_cast(value, type, options = {})
+        case value
+        when Array
+          value.collect { |v| type_cast(v, type) }
+        when Range
+          Range.new(type_cast(value.first, type), type_cast(value.last, type))
+        else
+          # Let's leverage ActiveRecord's type casting, so that casting is consistent
+          # with the other models.
+          column_for_type_cast = ::ActiveRecord::ConnectionAdapters::Column.new("", nil)
+          column_for_type_cast.instance_variable_set(:@type, type)
+          casted_value = column_for_type_cast.type_cast(value)
+          
+          if Time.zone && casted_value.is_a?(Time)
+            if value.is_a?(String)
+              if options[:skip_conversion]
+                casted_value.utc
+              else
+                (casted_value + (Time.zone.utc_offset * -1)).in_time_zone
+              end
+            else
+              if options[:skip_conversion]
+                casted_value.utc
+              else
+                casted_value.in_time_zone
+              end
+            end
+          else
+            casted_value
+          end
+        end
+      end
+      
+      def ignore_value?(value)
+        (value.is_a?(String) && value.blank?) || (value.is_a?(Array) && value.empty?)
+      end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require "searchlogic"

data/searchlogic.gemspec

@@ -0,0 +1,89 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{searchlogic}
+  s.version = "2.4.19.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ben Johnson of Binary Logic", "William Yeung @ Tofugear"]
+  s.date = %q{2010-07-26}
+  s.description = %q{Searchlogic makes using ActiveRecord named scopes easier and less repetitive. Patch to fix heroku form_for issue}
+  s.email = %q{bjohnson@binarylogic.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "init.rb",
+     "lib/searchlogic.rb",
+     "lib/searchlogic/active_record/association_proxy.rb",
+     "lib/searchlogic/active_record/consistency.rb",
+     "lib/searchlogic/active_record/named_scope_tools.rb",
+     "lib/searchlogic/core_ext/object.rb",
+     "lib/searchlogic/core_ext/proc.rb",
+     "lib/searchlogic/named_scopes/alias_scope.rb",
+     "lib/searchlogic/named_scopes/association_conditions.rb",
+     "lib/searchlogic/named_scopes/association_ordering.rb",
+     "lib/searchlogic/named_scopes/conditions.rb",
+     "lib/searchlogic/named_scopes/or_conditions.rb",
+     "lib/searchlogic/named_scopes/ordering.rb",
+     "lib/searchlogic/rails_helpers.rb",
+     "lib/searchlogic/search.rb",
+     "rails/init.rb",
+     "searchlogic.gemspec",
+     "spec/searchlogic/active_record/association_proxy_spec.rb",
+     "spec/searchlogic/active_record/consistency_spec.rb",
+     "spec/searchlogic/core_ext/object_spec.rb",
+     "spec/searchlogic/core_ext/proc_spec.rb",
+     "spec/searchlogic/named_scopes/alias_scope_spec.rb",
+     "spec/searchlogic/named_scopes/association_conditions_spec.rb",
+     "spec/searchlogic/named_scopes/association_ordering_spec.rb",
+     "spec/searchlogic/named_scopes/conditions_spec.rb",
+     "spec/searchlogic/named_scopes/or_conditions_spec.rb",
+     "spec/searchlogic/named_scopes/ordering_spec.rb",
+     "spec/searchlogic/search_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/goodwill/searchlogic}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{searchlogic}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Searchlogic makes using ActiveRecord named scopes easier and less repetitive.}
+  s.test_files = [
+    "spec/searchlogic/active_record/association_proxy_spec.rb",
+     "spec/searchlogic/active_record/consistency_spec.rb",
+     "spec/searchlogic/core_ext/object_spec.rb",
+     "spec/searchlogic/core_ext/proc_spec.rb",
+     "spec/searchlogic/named_scopes/alias_scope_spec.rb",
+     "spec/searchlogic/named_scopes/association_conditions_spec.rb",
+     "spec/searchlogic/named_scopes/association_ordering_spec.rb",
+     "spec/searchlogic/named_scopes/conditions_spec.rb",
+     "spec/searchlogic/named_scopes/or_conditions_spec.rb",
+     "spec/searchlogic/named_scopes/ordering_spec.rb",
+     "spec/searchlogic/search_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 2.0.0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 2.0.0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 2.0.0"])
+  end
+end
+

data/spec/searchlogic/active_record/association_proxy_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe "Searchlogic::ActiveRecord::AssociationProxy" do
+  it "should call location conditions" do
+    company = Company.create
+    user = company.users.create(:username => "bjohnson")
+    company.users.send(:username_like, "bjohnson").should == [user]
+  end
+  
+  it "should call ordering conditions" do
+    company = Company.create
+    user = company.users.create(:username => "bjohnson")
+    company.users.send(:ascend_by_username).should == [user]
+  end
+  
+  it "should call 'or' conditions" do
+    company = Company.create
+    user = company.users.create(:username => "bjohnson")
+    company.users.send(:username_or_some_type_id_like, "bjohnson").should == [user]
+  end
+    
+end
+

data/spec/searchlogic/active_record/consistency_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Searchlogic::ActiveRecord::Consistency do
+  it "should merge joins with consistent conditions" do
+    user_group = UserGroup.create
+    user_group.users.user_groups_name_like("name").user_groups_id_gt(10).scope(:find)[:joins].should == [
+      "INNER JOIN \"user_groups_users\" ON \"user_groups_users\".user_id = \"users\".id",
+      "INNER JOIN \"user_groups\" ON \"user_groups\".id = \"user_groups_users\".user_group_id"
+    ]
+  end
+  
+  it "should respect parenthesis when reordering conditions" do
+    joins = [
+      "INNER JOIN \"table\" ON (\"b\".user_id = \"a\".id)",
+      "INNER JOIN \"table\" ON (\"b\".id = \"a\".user_group_id)"
+    ]
+    ActiveRecord::Base.send(:merge_joins, joins).should == [
+      "INNER JOIN \"table\" ON \"a\".id = \"b\".user_id",
+      "INNER JOIN \"table\" ON \"a\".user_group_id = \"b\".id"
+    ]
+  end
+  
+  it "shuold not convert joins to strings when delegating via associations" do
+    User.alias_scope :has_id_gt, lambda { User.id_gt(10).has_name.orders_id_gt(10) }
+    User.alias_scope :has_name, lambda { User.orders_created_at_after(Time.now).name_equals("ben").username_equals("ben") }
+    Company.users_has_id_gt.proxy_options[:joins].should == {:users=>[:orders]}
+  end
+end

data/spec/searchlogic/core_ext/object_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Searchlogic::CoreExt::Object do
+  it "should accept and pass the argument to the searchlogic_options" do
+    proc = searchlogic_lambda(:integer, :test => :value) {}
+    proc.searchlogic_options[:type].should == :integer
+    proc.searchlogic_options[:test].should == :value
+  end
+end

data/spec/searchlogic/core_ext/proc_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Searchlogic::CoreExt::Proc do
+  it "should have a searchlogic_options accessor" do
+    p = Proc.new {}
+    p.searchlogic_options[:type] = :integer
+  end
+end

data/spec/searchlogic/named_scopes/alias_scope_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Searchlogic::NamedScopes::AliasScope do
+  before(:each) do
+    User.alias_scope :username_has, lambda { |value| User.username_like(value) }
+  end
+  
+  it "should allow alias scopes" do
+    User.create(:username => "bjohnson")
+    User.create(:username => "thunt")
+    User.username_has("bjohnson").all.should == User.find_all_by_username("bjohnson")
+  end
+  
+  it "should allow alias scopes from the search object" do
+    search = User.search
+    search.username_has = "bjohnson"
+    search.username_has.should == "bjohnson"
+  end
+  
+  it "should inherit alias scopes from superclasses" do
+    Class.new(User).alias_scope?("username_has").should be_true
+  end
+end

data/spec/searchlogic/named_scopes/association_conditions_spec.rb

@@ -0,0 +1,198 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Searchlogic::NamedScopes::AssociationConditions do
+  it "should create a named scope" do
+    Company.users_username_like("bjohnson").proxy_options.should == User.username_like("bjohnson").proxy_options.merge(:joins => :users)
+  end
+  
+  it "should create a deep named scope" do
+    Company.users_orders_total_greater_than(10).proxy_options.should == Order.total_greater_than(10).proxy_options.merge(:joins => {:users => :orders})
+  end
+  
+  it "should allow the use of foreign pre-existing named scopes" do
+    User.named_scope :uname, lambda { |value| {:conditions => ["users.username = ?", value]} }
+    Company.users_uname("bjohnson").proxy_options.should == User.uname("bjohnson").proxy_options.merge(:joins => :users)
+  end
+  
+  it "should allow the use of deep foreign pre-existing named scopes" do
+    pending
+    Order.named_scope :big_id, :conditions => "orders.id > 100"
+    Company.users_orders_big_id.proxy_options.should == Order.big_id.proxy_options.merge(:joins => {:users => :orders})
+  end
+  
+  it "should allow the use of foreign pre-existing alias scopes" do
+    User.alias_scope :username_has, lambda { |value| User.username_like(value) }
+    Company.users_username_has("bjohnson").proxy_options.should == User.username_has("bjohnson").proxy_options.merge(:joins => :users)
+  end
+  
+  it "should not raise errors for scopes that don't return anything" do
+    User.alias_scope :blank_scope, lambda { |value| }
+    Company.users_blank_scope("bjohnson").proxy_options.should == {:joins => :users}
+  end
+  
+  it "should ignore polymorphic associations" do
+    lambda { Fee.owner_created_at_gt(Time.now) }.should raise_error(NoMethodError)
+  end
+  
+  it "should not allow named scopes on non existent association columns" do
+    lambda { User.users_whatever_like("bjohnson") }.should raise_error(NoMethodError)
+  end
+  
+  it "should not allow named scopes on non existent deep association columns" do
+    lambda { User.users_orders_whatever_like("bjohnson") }.should raise_error(NoMethodError)
+  end
+  
+  it "should allow named scopes to be called multiple times and reflect the value passed" do
+    Company.users_username_like("bjohnson").proxy_options.should == User.username_like("bjohnson").proxy_options.merge(:joins => :users)
+    Company.users_username_like("thunt").proxy_options.should == User.username_like("thunt").proxy_options.merge(:joins => :users)
+  end
+  
+  it "should allow deep named scopes to be called multiple times and reflect the value passed" do
+    Company.users_orders_total_greater_than(10).proxy_options.should == Order.total_greater_than(10).proxy_options.merge(:joins => {:users => :orders})
+    Company.users_orders_total_greater_than(20).proxy_options.should == Order.total_greater_than(20).proxy_options.merge(:joins => {:users => :orders})
+  end
+  
+  it "should have an arity of 1 if the underlying scope has an arity of 1" do
+    Company.users_orders_total_greater_than(10)
+    Company.named_scope_arity("users_orders_total_greater_than").should == Order.named_scope_arity("total_greater_than")
+  end
+  
+  it "should have an arity of nil if the underlying scope has an arity of nil" do
+    Company.users_orders_total_null
+    Company.named_scope_arity("users_orders_total_null").should == Order.named_scope_arity("total_null")
+  end
+  
+  it "should have an arity of -1 if the underlying scope has an arity of -1" do
+    Company.users_id_equals_any
+    Company.named_scope_arity("users_id_equals_any").should == User.named_scope_arity("id_equals_any")
+  end
+  
+  it "should allow aliases" do
+    Company.users_username_contains("bjohnson").proxy_options.should == User.username_contains("bjohnson").proxy_options.merge(:joins => :users)
+  end
+  
+  it "should allow deep aliases" do
+    Company.users_orders_total_gt(10).proxy_options.should == Order.total_gt(10).proxy_options.merge(:joins => {:users => :orders})
+  end
+  
+  it "should include optional associations" do
+    pending # this is a problem with using inner joins and left outer joins
+    Company.create
+    company = Company.create
+    user = company.users.create
+    order = user.orders.create(:total => 20, :taxes => 3)
+    Company.ascend_by_users_orders_total.all.should == Company.all
+  end
+  
+  it "should implement exclusive scoping" do
+    scope = Company.users_company_name_like("name").users_company_description_like("description")
+    scope.scope(:find)[:joins].should == [
+      "INNER JOIN \"users\" ON companies.id = users.company_id",
+      "INNER JOIN \"companies\" companies_users ON \"companies_users\".id = \"users\".company_id"
+    ]
+    lambda { scope.all }.should_not raise_error
+  end
+  
+  it "should not create the same join twice" do
+    scope = Company.users_orders_total_gt(10).users_orders_taxes_lt(5).ascend_by_users_orders_total
+    scope.scope(:find)[:joins].should == [
+      "INNER JOIN \"users\" ON companies.id = users.company_id",
+      "INNER JOIN \"orders\" ON orders.user_id = users.id"
+    ]
+    lambda { scope.count }.should_not raise_error
+  end
+  
+  it "should not create the same join twice when traveling through the duplicate join" do
+    scope = Company.users_username_like("bjohnson").users_orders_total_gt(100)
+    scope.scope(:find)[:joins].should == [
+      "INNER JOIN \"users\" ON companies.id = users.company_id",
+      "INNER JOIN \"orders\" ON orders.user_id = users.id"
+    ]
+    lambda { scope.count }.should_not raise_error
+  end
+  
+  it "should not create the same join twice when traveling through the deep duplicate join" do
+    scope = Company.users_orders_total_gt(100).users_orders_line_items_price_gt(20)
+    scope.scope(:find)[:joins].should == [
+      "INNER JOIN \"users\" ON companies.id = users.company_id",
+      "INNER JOIN \"orders\" ON orders.user_id = users.id",
+      "INNER JOIN \"line_items\" ON line_items.order_id = orders.id"
+    ]
+    lambda { scope.all }.should_not raise_error
+  end
+  
+  it "should allow the use of :include when a join was created" do
+    company = Company.create
+    user = company.users.create
+    order = user.orders.create(:total => 20, :taxes => 3)
+    Company.users_orders_total_gt(10).users_orders_taxes_lt(5).ascend_by_users_orders_total.all(:include => :users).should == Company.all
+  end
+  
+  it "should allow the use of deep :include when a join was created" do
+    company = Company.create
+    user = company.users.create
+    order = user.orders.create(:total => 20, :taxes => 3)
+    Company.users_orders_total_gt(10).users_orders_taxes_lt(5).ascend_by_users_orders_total.all(:include => {:users => :orders}).should == Company.all
+  end
+  
+  it "should allow the use of :include when traveling through the duplicate join" do
+    company = Company.create
+    user = company.users.create(:username => "bjohnson")
+    order = user.orders.create(:total => 20, :taxes => 3)
+    Company.users_username_like("bjohnson").users_orders_taxes_lt(5).ascend_by_users_orders_total.all(:include => :users).should == Company.all
+  end
+  
+  it "should allow the use of deep :include when traveling through the duplicate join" do
+    company = Company.create
+    user = company.users.create(:username => "bjohnson")
+    order = user.orders.create(:total => 20, :taxes => 3)
+    Company.users_orders_taxes_lt(50).ascend_by_users_orders_total.all(:include => {:users => :orders}).should == Company.all
+  end
+  
+  it "should automatically add string joins if the association condition is using strings" do
+    User.named_scope(:orders_big_id, :joins => User.inner_joins(:orders))
+    Company.users_orders_big_id.proxy_options.should == {:joins=>[" INNER JOIN \"users\" ON users.company_id = companies.id ", " INNER JOIN \"orders\" ON orders.user_id = users.id "]}
+  end
+
+  it "should order the join statements ascending by the fieldnames so that we don't get double joins where the only difference is that the order of the fields is different" do
+    company = Company.create
+    user = company.users.create(:company_id => company.id)
+    company.users.company_id_eq(company.id).should == [user]
+  end
+  
+  it "should sanitize the scope on a foreign model instead of passing the raw options back to the original" do
+    Company.named_scope(:users_count_10, :conditions => {:users_count => 10})
+    User.company_users_count_10.proxy_options.should == {:conditions => "\"companies\".\"users_count\" = 10", :joins => :company}
+  end
+  
+  it "should delegate to polymorphic relationships" do
+    Audit.auditable_user_type_name_like("ben").proxy_options.should == {
+      :conditions => ["users.name LIKE ?", "%ben%"],
+      :joins => "INNER JOIN \"users\" ON \"users\".id = \"audits\".auditable_id AND \"audits\".auditable_type = 'User'"
+    }
+  end
+  
+  it "should delegate to polymorphic relationships (with a lazy split on _type_)" do
+    Audit.auditable_user_type_some_type_id_like("ben").proxy_options.should == {
+      :conditions => ["users.some_type_id LIKE ?", "%ben%"],
+      :joins => "INNER JOIN \"users\" ON \"users\".id = \"audits\".auditable_id AND \"audits\".auditable_type = 'User'"
+    }
+  end
+  
+  it "should deep delegate to polymorphic relationships" do
+    Audit.auditable_user_type_company_name_like("company").proxy_options.should == {
+      :conditions => ["companies.name LIKE ?", "%company%"],
+      :joins => ["INNER JOIN \"users\" ON \"users\".id = \"audits\".auditable_id AND \"audits\".auditable_type = 'User'", " INNER JOIN \"companies\" ON \"companies\".id = \"users\".company_id "]
+    }
+  end
+  
+  it "should allow any on a has_many relationship" do
+    company1 = Company.create
+    user1 = company1.users.create
+    company2 = Company.create
+    user2 = company2.users.create
+    user3 = company2.users.create
+    
+    Company.users_id_equals_any([user2.id, user3.id]).all(:select => "DISTINCT companies.*").should == [company2]
+  end
+end