activerecord-hash_options 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8813e9aab70d04b26a259dc942ce9d72ff617ab08bce5110efff8913314f74dd
+  data.tar.gz: 5066d7c5a45c2d815dc6cb8baefc45321cecdbd098dff6cde8570c689703b80e
+SHA512:
+  metadata.gz: 25f350ebb9ad1a614cbe2d853a4bb6a104d90064b2a1e363a571a04c775440ba476ef1f892a1dc0706ee9b723662588e5b9f76d9e07bfd9b17e62240061a88e7
+  data.tar.gz: a1567cb1f71a1a71b5af8c2358ad80b5de6f440625e9c119069230bf21178c283d29b8051ae6233cc2473cb5f13d262e95413cb8ae23659a28c94ae99a392448

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.rspec_status
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/Gemfile.lock
+/gemfiles/*.lock
+/pkg/
+/spec/reports/
+/tmp/
+*.local.rb

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,26 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+
+rvm:
+  - 2.5.3
+
+services:
+  - mysql
+  - postgresql
+
+env:
+  - DB=mysql2
+  - DB=pg
+  - DB=sqlite3
+
+gemfile:
+  - gemfiles/gemfile_50.gemfile
+  - gemfiles/gemfile_51.gemfile
+  - gemfiles/gemfile_52.gemfile
+  - gemfiles/gemfile_60.gemfile
+
+before_script:
+  - [ '$DB' = 'mysql2' ] && mysql -e 'create database hash_options_test;' || true
+  - [ '$DB' = 'pg' ] && psql -c 'create database hash_options_test;' -U postgres || true

data/Appraisals

@@ -0,0 +1,25 @@
+%w(5.0.7 5.1.7 5.2.3 6.0.0).each do |ar_version|
+  appraise "gemfile-#{ar_version.split('.').first(2).join}" do
+    gem "activerecord", "~> #{ar_version}"
+
+    if ar_version >= "5.0"
+      gem "mysql2"
+    elsif ar_version >= "4.2"
+      gem "mysql2", "~> 0.4.0"
+    else
+      gem "mysql"
+    end
+
+    if ar_version >= "5.0"
+      gem "pg"
+    else
+      gem "pg", "0.18.4"
+    end
+
+    if ar_version >= "5.2"
+      gem "sqlite3"
+    else
+      gem "sqlite3", "~> 1.3.13"
+    end
+  end
+end

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem "activerecord", '~> 5.2'
+gem "mysql2"
+gem "pg"
+gem "sqlite3"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Keenan Brock
+
+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,88 @@
+# ActiveRecord::HashOptions
+
+This extends the hash options passed into ActiveRecord `where`.
+
+Thanks to the example from [codesnik](https://gist.github.com/codesnik/2ebba1940c05b08b17f9)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activerecord-hash_options'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activerecord-hash_options
+
+## Usage
+
+There are a number of ways to use active record hash options.
+It all depends upon how much you want to monkey patch your environment
+
+```ruby
+require 'active_record/hash_options'
+
+Person.where(:name => ActiveRecord::HashOptions::LIKE('Smith%'))
+Person.where(:age => ActiveRecord::HashOptions::GTE(21))
+```
+
+---
+
+```ruby
+require 'active_record/hash_options'
+include ActiveRecord::HashOptions
+
+Person.where(:name => LIKE('Smith%'))
+Person.where.not(:age => GTE(21))
+
+ActiveRecord::HashOptions.filter(Person.all, :name => LIKE('Smith%'))
+ActiveRecord::HashOptions.filter(Person.all.to_a, :name => LIKE('Smith%'))
+ActiveRecord::HashOptions.filter(Person.all.to_a, :age => GTE(21), true)
+```
+
+---
+
+```ruby
+require 'active_record/hash_options'
+include ActiveRecord::HashOptions::Helpers
+
+Person.where(:name => like('Smith%'))
+Person.where.not(:age => gte(21))
+
+ActiveRecord::HashOptions.filter(Person.all.to_a, :name => like('Smith%'))
+```
+
+---
+
+```ruby
+require 'active_record/hash_options'
+include ActiveRecord::HashOptions::Helpers
+Array.send(:include, ActiveRecord::HashOptions::Enumerable)
+
+Person.all.to_a.where(:name => like('Smith%'))
+Person.all.to_a.where.not(:age => gte(21))
+
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
+
+You can also run `bin/console` for an interactive prompt that will allow you to experiment. Model `Table1` will be available
+for your convenience
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kbrock/activerecord-hash_options.
+
+
+## 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,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.ruby_opts = %w[-w]
+end
+
+task :default => :spec

data/activerecord-hash_options.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record/hash_options/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "activerecord-hash_options"
+  spec.version       = ActiveRecord::HashOptions::VERSION
+  spec.authors       = ["Keenan Brock"]
+  spec.email         = ["keenan@thebrocks.net"]
+
+  spec.summary       = %q{Give ActiveRecord where hashes more power }
+  spec.description   = %q{Gives ActiveRecord where hashes more power like the ability to gt or like}
+  spec.homepage      = "https://github.com/kbrock/activerecord-hash_options/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ["lib"]
+
+  # We use appraisal to generate the gemfiles
+  # but other than that, we do not use appraisal during the runtime/development time of gem
+  # spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "rake", ">= 12.3.3"
+  spec.add_development_dependency "rspec-core", "~>3.8.0"
+  spec.add_development_dependency "rspec-expectations", "~>3.8.0"
+  spec.add_development_dependency "activerecord", ">= 5.0"
+end

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "activerecord/hash_options"
+
+# models for local testing
+require "rspec"
+Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/gemfiles/gemfile_50.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.0.7"
+gem "mysql2"
+gem "pg"
+gem "sqlite3", "~> 1.3.13"
+
+gemspec path: "../"

data/gemfiles/gemfile_51.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.1.7"
+gem "mysql2"
+gem "pg"
+gem "sqlite3", "~> 1.3.13"
+
+gemspec path: "../"

data/gemfiles/gemfile_52.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.2.3"
+gem "mysql2"
+gem "pg"
+gem "sqlite3"
+
+gemspec path: "../"

data/gemfiles/gemfile_60.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 6.0.0"
+gem "mysql2"
+gem "pg"
+gem "sqlite3"
+
+gemspec path: "../"

data/init.rb

@@ -0,0 +1 @@
+require "activerecord-hash_options"

data/lib/active_record-hash_options.rb

@@ -0,0 +1 @@
+require "active_record/hash_options"

data/lib/active_record/hash_options.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+require "active_record/hash_options/version"
+require "active_record/hash_options/operators"
+require "active_record/hash_options/helpers"
+require "active_record/hash_options/enumerable"
+
+module ActiveRecord
+  module HashOptions
+    def self.extended(mod)
+      ActiveRecord::HashOptions.register_my_handler(mod)
+    end
+
+    def self.inherited(mod)
+      ActiveRecord::HashOptions.register_my_handler(mod)
+    end
+
+    def self.register_my_handler(mod)
+      if mod < ActiveRecord::Base && mod.kind_of?(Class)
+        mod.predicate_builder.register_handler(GT, GT.arel_proc)
+        mod.predicate_builder.register_handler(LT, LT.arel_proc)
+        mod.predicate_builder.register_handler(GTE, GTE.arel_proc)
+        mod.predicate_builder.register_handler(LTE, LTE.arel_proc)
+        mod.predicate_builder.register_handler(INSENSITIVE, INSENSITIVE.arel_proc)
+        mod.predicate_builder.register_handler(LIKE, LIKE.arel_proc)
+        mod.predicate_builder.register_handler(NOT_LIKE, NOT_LIKE.arel_proc)
+        # for postgres:
+        mod.predicate_builder.register_handler(ILIKE, ILIKE.arel_proc)
+
+        # NOTE: Probably want Regexp over REGEXP (e.g.: where(:name => /value/i))
+        mod.predicate_builder.register_handler(Regexp, REGEXP.arel_proc)
+        mod.predicate_builder.register_handler(REGEXP, REGEXP.arel_proc)
+      end
+    end
+
+    def self.filter(scope_or_array, conditions, negate = false)
+      if scope_or_array.kind_of?(Array)
+        filter_array(scope_or_array, conditions, negate)
+      else
+        filter_scope(scope_or_array, conditions, negate)
+      end
+    end
+
+    def self.filter_scope(scope, conditions, negate)
+      if negate
+        scope.where.not(conditions)
+      else
+        scope.where(conditions)
+      end
+    end
+
+    def self.filter_array(array, conditions, negate)
+      array.select do |rec|
+        conditions.all? do |name, value|
+          actual_val = rec.send(name)
+          # not thrilled about special cases, but `x in [..., nil]` and `x == nil` are the only cases
+          # that handle negation for a `nil` / `null` value correctly
+          if actual_val.nil? && (value != nil || value.kind_of?(Array) && !value.include?(nil))
+            false
+          else
+            compare_array_column(actual_val, value) ? !negate : negate
+          end
+        end
+      end
+    end
+
+    def self.compare_array_column(actual_val, value)
+      case value
+      when Regexp
+        actual_val =~ value
+      when Array
+        value.include?(actual_val)
+      when Range
+        value.cover?(actual_val)
+      when ActiveRecord::HashOptions::GenericOp
+        # NOTE: The `nil?` check in `filter_array` may skip this comparison and short circuit to a false
+        value.call(actual_val)
+      else # NilClass, String, Integer
+        # NOTE: this treats `x == nil` the same as `x IS NULL`
+        actual_val == value
+      end
+    end
+  end
+end

data/lib/active_record/hash_options/enumerable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# include into any file to add class to make Array#where
+module ActiveRecord
+  module HashOptions
+    module Enumerable
+      def where(conditions = :chain)
+        if :chain == conditions
+          ActiveRecord::HashOptions::Enumerable::NotChain.new(self)
+        else
+          ActiveRecord::HashOptions.filter(self, conditions, false)
+        end
+      end
+
+      class NotChain
+        def initialize(collection)
+          @collection = collection
+        end
+
+        def not(conditions = {})
+          ActiveRecord::HashOptions.filter(@collection, conditions, true)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/hash_options/helpers.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module ActiveRecord
+  module HashOptions
+    module Helpers
+      # numeric
+      def gt(val); ActiveRecord::HashOptions::GT.new(val); end
+      def lt(val); ActiveRecord::HashOptions::LT.new(val); end
+      def gte(val); ActiveRecord::HashOptions::GTE.new(val); end
+      def lte(val); ActiveRecord::HashOptions::LTE.new(val); end
+
+      # string
+      def insensitive(val); ActiveRecord::HashOptions::INSENSITIVE.new(val); end
+
+      def starts_with(val) ; ActiveRecord::HashOptions::LIKE.new("#{val}%"); end
+      def ends_with(val) ; ActiveRecord::HashOptions::LIKE.new("%#{val}"); end
+      def contains(val) ; ActiveRecord::HashOptions::LIKE.new("%#{val}%"); end
+      def not_like(val) ; ActiveRecord::HashOptions::NOT_LIKE.new(val); end
+      def like(val); ActiveRecord::HashOptions::LIKE.new(val); end
+      def ilike(val); ActiveRecord::HashOptions::ILIKE.new(val); end
+    end
+  end
+end

data/lib/active_record/hash_options/operators.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+module ActiveRecord
+  module HashOptions
+    # Operator contains logic for producing arel for the database and acts as a lambda for ruby
+    class GenericOp
+      attr_accessor :expression, :expression2
+
+      def initialize(expression, expression2 = nil)
+        @expression = expression
+        @expression2 = expression2
+      end
+
+      def self.quote(op_expression, column)
+        if op_expression.kind_of?(String)
+          Arel::Nodes.build_quoted(op_expression, column)
+        else
+          op_expression
+        end
+      end
+    end
+
+    class GT < GenericOp
+      def self.arel_proc
+        proc { |column, op| Arel::Nodes::GreaterThan.new(column, GenericOp.quote(op.expression, column)) }
+      end
+
+      def call(val)
+        val && val > expression
+      end
+    end
+
+    class LT < GenericOp
+      def self.arel_proc
+        proc { |column, op| Arel::Nodes::LessThan.new(column, GenericOp.quote(op.expression, column)) }
+      end
+
+      def call(val)
+        val && val < expression
+      end
+    end
+
+    class GTE < GenericOp
+      def self.arel_proc
+        proc { |column, op| Arel::Nodes::GreaterThanOrEqual.new(column, GenericOp.quote(op.expression, column)) }
+      end
+
+      def call(val)
+        val && val >= expression
+      end
+    end
+
+    class LTE < GenericOp
+      def self.arel_proc
+        proc { |column, op| Arel::Nodes::LessThanOrEqual.new(column, GenericOp.quote(op.expression, column)) }
+      end
+
+      def call(val)
+        val && val <= expression
+      end
+    end
+
+    class INSENSITIVE < GenericOp
+      def self.arel_proc
+        proc do |column, op|
+          lower_column = Arel::Nodes::NamedFunction.new("LOWER", [column])
+          Arel::Nodes::Equality.new(lower_column, GenericOp.quote(op.expression.downcase, column))
+        end
+      end
+
+      def call(val)
+        val&.downcase == expression&.downcase
+      end
+    end
+
+    # Ruby doesn't have like, so I converted regex to like best I could
+    # We could also do the reverse for database operations
+    class LIKE < GenericOp
+      def self.arel_proc
+        proc { |column, op| Arel::Nodes::Matches.new(column, GenericOp.quote(op.expression, column), nil, true) }
+      end
+
+      def call(val)
+        expression2 ||= like_to_regex(expression)
+        val && val =~ expression2
+      end
+
+      # escape . * ^ $ (this.gif => this[.]gif - so it won't match this_gif)
+      # leave [] as [] (use by like and regular expressions)
+      # convert % => .*, _ => .
+      # convert ^.*abc$ => abc$
+      # convert ^abc.*$ => ^abc
+      # @param extra ilike passes in Regexp::IGNORECASE
+      def like_to_regex(lk, extra = nil)
+        exp = lk.gsub(/([.*^$])/) {"[#{$1}]"} # escape special characters
+        exp = "^#{exp}$".gsub("%", '.*').gsub("_", ".").gsub(/^\.\*/, '').gsub(/\.\*$/, '')
+        Regexp.new(exp, extra)
+      end
+    end
+
+    class NOT_LIKE < LIKE
+      def self.arel_proc
+        proc { |column, op| Arel::Nodes::DoesNotMatch.new(column, GenericOp.quote(op.expression, column), nil, true) }
+      end
+
+      def call(val)
+        expression2 ||= like_to_regex(expression)
+        val && val !~ expression2
+      end
+    end
+
+    class ILIKE < LIKE
+      def self.arel_proc
+        proc { |column, op| Arel::Nodes::Matches.new(column, GenericOp.quote(op.expression, column), nil, false) }
+      end
+
+      def like_to_regex(lk)
+        super(lk, Regexp::IGNORECASE)
+      end
+    end
+
+    # typically, a Regexp will go through, so this should not becalled
+    # this is here to group proc for regexp with others
+    class REGEXP < GenericOp
+      def self.arel_proc
+        proc do |column, op|
+          regexp_text = Arel::Nodes.build_quoted(op.source, column)
+          case_sensitive = (op.options & Regexp::IGNORECASE == 0)
+          Arel::Nodes::Regexp.new(column, regexp_text, case_sensitive)
+        end
+      end
+
+      def call(val)
+        val && val =~ expression
+      end
+    end
+  end
+end

data/lib/active_record/hash_options/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module ActiveRecord
+  module HashOptions
+    VERSION = "0.1.0"
+  end
+end

data/lib/activerecord-hash_options.rb

@@ -0,0 +1 @@
+require "active_record/hash_options"

data/lib/activerecord/hash_options.rb

@@ -0,0 +1 @@
+require "active_record/hash_options"

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-hash_options
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Keenan Brock
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Gives ActiveRecord where hashes more power like the ability to gt or
+  like
+email:
+- keenan@thebrocks.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Appraisals
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord-hash_options.gemspec
+- bin/console
+- bin/setup
+- gemfiles/gemfile_50.gemfile
+- gemfiles/gemfile_51.gemfile
+- gemfiles/gemfile_52.gemfile
+- gemfiles/gemfile_60.gemfile
+- init.rb
+- lib/active_record-hash_options.rb
+- lib/active_record/hash_options.rb
+- lib/active_record/hash_options/enumerable.rb
+- lib/active_record/hash_options/helpers.rb
+- lib/active_record/hash_options/operators.rb
+- lib/active_record/hash_options/version.rb
+- lib/activerecord-hash_options.rb
+- lib/activerecord/hash_options.rb
+homepage: https://github.com/kbrock/activerecord-hash_options/
+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.6.2
+signing_key: 
+specification_version: 4
+summary: Give ActiveRecord where hashes more power
+test_files: []