activerecord_any_of 1.2 → 1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5047c28acc2012bdd8941d946180d5587354567b
-  data.tar.gz: fb3a7ec4a6a999b8c7b5877ee3317bdcd9a37912
+  metadata.gz: 3086cee8dc2889c8e3f8874ef32631af08c750c2
+  data.tar.gz: 5e01aa2499c952e4fc215c24890b215d1749f104
 SHA512:
-  metadata.gz: 723692244e87973207876e3b0e065c3ebe11f461f58b463a2270410fe6ece1cc2925a9ef3ee44b1f54a424f1cddba2cd5b15a8556fe43720541e2176a4c9e9f5
-  data.tar.gz: e4e673618cb1354433b5e374ecc966464a63b0b770a64931fa80216a494a9f8460b3f8f0a95754969a17f1c4710bd5941c7158eee816fc359467ec7707ff11ef
+  metadata.gz: 2288d0dec57e66b4b9b454f6082eca83125d30912044de57aedfc828f8aa20b98137b0d71c7de5b53a81f94a9c2f3ec6b2b6373b7afa1f10be58e1c127013832
+  data.tar.gz: 59c3984d1052c8cff9b04cf5bd8bd07b19fef3e3082d7379f56383a6531bf63bf94b002c810c24aa56d899948b14f923313f06a2c41fd78697dbd11632a36c8b

data/README.md

@@ -17,7 +17,7 @@ expected result, this should have been used :
 User.where.any_of({name: 'Doe'}, {active: true})
 ```
 
-  
+
 To be true to principle of least surprise, we now automatically expand
 parameters consisting of a single Hash as a hash for each key, so first
 query will indeed generate :
@@ -156,51 +156,18 @@ 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" ).any_of({ active: true }, { offline: true })`
-* `fakes = User.where( "email LIKE '%@example.com'" ).where( active: true ); User.any_of( fakes, { offline: true })` 
+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 })`
 
 ## I want this in active_record
 
 You can [say it there](https://github.com/rails/rails/pull/10891).
 
-
 ## Running test
 
-Activerecord_any_of allows to run tests against both rails-3 and rails-4. You
-have to run them seperately, but it's ok to use the same directory / machine to
-run both.
-
-### Running tests with rails-4
-
-```shell
-# One time setup
-bundle install --gemfile Gemfile.rails4
-cd test/dummy_rails4
-BUNDLE_GEMFILE=../../Gemfile.rails4 bundle exec rake db:migrate
-BUNDLE_GEMFILE=../../Gemfile.rails4 bundle exec rake db:test:prepare
-cd ../..
-
-# Then
-bundle exec rake test
-```
-
-### Running tests with rails-3
-
-```shell
-# One time setup
-bundle install --gemfile Gemfile.rails3
-cd test/dummy_rails3
-BUNDLE_GEMFILE=../../Gemfile.rails3 bundle exec rake db:migrate
-BUNDLE_GEMFILE=../../Gemfile.rails3 bundle exec rake db:test:prepare
-cd ../..
-
-# Then
-RAILS_VERSION=3 bundle exec rake 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
 

data/Rakefile

@@ -1,18 +1,17 @@
 #!/usr/bin/env rake
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 
-rails_version = ENV[ 'RAILS_VERSION' ] || '4'
+require 'rubygems'
+require 'bundler/setup'
+require 'activerecord_any_of/version'
 
-if rails_version == '3'
-  ENV[ 'BUNDLE_GEMFILE' ] = 'Gemfile.rails3'
-else
-  ENV[ 'BUNDLE_GEMFILE' ] = 'Gemfile.rails4'
-end
+task :default => :spec
 
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+task :spec do
+  puts "\n" + (cmd = "bundle exec rspec spec")
+  system cmd
 end
+
 begin
   require 'rdoc/task'
 rescue LoadError
@@ -28,20 +27,3 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('README.rdoc')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
-
-
-
-
-Bundler::GemHelper.install_tasks
-
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
-
-
-task :default => :test

data/lib/activerecord_any_of/alternative_builder.rb

@@ -37,13 +37,23 @@ module ActiverecordAnyOf
             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 Rails.version >= '4' && query.references_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
         end
 
         def uniq_queries_joins_values
-          @uniq_queries_joins_values ||= queries_joins_values.each { |tables| tables.uniq }
+          @uniq_queries_joins_values ||= begin
+            { includes: [], joins: [], references: [] }.tap do |values|
+              queries_joins_values.each do |join_type, statements|
+                if Symbol === statements.first or String === statements.first
+                  values[ join_type ] = statements.uniq
+                else
+                  values[ join_type ] = statements.uniq( &:to_sql )
+                end
+              end
+            end
+          end
         end
 
         def method_missing(method_name, *args, &block)
@@ -51,7 +61,7 @@ module ActiverecordAnyOf
         end
 
         def add_joins_to(relation)
-          relation = relation.references(uniq_queries_joins_values[:references]) if Rails.version >= '4'
+          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])
         end
@@ -60,10 +70,16 @@ module ActiverecordAnyOf
           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 Rails.version >= '4'
+          relation.references_values += uniq_queries_joins_values[:references] if ActiveRecord::VERSION::MAJOR >= 4
 
           relation
         end
+
+        def unprepare_query(query)
+          query.gsub(/((?<!\\)'.*?(?<!\\)'|(?<!\\)".*?(?<!\\)")|(\=\ \$\d)/) do |match|
+            $2 and $2.gsub(/\=\ \$\d/, "= ?") or match
+          end
+        end
     end
 
     class PositiveBuilder < Builder
@@ -71,7 +87,7 @@ module ActiverecordAnyOf
 
         def with_statement_cache
           if queries && queries_bind_values.any?
-            relation = where([queries.reduce(:or).to_sql, *queries_bind_values.map { |v| v[1] }])
+            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
@@ -89,15 +105,15 @@ module ActiverecordAnyOf
       private
 
         def with_statement_cache
-          if Rails.version >= '4'
+          if ActiveRecord::VERSION::MAJOR >= 4
             if queries && queries_bind_values.any?
-              relation = where.not([queries.reduce(:or).to_sql, *queries_bind_values.map { |v| v[1] }])
+              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([Arel::Nodes::Not.new(queries.reduce(:or)).to_sql, *queries_bind_values.map { |v| v[1] }])
+              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
@@ -107,7 +123,7 @@ module ActiverecordAnyOf
         end
 
         def without_statement_cache
-          if Rails.version >= '4'
+          if ActiveRecord::VERSION::MAJOR >= 4
             relation = where.not(queries.reduce(:or))
           else
             relation = where(Arel::Nodes::Not.new(queries.reduce(:or)))

data/lib/activerecord_any_of/version.rb

@@ -1,3 +1,3 @@
 module ActiverecordAnyOf
-  VERSION = "1.2"
+  VERSION = "1.3"
 end

data/lib/activerecord_any_of.rb

@@ -57,7 +57,7 @@ module ActiverecordAnyOf
 
   module Deprecated
     def any_of(*queries)
-      if Rails.version >= '4'
+      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
 
@@ -66,7 +66,7 @@ module ActiverecordAnyOf
     end
 
     def none_of(*queries)
-      if Rails.version >= '4'
+      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
 
@@ -76,7 +76,7 @@ module ActiverecordAnyOf
   end
 end
 
-if Rails.version >= '4'
+if ActiveRecord::VERSION::MAJOR >= 4
   module ActiverecordAnyOfDelegation
     delegate :any_of, to: :all
     delegate :none_of, to: :all
@@ -89,5 +89,5 @@ else
 end
 
 ActiveRecord::Relation.send(:include, ActiverecordAnyOf::Deprecated)
-ActiveRecord::Relation::WhereChain.send(:include, ActiverecordAnyOf::Chained) if Rails.version >= '4'
+ActiveRecord::Relation::WhereChain.send(:include, ActiverecordAnyOf::Chained) if ActiveRecord::VERSION::MAJOR >= 4
 ActiveRecord::Base.send(:extend, ActiverecordAnyOfDelegation)

data/spec/activerecord_any_of_spec.rb

@@ -0,0 +1,196 @@
+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 raise 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 raise 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 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
+
+  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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,33 @@
+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/users.yml

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

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,34 @@
+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