where_lower 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f84a4041a532127bb4bb9117fc11ecda4992f7ff
-  data.tar.gz: 51596a49ea5ee3f71eb6e375bc26562d90a4bf8a
+  metadata.gz: 563ea05e5d3855494dd93009c36748bd8d14356b
+  data.tar.gz: fe1e5b16a0a68258161ef14c4bd5c7553180ff3e
 SHA512:
-  metadata.gz: 9bdd4d235dfa5ff8e92b2e59877c6a1cafd7f29d1fa50d6dced92e72aceab149a0f55b5d24058992e4adf38ff65f98bd9ea6289d783d391ad3dacb3faee4fa3e
-  data.tar.gz: 077019dc9f7008c13fab4cc2975e259fbcb2d17eb5f3d56dfcc744e0bf065b4705c38d6c333d91c8ba505b2b8038001a0b43515c3207f3577a816730a110279a
+  metadata.gz: 9b9d6ff276b6223929801b1d29da190c1b71ecf02dcaf68d6cf5abeceb66de2cbae3c1c80898b17cb66223962a17b89ceb11a0a03bdde105e4ab560d15d13d8d
+  data.tar.gz: e2a2b9c8b334f8ce163e7fb23f44278e33d6e058182760ff596714f75f93f49ae840770169ba562a02a1e3e0683b609c4e7d3679fdae286218e54f3f3257d939

data/.travis.yml

@@ -1,8 +1,9 @@
-script: "bundle exec rspec"
+before_install: "gem install bundler -v=1.5.2"
 rvm:
   - 1.9.2
   - 1.9.3
   - 2.0.0
+  - 2.1.0
 gemfile:
   - gemfiles/rails3_1.gemfile
   - gemfiles/rails3_2.gemfile

data/Appraisals

@@ -5,11 +5,11 @@ appraise "rails3-1" do
 end
 
 appraise "rails3-2" do
-  version = "3.2.14"
+  version = "3.2.16"
   gem 'activerecord', version
 end
 
 appraise "rails4-0" do
-  version = "4.0.0"
+  version = "4.0.2"
   gem 'activerecord', version
 end

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+### Changelog
+
+
+- **0.3.0**
+  - Add: You can now pass a nested hash for associaiton conditions (see README)
+  - Change: Now it requires at least ruby 1.9.2
+
+- **0.2.0**
+  - Fix: You can now use this with named scopes
+  - Change: Use dynamic query string instead of Arel Table to generate relation (which cause the bug)
+  - Dev: Add a few test for compatibility with gem `squeel`
+
+- **0.1.0**
+  - Initail Release

data/Gemfile

@@ -1,11 +1,3 @@
 source 'https://rubygems.org'
-gemspec
 
-gem 'activerecord'
-gem 'squeel'
-gem 'appraisal'
-gem 'rake'
-gem 'sqlite3'
-gem 'rspec'
-gem 'database_cleaner'
-gem 'coveralls', require: false
+gemspec

data/README.md

@@ -32,6 +32,18 @@ Other types will not be touched
 SomeActiveRecordClass.where_lower(attribute1: 'AbC', attribute2: ['stRing', 123, :symBol], attribute3: ('AA'..'AZ'))
 ```
 
+Since `0.3.0`  
+You can pass a nested hash (1 level deep only) for association condition
+```ruby
+record.association_records.where_lower(association_table: {association_column: value})
+```
+
+You can also add table name in key if you are using it with association  
+I don't plan to support any "smart" table guessing though
+```ruby
+record.association_records.where_lower('association_table.association_column' => value)
+```
+
 Contributors
 ============
 [Matthew Rudy Jacobs](https://github.com/matthewrudy) (Who wrote the first version of `where_lower` method)

data/Rakefile

@@ -1,11 +1,15 @@
-require 'appraisal'
-require 'rubygems'
-require 'bundler/setup'
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
+require "appraisal"
+require "bundler"
+require "rspec/core/rake_task"
 
-task :default do
-  sh "rake appraisal:install && rake appraisal spec"
-end
+Bundler::GemHelper.install_tasks
 
 RSpec::Core::RakeTask.new(:spec)
+
+if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
+  task :default do
+    sh "rake appraisal:install && rake appraisal spec"
+  end
+else
+  task :default => :spec
+end

data/gemfiles/rails3_1.gemfile

@@ -2,13 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "squeel"
-gem "appraisal"
-gem "rake"
-gem "sqlite3"
-gem "rspec"
-gem "database_cleaner"
-gem "coveralls", :require=>false
 gem "activerecord", "3.1.12"
 
 gemspec :path=>"../"

data/gemfiles/rails3_2.gemfile

@@ -2,13 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "squeel"
-gem "appraisal"
-gem "rake"
-gem "sqlite3"
-gem "rspec"
-gem "database_cleaner"
-gem "coveralls", :require=>false
-gem "activerecord", "3.2.14"
+gem "activerecord", "3.2.16"
 
 gemspec :path=>"../"

data/gemfiles/rails4_0.gemfile

@@ -2,13 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "squeel"
-gem "appraisal"
-gem "rake"
-gem "sqlite3"
-gem "rspec"
-gem "database_cleaner"
-gem "coveralls", :require=>false
-gem "activerecord", "4.0.0"
+gem "activerecord", "4.0.2"
 
 gemspec :path=>"../"

data/lib/where_lower/active_record_extension.rb

@@ -0,0 +1,19 @@
+module WhereLower
+  module ActiveRecordExtension
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def where_lower(fields)
+        fields.is_a?(Hash) or raise AugumentError, 'fields is not a Hash'
+
+        WhereLower::Base.spawn_lower_scope(self, fields)
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include ::WhereLower::ActiveRecordExtension
+end

data/lib/where_lower/base.rb

@@ -0,0 +1,29 @@
+module WhereLower
+  SEPERATOR = '.'.freeze
+
+  class TooDeepNestedConditions < ArgumentError; end
+
+  module Base
+    class << self
+      # @params [ActiveRecord::Relation, ActiveRecord::Base] scope
+      # @params [Hash] fields
+      def spawn_lower_scope(scope, fields)
+        fields.inject(scope) do |new_scope, (name, value)|
+          spawn_lower_scope_by_type(new_scope, name, value)
+        end
+      end
+
+      # @params [ActiveRecord::Relation, ActiveRecord::Base] scope
+      # @params [String, Symbol] column_or_table_name When used with nested hash, this is table name
+      # @params [Object] value
+      # @params [String, Symbol] prefix used when doing recursive call
+      #
+      # @raise [TooDeepNestedConditions] if the conditions hash has is too deep nested
+      #
+      # @return [ActiveRecord::Relation]
+      def spawn_lower_scope_by_type(scope, column_or_table_name, value)
+        ScopeSpawner.spawn(scope, column_or_table_name, value)
+      end
+    end
+  end
+end

data/lib/where_lower/scope_spawner.rb

@@ -0,0 +1,107 @@
+module WhereLower
+  class ScopeSpawner
+    attr_reader :scope, :column_or_table_name, :value, :prefix
+
+    def self.spawn(*args)
+      new(*args).spawn
+    end
+
+    def initialize(scope, column_or_table_name, value, prefix = nil)
+      @scope, @column_or_table_name, @value, @prefix = scope, column_or_table_name, value, prefix
+    end
+
+    def scope_arguments
+      [scope, column_or_table_name, value, prefix]
+    end
+
+    # acts as factory
+    def spawn
+      case value
+      when Hash
+        HashScopeSpawner.spawn(*scope_arguments)
+      when String
+        StringScopeSpawner.spawn(*scope_arguments)
+      when Range
+        RangeScopeSpawner.spawn(*scope_arguments)
+      when Array
+        ArrayScopeSpawner.spawn(*scope_arguments)
+      else
+        BasicScopeSpawner.spawn(*scope_arguments)
+      end
+    end
+
+
+    private
+
+    class BasicScopeSpawner < ScopeSpawner
+      def spawn
+        scope.where(column_name => value)
+      end
+
+      private
+
+      def column_name
+        [prefix, column_or_table_name].compact.join(SEPERATOR)
+      end
+    end
+
+    # @abstract
+    class EqualScopeSpawner < BasicScopeSpawner
+      def spawn
+        scope.where(query_string, processed_value)
+      end
+
+      private
+
+      def query_string
+        "#{column_name} = ?"
+      end
+
+      def processed_value
+        value
+      end
+    end
+
+    class StringScopeSpawner < EqualScopeSpawner
+      def query_string
+        "lower(#{column_name}) = ?"
+      end
+
+      def processed_value
+        value.downcase
+      end
+    end
+
+    class RangeScopeSpawner < EqualScopeSpawner
+      def query_string
+        "lower(#{column_name}) IN (?)"
+      end
+
+      def processed_value
+        Range.new(value.begin.to_s.downcase, value.end.to_s.downcase, value.exclude_end?)
+      end
+    end
+
+    class ArrayScopeSpawner < EqualScopeSpawner
+      def query_string
+        "lower(#{column_name}) IN (?)"
+      end
+
+      def processed_value
+        value.to_a.map {|x| x.to_s.downcase}
+      end
+    end
+
+    class HashScopeSpawner < BasicScopeSpawner
+      def spawn
+        # If prefix already exists, that means we are in association table already, which cannot accept another hash
+        # This gem has no ability to handle deep nested associaiton reflection yet
+        raise TooDeepNestedConditions unless prefix.nil?
+
+        value.inject(scope) do |new_scope, (column_name, column_value)|
+          ScopeSpawner.spawn(new_scope, column_name, column_value, column_or_table_name)
+        end
+      end
+    end
+  end
+end

data/lib/where_lower/version.rb

@@ -1,3 +1,3 @@
 module WhereLower
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.3.0'
 end

data/lib/where_lower.rb

@@ -1,5 +1,5 @@
 require 'active_record'
 require 'where_lower/version'
-require 'where_lower/core'
-
-ActiveRecord::Base.send(:include, WhereLower::Core)
+require 'where_lower/base'
+require 'where_lower/scope_spawner'
+require 'where_lower/active_record_extension'

data/spec/spec_helper.rb

@@ -1,11 +1,11 @@
-require 'coveralls'
-Coveralls.wear!('rails')
+if ENV["TRAVIS"]
+  require 'coveralls'
+  Coveralls.wear!('rails')
+end
 
 require 'active_record'
 require 'where_lower'
 
-require 'squeel'
-
 require 'database_cleaner'
 require 'logger'
 
@@ -36,13 +36,13 @@ ActiveRecord::Schema.define(:version => 1) do
   create_table :parents do |t|
     t.string :name
     t.text :description
-    t.integer :age, null: false, default: 21
+    t.integer :age, null: false, default: 0
     t.boolean :is_minecraft_lover, default: true
 
     t.timestamps
   end
 
-  create_table :chirdren do |t|
+  create_table :children do |t|
     t.string :name
     t.text :description
     t.integer :age, null: false, default: 0
@@ -52,6 +52,17 @@ ActiveRecord::Schema.define(:version => 1) do
 
     t.timestamps
   end
+
+  create_table :grand_children do |t|
+    t.string :name
+    t.text :description
+    t.integer :age, null: false, default: 0
+    t.boolean :is_minecraft_lover, default: true
+
+    t.integer :child_id
+
+    t.timestamps
+  end
 end
 
 class ActiveRecord::Base
@@ -66,8 +77,20 @@ class Parent < ActiveRecord::Base
   has_many :children, inverse_of: :parent
 
   scope :latest_first, proc { order('created_at DESC') }
+  def self.earliest_first
+    order(:created_at)
+  end
 end
 
 class Child < ActiveRecord::Base
   belongs_to :parent, inverse_of: :children, touch: true
+  has_many :grand_children, inverse_of: :child
+
+  validates_presence_of :parent
+end
+
+class GrandChild < ActiveRecord::Base
+  belongs_to :child, inverse_of: :grand_children, touch: true
+
+  validates_presence_of :child
 end

data/spec/where_lower_spec.rb

@@ -6,11 +6,28 @@ describe WhereLower do
   let(:parent_name2) { 'Parent #10' }
   let(:parent_name3) { 'Parent #20' }
   let(:parent_description) { 'I need a Medic!' }
-  let(:parent_description2) { 'I need a Pokemon!' }
+  let(:parent_description2) { 'I need a Job!' }
+
+  let(:child_name) { 'Child' }
+  let(:child_name2) { 'Child #10' }
+  let(:child_name3) { 'Child #20' }
+  let(:child_description) { 'I need a Power Ranger!' }
+  let(:child_description2) { 'I need a Pokemon!' }
+
+  let(:grand_child_name) { 'Grand Child' }
+  let(:grand_child_name2) { 'Grand Child #10' }
 
   let!(:parent) do
     Parent.create!(name: parent_name, description: parent_description,
-        age: 40, is_minecraft_lover: false, created_at: 1.day.ago)
+        age: 40, is_minecraft_lover: false, created_at: 40.years.ago)
+  end
+  let!(:child) do
+    Child.create!(name: child_name, description: child_description,
+        age: 18, is_minecraft_lover: true, created_at: 18.years.ago, parent: parent)
+  end
+  let!(:grand_child) do
+    GrandChild.create!(name: grand_child_name, description: child_description,
+        age: 1, is_minecraft_lover: false, created_at: 1.year.ago, child: child)
   end
 
   describe 'finding records with condition(s) for columns inside the model table' do
@@ -59,8 +76,8 @@ describe WhereLower do
             Parent.where_lower(name: ('Parenu'..'Parenv')).should be_empty
           end
           it 'works like where case insensitively' do
-            Parent.where_lower(name: (('Parens'.downcase)..('Parenu'.downcase))).should_not be_empty
-            Parent.where_lower(name: (('Parenu'.downcase)..('Parenv'.downcase))).should be_empty
+            Parent.where_lower(name: (('Parens'.swapcase)..('Parenu'.swapcase))).should_not be_empty
+            Parent.where_lower(name: (('Parenu'.swapcase)..('Parenv'.swapcase))).should be_empty
           end
         end
 
@@ -120,7 +137,7 @@ describe WhereLower do
           it 'can be chained with where' do
             Parent.where_lower(name: parent_name).where(description: parent_description).should_not be_empty
           end
-          
+
           it 'can be chained with where_lower' do
             Parent.where_lower(name: parent_name).where_lower(description: parent_description).should_not be_empty
           end
@@ -133,15 +150,8 @@ describe WhereLower do
           it 'can be chained with name scope' do
             Parent.where_lower(name: parent_name).latest_first.should_not be_empty
           end
-
-
-          it 'can be chained with where in squeel' do
-            description_value = parent_description
-            Parent.where_lower(name: parent_name).where{description.eq description_value}.should_not be_empty
-          end
-
-          it 'can be chained with order in squeel' do
-            Parent.where_lower(name: parent_name).order{description}.should_not be_empty
+          it 'can be chained with class method scope' do
+            Parent.where_lower(name: parent_name).earliest_first.should_not be_empty
           end
         end
       end
@@ -150,27 +160,345 @@ describe WhereLower do
     describe 'finding record using non string columns' do
       describe 'with type integer' do
         before do
-          Parent.where(age: 40).should_not be_empty
-          Parent.where(age: 41).should be_empty
+          Parent.where(age: parent.age).should_not be_empty
+          Parent.where(age: parent.age + 1).should be_empty
         end
 
         it 'works like where' do
-          Parent.where_lower(age: 40).should_not be_empty
-          Parent.where_lower(age: 41).should be_empty
+          Parent.where_lower(age: parent.age).should_not be_empty
+          Parent.where_lower(age: parent.age + 1).should be_empty
         end
       end
 
       describe 'with type boolean' do
         before do
-          Parent.where(is_minecraft_lover: false).should_not be_empty
-          Parent.where(is_minecraft_lover: true).should be_empty
+          Parent.where(is_minecraft_lover: parent.is_minecraft_lover).should_not be_empty
+          Parent.where(is_minecraft_lover: !parent.is_minecraft_lover).should be_empty
         end
 
         it 'works like where' do
-          Parent.where_lower(is_minecraft_lover: false).should_not be_empty
-          Parent.where_lower(is_minecraft_lover: true).should be_empty
+          Parent.where_lower(is_minecraft_lover: parent.is_minecraft_lover).should_not be_empty
+          Parent.where_lower(is_minecraft_lover: !parent.is_minecraft_lover).should be_empty
         end
       end
     end
   end
+
+  describe 'finding records with condition(s) for columns outside the model table' do
+    describe 'using string as hash key' do
+      describe 'finding record using string column' do
+        describe 'with type string' do
+          before do
+            Parent.joins(:children).where('children.name' => child_name).should_not be_empty
+            Parent.joins(:children).where('children.name' => child_name2).should be_empty
+          end
+
+          it 'works like where' do
+            Parent.joins(:children).where_lower('children.name' => child_name).should_not be_empty
+            Parent.joins(:children).where_lower('children.name' => child_name2).should be_empty
+          end
+          it 'works like where case insensitively' do
+            Parent.joins(:children).where_lower('children.name' => child_name.swapcase).should_not be_empty
+            Parent.joins(:children).where_lower('children.name' => child_name2.swapcase).should be_empty
+          end
+        end
+
+        describe 'with type text' do
+          before do
+            Parent.joins(:children).where('children.description' => child_description).should_not be_empty
+            Parent.joins(:children).where('children.description' => child_description2).should be_empty
+          end
+
+          it 'works like where' do
+            Parent.joins(:children).where_lower('children.description' => child_description).should_not be_empty
+            Parent.joins(:children).where_lower('children.description' => child_description2).should be_empty
+          end
+          it 'works like where case insensitively' do
+            Parent.joins(:children).where_lower('children.description' => child_description.swapcase).should_not be_empty
+            Parent.joins(:children).where_lower('children.description' => child_description2.swapcase).should be_empty
+          end
+        end
+
+        describe 'with different types of values in conditions' do
+          describe 'with Range' do
+            before do
+              Parent.joins(:children).where('children.name' => ('Chilc'..'Chile')).should_not be_empty
+              Parent.joins(:children).where('children.name' => ('Chile'..'Chilf')).should be_empty
+            end
+
+            it 'works like where' do
+              Parent.joins(:children).where_lower('children.name' => ('Chilc'..'Chile')).should_not be_empty
+              Parent.joins(:children).where_lower('children.name' => ('Chile'..'Chilf')).should be_empty
+            end
+            it 'works like where case insensitively' do
+              Parent.joins(:children).where_lower('children.name' => (('Chilc'.swapcase)..('Chile'.swapcase))).should_not be_empty
+              Parent.joins(:children).where_lower('children.name' => (('Chile'.swapcase)..('Chilf'.swapcase))).should be_empty
+            end
+          end
+
+          describe 'with Array' do
+            before do
+              Parent.joins(:children).where('children.name' => [child_name, child_name2]).should_not be_empty
+              Parent.joins(:children).where('children.name' => [child_name2, child_name3]).should be_empty
+            end
+
+            it 'works like where' do
+              Parent.joins(:children).where_lower('children.name' => [child_name, child_name2]).should_not be_empty
+              Parent.joins(:children).where_lower('children.name' => [child_name2, child_name3]).should be_empty
+              Parent.joins(:children).where_lower('children.name' => []).should be_empty
+            end
+            it 'works like where case insensitively' do
+              Parent.joins(:children).where_lower('children.name' => [child_name.swapcase, child_name2.swapcase]).should_not be_empty
+              Parent.joins(:children).where_lower('children.name' => [child_name2.swapcase, child_name3.swapcase]).should be_empty
+              Parent.joins(:children).where_lower('children.name' => []).should be_empty
+            end
+          end
+
+          describe 'with nil' do
+            context 'when record with nil value does not exist' do
+              before do
+                Parent.joins(:children).where('children.name' => nil).should be_empty
+              end
+
+              it 'works like where' do
+                Parent.joins(:children).where_lower('children.name' => nil).should be_empty
+              end
+            end
+            context 'when record with nil value does exist' do
+              before do
+                Child.create!(name: nil, parent: parent)
+              end
+
+              before do
+                Parent.joins(:children).where('children.name' => nil).should_not be_empty
+              end
+
+              it 'works like where' do
+                Parent.joins(:children).where_lower('children.name' => nil).should_not be_empty
+              end
+            end
+          end
+
+          describe 'with query injection' do
+            it 'prevents injection' do
+              expect do
+                Parent.joins(:children).where_lower('children.name' => "'); truncate table parents")
+              end.to_not change(Child, :count)
+            end
+          end
+
+
+          describe 'with chaining' do
+            it 'can be chained with where' do
+              Parent.joins(:children).where_lower('children.name' => child_name).where('children.description' => child_description).should_not be_empty
+            end
+
+            it 'can be chained with where_lower' do
+              Parent.joins(:children).where_lower('children.name' => child_name).where_lower('children.description' => child_description).should_not be_empty
+            end
+
+            it 'can be chained with order' do
+              Parent.joins(:children).where_lower('children.name' => child_name).order('children.description').should_not be_empty
+            end
+
+
+            it 'can be chained with name scope' do
+              Parent.joins(:children).where_lower('children.name' => child_name).latest_first.should_not be_empty
+            end
+            it 'can be chained with class method scope' do
+              Parent.joins(:children).where_lower('children.name' => child_name).earliest_first.should_not be_empty
+            end
+          end
+        end
+      end
+
+      describe 'finding record using non string columns' do
+        describe 'with type integer' do
+          before do
+            Parent.joins(:children).where('children.age' => child.age).should_not be_empty
+            Parent.joins(:children).where('children.age' => child.age + 1).should be_empty
+          end
+
+          it 'works like where' do
+            Parent.joins(:children).where_lower('children.age' => child.age).should_not be_empty
+            Parent.joins(:children).where_lower('children.age' => child.age + 1).should be_empty
+          end
+        end
+
+        describe 'with type boolean' do
+          before do
+            Parent.joins(:children).where('children.is_minecraft_lover' => child.is_minecraft_lover).should_not be_empty
+            Parent.joins(:children).where('children.is_minecraft_lover' => !child.is_minecraft_lover).should be_empty
+          end
+
+          it 'works like where' do
+            Parent.joins(:children).where_lower('children.is_minecraft_lover' => child.is_minecraft_lover).should_not be_empty
+            Parent.joins(:children).where_lower('children.is_minecraft_lover' => !child.is_minecraft_lover).should be_empty
+          end
+        end
+      end
+    end
+
+    describe 'using nested hash' do
+      describe 'finding record using string column' do
+        describe 'with type string' do
+          before do
+            Parent.joins(:children).where(children: {name: child_name}).should_not be_empty
+            Parent.joins(:children).where(children: {name: child_name2}).should be_empty
+          end
+
+          it 'works like where' do
+            Parent.joins(:children).where_lower(children: {name: child_name}).should_not be_empty
+            Parent.joins(:children).where_lower(children: {name: child_name2}).should be_empty
+          end
+          it 'works like where case insensitively' do
+            Parent.joins(:children).where_lower(children: {name: child_name.swapcase}).should_not be_empty
+            Parent.joins(:children).where_lower(children: {name: child_name2.swapcase}).should be_empty
+          end
+        end
+
+        describe 'with type text' do
+          before do
+            Parent.joins(:children).where(children: {description: child_description}).should_not be_empty
+            Parent.joins(:children).where(children: {description: child_description2}).should be_empty
+          end
+
+          it 'works like where' do
+            Parent.joins(:children).where_lower(children: {description: child_description}).should_not be_empty
+            Parent.joins(:children).where_lower(children: {description: child_description2}).should be_empty
+          end
+          it 'works like where case insensitively' do
+            Parent.joins(:children).where_lower(children: {description: child_description.swapcase}).should_not be_empty
+            Parent.joins(:children).where_lower(children: {description: child_description2.swapcase}).should be_empty
+          end
+        end
+
+        describe 'with different types of values in conditions' do
+          describe 'with Range' do
+            before do
+              Parent.joins(:children).where(children: {name: ('Chilc'..'Chile')}).should_not be_empty
+              Parent.joins(:children).where(children: {name: ('Chile'..'Chilf')}).should be_empty
+            end
+
+            it 'works like where' do
+              Parent.joins(:children).where_lower(children: {name: ('Chilc'..'Chile')}).should_not be_empty
+              Parent.joins(:children).where_lower(children: {name: ('Chile'..'Chilf')}).should be_empty
+            end
+            it 'works like where case insensitively' do
+              Parent.joins(:children).where_lower(children: {name: (('Chilc'.swapcase)..('Chile'.swapcase))}).should_not be_empty
+              Parent.joins(:children).where_lower(children: {name: (('Chile'.swapcase)..('Chilf'.swapcase))}).should be_empty
+            end
+          end
+
+          describe 'with Array' do
+            before do
+              Parent.joins(:children).where(children: {name: [child_name, child_name2]}).should_not be_empty
+              Parent.joins(:children).where(children: {name: [child_name2, child_name3]}).should be_empty
+            end
+
+            it 'works like where' do
+              Parent.joins(:children).where_lower(children: {name: [child_name, child_name2]}).should_not be_empty
+              Parent.joins(:children).where_lower(children: {name: [child_name2, child_name3]}).should be_empty
+              Parent.joins(:children).where_lower(children: {name: []}).should be_empty
+            end
+            it 'works like where case insensitively' do
+              Parent.joins(:children).where_lower(children: {name: [child_name.swapcase, child_name2.swapcase]}).should_not be_empty
+              Parent.joins(:children).where_lower(children: {name: [child_name2.swapcase, child_name3.swapcase]}).should be_empty
+              Parent.joins(:children).where_lower(children: {name: []}).should be_empty
+            end
+          end
+
+          describe 'with nil' do
+            context 'when record with nil value does not exist' do
+              before do
+                Parent.joins(:children).where(children: {name: nil}).should be_empty
+              end
+
+              it 'works like where' do
+                Parent.joins(:children).where_lower(children: {name: nil}).should be_empty
+              end
+            end
+            context 'when record with nil value does exist' do
+              before do
+                Child.create!(name: nil, parent: parent)
+              end
+
+              before do
+                Parent.joins(:children).where(children: {name: nil}).should_not be_empty
+              end
+
+              it 'works like where' do
+                Parent.joins(:children).where_lower(children: {name: nil}).should_not be_empty
+              end
+            end
+          end
+
+          describe 'with query injection' do
+            it 'prevents injection' do
+              expect do
+                Parent.joins(:children).where_lower(children: {name: "'); truncate table parents"})
+              end.to_not change(Child, :count)
+            end
+          end
+
+
+          describe 'with chaining' do
+            it 'can be chained with where' do
+              Parent.joins(:children).where_lower(children: {name: child_name}).where(children: {description: child_description}).should_not be_empty
+            end
+
+            it 'can be chained with where_lower' do
+              Parent.joins(:children).where_lower(children: {name: child_name}).where_lower(children: {description: child_description}).should_not be_empty
+            end
+
+            it 'can be chained with order' do
+              Parent.joins(:children).where_lower(children: {name: child_name}).order('children.description').should_not be_empty
+            end
+
+
+            it 'can be chained with name scope' do
+              Parent.joins(:children).where_lower(children: {name: child_name}).latest_first.should_not be_empty
+            end
+            it 'can be chained with class method scope' do
+              Parent.joins(:children).where_lower(children: {name: child_name}).earliest_first.should_not be_empty
+            end
+          end
+        end
+      end
+
+      describe 'finding record using non string columns' do
+        describe 'with type integer' do
+          before do
+            Parent.joins(:children).where(children: {age: child.age}).should_not be_empty
+            Parent.joins(:children).where(children: {age: child.age + 1}).should be_empty
+          end
+
+          it 'works like where' do
+            Parent.joins(:children).where_lower(children: {age: child.age}).should_not be_empty
+            Parent.joins(:children).where_lower(children: {age: child.age + 1}).should be_empty
+          end
+        end
+
+        describe 'with type boolean' do
+          before do
+            Parent.joins(:children).where(children: {is_minecraft_lover: child.is_minecraft_lover}).should_not be_empty
+            Parent.joins(:children).where(children: {is_minecraft_lover: !child.is_minecraft_lover}).should be_empty
+          end
+
+          it 'works like where' do
+            Parent.joins(:children).where_lower(children: {is_minecraft_lover: child.is_minecraft_lover}).should_not be_empty
+            Parent.joins(:children).where_lower(children: {is_minecraft_lover: !child.is_minecraft_lover}).should be_empty
+          end
+        end
+      end
+
+
+      describe 'with more than one level deep'
+        it 'raises error' do
+          expect do
+            Parent.joins(children: :grand_children).where_lower(children: {grand_children: {name: grand_child_name}})
+          end.to raise_error(WhereLower::TooDeepNestedConditions)
+        end
+    end
+  end
 end

data/where_lower.gemspec

@@ -1,8 +1,8 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
 
-author_name = 'PikachuEXE'
-gem_name = 'where_lower'
+author_name = "PikachuEXE"
+gem_name = "where_lower"
 
 require "#{gem_name}/version"
 
@@ -10,26 +10,32 @@ Gem::Specification.new do |s|
   s.platform      = Gem::Platform::RUBY
   s.name          = gem_name
   s.version       = WhereLower::VERSION
-  s.summary       = 'Provide an easy way to use case insensitive `where` in ActiveRecord.'
-  s.description   = 'ActiveRecord provides no method for case insensitive version of `where` method. So here is one. No longer need to use SQL fragment yeah!'
+  s.summary       = "Provide an easy way to use case insensitive `where` in ActiveRecord."
+  s.description   = "ActiveRecord provides no method for case insensitive version of `where` method. So here is one. No longer need to use SQL fragment yeah!"
 
-  s.license       = 'MIT'
+  s.license       = "MIT"
 
   s.authors       = [author_name]
-  s.email         = ['pikachuexe@gmail.com']
+  s.email         = ["pikachuexe@gmail.com"]
   s.homepage      = "http://github.com/#{author_name}/#{gem_name}"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ['lib']
+  s.require_paths = ["lib"]
 
-  s.add_dependency 'activerecord', '>= 3.1.0', '< 5.0.0'
+  s.add_dependency "activerecord", ">= 3.1.0", "< 5.0.0"
 
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'appraisal'
-  s.add_development_dependency 'squeel'
-  s.add_development_dependency 'sqlite3'
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'database_cleaner'
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rake", ">= 0.9.2"
+  s.add_development_dependency "appraisal", ">= 0.5.2"
+  s.add_development_dependency "rspec", "~> 2.6"
+  s.add_development_dependency "sqlite3", ">= 1.3"
+  s.add_development_dependency "database_cleaner", ">= 1.0"
+  s.add_development_dependency "coveralls", ">= 0.7"
+  s.add_development_dependency "gem-release", ">= 0.7"
+
+  s.required_ruby_version = ">= 1.9.2"
+
+  s.required_rubygems_version = ">= 1.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: where_lower
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - PikachuEXE
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-06 00:00:00.000000000 Z
+date: 2014-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -30,90 +30,118 @@ dependencies:
     - - <
       - !ruby/object:Gem::Version
         version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.2
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
 - !ruby/object:Gem::Dependency
-  name: squeel
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
 - !ruby/object:Gem::Dependency
-  name: database_cleaner
+  name: gem-release
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
 description: ActiveRecord provides no method for case insensitive version of `where`
   method. So here is one. No longer need to use SQL fragment yeah!
 email:
@@ -126,6 +154,7 @@ files:
 - .rspec
 - .travis.yml
 - Appraisals
+- CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
@@ -133,7 +162,9 @@ files:
 - gemfiles/rails3_2.gemfile
 - gemfiles/rails4_0.gemfile
 - lib/where_lower.rb
-- lib/where_lower/core.rb
+- lib/where_lower/active_record_extension.rb
+- lib/where_lower/base.rb
+- lib/where_lower/scope_spawner.rb
 - lib/where_lower/version.rb
 - spec/spec_helper.rb
 - spec/where_lower_spec.rb
@@ -150,15 +181,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.4.0
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.7
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: Provide an easy way to use case insensitive `where` in ActiveRecord.

data/lib/where_lower/core.rb

@@ -1,62 +0,0 @@
-module WhereLower
-  module Core
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      def where_lower(fields)
-        fields.is_a?(Hash) or raise AugumentError, 'fields is not a Hash'
-
-        spawn_lower_scope(fields)
-      end
-
-      private
-
-      def spawn_lower_scope(fields)
-        scope = self
-
-        fields.each do |name, value|
-          scope = spawn_lower_scope_by_type(scope, name, value)
-        end
-
-        scope
-      end
-
-      def spawn_lower_scope_by_type(scope, column_name, value)
-        case value
-        when Range
-          value = Range.new(value.begin.to_s.downcase, value.end.to_s.downcase, value.exclude_end?)
-          scope = scope.where(
-            lower_query_string(column_name, :in), value
-          )
-        when Array # Assume the content to be string, or can be converted to string
-          value = value.to_a.map {|x| x.to_s.downcase}
-          scope = scope.where(
-            lower_query_string(column_name, :in), value
-          )
-        when String
-          value = value.downcase
-          scope = scope.where(
-            lower_query_string(column_name), value
-          )
-        else # other single value classes
-          scope = scope.where(column_name => value)
-        end 
-
-        scope
-      end
-
-      # @param column_name [String/Symbol] name of column
-      # @param type [Symbol] :in or :eq
-      def lower_query_string(column_name, type = :eq)
-        case type
-        when :in
-          "lower(#{column_name}) IN (?)"
-        else #:eq
-          "lower(#{column_name}) = ?"
-        end
-      end
-    end
-  end
-end