type_scopes 0.1.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e6f3c1b8e9ddeff61759d2244082f11058895dd1
-  data.tar.gz: 388729c5dee7cd2e6fd6668e558618ad68a236b4
+SHA256:
+  metadata.gz: d3ac3e90478e5e0aca44a37d9422d212af77ea01939072b12845d19f139ba3e2
+  data.tar.gz: 3fd3b0d8964ed751f3c304c91e0298ee4d4d8eb56a325ccb350193d4f92ea412
 SHA512:
-  metadata.gz: 9abff35463947151c2ab63053c7fda13ee2107c08f4a979ef0354224a20ea0dd6686392e49ae0319ed053f5df7473b9717e6838ffe983e81a4835627d310e277
-  data.tar.gz: 1dd119ba66eba838255ae0d7458e03459b7a493d01a489f2883d9ec093e9e9aa2651b10a878f4bd8f7fc53d72764702b5cb94a6da397cd5a549fa6cb9390a48a
+  metadata.gz: 322664b363b060bed5a744449975593bbb28c2b01a67b614a0dbc3325aea7f9ba57c3b048db250ff4bf2fbf515e28ed4d657b5744a2634bb27052232fc06c2cb
+  data.tar.gz: eb7388daf228f71ce4437134cb78b1369e8e75214d6f147c76e28aa71aac454e425cb5624c2ed434e5c816aca343bc946ff87cb9a6b3a77d31190e37b0c10ae4

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem "rake"
+gem "activerecord", ">= 6.1.3.2"
+gem "sqlite3"
+gem "pg"

data/Gemfile.lock

@@ -0,0 +1,36 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.1.3.2)
+      activesupport (= 6.1.3.2)
+    activerecord (6.1.3.2)
+      activemodel (= 6.1.3.2)
+      activesupport (= 6.1.3.2)
+    activesupport (6.1.3.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    concurrent-ruby (1.1.9)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    minitest (5.14.4)
+    pg (1.2.3)
+    rake (13.0.3)
+    sqlite3 (1.4.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 6.1.3.2)
+  pg
+  rake
+  sqlite3
+
+BUNDLED WITH
+   2.1.4

data/README.md

@@ -1,24 +1,27 @@
 # Type Scopes
 
-Type scopes creates useful scopes based on the type of the columns of your models.
-It handles dates, times, strings and numerics.
+Type scopes creates useful semantic scopes based on the type of the columns of your models.
+It handles dates, times, strings, numerics and booleans.
 
-Here is an example of all the available scopes:
+Here are examples for all the available scopes:
 
 ```ruby
 # paid_at: datetime
 # amount: decimal
 # description: string
 class Transaction < ActiveRecord::Base
-  include TypeScopes
+  TypeScopes.inject self
 end
 
 # Time scopes
-Transaction.paid_to("2017-09-06") # => where("paid_to <= '2017-09-06'")
-Transaction.paid_from("2017-09-06") # => where("paid_to >= '2017-09-06'")
-Transaction.paid_after("2017-09-06") # => where("paid_to > '2017-09-06'")
-Transaction.paid_before("2017-09-06") #= where("paid_to < '2017-09-06'")
-Transaction.paid_between("2017-09-06", "2017-09-07")  # => where("paid_to BETWEEN '2017-09-06' AND '2017-09-07'")
+Transaction.paid_to("2017-09-06") # => where("paid_at <= '2017-09-06'")
+Transaction.paid_from("2017-09-06") # => where("paid_at >= '2017-09-06'")
+Transaction.paid_after("2017-09-06") # => where("paid_at > '2017-09-06'")
+Transaction.paid_before("2017-09-06") #= where("paid_at < '2017-09-06'")
+Transaction.paid_between("2017-09-06", "2017-09-07")  # => where("paid_at BETWEEN '2017-09-06' AND '2017-09-07'")
+Transaction.paid_not_between("2017-09-06", "2017-09-07")  # => where("paid_at NOT BETWEEN '2017-09-06' AND '2017-09-07'")
+Transaction.paid_within("2017-09-06", "2017-09-07")  # => where("paid_at > '2017-09-06' AND paid_at < '2017-09-07'")
+Transaction.paid_not_within("2017-09-06", "2017-09-07")  # => where("paid_at <= '2017-09-06' OR paid_at >= '2017-09-07'")
 
 # Numeric scopes
 Transaction.amount_to(100) # => where("amount <= 100")
@@ -26,14 +29,40 @@ Transaction.amount_from(100) # => where("amount >= 100")
 Transaction.amount_above(100) # => where("amount > 100")
 Transaction.amount_below(100) # => where("amount < 100")
 Transaction.amount_between(100, 200) # => where("amount BETWEEN 100 AND 200")
+Transaction.amount_not_between(100, 200) # => where("amount NOT BETWEEN 100 AND 200")
+Transaction.amount_within(100, 200) # => where("amount > 100 AND amount < 200")
+Transaction.amount_not_within(100, 200) # => where("amount <= 100 OR amount >= 200")
 
 # String scopes
 Transaction.description_contains("foo") # => where("description LIKE '%foo%'")
+Transaction.description_contains("foo", sensitive: false) # => where("description ILIKE '%foo%'")
 Transaction.description_starts_with("foo") # => where("description LIKE 'foo%'")
+Transaction.description_starts_with("foo", sensitive: false) # => where("description ILIKE 'foo%'")
+Transaction.description_does_not_start_with("foo") # => where("description NOT LIKE 'foo%'")
+Transaction.description_does_not_start_with("foo", sensitive: false) # => where("description NOT ILIKE 'foo%'")
 Transaction.description_ends_with("foo") # => where("description LIKE '%foo'")
+Transaction.description_ends_with("foo", sensitive: false) # => where("description ILIKE '%foo'")
+Transaction.description_does_not_end_with("foo") # => where("description NOT LIKE '%foo'")
+Transaction.description_does_not_end_with("foo", sensitive: false) # => where("description NOT ILIKE '%foo'")
+Transaction.description_like("%foo%") # => where("description LIKE '%foo%'")
+Transaction.description_not_like("%foo%") # => where("description NOT LIKE '%foo%'")
+Transaction.description_ilike("%foo%") # => where("description ILIKE '%foo%'")
+Transaction.description_not_ilike("%foo%") # => where("description NOT ILIKE '%foo%'")
+Transaction.description_matches("^Regex$") # => where("description ~ '^Regex$'")
+Transaction.description_does_not_match("^Regex$") # => where("description !~ '^Regex$'")
+
+# Boolean scopes
+Transaction.non_profit # => where("non_profit = true")
+Transaction.not_non_profit # => where("non_profit = false")
+Transaction.is_valid # => where("is_valid = true")
+Transaction.is_not_valid # => where("is_valid = false")
+Transaction.has_payment # => where("has_payment = true")
+Transaction.has_not_payment # => where("has_payment = false")
+Transaction.was_processed # => where("was_processed = true")
+Transaction.was_not_processed # => where("was_processed = false")
 ```
 
-For the string scope the pattern matching is escaped:
+For the string colums, the pattern matching is escaped. So it's safe to provide directly a user input. There is an exception for the `column_like`, `column_ilike`, `column_matches` and `column_does_not_match` where the pattern is not escaped and you shouldn't provide untrusted strings.
 
 ```ruby
 Transaction.description_contains("%foo_") # => where("description LIKE '%[%]foo[_]%'")
@@ -41,26 +70,21 @@ Transaction.description_contains("%foo_") # => where("description LIKE '%[%]foo[
 
 ## Install
 
-Add to your Gemfile:
+Add to your Gemfile `gem "type_scopes"` and run in your terminal `bundle install`. Then call `TypeScopes.inject` from your models:
 
 ```ruby
-gem "type_scopes"
-```
-
-And run in your terminal:
-
-```shell
-bundle install
-```
+# /app/models/transaction.rb
+class Transaction < ApplicationRecord
+  # Creates scope for all supported column types
+  TypeScopes.inject self
 
-Then include TypeScopes from your models:
-
-```ruby
-class Transaction < ActiveRecord::Base
-  include TypeScopes
+  # Or if you prefer to enable scopes for specific columns only
+  TypeScopes.inject self, :amount, :paid_at
 end
 ```
 
+In case there is a conflict with a scope name, TypeScopes won't over write your existing scope. You can safely inject TypeScopes and it won't break any scope defined previously.
+
 ## MIT License
 
 Made by [Base Secrète](https://basesecrete.com/en).

data/Rakefile

@@ -0,0 +1,8 @@
+require "rake/testtask"
+
+Rake::TestTask.new :test do |t|
+  t.libs = ["lib", "test"]
+  t.pattern = "test/**/*_test.rb"
+end
+
+task default: :test

data/lib/type_scopes/boolean.rb

@@ -0,0 +1,15 @@
+class TypeScopes::Boolean < TypeScopes
+  def self.types
+    ["bool", "boolean", "tinyint(1)"].freeze
+  end
+
+  def self.inject_for_column(model, name)
+    append_scope(model, :"#{name}", lambda { where(name => true) })
+    prefix, suffix = /\A(has|is|was)_(.+)\z/.match(name).to_a[1..2]
+    if prefix && suffix
+      append_scope(model, :"#{prefix}_not_#{suffix}", lambda { where(name => false) })
+    else
+      append_scope(model, :"not_#{name}", lambda { where(name => false) })
+    end
+  end
+end

data/lib/type_scopes/numeric.rb

@@ -0,0 +1,17 @@
+class TypeScopes::Numeric < TypeScopes
+  def self.types
+    ["integer", "double precision", "numeric", "bigint", "decimal"].freeze
+  end
+
+  def self.inject_for_column(model, name)
+    column = model.arel_table[name]
+    append_scope(model, :"#{name}_to", lambda { |value| where(column.lteq(value)) })
+    append_scope(model, :"#{name}_from", lambda { |value| where(column.gteq(value)) })
+    append_scope(model, :"#{name}_above", lambda { |value| where(column.gt(value)) })
+    append_scope(model, :"#{name}_below", lambda { |value| where(column.lt(value)) })
+    append_scope(model, :"#{name}_between", lambda { |from, to| where(name => from..to) })
+    append_scope(model, :"#{name}_not_between", lambda { |from, to| where.not(name => from..to) })
+    append_scope(model, :"#{name}_within", lambda { |from, to| where(column.gt(from)).where(column.lt(to)) })
+    append_scope(model, :"#{name}_not_within", lambda { |from, to| where(column.lteq(from).or(column.gteq(to))) })
+  end
+end

data/lib/type_scopes/string.rb

@@ -0,0 +1,50 @@
+class TypeScopes::String < TypeScopes
+  def self.types
+    ["character", "text", "varchar"].freeze
+  end
+
+  def self.escape(string)
+    string = string.gsub("%".freeze, "[%]".freeze)
+    string.gsub!("_".freeze, "[_]".freeze)
+    string
+  end
+
+  def self.inject_for_column(model, name)
+    column = model.arel_table[name]
+    append_scope(model, :"#{name}_like", lambda { |str, sensitive: true| where(column.matches(str, nil, sensitive)) })
+    append_scope(model, :"#{name}_not_like", lambda { |str, sensitive: true| where(column.does_not_match(str, nil, sensitive)) })
+    append_scope(model, :"#{name}_ilike", lambda { |str| where(column.matches(str)) })
+    append_scope(model, :"#{name}_not_ilike", lambda { |str| where(column.does_not_match(str)) })
+
+    append_scope(model, :"#{name}_contains", lambda { |str, sensitive: true|
+      send("#{name}_like", "%#{TypeScopes::String.escape(str)}%", sensitive: sensitive)
+    })
+
+    append_scope(model, :"#{name}_does_not_contain", lambda { |str, sensitive: true|
+      send("#{name}_not_like", "%#{TypeScopes::String.escape(str)}%", sensitive: sensitive)
+    })
+
+    append_scope(model, :"#{name}_does_not_contain", lambda { |str, sensitive: true|
+      send("#{name}_like", "%#{TypeScopes::String.escape(str)}%", sensitive: sensitive)
+    })
+
+    append_scope(model, :"#{name}_starts_with", lambda { |str, sensitive: true|
+      send("#{name}_like", "#{TypeScopes::String.escape(str)}%", sensitive: sensitive)
+    })
+
+    append_scope(model, :"#{name}_does_not_start_with", lambda { |str, sensitive: true|
+      send("#{name}_not_like", "#{TypeScopes::String.escape(str)}%", sensitive: sensitive)
+    })
+
+    append_scope(model, :"#{name}_ends_with", lambda { |str, sensitive: true|
+      send("#{name}_like", "%#{TypeScopes::String.escape(str)}", sensitive: sensitive)
+    })
+
+    append_scope(model, :"#{name}_does_not_end_with", lambda { |str, sensitive: true|
+      send("#{name}_not_like", "%#{TypeScopes::String.escape(str)}", sensitive: sensitive)
+    })
+
+    append_scope(model, :"#{name}_matches", lambda { |str, sensitive: true| where(column.matches_regexp(str, sensitive)) })
+    append_scope(model, :"#{name}_does_not_match", lambda { |str, sensitive: true| where(column.does_not_match_regexp(str, sensitive)) })
+  end
+end

data/lib/type_scopes/time.rb

@@ -0,0 +1,23 @@
+class TypeScopes::Time < TypeScopes
+  def self.types
+    ["timestamp", "datetime", "date"].freeze
+  end
+
+  def self.inject_for_column(model, name)
+    short_name = shorten_column_name(name)
+    column = model.arel_table[name]
+
+    append_scope(model, :"#{short_name}_to", lambda { |date| where(column.lteq(date)) })
+    append_scope(model, :"#{short_name}_from", lambda { |date| where(column.gteq(date)) })
+    append_scope(model, :"#{short_name}_after", lambda { |date| where(column.gt(date)) })
+    append_scope(model, :"#{short_name}_before", lambda { |date| where(column.lt(date)) })
+    append_scope(model, :"#{short_name}_between", lambda { |from, to| where(name => from..to) })
+    append_scope(model, :"#{short_name}_not_between", lambda { |from, to| where.not(name => from..to) })
+    append_scope(model, :"#{short_name}_within", lambda { |from, to| where(column.gt(from)).where(column.lt(to)) })
+    append_scope(model, :"#{short_name}_not_within", lambda { |from, to| where(column.lteq(from).or(column.gteq(to))) })
+  end
+
+  def self.shorten_column_name(name)
+    name.chomp("_at").chomp("_on")
+  end
+end

data/lib/type_scopes/version.rb

@@ -1,3 +1,3 @@
-module TypeScopes
-  VERSION = "0.1.0".freeze
+class TypeScopes
+  VERSION = "0.6.0".freeze
 end

data/lib/type_scopes.rb

@@ -1,11 +1,33 @@
-require "string_scopes"
-require "numeric_scopes"
-require "timestamp_scopes"
+class TypeScopes
+  def self.inject(model, column_names = model.columns.map(&:name))
+    for name in column_names
+      if column = model.columns_hash[name]
+        Time.support?(column.sql_type) && Time.inject_for_column(model, name)
+        String.support?(column.sql_type) && String.inject_for_column(model, name)
+        Numeric.support?(column.sql_type) && Numeric.inject_for_column(model, name)
+        Boolean.support?(column.sql_type) && Boolean.inject_for_column(model, name)
+      end
+    end
+  end
+
+  def self.append_scope(model, name, block)
+    model.scope(name, block) if !model.respond_to?(name, true)
+  end
+
+  def self.support?(column_type)
+    types.any? { |type| column_type.include?(type) }
+  end
+
+  def self.types
+    raise NotImplementedError
+  end
 
-module TypeScopes
-  def self.included(model)
-    model.include(StringScopes)
-    model.include(NumericScopes)
-    model.include(TimestampScopes)
+  def self.inject_for_column(model, name)
+    raise NotImplementedError
   end
 end
+
+require "type_scopes/time"
+require "type_scopes/string"
+require "type_scopes/numeric"
+require "type_scopes/boolean"

data/test/test_helper.rb

@@ -0,0 +1,44 @@
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+
+require "active_record"
+require "type_scopes"
+require "minitest/autorun"
+
+class TypeScopes::Transaction < ActiveRecord::Base
+  class Migration < ActiveRecord::Migration::Current
+    def up
+      drop_table :transactions, if_exists: true
+      create_table :transactions do |t|
+        t.decimal :amount, null: false
+        t.datetime :paid_at
+        t.string :description
+        t.boolean :non_profit, null: false, default: false
+        t.boolean :is_valid, null: false, default: false
+        t.boolean :has_payment, null: false, default: false
+        t.boolean :was_processed, null: false, default: false
+      end
+    end
+  end
+end
+
+class TypeScopes::TestCase < Minitest::Test
+  def self.initialize_database
+    # To run against Postgresql set variable : DATABASE_URL=postgres:///type_scopes?user=postgres
+    ActiveRecord::Base.establish_connection(ENV["DATABASE_URL"] || "sqlite3::memory:")
+    ActiveRecord::Migration.verbose = false
+    TypeScopes::Transaction::Migration.new.up
+    TypeScopes.inject TypeScopes::Transaction
+  end
+
+  def sql_adapter_like_case_sensitive?
+    # By default SQLite's like is case insensitive.
+    # So it's not possible to have the exact same tests with other databases.
+    ActiveRecord::Base.connection.adapter_name != "SQLite"
+  end
+
+  def sql_adapter_supports_regex?
+    ActiveRecord::Base.connection.adapter_name != "SQLite"
+  end
+end
+
+TypeScopes::TestCase.initialize_database

data/test/type_scopes/boolean_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class TypeScopes::BooleanTest < TypeScopes::TestCase
+  def setup
+    TypeScopes::Transaction.connection.truncate(TypeScopes::Transaction.table_name)
+    TypeScopes::Transaction.create!(amount: 100, paid_at: "2021-06-23", description: "First transaction")
+    TypeScopes::Transaction.create!(amount: 200, paid_at: "2021-06-24", description: "Last transaction")
+  end
+
+  def test_without_prefix
+    assert_equal(0, TypeScopes::Transaction.non_profit.count)
+    assert_equal(2, TypeScopes::Transaction.not_non_profit.count)
+  end
+
+  def test_has
+    assert_equal(0, TypeScopes::Transaction.has_payment.count)
+    assert_equal(2, TypeScopes::Transaction.has_not_payment.count)
+  end
+
+  def test_is
+    assert_equal(0, TypeScopes::Transaction.is_valid.count)
+    assert_equal(2, TypeScopes::Transaction.is_not_valid.count)
+  end
+
+  def test_was
+    assert_equal(0, TypeScopes::Transaction.was_processed.count)
+    assert_equal(2, TypeScopes::Transaction.was_not_processed.count)
+  end
+end

data/test/type_scopes/numeric_test.rb

@@ -0,0 +1,49 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class TypeScopes::NumericTest < TypeScopes::TestCase
+  def setup
+    TypeScopes::Transaction.connection.truncate(TypeScopes::Transaction.table_name)
+    TypeScopes::Transaction.create!(amount: 100)
+    TypeScopes::Transaction.create!(amount: 200)
+  end
+
+  def test_to
+    assert_equal(1, TypeScopes::Transaction.amount_to(199.99).count)
+    assert_equal(2, TypeScopes::Transaction.amount_to(200).count)
+  end
+
+  def test_from
+    assert_equal(2, TypeScopes::Transaction.amount_from(100).count)
+    assert_equal(1, TypeScopes::Transaction.amount_from(100.01).count)
+  end
+
+  def test_above
+    assert_equal(2, TypeScopes::Transaction.amount_above(99.99).count)
+    assert_equal(1, TypeScopes::Transaction.amount_above(100).count)
+  end
+
+  def test_below
+    assert_equal(1, TypeScopes::Transaction.amount_below(200).count)
+    assert_equal(2, TypeScopes::Transaction.amount_below(200.01).count)
+  end
+
+  def test_between
+    assert_equal(2, TypeScopes::Transaction.amount_between(100, 200).count)
+    assert_equal(0, TypeScopes::Transaction.amount_between(100.01, 199.99).count)
+  end
+
+  def test_not_between
+    assert_equal(0, TypeScopes::Transaction.amount_not_between(100, 200).count)
+    assert_equal(2, TypeScopes::Transaction.amount_not_between(100.01, 199.99).count)
+  end
+
+  def test_within
+    assert_equal(0, TypeScopes::Transaction.amount_within(100, 200).count)
+    assert_equal(2, TypeScopes::Transaction.amount_within(99.99, 200.01).count)
+  end
+
+  def test_not_within
+    assert_equal(2, TypeScopes::Transaction.amount_not_within(100, 200).count)
+    assert_equal(0, TypeScopes::Transaction.amount_not_within(99.99, 200.01).count)
+  end
+end

data/test/type_scopes/string_test.rb

@@ -0,0 +1,90 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class TypeScopes::StringTest < TypeScopes::TestCase
+  def setup
+    TypeScopes::Transaction.connection.truncate(TypeScopes::Transaction.table_name)
+    TypeScopes::Transaction.create!(amount: 100, paid_at: "2021-06-23", description: "Lorem ipsum")
+    TypeScopes::Transaction.create!(amount: 200, paid_at: "2021-06-24", description: "Lorem ipsum")
+  end
+
+  def test_like
+    assert_equal(2, TypeScopes::Transaction.description_like("%Lorem%").count)
+    return unless sql_adapter_like_case_sensitive?
+    assert_equal(0, TypeScopes::Transaction.description_like("%LOREM%").count)
+    assert_equal(2, TypeScopes::Transaction.description_like("%LOREM%", sensitive: false).count)
+  end
+
+  def test_not_like
+    assert_equal(0, TypeScopes::Transaction.description_not_like("%ipsum").count)
+    return unless sql_adapter_like_case_sensitive?
+    assert_equal(2, TypeScopes::Transaction.description_not_like("%IPSUM").count)
+    assert_equal(0, TypeScopes::Transaction.description_not_like("%IPSUM", sensitive: false).count)
+  end
+
+  def test_ilike
+    assert_equal(0, TypeScopes::Transaction.description_ilike("%xxx%").count)
+    assert_equal(2, TypeScopes::Transaction.description_ilike("LOREM%").count)
+  end
+
+  def test_not_ilike
+    assert_equal(0, TypeScopes::Transaction.description_not_ilike("%IPSUM").count)
+    assert_equal(2, TypeScopes::Transaction.description_not_ilike("%xxx%").count)
+  end
+
+  def test_contains
+    assert_equal(2, TypeScopes::Transaction.description_contains("m i").count)
+    assert_equal(0, TypeScopes::Transaction.description_contains("xxx").count)
+  end
+
+  def test_does_not_contain
+    assert_equal(0, TypeScopes::Transaction.description_does_not_contain("m i").count)
+    assert_equal(2, TypeScopes::Transaction.description_does_not_contain("xxx").count)
+  end
+
+  def test_starts_with
+    assert_equal(2, TypeScopes::Transaction.description_starts_with("Lorem").count)
+    assert_equal(2, TypeScopes::Transaction.description_starts_with("LOREM", sensitive: false).count)
+    return unless sql_adapter_like_case_sensitive?
+    assert_equal(0, TypeScopes::Transaction.description_starts_with("LOREM").count)
+  end
+
+  def test_does_not_start_with
+    assert_equal(0, TypeScopes::Transaction.description_does_not_start_with("Lorem").count)
+    assert_equal(0, TypeScopes::Transaction.description_does_not_start_with("LOREM", sensitive: false).count)
+    return unless sql_adapter_like_case_sensitive?
+    assert_equal(2, TypeScopes::Transaction.description_does_not_start_with("LOREM").count)
+  end
+
+  def test_ends_with
+    assert_equal(2, TypeScopes::Transaction.description_ends_with("ipsum").count)
+    assert_equal(2, TypeScopes::Transaction.description_ends_with("IPSUM", sensitive: false).count)
+    return unless sql_adapter_like_case_sensitive?
+    assert_equal(0, TypeScopes::Transaction.description_ends_with("IPSUM").count)
+  end
+
+  def test_does_not_end_with
+    assert_equal(0, TypeScopes::Transaction.description_does_not_end_with("ipsum").count)
+    assert_equal(0, TypeScopes::Transaction.description_does_not_end_with("IPSUM", sensitive: false).count)
+    return unless sql_adapter_like_case_sensitive?
+    assert_equal(2, TypeScopes::Transaction.description_does_not_end_with("IPSUM").count)
+  end
+
+  def test_escaped_characters
+    assert_equal(0, TypeScopes::Transaction.description_contains("%").count)
+    assert_equal(0, TypeScopes::Transaction.description_contains("_").count)
+  end
+
+  def test_matches
+    skip unless sql_adapter_supports_regex?
+    assert_equal(2, TypeScopes::Transaction.description_matches("Lorem.").count)
+    assert_equal(2, TypeScopes::Transaction.description_matches("LOREM.", sensitive: false).count)
+    assert_equal(0, TypeScopes::Transaction.description_matches("LOREM.").count)
+  end
+
+  def test_does_not_match
+    skip unless sql_adapter_supports_regex?
+    assert_equal(0, TypeScopes::Transaction.description_does_not_match("Lorem.").count)
+    assert_equal(0, TypeScopes::Transaction.description_does_not_match("LOREM.", sensitive: false).count)
+    assert_equal(2, TypeScopes::Transaction.description_does_not_match("LOREM.").count)
+  end
+end

data/test/type_scopes/time_test.rb

@@ -0,0 +1,49 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class TypeScopes::TimeTest < TypeScopes::TestCase
+  def setup
+    TypeScopes::Transaction.connection.truncate(TypeScopes::Transaction.table_name)
+    TypeScopes::Transaction.create!(amount: 100, paid_at: "2021-06-23")
+    TypeScopes::Transaction.create!(amount: 200, paid_at: "2021-06-24")
+  end
+
+  def test_to
+    assert_equal(1, TypeScopes::Transaction.paid_to("2021-06-23T23:59:59").count)
+    assert_equal(2, TypeScopes::Transaction.paid_to("2021-06-24T00:00:00").count)
+  end
+
+  def test_from
+    assert_equal(2, TypeScopes::Transaction.paid_from("2021-06-23").count)
+    assert_equal(1, TypeScopes::Transaction.paid_from("2021-06-23T00:00:01").count)
+  end
+
+  def test_above
+    assert_equal(2, TypeScopes::Transaction.paid_after("2021-06-22T23:59:59").count)
+    assert_equal(1, TypeScopes::Transaction.paid_after("2021-06-23T00:00:00").count)
+  end
+
+  def test_below
+    assert_equal(1, TypeScopes::Transaction.paid_before("2021-06-24").count)
+    assert_equal(2, TypeScopes::Transaction.paid_before("2021-06-24T00:00:01").count)
+  end
+
+  def test_between
+    assert_equal(2, TypeScopes::Transaction.paid_between("2021-06-23", "2021-06-24T00:00:00").count)
+    assert_equal(0, TypeScopes::Transaction.paid_between("2021-06-23T00:00:01", "2021-06-23T23:59:59").count)
+  end
+
+  def test_not_between
+    assert_equal(0, TypeScopes::Transaction.paid_not_between("2021-06-23", "2021-06-24T00:00:00").count)
+    assert_equal(2, TypeScopes::Transaction.paid_not_between("2021-06-23T00:00:01", "2021-06-23T23:59:59").count)
+  end
+
+  def test_within
+    assert_equal(0, TypeScopes::Transaction.paid_within("2021-06-23T00:00:00", "2021-06-24").count)
+    assert_equal(2, TypeScopes::Transaction.paid_within("2021-06-22T23:59:59", "2021-06-24T:00:00:01").count)
+  end
+
+  def test_not_within
+    assert_equal(2, TypeScopes::Transaction.paid_not_within("2021-06-23T00:00:00", "2021-06-24").count)
+    assert_equal(0, TypeScopes::Transaction.paid_not_within("2021-06-22T23:59:59", "2021-06-24T:00:00:01").count)
+  end
+end

data/type_scopes.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = TypeScopes::VERSION
   spec.authors       = ["Alexis Bernard"]
   spec.email         = ["alexis@bernard.io"]
-  spec.summary       = "Automatic scopes for ActiveRecord models."
-  spec.description   = "Useful scopes based on columns' types (dates, times, strings and numerics)."
+  spec.summary       = "Semantic scopes for your ActiveRecord models."
+  spec.description   = "Automatically create semantic scopes based on columns' types (dates, times, strings and numerics)."
   spec.homepage      = "https://github.com/BaseSecrete/type_scopes"
   spec.license       = "MIT"
 

metadata

@@ -1,28 +1,38 @@
 --- !ruby/object:Gem::Specification
 name: type_scopes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Alexis Bernard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-06 00:00:00.000000000 Z
+date: 2021-10-15 00:00:00.000000000 Z
 dependencies: []
-description: Useful scopes based on columns' types (dates, times, strings and numerics).
+description: Automatically create semantic scopes based on columns' types (dates,
+  times, strings and numerics).
 email:
 - alexis@bernard.io
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Gemfile
+- Gemfile.lock
 - README.md
-- lib/numeric_scopes.rb
-- lib/string_scopes.rb
-- lib/timestamp_scopes.rb
+- Rakefile
 - lib/type_scopes.rb
+- lib/type_scopes/boolean.rb
+- lib/type_scopes/numeric.rb
+- lib/type_scopes/string.rb
+- lib/type_scopes/time.rb
 - lib/type_scopes/version.rb
+- test/test_helper.rb
+- test/type_scopes/boolean_test.rb
+- test/type_scopes/numeric_test.rb
+- test/type_scopes/string_test.rb
+- test/type_scopes/time_test.rb
 - type_scopes.gemspec
 homepage: https://github.com/BaseSecrete/type_scopes
 licenses:
@@ -43,10 +53,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
-summary: Automatic scopes for ActiveRecord models.
-test_files: []
-has_rdoc: 
+summary: Semantic scopes for your ActiveRecord models.
+test_files:
+- test/test_helper.rb
+- test/type_scopes/boolean_test.rb
+- test/type_scopes/numeric_test.rb
+- test/type_scopes/string_test.rb
+- test/type_scopes/time_test.rb

data/lib/numeric_scopes.rb

@@ -1,24 +0,0 @@
-module NumericScopes
-  def self.included(model)
-    model.extend(ClassMethods)
-    model.create_numeric_scopes
-  end
-
-  module ClassMethods
-    def create_numeric_scopes
-      for column in columns
-        if column.sql_type.index("integer") == 0
-          create_numeric_scopes_for_column(column.name)
-        end
-      end
-    end
-
-    def create_numeric_scopes_for_column(name)
-      scope :"#{name}_to", lambda { |value| where("#{quoted_table_name}.#{name} <= ?", value) }
-      scope :"#{name}_from", lambda { |value| where("#{quoted_table_name}.#{name} >= ?", value) }
-      scope :"#{name}_above", lambda { |value| where("#{quoted_table_name}.#{name} > ?", value) }
-      scope :"#{name}_below", lambda { |value| where("#{quoted_table_name}.#{name} < ?", value) }
-      scope :"#{name}_between", lambda { |from, to| where("#{quoted_table_name}.#{name} BETWEEN ? AND ?", from, to) }
-    end
-  end
-end

data/lib/string_scopes.rb

@@ -1,28 +0,0 @@
-module StringScopes
-  def self.included(model)
-    model.extend(ClassMethods)
-    model.create_string_scopes
-  end
-
-  def self.escape(string)
-    string = string.gsub("%".freeze, "[%]".freeze)
-    string.gsub!("_".freeze, "[_]".freeze)
-    string
-  end
-
-  module ClassMethods
-    def create_string_scopes
-      for column in columns
-        if column.sql_type.index("character") == 0 || column.sql_type.index("text") == 0
-          create_string_scopes_for_column(column.name)
-        end
-      end
-    end
-
-    def create_string_scopes_for_column(name)
-      scope :"#{name}_contains", lambda { |str| where("#{quoted_table_name}.#{name} LIKE ?", "%#{StringScopes.escape(str)}%") }
-      scope :"#{name}_starts_with", lambda { |str| where("#{quoted_table_name}.#{name} LIKE ?", "#{StringScopes.escape(str)}%") }
-      scope :"#{name}_ends_with", lambda { |str| where("#{quoted_table_name}.#{name} LIKE ?", "%#{StringScopes.escape(str)}") }
-    end
-  end
-end

data/lib/timestamp_scopes.rb

@@ -1,29 +0,0 @@
-module TimestampScopes
-  def self.included(model)
-    model.extend(ClassMethods)
-    model.create_timestamp_scopes
-  end
-
-  module ClassMethods
-    def create_timestamp_scopes
-      for column in columns
-        if column.sql_type.index("timestamp") == 0
-          create_timestamp_scopes_for_column(column.name)
-        end
-      end
-    end
-
-    def create_timestamp_scopes_for_column(name)
-      short_name = shorten_column_name(name)
-      scope :"#{short_name}_to", lambda { |date| where("#{quoted_table_name}.#{name} <= ?", date) }
-      scope :"#{short_name}_from", lambda { |date| where("#{quoted_table_name}.#{name} >= ?", date) }
-      scope :"#{short_name}_after", lambda { |date| where("#{quoted_table_name}.#{name} > ?", date) }
-      scope :"#{short_name}_before", lambda { |date| where("#{quoted_table_name}.#{name} < ?", date) }
-      scope :"#{short_name}_between", lambda { |from, to| where("#{quoted_table_name}.#{name} BETWEEN ? AND ?", from, to) }
-    end
-
-    def shorten_column_name(name)
-      name.chomp("_at").chomp("_on")
-    end
-  end
-end