where_conditioner 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2cbdd592512b031ccd2c5d372c5c523e2397d361
+  data.tar.gz: 33e5d99969813c2ec9bb10e986f62e96a79b27b7
+SHA512:
+  metadata.gz: dbcb4cc8993e3188161690f895a3ac38ac39212172370b8d656fd6290de211e3026a704036c0ad2188537ab9e540d685bda2b8f55145cc1509ad60c34a5fb806
+  data.tar.gz: fa8d21e6d95897283363f2713d17c0b37815c6b3d51895879658859ca4aa82e53c03b0870db63a1f171c57685b3395725a27e4d53912776aa46fc9a39f032a44

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Amitree
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,119 @@
+where\_conditioner
+==================
+
+Here at Amitree, we've found that some of our controllers end up with a lot of
+duplication stemming from the fact that `where` is being invoked conditionally:
+
+```ruby
+purchases = Purchase.all
+purchases = purchases.where('start_date > ?', params[:start_date])
+  if params[:start_date].present?
+```
+
+The **where\_conditioner** gem allows us to write more simply:
+
+```ruby
+purchases = Purchase.all
+  .where_if_present('start_date > ?', params[:start_date])
+```
+
+See more details on our blog: [http://thesource.amitree.com/2014/04/where-conditioner.html](http://thesource.amitree.com/2014/04/where-conditioner.html).
+
+Installation
+-----
+
+Simply add to your Gemfile:
+
+```ruby
+gem 'where_conditioner'
+```
+
+Usage
+----
+
+### where\_if\_present
+
+#### ...with a parameterized SQL string
+
+Apply the conditions if **all** parameters are non-`nil`:
+
+```ruby
+start_date = Date.yesterday
+end_date = nil
+Purchase.all.where_if_present('date BETWEEN ? and ?', start_date, end_date)
+ # => Purchase.all
+
+start_date = Date.yesterday
+end_date = Date.today
+Purchase.all.where_if_present('date BETWEEN ? and ?', start_date, end_date)
+ # => Purchase.where('date BETWEEN ? and ?', start_date, end_date)
+```
+
+#### ...with a hash
+
+Apply only those conditions where the value is non-`nil`:
+
+```ruby
+status = 'shipped'
+customer_id = nil
+Purchase.all.where_if_present(status: status, customer_id: customer_id)
+ # => Purchase.all.where(status: 'shipped')
+```
+
+### if
+
+```ruby
+show_pending = false
+Purchase.all
+  .if(!show_pending)
+    .where(status: 'shipped')
+ # => Purchase.all.where(status: 'shipped')
+
+show_pending = true
+Purchase.all
+  .if(!show_pending)
+    .where(status: 'shipped')
+ # => Purchase.all
+```
+
+### unless
+
+Like `if`, but the opposite! :)
+
+```ruby
+show_pending = false
+Purchase.all
+  .unless(show_pending)
+    .where(status: 'shipped')
+ # => Purchase.all.where(status: 'shipped')
+
+show_pending = true
+Purchase.all
+  .unless(show_pending)
+    .where(status: 'shipped')
+ # => Purchase.all
+```
+
+### else
+
+```ruby
+wacky_order = false
+Purchase.all
+  .if(wacky_order)
+    .order(customer_id: :desc)
+  .else
+    .order(:date)
+ # => Purchase.all.order(:date)
+```
+
+### Passing blocks
+
+If the result of a condition is more than one method call, you can pass in a
+block instead:
+
+```ruby
+recent = false
+Purchase.all
+  .if(recent) { where('date > ?', 30.days.ago).order(date: :desc) }
+  .else { where.not('date > ?', 30.days.ago).order(:date) }
+```

data/lib/where_conditioner.rb

@@ -0,0 +1,68 @@
+module WhereConditioner
+  class NullSink < BasicObject
+    def initialize obj
+      @obj = obj
+    end
+
+    def method_missing symbol, *args
+      @obj
+    end
+  end
+
+  extend ActiveSupport::Concern
+
+  def if condition, &block
+    @last_condition = condition
+    conditional @last_condition, &block
+  end
+
+  def unless condition, &block
+    self.if !condition, &block
+  end
+
+  def else &block
+    conditional !@last_condition, &block
+  end
+
+  def where_if_present *args    
+    if Hash === args.first && args.length == 1
+      hash = args.first.compact
+      if hash.present?
+        self.where hash
+      else
+        self
+      end
+    elsif String === args.first
+      unless args.include? nil
+        self.where *args
+      else
+        self
+      end
+    else
+      self.where *args
+    end
+  end
+
+private
+  def conditional condition, &block
+    if block_given?
+      if condition
+        self.instance_eval &block
+      else
+        self
+      end
+    else
+      if condition
+        self
+      else
+        NullSink.new(self)
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  class Relation
+    include WhereConditioner
+  end
+end

data/spec/lib/where_conditioner_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe WhereConditioner do
+  let(:relation) { ActiveRecord::Relation.new }
+
+  describe '#where_if_present' do
+    context 'with a parameterized SQL string' do
+      it 'calls where() if all values are present' do
+        expect(relation).to receive(:where).with('version BETWEEN ? AND ?', 1, 2)
+        relation.where_if_present('version BETWEEN ? AND ?', 1, 2)
+      end
+
+      it 'does not call where(), and returns self, if some values are missing' do
+        expect(relation).not_to receive(:where)
+        expect(relation.where_if_present('version BETWEEN ? AND ?', nil, 2)).to eq relation
+      end
+    end
+
+    context 'with a hash' do
+      it 'calls where() with all non-nil values' do
+        expect(relation).to receive(:where).with(key1: '', key3: 'value', key4: 0)
+        relation.where_if_present(key1: '', key2: nil, key3: 'value', key4: 0)
+      end
+
+      it 'does not call where(), and returns self, if all values are nil' do
+        expect(relation).not_to receive(:where)
+        relation.where_if_present(key1: nil, key2: nil)
+      end
+    end
+  end
+
+  describe '#if' do
+    context 'chained' do
+      context 'with true condition' do
+        it 'passes method calls to relation' do
+          expect(relation).to receive_message_chain(:foo, :bar)
+          relation.if(true).foo.bar
+        end
+      end
+
+      context 'with false condition' do
+        it 'passes method calls to relation' do
+          expect(relation).to receive_message_chain(:bar)
+          relation.if(false).foo.bar
+        end
+      end
+    end
+
+    context 'with a block' do
+      context 'with true condition' do
+        it 'passes method calls to relation' do
+          expect(relation).to receive_message_chain(:foo, :bar, :baz)
+          relation.if(true) { foo.bar }.baz
+        end
+      end
+
+      context 'with false condition' do
+        it 'passes method calls to relation' do
+          expect(relation).to receive_message_chain(:baz)
+          relation.if(false) { foo.bar }.baz
+        end
+      end
+    end
+  end
+
+  describe '#unless' do
+    context 'chained' do
+      context 'with true condition' do
+        it 'passes method calls to relation' do
+          expect(relation).to receive_message_chain(:bar)
+          relation.unless(true).foo.bar
+        end
+      end
+
+      context 'with false condition' do
+        it 'passes method calls to relation' do
+          expect(relation).to receive_message_chain(:foo, :bar)
+          relation.unless(false).foo.bar
+        end
+      end
+    end
+
+    context 'with a block' do
+      context 'with true condition' do
+        it 'passes method calls to relation' do
+          expect(relation).to receive_message_chain(:baz)
+          relation.unless(true) { foo.bar }.baz
+        end
+      end
+
+      context 'with false condition' do
+        it 'passes method calls to relation' do
+          expect(relation).to receive_message_chain(:foo, :bar, :baz)
+          relation.unless(false) { foo.bar }.baz
+        end
+      end
+    end
+  end
+
+  describe '#else' do
+    context 'chained' do
+      context 'with true condition' do
+        it 'passes method calls to relation' do
+          expect(relation).to receive(:foo).and_return(relation)
+          expect(relation).to receive(:baz)
+          relation.if(true).foo.else.bar.baz
+        end
+      end
+
+      context 'with false condition' do
+        it 'passes method calls to relation' do
+          expect(relation).to receive_message_chain(:bar, :baz)
+          relation.if(false).foo.else.bar.baz
+        end
+      end
+    end
+
+    context 'with a block' do
+      context 'with true condition' do
+        it 'passes method calls to relation' do
+          expect(relation).to receive(:foo).and_return(relation)
+          expect(relation).to receive(:moop)
+          relation.if(true).foo.else { bar.baz }.moop
+        end
+      end
+
+      context 'with false condition' do
+        it 'passes method calls to relation' do
+          expect(relation).to receive_message_chain(:bar, :baz, :moop)
+          relation.if(false).foo.else { bar.baz }.moop
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'active_support'
+require 'active_support/core_ext'
+
+require 'where_conditioner'

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: where_conditioner
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tony Novak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta
+description: Where Conditioner allows you to write conditional `where` expressions
+  in a DRY manner.
+email: tony@amitree.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- lib/where_conditioner.rb
+- spec/lib/where_conditioner_spec.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/where_conditioner
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Where Conditioner
+test_files: []