activerecord_any_of 1.4 → 2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 47eee92223e93989b63ad4b3ae077bf438bf70fc
-  data.tar.gz: 31b4d5f385ea3d699ad5abca878ef7612649959c
+SHA256:
+  metadata.gz: 3f426526955604bce6800c7d7b84913cd198ad0a0b821be1e5fa7dc5b0bb215b
+  data.tar.gz: '08597e05b96433c2bd29cd95750beba918810fe50c320733bb864e93b273eeb1'
 SHA512:
-  metadata.gz: 1b2d782aa4da21b7823f1ae978f6effcc0d55460dbbdb51bb7fabdd34d21ce9e50023de2c237857dfba6729d9d1d5c2f377d76d5f842f158d8ff5c4ff6a50552
-  data.tar.gz: f174291bbc3e50f0a48ac8414988f84d01413f21a3a603b63ebc8270afd9163800d91f87f72351b9972ecc6f433fec5860ebb24deb3f17cfd77d6ff058549d7b
+  metadata.gz: a4451ade0e580f14d30f943989c3263e1ee322bfb6d9a32483c29407c1f9b3e96e4781b7ec9a6adda3ae02675c711f0d4e6009e8c88d378fc1786ad02e33660b
+  data.tar.gz: e64bb560165f871e14687b27bab765d30e5a575bce057b1387a58115ec40cb8b7b15707228675f0ade9847bfeb94f7326239c97d38fd13cc1bc78d24b03bb428

data/README.md

@@ -6,11 +6,36 @@ This gem provides `#any_of` and `#none_of` on ActiveRecord.
 
 `#any_of` is inspired by [any_of from mongoid](http://two.mongoid.org/docs/querying/criteria.html#any_of).
 
-Its main purpose is to both :
+It was released before `#or` was implemented in ActiveRecord. Its main purpose was to both :
 
 * remove the need to write a sql string when we want an `OR`
 * allows to write dynamic `OR` queries, which would be a pain with a string
 
+It can still be useful today given the various ways you can call it. While
+ActiveRecord's `#or` only accepts relations, you can pass to `#any_of` and
+`#none_of` the same kind of conditions you would pass to `#where`:
+
+
+```ruby
+User.where.any_of({ active: true }, ['offline = ?', required_status], 'posts_count > 0')
+```
+
+And you can still use relations, like AR's `#or`:
+
+```ruby
+inactive_users = User.not_activated
+offline_users = User.offline
+
+User.where.any_of(inactive_users, offline)
+```
+
+## Installation
+
+In your Gemfile :
+
+```
+gem 'activerecord_any_of'
+```
 
 ## Usage
 
@@ -18,7 +43,6 @@ Its main purpose is to both :
 
 It allows to compute an `OR` like query that leverages AR's `#where` syntax:
 
-
 #### basics
 
 ```ruby
@@ -26,26 +50,23 @@ User.where.any_of(first_name: 'Joe', last_name: 'Joe')
 # => SELECT * FROM users WHERE first_name = 'Joe' OR last_name = 'Joe'
 ```
 
-
 #### grouped conditions
 
 You can separate sets of hash condition by explicitly group them as hashes :
 
 ```ruby
-User.where.any_of({first_name: 'John', last_name: 'Joe'}, {first_name: 'Simon', last_name: 'Joe'})
+User.where.any_of({ first_name: 'John', last_name: 'Joe' }, { first_name: 'Simon', last_name: 'Joe' })
 # => SELECT * FROM users WHERE ( first_name = 'John' AND last_name = 'Joe' ) OR ( first_name = 'Simon' AND last_name = 'Joe' )
 ```
 
-
 #### it's plain #where syntax
 
 Each `#any_of` set is the same kind you would have passed to #where :
 
 ```ruby
-Client.where.any_of("orders_count = '2'", ["name = ?", 'Joe'], {email: 'joe@example.com'})
+Client.where.any_of("orders_count = '2'", ["name = ?", 'Joe'], { email: 'joe@example.com' })
 ```
 
-
 #### with relations
 
 You can as well pass `#any_of` to other relations :
@@ -54,16 +75,14 @@ You can as well pass `#any_of` to other relations :
 Client.where("orders_count = '2'").where.any_of({ email: 'joe@example.com' }, { email: 'john@example.com' })
 ```
 
-
 #### with associations
 
 And with associations :
 
 ```ruby
-User.find(1).posts.where.any_of({published: false}, "user_id IS NULL")
+User.find(1).posts.where.any_of({ published: false }, 'user_id IS NULL')
 ```
 
-
 #### dynamic OR queries
 
 The best part is that `#any_of` accepts other relations as parameter, to help compute
@@ -81,64 +100,6 @@ inactive_users = User.where.any_of(banned_users, unconfirmed_users)
 
 ```ruby
 banned_users = User.where(banned: true)
-unconfirmed_users = User.where("confirmed_at IS NULL")
+unconfirmed_users = User.where('confirmed_at IS NULL')
 active_users = User.where.none_of(banned_users, unconfirmed_users)
 ```
-
-## Rails-3
-
-`activerecord_any_of` uses WhereChain, which has been introduced in rails-4. In
-rails-3, simply call `#any_of` and `#none_of` directly, without using `#where` :
-
-```ruby
-manual_removal = User.where(id: params[:users][:destroy_ids])
-User.any_of(manual_removal, "email like '%@example.com'", {banned: true})
-@company.users.any_of(manual_removal, "email like '%@example.com'", {banned: true})
-User.where(offline: false).any_of( manual_removal, "email like '%@example.com'", {banned: true})
-```
-
-## Installation
-
-In your Gemfile :
-
-```
-gem 'activerecord_any_of'
-```
-
-Activerecord_any_of supports rails >= 3.2.13 and rails-4 (let me know if tests
-pass for rails < 3.2.13, I may edit gem dependencies).
-
-
-## Why not an `#or` method instead ?
-
-```ruby
-User.where( "email LIKE '%@example.com" ).where( active: true ).or( offline: true )
-```
-
-What does this query do ? `where (email LIKE '%@example.com' AND active = '1' )
-OR offline = '1'` ? Or `where email LIKE '%@example.com' AND ( active = '1' OR
-offline = '1' )` ? This can quickly get messy and counter intuitive.
-
-The MongoId solution is quite elegant. Using `#any_of`, it is made clear which
-conditions are grouped through `OR` and which are grouped through `AND` :
-
-* `User.where( "email LIKE '%@example.com" ).where.any_of({ active: true }, { offline: true })`
-* `fakes = User.where( "email LIKE '%@example.com'" ).where( active: true ); User.where.any_of( fakes, { offline: true })`
-
-
-## Running test
-
-Testing is done using TravisCI. You can use the wonderful [wwtd gem](https://github.com/grosser/wwtd) to run all tests locally. By default, the task to run is `bundle exec rake spec`, and will run against `sqlite3` in memory. You can change the database like so: `DB=postgresql bundle exec rake spec`. Please note that you may need to change the credentials for your database in the `database.yml` file. *Do not commit those changes.*
-
-## Pull requests
-
-This gem is extracted from a pull request made to activerecord core, and
-still hope to be merged. So, any pull request here should respects usual
-[Rails contributing rules](http://guides.rubyonrails.org/contributing_to_ruby_on_rails.html#contributing-to-the-rails-code)
-when it makes sense (especially : coding conventions) to make integration
-in source pull request easy.
-
-
-## Licence
-
-MIT-LICENSE.

data/Rakefile

@@ -1,2 +1,4 @@
-require "bundler/gem_tasks"
-task :default => :spec
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+task default: :spec

data/lib/activerecord_any_of/alternative_builder.rb

@@ -1,136 +1,141 @@
+# frozen_string_literal: true
+
 module ActiverecordAnyOf
+  # Main class allowing to build alternative conditions for the query.
   class AlternativeBuilder
     def initialize(match_type, context, *queries)
-      if Hash === queries.first and queries.count == 1
-        queries = queries.first.each_pair.map { |attr, predicate| Hash[attr, predicate] }
+      if queries.first.is_a?(Hash) && (queries.count == 1)
+        queries = queries.first.each_pair.map { |attr, predicate| { attr => predicate } }
       end
 
-      @builder = match_type == :negative ? NegativeBuilder.new(context, *queries) : PositiveBuilder.new(context, *queries)
+      @builder = if match_type == :negative
+                   NegativeBuilder.new(context,
+                                       *queries)
+                 else
+                   PositiveBuilder.new(context, *queries)
+                 end
     end
 
     def build
       @builder.build
     end
 
+    # Common methods for both the positive builder and the negative one.
     class Builder
-      attr_accessor :queries_bind_values, :queries_joins_values
+      attr_accessor :queries_joins_values
 
       def initialize(context, *source_queries)
-        @context, @source_queries = context, source_queries
-        @queries_bind_values, @queries_joins_values = [], { includes: [],  joins: [], references: [] }
-      end
-
-      def build
-        ActiveRecord::Base.connection.supports_statement_cache? ? with_statement_cache : without_statement_cache
+        @context = context
+        @source_queries = source_queries
+        @queries_joins_values = { includes: [], joins: [], references: [] }
       end
 
       private
 
-        def queries
-          @queries ||= @source_queries.map do |query|
-            if String === query || Hash === query
-              query = where(query)
-            elsif Array === query
-              query = where(*query)
-            end
-
-            self.queries_bind_values += query.bind_values if query.bind_values.any?
-            queries_joins_values[:includes].concat(query.includes_values) if query.includes_values.any?
-            queries_joins_values[:joins].concat(query.joins_values) if query.joins_values.any?
-            queries_joins_values[:references].concat(query.references_values) if ActiveRecord::VERSION::MAJOR >= 4 && query.references_values.any?
-            query.arel.constraints.reduce(:and)
-          end
+      def query_to_relation(query)
+        if query.is_a?(String) || query.is_a?(Hash)
+          query = where(query)
+        elsif query.is_a?(Array)
+          query = where(*query)
         end
 
-        def uniq_queries_joins_values
-          @uniq_queries_joins_values ||= begin
-            { includes: [], joins: [], references: [] }.tap do |values|
-              queries_joins_values.each do |join_type, statements|
-                if statements.first.respond_to?(:to_sql)
-                  values[ join_type ] = statements.uniq( &:to_sql )
-                else
-                  values[ join_type ] = statements.uniq
-                end
-              end
-            end
-          end
+        query
+      end
+
+      def append_join_values(query)
+        { includes_values: :includes, joins_values: :joins, references_values: :references }.each do |q, joins|
+          values = query.send(q)
+          queries_joins_values[joins].concat(values) if values.any?
         end
+      end
 
-        def method_missing(method_name, *args, &block)
-          @context.send(method_name, *args, &block)
+      def queries
+        @queries ||= @source_queries.map do |query|
+          query = query_to_relation(query)
+          append_join_values(query)
+          query.arel.constraints.reduce(:and)
         end
+      end
 
-        def add_joins_to(relation)
-          relation = relation.references(uniq_queries_joins_values[:references]) if ActiveRecord::VERSION::MAJOR >= 4
-          relation = relation.includes(uniq_queries_joins_values[:includes])
-          relation.joins(uniq_queries_joins_values[:joins])
+      def uniq_queries_joins_values
+        @uniq_queries_joins_values ||= { includes: [], joins: [], references: [] }.tap do |values|
+          queries_joins_values.each do |join_type, statements|
+            values[join_type] = if statements.first.respond_to?(:to_sql)
+                                  statements.uniq(&:to_sql)
+                                else
+                                  statements.uniq
+                                end
+          end
         end
+      end
 
-        def add_related_values_to(relation)
-          relation.bind_values += queries_bind_values
-          relation.includes_values += uniq_queries_joins_values[:includes]
-          relation.joins_values += uniq_queries_joins_values[:joins]
-          relation.references_values += uniq_queries_joins_values[:references] if ActiveRecord::VERSION::MAJOR >= 4
+      def map_multiple_bind_values(query)
+        query.children.map do |child|
+          next unless child.respond_to?(:right)
+          next unless child.right.respond_to?(:value)
 
-          relation
+          child.right.value
         end
+      end
+
+      def queries_bind_values
+        queries.map do |query|
+          if query.respond_to?(:children)
+            map_multiple_bind_values(query)
+          else
+            next unless query.respond_to?(:right)
+            next unless query.right.respond_to?(:value)
 
-        def unprepare_query(query)
-          query.gsub(/((?<!\\)'.*?(?<!\\)'|(?<!\\)".*?(?<!\\)")|(\=\ \$\d+)/) do |match|
-            $2 and $2.gsub(/\=\ \$\d+/, "= ?") or match
+            query.right.value
           end
-        end
-    end
+        end.flatten.compact
+      end
 
-    class PositiveBuilder < Builder
-      private
+      def method_missing(method_name, *args, &block)
+        @context.send(method_name, *args, &block)
+      end
 
-        def with_statement_cache
-          if queries && queries_bind_values.any?
-            relation = where([unprepare_query(queries.reduce(:or).to_sql), *queries_bind_values.map { |v| v[1] }])
-          else
-            relation = where(queries.reduce(:or).to_sql)
-          end
+      def respond_to_missing?(method, *)
+        @context.respond_to? method
+      end
 
-          add_joins_to relation
-        end
+      def add_joins_to(relation)
+        relation = relation.references(uniq_queries_joins_values[:references])
+        relation = relation.includes(uniq_queries_joins_values[:includes])
+        relation.joins(uniq_queries_joins_values[:joins])
+      end
 
-        def without_statement_cache
-          relation = where(queries.reduce(:or))
-          add_related_values_to relation
+      def unprepare_query(query)
+        query.gsub(/((?<!\\)'.*?(?<!\\)'|(?<!\\)".*?(?<!\\)")|(=\ \$\d+)/) do |match|
+          ::Regexp.last_match(2)&.gsub(/=\ \$\d+/, '= ?') or match
         end
+      end
     end
 
-    class NegativeBuilder < Builder
-      private
-
-        def with_statement_cache
-          if ActiveRecord::VERSION::MAJOR >= 4
-            if queries && queries_bind_values.any?
-              relation = where.not([unprepare_query(queries.reduce(:or).to_sql), *queries_bind_values.map { |v| v[1] }])
-            else
-              relation = where.not(queries.reduce(:or).to_sql)
-            end
-          else
-            if queries && queries_bind_values.any?
-              relation = where([unprepare_query(Arel::Nodes::Not.new(queries.reduce(:or)).to_sql), *queries_bind_values.map { |v| v[1] }])
-            else
-              relation = where(Arel::Nodes::Not.new(queries.reduce(:or)).to_sql)
-            end
-          end
+    # Returns records that match any of the conditions, ie `#any_of`.
+    class PositiveBuilder < Builder
+      def build
+        relation = if queries && queries_bind_values.any?
+                     where([unprepare_query(queries.reduce(:or).to_sql), *queries_bind_values])
+                   else
+                     where(queries.reduce(:or).to_sql)
+                   end
 
-          add_joins_to relation
-        end
+        add_joins_to relation
+      end
+    end
 
-        def without_statement_cache
-          if ActiveRecord::VERSION::MAJOR >= 4
-            relation = where.not(queries.reduce(:or))
-          else
-            relation = where(Arel::Nodes::Not.new(queries.reduce(:or)))
-          end
+    # Returns records that match none of the conditions, ie `#none_of`.
+    class NegativeBuilder < Builder
+      def build
+        relation = if queries && queries_bind_values.any?
+                     where.not([unprepare_query(queries.reduce(:or).to_sql), *queries_bind_values])
+                   else
+                     where.not(queries.reduce(:or).to_sql)
+                   end
 
-          add_related_values_to relation
-        end
+        add_joins_to relation
+      end
     end
   end
 end

data/lib/activerecord_any_of/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiverecordAnyOf
-  VERSION = "1.4"
+  VERSION = '2.0'
 end

data/lib/activerecord_any_of.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require 'activerecord_any_of/alternative_builder'
 
 module ActiverecordAnyOf
+  # Injected into WhereChain.
   module Chained
     # Returns a new relation, which includes results matching any of the conditions
     # passed as parameters. You can think of it as a sql <tt>OR</tt> implementation :
@@ -12,7 +15,8 @@ module ActiverecordAnyOf
     # You can separate sets of hash condition by explicitly group them as hashes :
     #
     #    User.where.any_of({first_name: 'John', last_name: 'Joe'}, {first_name: 'Simon', last_name: 'Joe'})
-    #    # => SELECT * FROM users WHERE ( first_name = 'John' AND last_name = 'Joe' ) OR ( first_name = 'Simon' AND last_name = 'Joe' )
+    #    # => SELECT * FROM users WHERE ( first_name = 'John' AND last_name = 'Joe' ) OR
+    #    ( first_name = 'Simon' AND last_name = 'Joe' )
     #
     #
     # Each #any_of set is the same kind you would have passed to #where :
@@ -38,6 +42,7 @@ module ActiverecordAnyOf
     #    inactive_users = User.where.any_of(banned_users, unconfirmed_users)
     def any_of(*queries)
       raise ArgumentError, 'Called any_of() with no arguments.' if queries.none?
+
       AlternativeBuilder.new(:positive, @scope, *queries).build
     end
 
@@ -51,43 +56,10 @@ module ActiverecordAnyOf
     #    active_users = User.where.none_of(banned_users, unconfirmed_users)
     def none_of(*queries)
       raise ArgumentError, 'Called none_of() with no arguments.' if queries.none?
-      AlternativeBuilder.new(:negative, @scope, *queries).build
-    end
-  end
-
-  module Deprecated
-    def any_of(*queries)
-      if ActiveRecord::VERSION::MAJOR >= 4
-        ActiveSupport::Deprecation.warn( "Calling #any_of directly is deprecated and will be removed in activerecord_any_of-1.2.\nPlease call it with #where : User.where.any_of(cond1, cond2)." )
-      end
-
-      raise ArgumentError, 'Called any_of() with no arguments.' if queries.none?
-      AlternativeBuilder.new(:positive, self, *queries).build
-    end
-
-    def none_of(*queries)
-      if ActiveRecord::VERSION::MAJOR >= 4
-        ActiveSupport::Deprecation.warn( "Calling #none_of directly is deprecated and will be removed in activerecord_any_of-1.2.\nPlease call it with #where : User.where.none_of(cond1, cond2)." )
-      end
 
-      raise ArgumentError, 'Called none_of() with no arguments.' if queries.none?
-      AlternativeBuilder.new(:negative, self, *queries).build
+      AlternativeBuilder.new(:negative, @scope, *queries).build
     end
   end
 end
 
-if ActiveRecord::VERSION::MAJOR >= 4
-  module ActiverecordAnyOfDelegation
-    delegate :any_of, to: :all
-    delegate :none_of, to: :all
-  end
-else
-  module ActiverecordAnyOfDelegation
-    delegate :any_of, to: :scoped
-    delegate :none_of, to: :scoped
-  end
-end
-
-ActiveRecord::Relation.send(:include, ActiverecordAnyOf::Deprecated)
-ActiveRecord::Relation::WhereChain.send(:include, ActiverecordAnyOf::Chained) if ActiveRecord::VERSION::MAJOR >= 4
-ActiveRecord::Base.send(:extend, ActiverecordAnyOfDelegation)
+ActiveRecord::Relation::WhereChain.include ActiverecordAnyOf::Chained

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_any_of
 version: !ruby/object:Gem::Version
-  version: '1.4'
+  version: '2.0'
 platform: ruby
 authors:
 - Olivier El Mekki
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-01-23 00:00:00.000000000 Z
+date: 2023-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,76 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.13
+        version: '7'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.13
+        version: '7'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5'
-- !ruby/object:Gem::Dependency
-  name: rspec-rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.12'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.12'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10'
-- !ruby/object:Gem::Dependency
-  name: combustion
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.1
-- !ruby/object:Gem::Dependency
-  name: database_cleaner
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '8'
 description: Any_of allows to compute dynamic OR queries.
 email:
 - olivier@el-mekki.com
@@ -99,19 +43,12 @@ files:
 - lib/activerecord_any_of.rb
 - lib/activerecord_any_of/alternative_builder.rb
 - lib/activerecord_any_of/version.rb
-- spec/activerecord_any_of_spec.rb
-- spec/db/database.yml
-- spec/db/schema.rb
-- spec/fixtures/authors.yml
-- spec/fixtures/posts.yml
-- spec/fixtures/users.yml
-- spec/spec_helper.rb
-- spec/support/models.rb
 homepage: https://github.com/oelmekki/activerecord_any_of
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -119,24 +56,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.3.26
+signing_key:
 specification_version: 4
 summary: Mongoid's any_of like implementation for activerecord
-test_files:
-- spec/activerecord_any_of_spec.rb
-- spec/fixtures/users.yml
-- spec/fixtures/authors.yml
-- spec/fixtures/posts.yml
-- spec/support/models.rb
-- spec/db/database.yml
-- spec/db/schema.rb
-- spec/spec_helper.rb
+test_files: []

data/spec/activerecord_any_of_spec.rb

@@ -1,233 +0,0 @@
-require 'spec_helper'
-
-describe ActiverecordAnyOf do
-  fixtures :authors, :posts, :users
-
-  describe 'finding with alternate conditions' do
-    let(:davids) { Author.where(name: "David") }
-
-    it "matches hash combinations" do
-      if ActiveRecord::VERSION::MAJOR >= 4
-        expect(Author.where.any_of({name: 'David'}, {name: 'Mary'})).to match_array(authors(:david, :mary))
-      else
-        expect(Author.any_of({name: 'David'}, {name: 'Mary'})).to match_array(authors(:david, :mary))
-      end
-    end
-
-    it "matches combination of hash and array" do
-      if ActiveRecord::VERSION::MAJOR >= 4
-        expect(Author.where.any_of({name: 'David'}, ['name = ?', 'Mary'])).to match_array(authors(:david, :mary))
-      else
-        expect(Author.any_of({name: 'David'}, ['name = ?', 'Mary'])).to match_array(authors(:david, :mary))
-      end
-    end
-
-    it "matches a combination of hashes, arrays, and AR relations" do
-      if ActiveRecord::VERSION::MAJOR >= 4
-        expect(Author.where.any_of(davids, ['name = ?', 'Mary'], {name: 'Bob'})).to match_array(authors(:david, :mary, :bob))
-      else
-        expect(Author.any_of(davids, ['name = ?', 'Mary'], {name: 'Bob'})).to match_array(authors(:david, :mary, :bob))
-      end
-    end
-
-    it "matches a combination of strings, hashes, and AR relations" do
-      if ActiveRecord::VERSION::MAJOR >= 4
-        expect(Author.where.any_of(davids, "name = 'Mary'", {name: 'Bob', id: 3})).to match_array(authors(:david, :mary, :bob))
-      else
-        expect(Author.any_of(davids, "name = 'Mary'", {name: 'Bob', id: 3})).to match_array(authors(:david, :mary, :bob))
-      end
-    end
-
-    it "doesn't find combinations previously filtered out" do
-      if ActiveRecord::VERSION::MAJOR >= 4
-        expect(Author.where.not(name: 'Mary').where.any_of(davids, ['name = ?', 'Mary'])).to match_array([authors(:david)])
-      else
-        expect(Author.where("name != 'Mary'").any_of(davids, ['name = ?', 'Mary'])).to match_array([authors(:david)])
-      end
-    end
-  end
-
-  it 'finding with alternate conditions on has_many association' do
-    david = authors(:david)
-    welcome = david.posts.where(body: 'Such a lovely day')
-    expected = ['Welcome to the weblog', 'So I was thinking']
-
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect(david.posts.where.any_of(welcome, {type: 'SpecialPost'}).map(&:title)).to match_array(expected)
-    else
-      expect(david.posts.any_of(welcome, {type: 'SpecialPost'}).map(&:title)).to match_array(expected)
-    end
-  end
-
-  it 'finds with combined polymorphic associations' do
-    company = Company.create!
-    university = University.create!
-
-    company.users << users(:ezra)
-    university.users << users(:aria)
-
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect(User.where.any_of(company.users, university.users)).to match_array(users(:ezra, :aria))
-    else
-      expect(User.any_of(company.users, university.users)).to match_array(users(:ezra, :aria))
-    end
-  end
-
-  it 'finds with more than 2 combined polymorphic associations' do
-    company = Company.create!
-    university = University.create!
-    company2 = Company.create!
-
-    company.users << users(:ezra)
-    university.users << users(:aria)
-    company2.users << users(:james)
-
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect(User.where.any_of(company.users, university.users, company2.users)).to match_array(users(:ezra, :aria, :james))
-    else
-      expect(User.any_of(company.users, university.users, company2.users)).to match_array(users(:ezra, :aria, :james))
-    end
-  end
-
-  it 'finds alternatives with combined has_many associations' do
-    david, mary = authors(:david, :mary)
-
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect(Post.where.any_of(david.posts, mary.posts)).to match_array(david.posts + mary.posts)
-    else
-      expect(Post.any_of(david.posts, mary.posts)).to match_array(david.posts + mary.posts)
-    end
-  end
-
-  it 'finds alternatives with more than 2 combined has_many associations' do
-    david, mary, bob = authors(:david, :mary, :bob)
-
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect(Post.where.any_of(david.posts, mary.posts, bob.posts)).to match_array(david.posts + mary.posts + bob.posts)
-    else
-      expect(Post.any_of(david.posts, mary.posts, bob.posts)).to match_array(david.posts + mary.posts + bob.posts)
-    end
-  end
-
-  describe 'finding alternate dynamically with joined queries' do
-    it "matches combined AR relations with joins" do
-      david = Author.where(posts: { title: 'Welcome to the weblog' }).joins(:posts)
-      mary = Author.where(posts: { title: "eager loading with OR'd conditions" }).joins(:posts)
-
-      if ActiveRecord::VERSION::MAJOR >= 4
-        expect(Author.where.any_of(david, mary)).to match_array(authors(:david, :mary))
-      else
-        expect(Author.any_of(david, mary)).to match_array(authors(:david, :mary))
-      end
-    end
-
-    it "matches combined AR relations with joins and includes" do
-      if ActiveRecord::VERSION::MAJOR >= 4
-        david = Author.where(posts: { title: 'Welcome to the weblog' }).includes(:posts).references(:posts)
-        mary = Author.where(posts: { title: "eager loading with OR'd conditions" }).includes(:posts).references(:posts)
-        expect(Author.where.any_of(david, mary)).to match_array(authors(:david, :mary))
-      else
-        david = Author.where(posts: { title: 'Welcome to the weblog' }).includes(:posts)
-        mary = Author.where(posts: { title: "eager loading with OR'd conditions" }).includes(:posts)
-        expect(Author.any_of(david, mary)).to match_array(authors(:david, :mary))
-      end
-    end
-  end
-
-  it 'finding with alternate negative conditions' do
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect(Author.where.none_of({name: 'David'}, {name: 'Mary'})).to match_array([authors(:bob)])
-    else
-      expect(Author.none_of({name: 'David'}, {name: 'Mary'})).to match_array([authors(:bob)])
-    end
-  end
-
-  it 'finding with alternate negative conditions on association' do
-    david = Author.where(name: 'David').first
-    welcome = david.posts.where(body: 'Such a lovely day')
-    expected = ['sti comments', 'sti me', 'habtm sti test']
-
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect(david.posts.where.none_of(welcome, {type: 'SpecialPost'}).map(&:title)).to match_array(expected)
-    else
-      expect(david.posts.none_of(welcome, {type: 'SpecialPost'}).map(&:title)).to match_array(expected)
-    end
-  end
-
-  it 'calling #any_of with no argument raises exception' do
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect { Author.where.any_of }.to raise_exception(ArgumentError)
-    else
-      expect { Author.any_of }.to raise_exception(ArgumentError)
-    end
-  end
-
-  it 'calling #none_of with no argument raises exception' do
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect { Author.where.none_of }.to raise_exception(ArgumentError)
-    else
-      expect { Author.none_of }.to raise_exception(ArgumentError)
-    end
-  end
-
-  it 'calling #any_of after including via a hash does not raise an exception' do
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect { User.includes(memberships: :companies).where.any_of(user_id: 1, company_id: 1) }.
-        to_not raise_exception
-    else
-      expect { User.includes(memberships: :companies).any_of(user_id: 1, company_id: 1) }.
-        to_not raise_exception
-    end
-  end
-
-  it 'calling #any_of after a wildcard query works' do
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect(Author.where("name like '%av%'").where.any_of({name: 'David'}, {name: 'Mary'})).to match_array([authors(:david)])
-    else
-      expect(Author.where("name like '%av%'").any_of({name: 'David'}, {name: 'Mary'})).to match_array([authors(:david)])
-    end
-  end
-
-  it 'calling #any_of with a single Hash as parameter expands it' do
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect(Author.where.any_of(name: 'David', id: 2)).to match_array(authors(:david, :mary))
-    else
-      expect(Author.any_of(name: 'David', id: 2)).to match_array(authors(:david, :mary))
-    end
-  end
-
-  it "does not fail on hudge number for bind values" do
-    conditions = [
-      { name: 'Mary' },
-      { name: 'David' },
-      { name: 'David1' },
-      { name: 'David2' },
-      { name: 'David3' },
-      { name: 'David4' },
-      { name: 'David5' },
-      { name: 'David6' },
-      { name: 'David7' },
-      { name: 'David8' },
-      { name: 'David9' },
-      { name: 'David10' },
-      { name: 'David11' },
-      { name: 'David12' },
-      { name: 'David13' },
-      { name: 'David14' }
-    ]
-
-    if ActiveRecord::VERSION::MAJOR >= 4
-      expect(Author.where.any_of(*conditions)).to match_array(authors(:david, :mary))
-    else
-      expect(Author.any_of(*conditions)).to match_array(authors(:david, :mary))
-    end
-  end
-
-  if ActiveRecord::VERSION::MAJOR >= 4
-    it 'calling directly #any_of is deprecated in rails-4' do
-      allow(ActiveSupport::Deprecation).to receive(:warn)
-      Author.any_of({name: 'David'}, {name: 'Mary'})
-      expect(ActiveSupport::Deprecation).to have_received(:warn)
-    end
-  end
-end

data/spec/db/database.yml

@@ -1,28 +0,0 @@
-sqlite3:
-  adapter: <%= "jdbc" if defined? JRUBY_VERSION %>sqlite3
-  database: activerecord_any_of.sqlite3.db
-sqlite3mem:
-  adapter: <%= "jdbc" if defined? JRUBY_VERSION %>sqlite3
-  database: ":memory:"
-postgresql:
-  adapter: postgresql
-  encoding: unicode
-  database: activerecord_any_of_test
-  pool: 5
-  username: postgres
-  password:
-  min_messages: warning
-mysql:
-  adapter: <%= defined?(JRUBY_VERSION) ? "jdbcmysql" : "mysql2" %>
-  host: localhost
-  username: root
-  password:
-  database: activerecord_any_of_test
-  encoding: utf8
-## Add DB Configuration to run Oracle tests
-oracle:
-  adapter: oracle_enhanced
-  host: localhost
-  username: activerecord_any_of_dev
-  password:
-  database: xe

data/spec/db/schema.rb

@@ -1,33 +0,0 @@
-ActiveRecord::Schema.define do
-  create_table :authors do |t|
-    t.string   :name
-    t.datetime :created_at
-    t.datetime :updated_at
-  end
-
-  create_table :posts do |t|
-    t.string   :title
-    t.text     :body
-    t.integer  :author_id
-    t.string   :type
-    t.datetime :created_at
-    t.datetime :updated_at
-  end
-
-  create_table :companies do |t|
-    t.string :name
-  end
-
-  create_table :universities do |t|
-    t.string :name
-  end
-
-  create_table :memberships do |t|
-    t.references :organization, polymorphic: true
-    t.references :user
-  end
-
-  create_table :users do |t|
-    t.string  :name
-  end
-end

data/spec/fixtures/authors.yml

@@ -1,11 +0,0 @@
-david:
-  id: 1
-  name: David
-
-mary:
-  id: 2
-  name: Mary
-
-bob:
-  id: 3
-  name: Bob

data/spec/fixtures/posts.yml

@@ -1,76 +0,0 @@
-welcome:
-  id: 1
-  author_id: 1
-  title: Welcome to the weblog
-  body: Such a lovely day
-  type: Post
-
-thinking:
-  id: 2
-  author_id: 1
-  title: So I was thinking
-  body: Like I hopefully always am
-  type: SpecialPost
-
-authorless:
-  id: 3
-  author_id: 0
-  title: I don't have any comments
-  body: I just don't want to
-  type: Post
-
-sti_comments:
-  id: 4
-  author_id: 1
-  title: sti comments
-  body: hello
-  type: Post
-
-sti_post_and_comments:
-  id: 5
-  author_id: 1
-  title: sti me
-  body: hello
-  type: StiPost
-
-sti_habtm:
-  id: 6
-  author_id: 1
-  title: habtm sti test
-  body: hello
-  type: Post
-
-eager_other:
-  id: 7
-  author_id: 2
-  title: eager loading with OR'd conditions
-  body: hello
-  type: Post
-
-misc_by_bob:
-  id: 8
-  author_id: 3
-  title: misc post by bob
-  body: hello
-  type: Post
-
-misc_by_mary:
-  id: 9
-  author_id: 2
-  title: misc post by mary
-  body: hello
-  type: Post
-
-other_by_bob:
-  id: 10
-  author_id: 3
-  title: other post by bob
-  body: hello
-  type: Post
-
-other_by_mary:
-  id: 11
-  author_id: 2
-  title: other post by mary
-  body: hello
-  type: Post

data/spec/fixtures/users.yml

@@ -1,9 +0,0 @@
-ezra:
-  id: 1
-  name: "Ezra"
-aria:
-  id: 2
-  name: "Aria"
-james:
-  id: 3
-  name: "James"

data/spec/spec_helper.rb

@@ -1,36 +0,0 @@
-plugin_test_dir = File.dirname(__FILE__)
-
-require 'rubygems'
-require 'bundler/setup'
-require 'pry'
-
-require 'logger'
-require 'rails/all'
-require 'active_record'
-ActiveRecord::Base.logger = Logger.new(plugin_test_dir + "/debug.log")
-
-require 'yaml'
-require 'erb'
-ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(plugin_test_dir + "/db/database.yml")).result)
-ActiveRecord::Base.establish_connection((ENV["DB"] ||= 'sqlite3mem').to_sym)
-ActiveRecord::Migration.verbose = false
-
-require 'combustion/database'
-Combustion::Database.create_database(ActiveRecord::Base.configurations[ENV["DB"]])
-load(File.join(plugin_test_dir, "db", "schema.rb"))
-
-require 'activerecord_any_of'
-require 'support/models'
-
-require 'action_controller'
-require 'rspec/rails'
-require 'database_cleaner'
-RSpec.configure do |config|
-  config.fixture_path = "#{plugin_test_dir}/fixtures"
-  config.use_transactional_fixtures = true
-  config.after(:suite) do
-    unless /sqlite/ === ENV['DB']
-      Combustion::Database.drop_database(ActiveRecord::Base.configurations[ENV['DB']])
-    end
-  end
-end

data/spec/support/models.rb

@@ -1,34 +0,0 @@
-class Author < ActiveRecord::Base
-  has_many :posts
-end
-
-class Post < ActiveRecord::Base
-  belongs_to :author
-end
-
-class SpecialPost < Post
-end
-
-class StiPost < Post
-end
-
-class User < ActiveRecord::Base
-  has_many :memberships
-  has_many :companies, through: :memberships, source: :organization, source_type: "Company"
-  has_many :universities, through: :memberships, source: :organization, source_type: "University"
-end
-
-class Membership < ActiveRecord::Base
-  belongs_to :user
-  belongs_to :organization, polymorphic: true
-end
-
-class Company < ActiveRecord::Base
-  has_many :memberships, as: :organization
-  has_many :users, through: :memberships
-end
-
-class University < ActiveRecord::Base
-  has_many :memberships, as: :organization
-  has_many :users, through: :memberships
-end