activerecord_any_of 1.0.2 → 1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2eb1c3bc8c812cafeac5742eda463f36a1517336
-  data.tar.gz: 9e1c425f8faf771056efa3af3c38dcec05ed7353
+  metadata.gz: a9596994399dde0f68fd7f66190597b3d1342aea
+  data.tar.gz: 92c72d9afc6d5748552c2dd582aae86aa0763f0c
 SHA512:
-  metadata.gz: 9093159a107a57d4f94e01aaea598e8e66f37b138e7d211be6bdd60f0946d22d98253d2a00999a8783b78d4d131687dbf9305e86f7c448d3529cd38ec3928277
-  data.tar.gz: a18604f93e8fb7ba4fca299a2c376a16a9e641109bb37edcc6b2ec267924ac7a80bc2d97e6160d6542b92afa3698ed6804031d8b4982cb94362703b9a26036fd
+  metadata.gz: 5d801f39fdd970de448edeb11bf1abbc3bd41e6c69a94fd56a8b51f8664c8247e25ea86044859671a7ad508feac9e842ccce3a59f69951660e27b97536eef299
+  data.tar.gz: 2621b8ebbb70ad7933c4df55f3b676d752b856da623aa7bd1d2b5acc9b93f45b542f99132343a2b4d2283e4f6203e0a3a6ac3ec3b3755098fcdfb7d0ef7e4239

data/README.md

@@ -7,18 +7,17 @@ This gem provides `#any_of` and `#none_of` on ActiveRecord.
 It allows to compute an `OR` like query that leverages AR's `#where` syntax:
 
 ```ruby
-users = User.any_of("email like '%@example.com'", {banned: true}).destroy_all
+users = User.where.any_of("email like '%@example.com'", {banned: true}).destroy_all
 # DELETE FROM users WHERE email LIKE '%@example.com' OR banned = '1';
 ```
 
-It can be used directly on model class, or through an association, or
-behind an other relation.
+It can be used anywhere `#where` is valid :
 
 ```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})
+User.where.any_of(manual_removal, "email like '%@example.com'", {banned: true})
+@company.users.where.any_of(manual_removal, "email like '%@example.com'", {banned: true})
+User.where(offline: false).where.any_of( manual_removal, "email like '%@example.com'", {banned: true})
 ```
 
 Its main purpose is to both :
@@ -31,9 +30,20 @@ Its main purpose is to both :
 ```ruby
 banned_users = User.where(banned: true)
 unconfirmed_users = User.where("confirmed_at IS NULL")
-active_users = User.none_of(banned_users, unconfirmed_users)
+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
 
@@ -53,9 +63,12 @@ pass for rails < 3.2.13, I may edit gem dependencies).
 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.
+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` : 
+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 })` 
@@ -68,14 +81,36 @@ 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
-cd test/dummy
-rake db:migrate
-rake db:test:prepare
+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
-rake test
+RAILS_VERSION=3 bundle exec rake test
 ```
 
 

data/Rakefile

@@ -1,4 +1,13 @@
 #!/usr/bin/env rake
+
+rails_version = ENV[ 'RAILS_VERSION' ] || '4'
+
+if rails_version == '3'
+  ENV[ 'BUNDLE_GEMFILE' ] = 'Gemfile.rails3'
+else
+  ENV[ 'BUNDLE_GEMFILE' ] = 'Gemfile.rails4'
+end
+
 begin
   require 'bundler/setup'
 rescue LoadError

data/lib/activerecord_any_of/version.rb

@@ -1,3 +1,3 @@
 module ActiverecordAnyOf
-  VERSION = "1.0.2"
+  VERSION = "1.1"
 end

data/lib/activerecord_any_of.rb

@@ -1,43 +1,65 @@
 require 'activerecord_any_of/alternative_builder'
 
 module ActiverecordAnyOf
-  # 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.
-  #
-  # Each #any_of parameter is the same set you would have passed to #where :
-  #
-  #    Client.any_of("orders_count = '2'", ["name = ?", 'Joe'], {email: 'joe@example.com'})
-  #
-  # You can as well pass #any_of to other relations :
-  #
-  #    Client.where("orders_count = '2'").any_of({ email: 'joe@example.com' }, { email: 'john@example.com' })
-  #
-  # And with associations :
-  #
-  #    User.find(1).posts.any_of({published: false}, "user_id IS NULL")
-  #
-  # The best part is that #any_of accepts other relations as parameter, to help compute
-  # dynamic <tt>OR</tt> queries :
-  #
-  #    banned_users = User.where(banned: true)
-  #    unconfirmed_users = User.where("confirmed_at IS NULL")
-  #    inactive_users = User.any_of(banned_users, unconfirmed_users)
-  def any_of(*queries)
-    raise ArgumentError, 'Called any_of() with no arguments.' if queries.none?
-    AlternativeBuilder.new(:positive, self, *queries).build
+  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.
+    #
+    # Each #any_of parameter is the same set you would have passed to #where :
+    #
+    #    Client.any_of("orders_count = '2'", ["name = ?", 'Joe'], {email: 'joe@example.com'})
+    #
+    # You can as well pass #any_of to other relations :
+    #
+    #    Client.where("orders_count = '2'").any_of({ email: 'joe@example.com' }, { email: 'john@example.com' })
+    #
+    # And with associations :
+    #
+    #    User.find(1).posts.any_of({published: false}, "user_id IS NULL")
+    #
+    # The best part is that #any_of accepts other relations as parameter, to help compute
+    # dynamic <tt>OR</tt> queries :
+    #
+    #    banned_users = User.where(banned: true)
+    #    unconfirmed_users = User.where("confirmed_at IS NULL")
+    #    inactive_users = User.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
+
+    # Returns a new relation, which includes results not matching any of the conditions
+    # passed as parameters. It's the negative version of <tt>#any_of</tt>.
+    #
+    # This will return all active users :
+    #
+    #    banned_users = User.where(banned: true)
+    #    unconfirmed_users = User.where("confirmed_at IS NULL")
+    #    active_users = User.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
 
-  # Returns a new relation, which includes results not matching any of the conditions
-  # passed as parameters. It's the negative version of <tt>#any_of</tt>.
-  #
-  # This will return all active users :
-  #
-  #    banned_users = User.where(banned: true)
-  #    unconfirmed_users = User.where("confirmed_at IS NULL")
-  #    active_users = User.none_of(banned_users, unconfirmed_users)
-  def none_of(*queries)
-    raise ArgumentError, 'Called none_of() with no arguments.' if queries.none?
-    AlternativeBuilder.new(:negative, self, *queries).build
+  module Deprecated
+    def any_of(*queries)
+      if Rails.version >= '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 Rails.version >= '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
+    end
   end
 end
 
@@ -53,5 +75,6 @@ else
   end
 end
 
-ActiveRecord::Relation.send(:include, ActiverecordAnyOf)
+ActiveRecord::Relation.send(:include, ActiverecordAnyOf::Deprecated)
+ActiveRecord::Relation::WhereChain.send(:include, ActiverecordAnyOf::Chained) if Rails.version >= '4'
 ActiveRecord::Base.send(:extend, ActiverecordAnyOfDelegation)

data/test/activerecord_any_of_test.rb

@@ -4,16 +4,21 @@ class ActiverecordAnyOfTest < ActiveSupport::TestCase
   fixtures :authors, :posts
 
   test 'finding with alternate conditions' do
-    assert_equal ['David', 'Mary'], Author.any_of({name: 'David'}, {name: 'Mary'}).map(&:name)
-    assert_equal ['David', 'Mary'], Author.any_of({name: 'David'}, ['name = ?', 'Mary']).map(&:name)
-
-    davids = Author.where(name: 'David')
-    assert_equal ['David', 'Mary', 'Bob'], Author.any_of(davids, ['name = ?', 'Mary'], {name: 'Bob'}).map(&:name)
-    assert_equal ['David', 'Mary', 'Bob'], Author.any_of(davids, "name = 'Mary'", {name: 'Bob', id: 3}).map(&:name)
-
     if Rails.version >= '4'
-      assert_equal ['David'], Author.where.not(name: 'Mary').any_of(davids, ['name = ?', 'Mary']).map(&:name)
+      assert_equal ['David', 'Mary'], Author.where.any_of({name: 'David'}, {name: 'Mary'}).map(&:name)
+      assert_equal ['David', 'Mary'], Author.where.any_of({name: 'David'}, ['name = ?', 'Mary']).map(&:name)
+
+      davids = Author.where(name: 'David')
+      assert_equal ['David', 'Mary', 'Bob'], Author.where.any_of(davids, ['name = ?', 'Mary'], {name: 'Bob'}).map(&:name)
+      assert_equal ['David', 'Mary', 'Bob'], Author.where.any_of(davids, "name = 'Mary'", {name: 'Bob', id: 3}).map(&:name)
+      assert_equal ['David'], Author.where.not(name: 'Mary').where.any_of(davids, ['name = ?', 'Mary']).map(&:name)
     else
+      assert_equal ['David', 'Mary'], Author.any_of({name: 'David'}, {name: 'Mary'}).map(&:name)
+      assert_equal ['David', 'Mary'], Author.any_of({name: 'David'}, ['name = ?', 'Mary']).map(&:name)
+
+      davids = Author.where(name: 'David')
+      assert_equal ['David', 'Mary', 'Bob'], Author.any_of(davids, ['name = ?', 'Mary'], {name: 'Bob'}).map(&:name)
+      assert_equal ['David', 'Mary', 'Bob'], Author.any_of(davids, "name = 'Mary'", {name: 'Bob', id: 3}).map(&:name)
       assert_equal ['David'], Author.where("name IS NOT 'Mary'").any_of(davids, ['name = ?', 'Mary']).map(&:name)
     end
   end
@@ -22,46 +27,84 @@ class ActiverecordAnyOfTest < ActiveSupport::TestCase
     david = Author.where(name: 'David').first
     welcome = david.posts.where(body: 'Such a lovely day')
     expected = ['Welcome to the weblog', 'So I was thinking']
-    assert_equal expected, david.posts.any_of(welcome, {type: 'SpecialPost'}).map(&:title)
+
+    if Rails.version >= '4'
+      assert_equal expected, david.posts.where.any_of(welcome, {type: 'SpecialPost'}).map(&:title)
+    else
+      assert_equal expected, david.posts.any_of(welcome, {type: 'SpecialPost'}).map(&:title)
+    end
   end
 
   test 'finding alternate dynamically with joined queries' 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)
 
-    assert_equal ['David', 'Mary'], Author.any_of(david, mary).map(&:name)
+    if Rails.version >= '4'
+      assert_equal ['David', 'Mary'], Author.where.any_of(david, mary).map(&:name)
+    else
+      assert_equal ['David', 'Mary'], Author.any_of(david, mary).map(&:name)
+    end
 
     if Rails.version >= '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)
+      assert_equal ['David', 'Mary'], Author.where.any_of(david, mary).map(&:name)
     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)
+      assert_equal ['David', 'Mary'], Author.any_of(david, mary).map(&:name)
     end
-
-    assert_equal ['David', 'Mary'], Author.any_of(david, mary).map(&:name)
   end
 
   test 'finding with alternate negative conditions' do
-    assert_equal ['Bob'], Author.none_of({name: 'David'}, {name: 'Mary'}).map(&:name)
+    if Rails.version >= '4'
+      assert_equal ['Bob'], Author.where.none_of({name: 'David'}, {name: 'Mary'}).map(&:name)
+    else
+      assert_equal ['Bob'], Author.none_of({name: 'David'}, {name: 'Mary'}).map(&:name)
+    end
   end
 
   test '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']
-    assert_equal expected, david.posts.none_of(welcome, {type: 'SpecialPost'}).map(&:title)
+
+    if Rails.version >= '4'
+      assert_equal expected, david.posts.where.none_of(welcome, {type: 'SpecialPost'}).map(&:title)
+    else
+      assert_equal expected, david.posts.none_of(welcome, {type: 'SpecialPost'}).map(&:title)
+    end
   end
 
   test 'calling #any_of with no argument raise exception' do
-    assert_raise(ArgumentError) { Author.any_of }
+    if Rails.version >= '4'
+      assert_raise(ArgumentError) { Author.where.any_of }
+    else
+      assert_raise(ArgumentError) { Author.any_of }
+    end
   end
 
   test 'calling #none_of with no argument raise exception' do
-    assert_raise(ArgumentError) { Author.none_of }
+    if Rails.version >= '4'
+      assert_raise(ArgumentError) { Author.where.none_of }
+    else
+      assert_raise(ArgumentError) { Author.none_of }
+    end
   end
 
   test 'calling #any_of after a wildcard query works' do
-    assert_equal ['David'], Author.where("name like '%av%'").any_of({name: 'David'}, {name: 'Mary'}).map(&:name)
+    if Rails.version >= '4'
+      assert_equal ['David'], Author.where("name like '%av%'").where.any_of({name: 'David'}, {name: 'Mary'}).map(&:name)
+    else
+      assert_equal ['David'], Author.where("name like '%av%'").any_of({name: 'David'}, {name: 'Mary'}).map(&:name)
+    end
+  end
+
+  if Rails.version >= '4'
+    test 'calling directly #any_of is deprecated in rails-4' do
+      assert_deprecated do
+        Author.any_of({name: 'David'}, {name: 'Mary'}).map(&:name)
+      end
+    end
   end
 end

data/test/{dummy → dummy_rails3}/log/development.log

@@ -89,3 +89,13 @@ Connecting to database specified by database.yml
    (288.7ms)  INSERT INTO "schema_migrations" (version) VALUES ('20130617173313')
    (289.4ms)  INSERT INTO "schema_migrations" (version) VALUES ('20130617172335')
 Connecting to database specified by database.yml
+Connecting to database specified by database.yml
+   (0.0ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.1ms)  select sqlite_version(*)
+   (273.6ms)  CREATE TABLE "authors" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "name" varchar(255), "created_at" datetime NOT NULL, "updated_at" datetime NOT NULL) 
+   (300.0ms)  CREATE TABLE "posts" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "title" varchar(255), "body" text, "author_id" integer, "type" varchar(255), "created_at" datetime NOT NULL, "updated_at" datetime NOT NULL) 
+   (324.0ms)  CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) 
+   (311.3ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.1ms)  SELECT version FROM "schema_migrations"
+   (277.6ms)  INSERT INTO "schema_migrations" (version) VALUES ('20130617173313')
+   (300.5ms)  INSERT INTO "schema_migrations" (version) VALUES ('20130617172335')