activerecord-where-any-of 1.0.5 → 1.1.3

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 2.3.1
+before_install:
+  - gem install bundler -v 1.12.5
+  - gem install activerecord -v '~> 3'
+  - gem install activerecord -v '~> 4'
+  - gem install activerecord -v '~> 5'
+script:
+  - rake spec:all
+addons:
+    code_climate:
+        repo_token: a778d31468c1d1c1376890f708b04c93c7cc0af521a15e91c9ba00e08cfeeaf0

data/README.md

@@ -1,16 +1,24 @@
-activerecord-where-any-of
-=========================
+# ActiveRecord where_any_of
 
-Description:
------------
+* README:         https://github.com/david-mccullars/activerecord-where-any-of
+* Documentation:  http://www.rubydoc.info/github/david-mccullars/activerecord-where-any-of
+* Bug Reports:    https://github.com/david-mccullars/activerecord-where-any-of/issues
+
+
+## Status
+
+[![Travis Build Status](https://travis-ci.org/david-mccullars/activerecord-where-any-of.svg?branch=master)](https://travis-ci.org/david-mccullars/activerecord-where-any-of)
+[![Code Climate](https://codeclimate.com/github/david-mccullars/activerecord-where-any-of/badges/gpa.svg)](https://codeclimate.com/github/david-mccullars/activerecord-where-any-of)
+
+
+## Description
 
 Provides a mechanism for OR'ing together one or more AREL relations.  Normally when
 one performs `SomeModel.where(condition_1).where(condition_2)`, the result is to AND
 those conditions together.  Unfortunately, there is no good way of OR'ing them without
 converting the conditions into manual SQL.  This mixin addresses that issue.
 
-Usage:
-------
+## Usage
 
 `where_any_of` accepts any number of relations, symbols, or strings.  For symbols and strings,
 the corresponding method is called (unscoped) which is expected to return a relation.
@@ -60,8 +68,7 @@ puts SomeRecord.where_any_of(
 > SELECT "some_records".* FROM "some_records"
 > WHERE (extra is not null) AND ((("some_records"."extra" = 'A' OR "some_records"."owner" = 'Bill') OR "some_records"."active" = 't'))
 
-Install:
---------
+## Install
 
 In your app, add this line to your `Gemfile`:
 

data/Rakefile

@@ -1 +1,30 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+module WithoutBundler
+  def run_task(*args)
+    Bundler.with_clean_env do
+      ENV['ACTIVE_RECORD_VERSION'] = $1 if name.to_s =~ /active_record_(\d+)/
+      super
+    end
+  end
+end
+
+RSpec::Core::RakeTask.prepend(WithoutBundler)
+
+namespace :spec do
+  tasks = [3, 4, 5].map do |version|
+    name = "active_record_#{version}"
+    RSpec::Core::RakeTask.new(name).rspec_opts = '-O spec/spec.opts'
+    name
+  end
+
+  desc "Run specs against all three versions of ActiveRecord"
+  task all: tasks
+end
+
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.md"
+  rdoc.rdoc_files.include("README.md", "lib/**/*.rb")
+end

data/activerecord-where-any-of.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |s|
   s.name = 'activerecord-where-any-of'
-  s.version = '1.0.5'
+  s.version = '1.1.3'
   s.license = 'MIT'
-  s.date = '2014-07-24'
+  s.date = '2020-06-25'
   s.summary = 'A simple mixin to ActiveRecord::Base that allows use of OR arel relations.'
-  s.description = '...'
+  s.description = 'Should work in Rails 3, 4, & 5.  However, in Rails 5 use of #or is prefered.'
   s.description = File.read(File.expand_path('../README.md', __FILE__))[/Description:\n-+\s*(.*?)\n\n/m, 1]
   s.authors = ['David McCullars']
   s.email = ['david.mccullars@gmail.com']
@@ -15,4 +15,6 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'activerecord', '>= 3.0'
   s.add_development_dependency 'bundler', '>= 1.3'
   s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'sqlite3'
 end

data/lib/active_record/where-any-of-mixin-rails-5.rb

@@ -0,0 +1,62 @@
+# Rails 5+ mixin
+module ActiveRecord
+  module WhereAnyOfMixin
+
+    INVALID_RELATION_VALUES = %i[
+      eager_load
+      group
+      union_ordering
+      union
+      unscope
+      window
+      with
+    ]
+
+    RELATION_VALUES_TO_COPY = %i[
+      includes
+      joined_includes
+      joins
+      left_outer_joins
+      preload
+      references
+    ]
+
+    def where_any_of(*conditions)
+      # Rails 5 comes with an #or method for relations, so we can just use that
+      # It is advised that once on Rails 5, this gem should be removed.
+
+      # Do our best to preserve joins from the conditions into the outer relation
+      values_to_copy = {}
+
+      conditions = conditions.map do |c|
+        c = self.unscoped.send(c) if c.is_a? Symbol or c.is_a? String
+        raise ArgumentError, "Unsupported argument type: #{c.class.name}" unless c.is_a?(ActiveRecord::Relation)
+
+        INVALID_RELATION_VALUES.each do |m|
+          raise ArgumentError, "Unsupported condition contains #{m} values" if c.send("#{m}_values").present?
+        end
+
+        RELATION_VALUES_TO_COPY.each do |m|
+          values = c.send("#{m}_values").presence or next
+          values_to_copy[m] ||= []
+          values_to_copy[m].concat(values)
+        end
+
+        # Only preserve the where clause of the condition
+        c2 = ActiveRecord::Relation.new(c.klass)
+        c2.where_clause = c.where_clause
+        c2
+      end
+
+      if conditions.empty?
+        all.none
+      else
+        all_with_copied_values = values_to_copy.reduce(all) do |s, (key, values)|
+          s.send(key, values)
+        end
+        all_with_copied_values.merge conditions.reduce(:or)
+      end
+    end
+
+  end
+end

data/lib/active_record/where-any-of-mixin.rb

@@ -1,16 +1,36 @@
+# Rails 4+ mixin
 module ActiveRecord
   module WhereAnyOfMixin
 
     def where_any_of(*conditions)
       # Takes any number of scopes and OR them together
       # into a new scope which can be combined with other scopes
+      bind_values = []
       conditions = conditions.map do |c|
         if c.is_a? Symbol or c.is_a? String
           c = self.unscoped.send(c)
         end
-        c.where_values.reduce(:and)
+        bind_values.concat(c.bind_values)
+        __convert_string_wheres(c.where_values).reduce(:and)
+      end
+      if conditions.empty?
+        respond_to?(:none) ? none : where('1=0')
+      else
+        s = where(conditions.reduce(:or))
+        s.bind_values += bind_values if bind_values.present?
+        s
+      end
+    end
+
+    def __convert_string_wheres(wheres)
+      wheres.map do |w|
+        if w.is_a?(Arel::Nodes::Equality)
+          w
+        else
+          w = Arel.sql(w) if String === w
+          Arel::Nodes::Grouping.new(w)
+        end
       end
-      where(conditions.reduce(:or))
     end
 
   end

data/lib/activerecord-where-any-of.rb

@@ -1,3 +1,7 @@
 require 'active_record'
-require 'active_record/where-any-of-mixin'
+if ActiveRecord::VERSION::MAJOR >= 5
+  require 'active_record/where-any-of-mixin-rails-5'
+else
+  require 'active_record/where-any-of-mixin'
+end
 ActiveRecord::Base.send(:extend, ActiveRecord::WhereAnyOfMixin)

data/spec/lib/activerecord_where_any_of_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'activerecord-where-any-of'
+
+describe 'where_any_of' do
+
+  subject { ExampleModel }
+
+  let(:lparen) do
+    '(' if ActiveRecord::VERSION::MAJOR <= 3
+  end
+
+  let(:rparen) do
+    ')' if ActiveRecord::VERSION::MAJOR <= 3
+  end
+
+  describe '(*relations)' do
+
+    let(:relation) do
+      subject.where_any_of(
+        subject.active.on_shelf('h'),
+        subject.inactive.recent,
+        subject.with_name('apple'),
+      )
+    end
+
+    specify :count do
+      expect(relation.count).to eq(6)
+    end
+
+    specify :first do
+      m = relation.first
+      expect(m.id).to eq(1)
+      expect(m.name).to eq('apple')
+    end
+
+    specify :to_sql do
+      expect(relation.to_sql).to match_ignoring_whitespace(<<-END)
+        SELECT "example_models".*
+        FROM "example_models"
+        WHERE #{lparen}((
+             "example_models"."active" = 't' AND (name LIKE 'h%')
+          OR "example_models"."active" = 'f' AND (created_at > '2016-11-01'))
+          OR "example_models"."name" = 'apple'
+        )#{rparen}
+      END
+    end
+
+    specify :group_count do
+      expect(relation.group(:active).count).to match(true => 2, false => 4)
+    end
+
+    specify :order_limit do
+      expect(relation.order('updated_at DESC').limit(2).pluck(:name)).to eq [
+        "historiette boxthorn quinaldine",
+        "slipcase diorthotic holocentrid plessimetry prestudiously",
+      ]
+    end
+
+  end
+
+  describe "(:symbol, 'string', relation)" do
+
+    let(:relation) do
+      subject.where('name <> ?', 'bad').where_any_of(
+        :recent,
+        'active',
+        subject.on_shelf('z'),
+      )
+    end
+
+    specify :count do
+      expect(relation.count).to eq(38)
+    end
+
+    specify :merge_and_count do
+      expect(relation.merge(subject.inactive).count).to eq(4)
+    end
+
+    specify :to_sql do
+      expect(relation.to_sql).to match_ignoring_whitespace(<<-END)
+        SELECT "example_models".*
+        FROM "example_models"
+        WHERE (name <> 'bad') AND #{lparen}((
+             (created_at > '2016-11-01')
+          OR "example_models"."active" = 't')
+          OR (name LIKE 'z%')
+        )#{rparen}
+      END
+    end
+
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--format progress

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |f| require f }

data/spec/support/active_record.rb

@@ -0,0 +1,10 @@
+version = ENV.fetch('ACTIVE_RECORD_VERSION', '3.0').to_f
+raise "Unsupported ActiveRecord version #{version.inspect}" unless version >= 3.0 && version < 6.0
+gem 'activerecord', "~> #{version}"
+
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  adapter:  'sqlite3',
+  database: File.expand_path('../../database.sqlite3', __FILE__),
+)

data/spec/support/example_model.rb

@@ -0,0 +1,23 @@
+class ExampleModel < ActiveRecord::Base
+
+  def self.with_name(name)
+    where(name: name)
+  end
+
+  def self.on_shelf(letter)
+    letter =~ /\A[a-z]\z/i ? where("name LIKE '#{letter}%'") : where('1=0')
+  end
+
+  def self.active
+    where(active: true)
+  end
+
+  def self.inactive
+    where(active: false)
+  end
+
+  def self.recent
+    where('created_at > ?', Date.parse('2016-11-01'))
+  end
+
+end

data/spec/support/match_ignoring_whitespace.rb

@@ -0,0 +1,18 @@
+RSpec::Matchers.define :match_ignoring_whitespace do |expected|
+  match do |actual|
+    expected.to_s.gsub(/\s/, '') == actual.to_s.gsub(/\s/, '')
+  end
+
+  failure_message do |actual|
+    sep = '=' * 80
+    <<-END
+#{sep}
+Expected:
+#{expected.to_s.strip}
+#{sep}
+Actual:
+#{actual.to_s.strip}
+#{sep}
+    END
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-where-any-of
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.3
 platform: ruby
 authors:
 - David McCullars
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-24 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -52,25 +52,60 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: |-
-  Provides a mechanism for OR'ing together one or more AREL relations.  Normally when
-  one performs `SomeModel.where(condition_1).where(condition_2)`, the result is to AND
-  those conditions together.  Unfortunately, there is no good way of OR'ing them without
-  converting the conditions into manual SQL.  This mixin addresses that issue.
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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'
+description: ''
 email:
 - david.mccullars@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - activerecord-where-any-of.gemspec
+- lib/active_record/where-any-of-mixin-rails-5.rb
 - lib/active_record/where-any-of-mixin.rb
 - lib/activerecord-where-any-of.rb
+- spec/database.sqlite3
+- spec/lib/activerecord_where_any_of_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/support/active_record.rb
+- spec/support/example_model.rb
+- spec/support/match_ignoring_whitespace.rb
 homepage: 
 licenses:
 - MIT
@@ -91,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: A simple mixin to ActiveRecord::Base that allows use of OR arel relations.