type_scopes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e6f3c1b8e9ddeff61759d2244082f11058895dd1
+  data.tar.gz: 388729c5dee7cd2e6fd6668e558618ad68a236b4
+SHA512:
+  metadata.gz: 9abff35463947151c2ab63053c7fda13ee2107c08f4a979ef0354224a20ea0dd6686392e49ae0319ed053f5df7473b9717e6838ffe983e81a4835627d310e277
+  data.tar.gz: 1dd119ba66eba838255ae0d7458e03459b7a493d01a489f2883d9ec093e9e9aa2651b10a878f4bd8f7fc53d72764702b5cb94a6da397cd5a549fa6cb9390a48a

data/README.md

@@ -0,0 +1,68 @@
+# Type Scopes
+
+Type scopes creates useful scopes based on the type of the columns of your models.
+It handles dates, times, strings and numerics.
+
+Here is an example of all the available scopes:
+
+```ruby
+# paid_at: datetime
+# amount: decimal
+# description: string
+class Transaction < ActiveRecord::Base
+  include TypeScopes
+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'")
+
+# Numeric scopes
+Transaction.amount_to(100) # => where("amount <= 100")
+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")
+
+# String scopes
+Transaction.description_contains("foo") # => where("description LIKE '%foo%'")
+Transaction.description_starts_with("foo") # => where("description LIKE 'foo%'")
+Transaction.description_ends_with("foo") # => where("description LIKE '%foo'")
+```
+
+For the string scope the pattern matching is escaped:
+
+```ruby
+Transaction.description_contains("%foo_") # => where("description LIKE '%[%]foo[_]%'")
+```
+
+## Install
+
+Add to your Gemfile:
+
+```ruby
+gem "type_scopes"
+```
+
+And run in your terminal:
+
+```shell
+bundle install
+```
+
+Then include TypeScopes from your models:
+
+```ruby
+class Transaction < ActiveRecord::Base
+  include TypeScopes
+end
+```
+
+## MIT License
+
+Made by [Base Secrète](https://basesecrete.com/en).
+
+Rails developer? Check out [RoRvsWild](https://www.rorvswild.com), our Ruby on Rails application monitoring tool.

data/lib/numeric_scopes.rb

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,29 @@
+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

data/lib/type_scopes/version.rb

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

data/lib/type_scopes.rb

@@ -0,0 +1,11 @@
+require "string_scopes"
+require "numeric_scopes"
+require "timestamp_scopes"
+
+module TypeScopes
+  def self.included(model)
+    model.include(StringScopes)
+    model.include(NumericScopes)
+    model.include(TimestampScopes)
+  end
+end

data/type_scopes.gemspec

@@ -0,0 +1,20 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'type_scopes/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "type_scopes"
+  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.homepage      = "https://github.com/BaseSecrete/type_scopes"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: type_scopes
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alexis Bernard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-06 00:00:00.000000000 Z
+dependencies: []
+description: Useful scopes based on columns' types (dates, times, strings and numerics).
+email:
+- alexis@bernard.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/numeric_scopes.rb
+- lib/string_scopes.rb
+- lib/timestamp_scopes.rb
+- lib/type_scopes.rb
+- lib/type_scopes/version.rb
+- type_scopes.gemspec
+homepage: https://github.com/BaseSecrete/type_scopes
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Automatic scopes for ActiveRecord models.
+test_files: []
+has_rdoc: