where_chain 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9056c05e208067983f91e1bcb9343cd8c1e43a924351cfcf0092efc012a806fa
+  data.tar.gz: 6f9b610d7b560e4d457e79d5448d5afd849924d6b0c1a71a3228e55d0ad62e54
+SHA512:
+  metadata.gz: 5338073a0179b6084b87211d915542500b4064552c0f536c5f0f78ae39ce6abb18914c60d87bc5636215da77c822877d0004eb46076d5ecc362b1f099d874224
+  data.tar.gz: ba3d5820c1d7384918e1eb2744113fbef2d4f75f797d6316cdf27cea8ec316c86b88e0fa811a73bb70d075b9e5e062d2865e05df5c5df12d33ec049a7b596dec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 Marcin Ruszkiewicz
+
+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,85 @@
+[![CircleCI](https://circleci.com/gh/marcinruszkiewicz/where_chain.svg?style=svg)](https://circleci.com/gh/marcinruszkiewicz/where_chain)
+
+# WhereChain
+
+In Rails, we usually use Active Record, which allows us to escape from writing SQL code like this `SELECT * FROM posts WHERE posts.name = 'Foo'` and allows us to write `Post.where(name: 'Foo')` instead. However, this has always been limited to matching equality, so you still have to write `Post.where('comments > ?', 5)` to get Posts that have more than 5 comments. 
+
+In the older versions, you also had to write `Post.where('name IS NOT null')` to do a negation. Rails 4.0 added a class called `WhereChain` that added some [new possibilities](https://github.com/rails/rails/commit/de75af7acc5c05c708443de40e78965925165217), one of which was a `not` method. The proper way to write  became `Post.where.not(name: nil)` instead.
+
+Within the same comment there were also two new methods that [didn't survive to the release of Rails 4.0](https://github.com/rails/rails/commit/8d02afeaee8993bd0fde69687fdd9bf30921e805) - `.like` and `.not_like`. As you can read in this commit discussion, there has been work made to bring them back, like the [activerecord-like](https://github.com/ReneB/activerecord-like) gem or [Squeel](https://github.com/activerecord-hackery/squeel), but these has their own problems - activerecord-like only adds `.like` and `.not_like` back and the latest version is locked to Active Record 5; and Squeel provides a whole new query DSL, which not everyone will like. There was actually a pull request adding `.gt` and other [inequality methods](https://github.com/rails/rails/pull/8453), which was closed even faster than the first one.
+
+This gem brings these two methods back and extends WhereChain with additional methods: `.gt`, `.gte`, `.lt` and `.lte`, so that by using it you can replace the SQL strings like `Post.where('comments > 5')` with `Post.where.gt(comments: 5)`.
+
+WhereChain depends on the Active Record gem in a version higher than 4.2, due to problems with Ruby versions lesser than 2.4. Rails 4.2 is already the version that's being maintained, so you probably should not use an earlier one anyway. The gem is tested on the latest Ruby and all current Rails versions - 4.2, 5.0, 5.1 and 5.2 RC 1.
+
+## Usage
+
+Some examples of using the gem and what can be replaced with it:
+
+| Rails SQL string | with WhereChain |
+|------------|-----------------|
+|`Post.where('comments > ?', 5)` | `Post.where.gt(comments: 5)` |
+|`Post.where('comments >= ?', 5)` | `Post.where.gte(comments: 5)` |
+|`Post.where('comments < ?', 5)` | `Post.where.lt(comments: 5)` |
+|`Post.where('comments <= ?', 5)` | `Post.where.lte(comments: 5)` |
+|`Post.where('name LIKE ?', "%foo%")` | `Post.where.like(name: "%foo%")` |
+|`Post.where('name NOT LIKE ?', "%foo%")` | `Post.where.unlike(name: "%foo%")` |
+|`Post.where('comments > ? AND shares > ?', 5, 10)` | `Post.where.gt({ comments: 5, shares: 10 })` |
+|`Post.where('comments > ? OR shares > ?', 5, 10)` | `Post.where.gt(comments: 5).or(Post.where.gt(shares: 10))` |
+
+You can now also chain the methods in your Active Record queries:
+
+```ruby
+Post.where.not.gt(comments: 5).where.like(name: '%foo%')
+```
+
+This, however, will **NOT** work at all:
+
+```ruby
+Post.gt(comments: 5).like(name: '%foo%')
+Post.where.gt(comments: 5).lt(comments: 10)
+```
+
+You need to prepend each of the new methods with either `.where` or `.where.not` for them to work.
+
+All the methods accept a Hash attribute and can compare all proper types as values, except Arrays and Hashes. These will **not** work and will raise an ArgumentError exception:
+
+```ruby
+Post.where.gt(comments: [1, 2, 3])
+Post.where.gt(comments: { bad: :thing })
+
+ArgumentError: The value passed to this method should be a valid type.
+
+Post.where.gt('comments > ?', 5)
+Post.where.gt([{number: 5}, 'name > ?'], 'abc')
+
+ArgumentError: This method requires a Hash as an argument.
+```
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'where_chain'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install where_chain
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'WhereChain'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'

data/lib/active_record/where_chain_extensions_rails4.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+  module QueryMethods
+    class WhereChain
+      include WhereChainSharedMethods
+
+      # if passed nothing, default to chaining further
+      def not(opts = :chain, *rest)
+        where_value = @scope.send(:build_where, opts, rest).map do |rel|
+          case rel
+          when :chain
+            @invert = true
+            return self
+          when NilClass
+            raise ArgumentError, 'Invalid argument for .where.not(), got nil.'
+          when Arel::Nodes::In
+            Arel::Nodes::NotIn.new(rel.left, rel.right)
+          when Arel::Nodes::Equality
+            Arel::Nodes::NotEqual.new(rel.left, rel.right)
+          when String
+            Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new(rel))
+          else
+            Arel::Nodes::Not.new(rel)
+          end
+        end
+
+        @scope.references!(PredicateBuilder.references(opts)) if Hash === opts
+        @scope.where_values += where_value
+        @scope
+      end 
+
+      private
+
+      def prepare_where(node_type, infix, opts, *rest)
+        where_value = @scope.send(:build_where, opts, rest).map do |rel|
+          if @invert
+            Arel::Nodes::Not.new arel_node(node_type, infix, rel)
+          else
+            arel_node(node_type, infix, rel)
+          end
+        end
+        @scope.where_values += where_value
+        @scope
+      end
+    end
+  end
+end

data/lib/active_record/where_chain_extensions_rails5.rb

@@ -0,0 +1,53 @@
+module ActiveRecord
+  class Relation
+    class QueryMethods; end
+  end
+
+  module QueryMethods
+    class WhereChain
+      include WhereChainSharedMethods
+
+      def not(opts = :chain, *rest)
+        if :chain == opts
+          @invert = true
+          return self
+        end
+
+        opts = sanitize_forbidden_attributes(opts)
+
+        where_clause = @scope.send(:where_clause_factory).build(opts, rest)
+
+        @scope.references!(PredicateBuilder.references(opts)) if Hash === opts
+        @scope.where_clause += where_clause.invert
+        @scope
+      end
+
+      private 
+
+      def prepare_where(node_type, infix, opts, rest)
+        @scope.tap do |s|
+          opts.each_pair do |key, value|
+            equal_where_clause = s.send(:where_clause_factory).build({ key => value }, rest)
+            equal_where_clause_predicate = equal_where_clause.send(:predicates).first
+
+            new_predicate = arel_node(node_type, infix, equal_where_clause_predicate)
+            new_where_clause = build_where_clause(new_predicate, equal_where_clause)
+            if @invert
+              s.where_clause += new_where_clause.invert
+            else
+              s.where_clause += new_where_clause
+            end
+          end
+        end
+      end
+
+      def build_where_clause(new_predicate, old_where_clause)
+        if old_where_clause.respond_to?(:binds)
+          Relation::WhereClause.new([new_predicate], old_where_clause.binds)
+        else
+          Relation::WhereClause.new([new_predicate])
+        end
+      end   
+    end
+  end
+end

data/lib/active_record/where_chain_shared_methods.rb

@@ -0,0 +1,71 @@
+module ActiveRecord
+  module WhereChainSharedMethods
+    extend ActiveSupport::Concern
+
+    included do
+      def initialize(scope, invert=false)
+        @scope = scope
+        @invert = invert
+      end
+            
+      # Returns a new relation expressing WHERE + LIKE condition
+      # according to the conditions provided as a hash in the arguments.
+      #
+      #    Book.where.like(title: "Rails%")
+      #    # SELECT * FROM books WHERE title LIKE 'Rails%'
+      def like(opts, *rest)
+        prepare_where(Arel::Nodes::Matches, nil, opts, rest)
+      end
+
+      # Returns a new relation expressing WHERE + NOT LIKE condition
+      # according to the conditions provided as a hash in the arguments.
+      #
+      #    Conference.where.not_like(name: "%Kaigi")
+      #    # SELECT * FROM conferences WHERE name NOT LIKE '%Kaigi'
+      def unlike(opts, *rest)
+        prepare_where(Arel::Nodes::DoesNotMatch, nil, opts, rest)
+      end
+      alias not_like unlike # maintain compatibility with activerecord-like gem
+
+      def gt(opts, *rest)
+        ensure_proper_attributes(opts)
+        prepare_where(Arel::Nodes::InfixOperation, '>', opts, rest)
+      end
+
+      def gte(opts, *rest)
+        ensure_proper_attributes(opts)
+        prepare_where(Arel::Nodes::InfixOperation, '>=', opts, rest)
+      end
+
+      def lt(opts, *rest)
+        ensure_proper_attributes(opts)
+        prepare_where(Arel::Nodes::InfixOperation, '<', opts, rest)
+      end
+
+      def lte(opts, *rest)
+        ensure_proper_attributes(opts)
+        prepare_where(Arel::Nodes::InfixOperation, '<=', opts, rest)
+      end
+
+      private 
+
+      def ensure_proper_attributes(opts)
+        raise ArgumentError, 'This method requires a Hash as an argument.' unless opts.is_a?(Hash)
+
+        opts.each_pair do |key, value|
+          if value.is_a?(Hash) || value.is_a?(Array)
+            raise ArgumentError, 'The value passed to this method should be a valid type.' 
+          end
+        end
+      end
+
+      def arel_node(node_type, infix, rel)
+        if infix.present?
+          node_type.new(infix, rel.left, rel.right)
+        else
+          node_type.new(rel.left, rel.right)
+        end
+      end      
+    end
+  end
+end

data/lib/where_chain.rb

@@ -0,0 +1,7 @@
+require 'active_record/where_chain_shared_methods'
+
+if ActiveRecord::VERSION::MAJOR == 4
+  require 'active_record/where_chain_extensions_rails4'
+elsif ActiveRecord::VERSION::MAJOR == 5
+  require 'active_record/where_chain_extensions_rails5'
+end

data/lib/where_chain/version.rb

@@ -0,0 +1,3 @@
+module WhereChain
+  VERSION = '0.2.0'
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: where_chain
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Marcin Ruszkiewicz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: pry-rails
+  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: rspec-rails
+  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: factory_bot_rails
+  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: appraisal
+  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: database_cleaner
+  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: rspec_junit_formatter
+  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: 'WhereChain is a Rails plugin that provides extensions for ActiveRecord.
+  Since Rails 4 you can do Model.where.not(name: ''Bad'') and this module adds '
+email:
+- marcin.ruszkiewicz@polcode.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/active_record/where_chain_extensions_rails4.rb
+- lib/active_record/where_chain_extensions_rails5.rb
+- lib/active_record/where_chain_shared_methods.rb
+- lib/where_chain.rb
+- lib/where_chain/version.rb
+homepage: https://github.com/marcinruszkiewicz
+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.7.3
+signing_key: 
+specification_version: 4
+summary: 'WhereChain extensions - Model.where.lt(created_at: Date.today)'
+test_files: []