default_where 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b85a4951acd26f1a6797d490d439eee08d8c67e3ffb85b448b575e397944198
-  data.tar.gz: 4170d4c7ef435d25c74ba47baf650d55b2bf452552be983a853df4be470a7034
+  metadata.gz: b496f6c6778aac3b2e8ef9d0a47f8d7e8557f2080aeaa0dc15605f80266c3760
+  data.tar.gz: 0320e5570248726e1a4716f852ba951480fccb386b298db0d1118181fb1180eb
 SHA512:
-  metadata.gz: fdd9c0a69cb31188ce01230ace81e618e4c14ad92f88f9e6622d2857c253ca6363c34d17bd5c1269cf8a7c7f7338e4a4d463cfde03950616e274ad6dd6129de3
-  data.tar.gz: eb48499fae1cbe71cb4adb659982b31145a1f29a3d22ce950e25735ac4a2df6e3614641b9b419da35e677a75b84c22358a166a0da2abaaa77857f18613c70a40
+  metadata.gz: 0fec4d669be1436bdf7cb217bdb0cee4a30fdd4e7dd4e8b201a9c444da07bc3a5ef100a0329a7c4c3c679af045aa08e48ef2137105b24cc15adcc44f69af7ddf
+  data.tar.gz: 2633a6a9cab857a51fc321efce967f7fe4c7fbcc835abed292066a2c90367ad4f6a2746e76bdf4a8418f62f18707851c944ecff1a93a7dec73987d98e37a8fdc

data/{MIT-LICENSE → LICENSE}

@@ -1,4 +1,4 @@
-Copyright 2015 qinmingyuan<mingyuan0715@foxmail.com>
+Copyright (c) 2015-Present Mingyuan Qin <mingyuan0715@foxmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,10 +1,21 @@
 ## DefaultWhere
 
-This Library set default params process for where query in ActiveRecord
+
+`default_where` set default params process for where query in ActiveRecord
 
 It's a wise decision to use `default_where` with [default_form](https://github.com/qinmingyuan/default_form) to replace `ransack`
 
-## Features and Usage
+## 使用说明
+
+
+### 语法概览
+
+* 等于：key: value
+* 范围：key-gte: value, 
+* 排序：key-asc: 1, key-desc: 2
+* 排除：key-not: value
+#### 对于postgresql 数据库
+* 包含任一值：key-any: value
 
 ### Normal equal params
 
@@ -62,8 +73,27 @@ users = users.where(age: params[:age]) if params[:age]
 ```ruby
 User.default_where(params)
 
-# also can control which blank value can use
-User.default_where(params, { allow: [nil] })
+```
+
+### allow
+you can control which blank value can use
+
+```ruby
+{
+  name: nil,
+  allow: { name: nil }
+}
+```
+
+### OR
+```ruby
+params = {
+  or: { 
+    'users.email-not': 'qin',
+    'name': 'qin'
+  }
+}
+
 ```
 
 ### Auto call strip for string 
@@ -80,7 +110,13 @@ User.where(name: params[:name].strip)
 User.default_where(params)
 
 # also can control whether use strip
-User.default_where(params, { strip: false })
+
+{
+  name: ' qin',
+  strip: { 
+    name: false
+  }
+}
 ```
 
 ### Order params
@@ -97,10 +133,30 @@ User.order(age: :asc, last_login_at: :asc)
 User.default_where(params)
 ```
 
+## For Postgresql
+* support JSONB filter，just use like this: `column_name/json_key`, just notice jsonb all value is string type;
+```ruby
+# before
+Order.where("extra->>'maintain_id' = :key", key: id.to_s) 
+# after
+Order.default_where('extra/maintain_id': id.to_s)
+```
+
 ## A sample with all params above
 * Params
 ```ruby
-{ name: 'dhh', 'role.id': 2, 'age-lte': 2, 'age-asc': '1', 'last_login_at-asc': '2' }
+{ 
+  name: 'dhh',
+  'role.id': 2, 
+  'age-lte': 2, 
+  'age-asc': '1', 
+  'last_login_at-asc': '2',
+  or: {
+    name: 'dhh',
+    email: 'dhh'
+  },
+  allow: { name: nil }
+}
 ```
 * Before use `default_where`
 ```ruby
@@ -109,4 +165,7 @@ User.includes(:role).where(name: params[:name], 'roles.id': params[:'role.id']).
 * After use `default_where`
 ```ruby
 User.default_where(params)
-```
+```
+
+## 许可证
+遵循 MIT 协议

data/Rakefile

@@ -8,25 +8,29 @@ require 'rdoc/task'
 
 RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'QueryScope'
+  rdoc.title = 'DefaultWhere'
   rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('README.md')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-
-
-
 Bundler::GemHelper.install_tasks
 
 require 'rake/testtask'
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
+Rake::TestTask.new(test: :environment) do |t|
   t.libs << 'test'
   t.pattern = 'test/**/*_test.rb'
   t.verbose = false
 end
 
+task :environment do
+  ActiveRecord::Tasks::DatabaseTasks.database_configuration = YAML.load_file('test/config/database.yml')
+  ActiveRecord::Tasks::DatabaseTasks.env = 'test'
+  ActiveRecord::Tasks::DatabaseTasks.root = __dir__
+  ActiveRecord::Tasks::DatabaseTasks.migrations_paths = ['test/migrations']
+  ActiveRecord::Base.configurations = ActiveRecord::Tasks::DatabaseTasks.database_configuration
+  ActiveRecord::Base.establish_connection :test
+end
 
-task default: :test
+load 'active_record/railties/databases.rake'

data/lib/default_where.rb

@@ -1,88 +1,69 @@
-require 'default_where/not'
-require 'default_where/range'
-require 'default_where/like'
+# frozen_string_literal: true
+
+require 'default_where/scope'
 require 'default_where/order'
+require 'default_where/params'
+require 'default_where/group'
 
 module DefaultWhere
-  include DefaultWhere::Not
-  include DefaultWhere::Range
-  include DefaultWhere::Order
-  include DefaultWhere::Like
+  include Scope
+  include Order
+  include Params
+  include Group
 
-  REJECT = ['', ' ', nil]
+  REJECT = ['', nil].freeze
   STRIP = true
 
-  def default_where(params = {}, options = {})
+  def default_where(params = {})
     return all if params.blank?
 
-    params, refs, tables = params_with_table(params, options)
+    params = params.to_h
+    options = {}
+    [:strip, :allow, :reject].each do |key|
+      options[key] = params.delete(key) if params[key].respond_to?(:to_hash)
+    end
+    or_params = {}
+    or_params = params.delete(:or) if params[:or].respond_to?(:to_hash)
 
-    range_params = filter_range(params)
-    order_params = filter_order(params)
-    not_params = filter_not(params)
-    like_params = filter_like(params)
+    and_params, and_refs, and_tables = default_where_params(params, options)
+    order_params = default_where_order_filter(and_params)
+    and_params.except!(*order_params.keys)
 
-    equal_params = params.except!(*range_params.keys, *order_params.keys, *not_params.keys, *like_params.keys)
+    or_params, or_refs, or_tables = default_where_params(or_params, options)
+    refs = and_refs + or_refs
+    tables = and_tables + or_tables
 
-    includes(refs).where(equal_params).references(tables)
-      .not_scope(not_params)
-      .like_scope(like_params)
-      .range_scope(range_params)
-      .order_scope(order_params)
+    includes(refs).default_where_and(and_params).default_where_or(or_params).default_where_order(order_params).references(tables)
   end
 
-  def params_with_table(params = {}, options = {})
-    if options[:reject]
-      default_reject = [options[:reject]].flatten
-    elsif options[:allow]
-      default_reject = REJECT - [options[:allow]].flatten
-    else
-      default_reject = REJECT
-    end
+  def default_where_and(params = {})
+    return current_scope if params.blank?
 
-    unless options.has_key? :strip
-      options[:strip] = STRIP
+    equal_params = {}
+    params.each do |key, _|
+      equal_params[key] = params.delete(key) unless key.match? /[-\/]/
     end
+    where_string, where_hash = default_where_scope(params)
+    where_string = where_string.join ' AND '
 
-    params = params.to_h
-    params.stringify_keys!
-    params.reject! { |_, value| default_reject.include?(value) }
-
-    refs = []
-    tables = []
-    final_params = {}
-
-    params.each do |key, value|
-      value = value.strip if value.is_a?(String) && options[:strip]
-
-      if key =~ /\./
-        table, col = key.split('.')
-        as_model = reflections[table]
-        f_col, _ = col.split('-')
-
-        if as_model && as_model.klass.column_names.include?(f_col)
-          final_params["#{as_model.table_name}.#{col}"] = value
-          tables << as_model.table_name
-          refs << table.to_sym
-        elsif connection.data_sources.include? table
-          final_params["#{table}.#{col}"] = value
-          tables << table
-          keys = reflections.select { |_, v| !v.polymorphic? && v.table_name == table }.keys
-          if keys && keys.size == 1
-            refs << keys.first.to_sym
-          end
-        end
-      else
-        f_key, _ = key.split('-')
-        if column_names.include?(f_key)
-          final_params["#{key}"] = value
-        end
-      end
-    end
+    where(equal_params).where(where_string, where_hash)
+  end
+
+  def default_where_or(params = {})
+    return current_scope if params.blank?
+
+    where_string, where_hash = default_where_scope(params)
+    where_string = where_string.join ' OR '
 
-    [final_params, refs, tables]
+    where(where_string, where_hash)
+  end
+
+  def logger
+    ::ActiveRecord::Base.logger
   end
 
 end
 
-ActiveRecord::Base.extend DefaultWhere
+ActiveSupport.on_load :active_record do
+  extend DefaultWhere
+end

data/lib/default_where/group.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DefaultWhere
+  module Group
+
+    # {
+    #   select: 'sum(total_amount)',
+    #   select: {
+    #     a: 'sum(total_amount)',
+    #     b: 'sum()'
+    #   }
+    # }
+    #  group: 'date(created_at)',
+    def default_group(*group, select:)
+      if select.respond_to?(:to_hash)
+        selected = select.map do |k, v|
+          "#{v} AS #{k}"
+        end
+      else
+        selected = Array(select)
+      end
+      
+      unscoped.select(*selected, *group).group(*select.values)
+    end
+    
+  end
+end

data/lib/default_where/order.rb

@@ -1,23 +1,26 @@
+# frozen_string_literal: true
+
 module DefaultWhere
   module Order
+    PATTERN = {
+      '-asc': :asc,
+      '-desc': :desc
+    }
 
-    def order_scope(params)
-      order_array = []
-
-      params.select{ |key, _| key.end_with?('-asc') }.each do |k, _|
-        order_array << k.sub(/-asc$/, ' ASC')
-      end
+    def default_where_order(params)
+      order_hash = {}
 
-      params.select{ |key, _| key.end_with?('-desc') }.each do |k, _|
-        order_array << k.sub(/-desc$/, ' DESC')
+      params.sort_by{ |_, v| v.to_i }.each do |i|
+        k, v = i[0].split('-')
+        order_hash[k] = v
       end
 
-      order(order_array)
+      order(order_hash)
     end
 
-    def filter_order(params)
+    def default_where_order_filter(params)
       params.select do |k, v|
-        k.end_with?('-asc', '-desc') && v =~ /^[1-9]$/
+        k.end_with?('-asc', '-desc') && String(v) =~ /^[1-9]$/
       end
     end
 

data/lib/default_where/params.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module DefaultWhere
+  module Params
+
+    def default_where_params(params = {}, options = {})
+      refs = []
+      tables = []
+      final_params = {}
+
+      params.each do |key, value|
+        # strip, if assign key to false, will not works
+        strip = options.fetch(:strip, {}).fetch(key, STRIP)
+        value = value.strip if value.is_a?(String) && strip
+
+        # reject
+        if options.key?(:reject)
+          reject = options.fetch(:reject, {}).fetch(key, REJECT)
+          if reject == nil
+            reject = [nil]
+          elsif reject == []
+            reject = [[]]
+          else
+            reject = Array(reject)
+          end
+        else
+          allow = options.fetch(:allow, {}).fetch(key, [])
+          if allow == nil
+            allow = [nil]
+          else
+            allow = Array(allow)
+          end
+          reject = REJECT - allow
+        end
+        next if reject.include?(value)
+
+        items = key.to_s.split('.')
+        column = items[-1]
+        real_column = column.split(/[-\/]/)[0]
+
+        if items.size == 1
+          next unless column_names.include?(real_column)
+          table = nil
+        else
+          prefix = items[0]
+          ref = reflections[prefix]
+
+          # 检查 prefix 是否为关联关系的名称
+          if ref && !ref.polymorphic?
+            table = ref.table_name
+            # 检查 prefix 是否为表名，且表中存在 real_column 字段
+          elsif connection.data_sources.include?(prefix) && connection.column_exists?(prefix, real_column)
+            possible_refs = reflections.select { |_, v| v.table_name == prefix }
+            if possible_refs.size < 1
+              ref = nil
+            elsif possible_refs.size == 1
+              ref = possible_refs[0]
+            else
+              raise "#{key} makes confused, please use reflection name!"
+            end
+
+            table = prefix
+          else
+            next
+          end
+
+          if ref && !ref.klass.column_names.include?(real_column)
+            next
+          end
+
+          if ref && !refs.include?(ref.name)
+            refs << ref.name
+          end
+
+          unless tables.include?(table)
+            tables << table
+          end
+        end
+
+        if table
+          final_params["#{table}.#{column}"] = value
+        else
+          final_params[column] = value
+        end
+      end
+
+      [final_params, refs, tables]
+    end
+
+  end
+end

data/lib/default_where/scope.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module DefaultWhere
+  module Scope
+    PATTERN = {
+      gt: '>',
+      gte: '>=',
+      lt: '<',
+      lte: '<=',
+      not: '!=',
+      like: 'LIKE',
+      rl: 'LIKE',
+      ll: 'LIKE',
+      :'' => '='
+    }.freeze
+
+    def default_where_scope(params)
+      where_string = []
+      where_hash = {}
+
+      params.each do |key, value|
+        real_key, sign_str = key.split('-')
+        agent_key = key.gsub(/[-.\/]/, '_')
+
+        if value.nil? || value == []
+          if sign_str == 'not'
+            where_string << "#{real_key} IS NOT NULL"
+          elsif sign_str.nil?
+            where_string << "#{real_key} IS NULL"
+          else
+            raise "#{key}'s value can not be nil"
+          end
+        elsif sign_str == 'any' # 支持 postgres array 查询
+          where_string << ":#{agent_key} = ANY(#{real_key})"
+          where_hash.merge! agent_key.to_sym => value
+        elsif real_key.match?(/.\/./) # 支持 postgres json 查询
+          real_key, i18n_key = key.split('/')
+          where_string << "#{real_key}->>'#{i18n_key}' = :#{agent_key}"
+          where_hash.merge! agent_key.to_sym => value
+        else
+          case sign_str
+          when 'll'
+            real_value = "#{value}%"
+          when 'rl'
+            real_value = "%#{value}"
+          when 'like'
+            real_value = "%#{value}%"
+          else
+            real_value = value
+          end
+
+          where_string << "#{table_name}.#{real_key} #{PATTERN[sign_str.to_s.to_sym]} :#{agent_key}"
+          where_hash.merge! agent_key.to_sym => real_value
+        end
+      end
+
+      [where_string, where_hash]
+    end
+
+  end
+end

data/lib/default_where/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DefaultWhere
-  VERSION = '2.2.0'
-end
+  VERSION = '2.3.0'
+end

data/test/config/database.yml

@@ -0,0 +1,32 @@
+default: &default
+  adapter: mysql2
+  encoding: utf8
+  pool: 5
+  username: root
+  password: root123_ROOT
+  socket: /tmp/mysql.sock
+
+development:
+  <<: *default
+  database: default_where_development
+
+test:
+  <<: *default
+  database: default_where_test
+
+sqlite:
+  adapter: sqlite3
+  database: "file:memdb1?mode=memory&cache=shared"
+
+mysql:
+  adapter: mysql2
+  username: root
+  password: root
+  database: default_where
+
+postgresql:
+  adapter: postgresql
+  username: postgres
+  password:
+  database: default_where
+  min_messages: ERROR

data/test/config/database.yml.example

@@ -0,0 +1,32 @@
+default: &default
+  adapter: mysql2
+  encoding: utf8
+  pool: 5
+  username: root
+  password: root123_ROOT
+  socket: /tmp/mysql.sock
+
+development:
+  <<: *default
+  database: default_where_development
+
+test:
+  <<: *default
+  database: default_where_test
+
+sqlite:
+  adapter: sqlite3
+  database: "file:memdb1?mode=memory&cache=shared"
+
+mysql:
+  adapter: mysql2
+  username: root
+  password: root
+  database: default_where
+
+postgresql:
+  adapter: postgresql
+  username: postgres
+  password:
+  database: default_where
+  min_messages: ERROR

data/test/default_where_test.rb

@@ -1,16 +1,19 @@
 require 'helper'
+require 'models/user'
 
 class DefaultWhereTest < ActiveSupport::TestCase
 
-  test "truth" do
+  test 'truth' do
     assert_kind_of Module, DefaultWhere
   end
 
-  test "" do
+  test 'basic' do
+    create :user
     params = { id: 1, uid: 2, name: 3 }
     options = { signs: 'name' }
 
-
+    count = User.default_where(name: 'qinmingyuan').count
+    assert_equal 1, count
   end
 
 end

data/test/factories/users.rb

@@ -0,0 +1,7 @@
+FactoryBot.define do
+
+  factory :user do
+    name 'qinmingyuan'
+  end
+
+end

data/test/helper.rb

@@ -1,24 +1,25 @@
-# $DEBUG = true
+require 'active_record'
+require 'minitest/autorun'
+require 'factory_bot'
 
-require "rubygems"
-require "bundler/setup"
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
+ActiveRecord::Schema.verbose = false
+ActiveRecord::Tasks::DatabaseTasks.database_configuration = YAML.load_file('test/config/database.yml')
+ActiveRecord::Base.configurations = ActiveRecord::Tasks::DatabaseTasks.database_configuration
+ActiveRecord::Base.establish_connection :test
+
+if defined?(FactoryBot)
+  FactoryBot.definition_file_paths << File.expand_path('test/factories', __dir__)
+  FactoryBot.find_definitions
 end
-require "active_record"
-require "minitest/autorun"
 
-db_config = YAML.load_file(File.expand_path("../database.yml", __FILE__)).fetch(ENV["DB"] || "sqlite")
-ActiveRecord::Base.establish_connection(db_config)
-ActiveRecord::Schema.verbose = false
+class ActiveSupport::TestCase
+  include FactoryBot::Syntax::Methods
+end
 
 def teardown_db
   tables = ActiveRecord::Base.connection.data_sources
   tables.each do |table|
-    ActiveRecord::Base.connection.drop_table(table)
+    ActiveRecord::Base.connection.truncate(table)
   end
-end
+end
+teardown_db

data/test/migrations/20180508082145_test_init.rb

@@ -0,0 +1,12 @@
+class TestInit < ActiveRecord::Migration[5.2]
+  def change
+    create_table :users do |t|
+      t.string :name
+    end
+
+    create_table :posts do |t|
+      t.string :title
+      t.references :user
+    end
+  end
+end

data/test/models/user.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+require 'default_where'
+class User < ActiveRecord::Base
+  extend DefaultWhere
+
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: default_where
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - qinmingyuan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-02 00:00:00.000000000 Z
+date: 2021-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,61 +16,71 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: '4.0'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: '4.0'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '7.0'
 - !ruby/object:Gem::Dependency
-  name: rdoc
+  name: sdoc
   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: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '12.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: Description of QueryScope.
+        version: '12.3'
+description: Default where
 email:
 - mingyuan0715@foxmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- MIT-LICENSE
+- LICENSE
 - README.md
 - Rakefile
 - lib/default_where.rb
-- lib/default_where/like.rb
-- lib/default_where/not.rb
+- lib/default_where/group.rb
 - lib/default_where/order.rb
-- lib/default_where/range.rb
+- lib/default_where/params.rb
+- lib/default_where/scope.rb
 - lib/default_where/version.rb
-- test/database.yml
+- test/config/database.yml
+- test/config/database.yml.example
 - test/default_where_test.rb
+- test/factories/users.rb
 - test/helper.rb
+- test/migrations/20180508082145_test_init.rb
+- test/models/user.rb
 homepage: https://github.com/qinmingyuan/default_where
 licenses:
 - MIT
@@ -90,12 +100,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: default process params for where
 test_files:
+- test/config/database.yml
+- test/config/database.yml.example
 - test/default_where_test.rb
+- test/factories/users.rb
 - test/helper.rb
-- test/database.yml
+- test/migrations/20180508082145_test_init.rb
+- test/models/user.rb

data/lib/default_where/like.rb

@@ -1,37 +0,0 @@
-module DefaultWhere
-  module Like
-
-    def like_scope(params)
-      where_string = []
-      where_hash = {}
-
-      params.select{ |k, _| k.end_with?('-like') }.each do |key, value|
-        real_key = key.sub(/-like$/, '')
-        agent_key = key.gsub(/[-.]/, '_')
-
-        if column_names.include?(real_key)
-          real_key = "#{table_name}.#{real_key}"
-        end
-
-        where_string << "#{real_key} like :#{agent_key}"
-        where_hash.merge! agent_key.to_sym => '%' + value.to_s + '%'
-      end
-
-      where_string = where_string.join ' AND '
-
-      if where_string.present?
-        condition = [where_string, where_hash]
-        where(condition)
-      else
-        all
-      end
-    end
-
-    def filter_like(params)
-      params.select do |k, _|
-        k.end_with?('-like')
-      end
-    end
-
-  end
-end

data/lib/default_where/not.rb

@@ -1,32 +0,0 @@
-module DefaultWhere
-  module Not
-
-    def not_scope(params)
-      where_hash = {}
-
-      params.each do |key, value|
-        real_key = key.sub(/-not$/, '')
-
-        if column_names.include?(real_key)
-          real_key = "#{table_name}.#{real_key}"
-        end
-
-        where_hash.merge! real_key => value
-      end
-
-      if where_hash.present?
-        where.not(where_hash)
-      else
-        all
-      end
-    end
-
-    def filter_not(params)
-      params.select do |k, _|
-        k.end_with?('-not')
-      end
-    end
-
-  end
-end
-

data/lib/default_where/range.rb

@@ -1,50 +0,0 @@
-module DefaultWhere
-  module Range
-
-    PATTERN = {
-      '-gt' => '>',
-      '-gte' => '>=',
-      '-lt' => '<',
-      '-lte' => '<='
-    }
-
-    def range_scope(params)
-      where_string = []
-      where_hash = {}
-
-      PATTERN.each do |char, sign|
-        options = params.select{ |key, _| key.end_with?(char) }
-
-        options.each do |key, value|
-          exp = Regexp.new(char + '$')
-          real_key = key.sub(exp, '')
-          agent_key = key.gsub(/[-.]/, '_')
-
-          if column_names.include?(real_key)
-            real_key = "#{table_name}.#{real_key}"
-          end
-
-          where_string << "#{real_key} #{sign} :#{agent_key}"
-
-          where_hash.merge! agent_key.to_sym => value
-        end
-      end
-
-      where_string = where_string.join ' AND '
-
-      if where_string.present?
-        condition = [where_string, where_hash]
-        where(condition)
-      else
-        all
-      end
-    end
-
-    def filter_range(params)
-      params.select do |k, _|
-        k.end_with?(*PATTERN.keys)
-      end
-    end
-
-  end
-end

data/test/database.yml

@@ -1,16 +0,0 @@
-sqlite:
-  adapter: sqlite3
-  database: "file:memdb1?mode=memory&cache=shared"
-
-mysql:
-  adapter: mysql2
-  username: root
-  password:
-  database: default_where
-
-postgresql:
-  adapter: postgresql
-  username: postgres
-  password:
-  database: default_where
-  min_messages: ERROR