whereable 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea1b122fb55b9fca4d22efd7d32057bbc198ef97f4090bdf8bdaa42da6b15a7f
-  data.tar.gz: 8a0d13ea659a80ca2f34df1e7e970ee6716bed272a36e288472a1827c6b61855
+  metadata.gz: a63f7a79cff3aa76f6c0d05d15bb318476188870cc121e6e7d1d9d44de2e4349
+  data.tar.gz: 58283edffdd9ccbe6283f0c7cba5d52342a0b37460fac7e747393442f3746e52
 SHA512:
-  metadata.gz: 1e66e7d892444322c226af98aedd2639b31d3ebb1444bd6337582c6e40248dd2276b183ad70e6794430f0ed0cfa6618fccc37a9308ddf2a50c53453db74e05ac
-  data.tar.gz: 2552253cb5f31f90d5830a95db7f0f328b05f477e8f31709cb76234ebcfb3782709e322e1fa8c45b48b8645e413ac5d40f0f81045b7521979875d7432fece3bd
+  metadata.gz: a9bd520efc357f0f8391bcfe56af756ca462f107a7a7919c81bb9825e0790eb99499f372a570ddf3d3d8aea18ae503b11b07ef4cd64405a407b160c0bb0ff18d
+  data.tar.gz: af2956f56cb244f79d96bea6301f41a87b8e5bb8ede3df4bf0e71223e7dc71b1dea3e8a53dde6d471d8a74dcbc5f12e5e2af130cee77cc23b585aee48c9f6f2e

data/CHANGELOG.md

@@ -1,8 +1,11 @@
 Release History
 ===============
+# 0.2.0
+* Add support for IN and BETWEEN
+
 # 0.1.2
-* Appears to work with Ruby 2.3.0 and ActiveRecord 4.1.0 or newer.
-  However, there's a version conflict surrounding Treetop in Rails < 4.1.6.
+* Minor changes to play nice with older versions of Rails
+* Update gemspec dependencies based on additional testing
 
 # 0.1.1
 * Make operators case-insensitive

data/README.md

@@ -3,7 +3,7 @@
 # Whereable
 
 Translates where-like filter syntax into an Arel-based ActiveRecord scope, so you can safely use SQL syntax in Rails controller parameters.
-Not as powerful as [Ransack](https://github.com/activerecord-hackery/ransack), but simple and lightweight.
+What it lacks in power, it gains in simplicity and ease of use for API consumers.
 
 ## Installation
 
@@ -30,6 +30,8 @@ class User < ActiveRecord::Base
 
   validates :username, presence: true, uniqueness: true
 
+  validates :born_on, presence: true
+
   enum role: { standard: 0, admin: 1 }
 end
 ```
@@ -37,15 +39,16 @@ With this data:
 ``` ruby
 User.create!(username: 'Morpheus', role: :admin, born_on: '1961-07-30')
 User.create!(username: 'Neo', role: :standard, born_on: '1964-09-02')
+User.create!(username: 'Trinity', role: :standard, born_on: '1967-08-21')
 ```
 Let's assume you're allowing filtered API access to your Users,
 but using the `#standard` scope to keep admins hidden. So your controller might include:
 ``` ruby
 User.standard.where(params[:filter])
 ```
-And your white hat API consumers pass in `filter=born_on < '1970-11-11'` to get Users over 50, and &hellip;
+And your white hat API consumers pass in `filter=born_on < '1967-01-01'`, and &hellip;
 ``` ruby
-User.standard.where("born_on < '1970-11-11'")
+User.standard.where("born_on < '1967-01-01'")
 ```
 returns Neo as expected, so we're all good.
 
@@ -65,7 +68,7 @@ User.standard.whereable(params[:filter])
 ```
 And then &hellip;
 ``` ruby
-User.standard.whereable("born_on < '1970-11-11'")
+User.standard.whereable("born_on < '1967-01-01'")
 ```
 returns Neo as before, but &hellip;
 ``` ruby
@@ -78,9 +81,13 @@ Whereable::FilterInvalid ('Invalid filter at ) or (true')
 
 ### Syntax
 * Supports and/or with nested parentheses as needed
-* Recognizes these operators: `eq ne gte gt lte lt = != <> >= > <= <`
-* Column must be to left of operator, and literal to right
-  * Comparing columns is *not* supported
+* Recognizes these operators: `eq ne gte gt lte lt = != <> >= > <= <`, plus `IN` and `BETWEEN`
+* Column must be to left of operator, and literal(s) to right
+  * Comparing columns to each other is *not* supported
+  * `BETWEEN` requires two literals separated by `AND`
+    * Example: `publish_at between '2020-11-01 12:00 EST' and '2020-11-15 23:59:59 EST'`
+  * `IN` requires comma-separated literals in parentheses
+    * Example: `username in (Morpheus, Trinity)`
 * Quotes are optional unless the literal contains spaces or quotes
   * Supports double or single quotes, and embedded quotes may be backslash escaped
   * Also supports the PostgreSQL double-single embedded quote
@@ -88,6 +95,9 @@ Whereable::FilterInvalid ('Invalid filter at ) or (true')
   * 👍 `User.whereable('role = admin')`
   * 👎 `User.whereable('role = 1')`
 
+### More
+See the [Wiki](https://github.com/MacksMind/whereable/wiki) for more.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/whereable.rb

@@ -4,8 +4,7 @@
 
 require 'whereable/version'
 require 'active_record'
-require 'treetop'
-require 'whereable.treetop'
+require 'whereable_clause'
 
 # Whereable module
 module Whereable
@@ -13,85 +12,6 @@ module Whereable
 
   class FilterInvalid < StandardError; end
 
-  module Disjunction
-    # Hash for OR
-    def to_h
-      return conjunction.to_h if opt.empty?
-
-      {
-        or: [conjunction.to_h] + opt.elements.map { |o| o.conjunction.to_h },
-      }
-    end
-  end
-
-  module Conjunction
-    # Hash for AND
-    def to_h
-      return term.to_h if opt.empty?
-
-      {
-        and: [term.to_h] + opt.elements.map { |o| o.term.to_h },
-      }
-    end
-  end
-
-  module NestedExpression
-    # Hash for nested expression
-    delegate :to_h, to: :expression
-  end
-
-  module Condition
-    # Hash for comparison
-    def to_h
-      {
-        operator.to_sym => {
-          column: column.to_s,
-          literal: literal.to_s,
-        },
-      }
-    end
-  end
-
-  module Column
-    # String column name
-    def to_s
-      text_value
-    end
-  end
-
-  # Operators such as 'eq' that match their Arel equivalent aren't needed here
-  OP_SYMS = {
-    'ne' => :not_eq,
-    'lte' => :lteq,
-    'gte' => :gteq,
-    '=' => :eq,
-    '!=' => :not_eq,
-    '<>' => :not_eq,
-    '<' => :lt,
-    '<=' => :lteq,
-    '>' => :gt,
-    '>=' => :gteq,
-  }.freeze
-  private_constant :OP_SYMS
-
-  module Operator
-    # Arel comparion method
-    def to_sym
-      OP_SYMS[text_value.downcase] || text_value.downcase.to_sym
-    end
-  end
-
-  module Literal
-    # Strip enclosing quotes and tranlate embedded quote patterns
-    def to_s
-      text_value
-        .gsub(/\A['"]|['"]\z/, '')
-        .gsub("''", "'")
-        .gsub("\\'", "'")
-        .gsub('\"', '"')
-    end
-  end
-
   included do
     scope(
       :whereable,
@@ -108,14 +28,32 @@ module Whereable
   module ClassMethods
     # Parse filter to hash tree using Treetop PEG
     def whereable_hash_tree(filter)
-      parser = WhereableParser.new
-      hash = parser.parse(filter)&.to_h
+      parser = WhereableClauseParser.new
+      hash = parser.parse(filter.strip)&.to_h
 
       raise FilterInvalid, "Invalid filter at #{filter[parser.max_terminal_failure_index..-1]}" if hash.nil?
 
       hash
     end
 
+    # Test column validity
+    def whereable_valid_column(column)
+      raise FilterInvalid, "Invalid column #{column}" unless column_names.include?(column)
+
+      column
+    end
+
+    # Test literal validity
+    def whereable_valid_literal(column, literal)
+      if defined_enums.key?(column)
+        raise(FilterInvalid, "Invalid value #{literal} for #{column}") unless defined_enums[column].key?(literal)
+
+        defined_enums[column][literal]
+      else
+        literal
+      end
+    end
+
     # deparse hash tree to Arel
     def whereable_deparse(hash)
       raise FilterInvalid, "Invalid hash #{hash}" if hash.size > 1
@@ -130,14 +68,20 @@ module Whereable
         end
         arel
       when :eq, :not_eq, :gt, :gteq, :lt, :lteq
-        column = value[:column]
-        literal = value[:literal]
-        raise FilterInvalid, "Invalid column #{column}" unless column_names.include?(column)
-
-        if defined_enums.key?(column)
-          literal = defined_enums[column][literal] || raise(FilterInvalid, "Invalid value #{literal} for #{column}")
-        end
+        column = whereable_valid_column(value[:column])
+        literal = whereable_valid_literal(column, value[:literal])
         arel_table[column].public_send(key, literal)
+      when :between
+        column = whereable_valid_column(value[:column])
+        literals = value[:literals]
+        raise(FilterInvalid, "Invalid operation for #{column}") if defined_enums.key?(column)
+
+        arel_table[column].between(literals)
+      when :in
+        column = whereable_valid_column(value[:column])
+        literals = value[:literals].map { |l| whereable_valid_literal(column, l) }
+
+        arel_table[column].in(literals)
       else
         raise FilterInvalid, "Invalid hash #{hash}"
       end

data/lib/whereable/version.rb

@@ -3,6 +3,6 @@
 # Copyright 2020 Mack Earnhardt
 
 module Whereable
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
   public_constant :VERSION
 end

data/lib/whereable_clause.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Mack Earnhardt
+
+require 'treetop'
+
+module WhereableClause
+  Treetop.load(File.join(__dir__, 'whereable_clause.treetop'))
+
+  module Disjunction
+    # Hash for OR
+    def to_h
+      return conjunction.to_h if opt.empty?
+
+      {
+        or: [conjunction.to_h] + opt.elements.map { |o| o.conjunction.to_h },
+      }
+    end
+  end
+
+  module Conjunction
+    # Hash for AND
+    def to_h
+      return term.to_h if opt.empty?
+
+      {
+        and: [term.to_h] + opt.elements.map { |o| o.term.to_h },
+      }
+    end
+  end
+
+  module NestedExpression
+    # Hash for nested expression
+    delegate :to_h, to: :expression
+  end
+
+  module Condition
+    # Hash for comparison
+    def to_h
+      {
+        operator.to_sym => {
+          column: column.to_s,
+          literal: literal.to_s,
+        },
+      }
+    end
+  end
+
+  module ConditionBetween
+    # Hash for between operator
+    def to_h
+      {
+        between: {
+          column: column.to_s,
+          literals: left.to_s..right.to_s,
+        },
+      }
+    end
+  end
+
+  module ConditionIn
+    # Hash for in operator
+    def to_h
+      if opt.empty?
+        {
+          eq: {
+            column: column.to_s,
+            literal: literal.to_s,
+          },
+        }
+      else
+        {
+          in: {
+            column: column.to_s,
+            literals: [literal.to_s] + opt.elements.map { |o| o.literal.to_s },
+          },
+        }
+      end
+    end
+  end
+
+  module Column
+    # String column name
+    def to_s
+      text_value
+    end
+  end
+
+  # Operators such as 'eq' that match their Arel equivalent aren't needed here
+  OP_SYMS = {
+    'ne' => :not_eq,
+    'lte' => :lteq,
+    'gte' => :gteq,
+    '=' => :eq,
+    '!=' => :not_eq,
+    '<>' => :not_eq,
+    '<' => :lt,
+    '<=' => :lteq,
+    '>' => :gt,
+    '>=' => :gteq,
+  }.freeze
+  private_constant :OP_SYMS
+
+  module Operator
+    # Arel comparion method
+    def to_sym
+      OP_SYMS[text_value.downcase] || text_value.downcase.to_sym
+    end
+  end
+
+  module Literal
+    # Strip enclosing quotes and tranlate embedded quote patterns
+    def to_s
+      text_value
+        .gsub(/\A['"]|['"]\z/, '')
+        .gsub("''", "'")
+        .gsub("\\'", "'")
+        .gsub('\"', '"')
+    end
+  end
+end

data/lib/whereable_clause.treetop

@@ -0,0 +1,45 @@
+grammar WhereableClause
+  rule expression
+    disjunction
+  end
+
+  rule disjunction
+    conjunction opt:( _sp? 'or'i _sp? conjunction )* <Disjunction>
+  end
+
+  rule conjunction
+    term opt:( _sp? 'and'i _sp? term )* <Conjunction>
+  end
+
+  rule term
+    condition / condition_between / condition_in / '(' _sp? expression _sp? ')' <NestedExpression>
+  end
+
+  rule condition
+    column _sp? operator _sp? literal <Condition>
+  end
+
+  rule condition_between
+    column _sp 'between'i _sp left:literal _sp 'and'i _sp right:literal <ConditionBetween>
+  end
+
+  rule condition_in
+    column _sp 'in'i _sp? '(' _sp? literal _sp? opt:( ',' _sp? literal _sp? )* ')' <ConditionIn>
+  end
+
+  rule _sp
+    [\s]+
+  end
+
+  rule column
+    [a-zA-Z0-9_]+ <Column>
+  end
+
+  rule operator
+    ( 'eq'i &_sp / 'ne'i &_sp / 'gte'i &_sp / 'gt'i &_sp / 'lte'i &_sp / 'lt'i &_sp / '=' / '!=' / '<>' / '>=' / '>' / '<=' / '<' ) <Operator>
+  end
+
+  rule literal
+    ( '"' ( '\"' / [^"] )+ '"' / "'" ( "''" / "\\'" / [^'] )+ "'" / [^\s,)]+ ) <Literal>
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: whereable
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Mack Earnhardt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-12 00:00:00.000000000 Z
+date: 2020-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -41,7 +41,7 @@ dependencies:
 description: |
   Translates where-like filter syntax into an Arel-based ActiveRecord scope,
   so you can safely use SQL syntax in Rails controller parameters.
-  Not as powerful as Ransack, but simple and lightweight.
+  What it lacks in power, it gains in simplicity and ease of use for API consumers.
 email:
 - mack@agilereasoning.com
 executables: []
@@ -51,16 +51,17 @@ files:
 - "./CHANGELOG.md"
 - "./LICENSE.txt"
 - "./README.md"
-- "./lib/whereable.treetop"
+- "./lib/whereable_clause.treetop"
 - lib/whereable.rb
 - lib/whereable/version.rb
+- lib/whereable_clause.rb
 homepage: https://github.com/MacksMind/whereable
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/MacksMind/whereable
   source_code_uri: https://github.com/MacksMind/whereable
-  changelog_uri: https://github.com/MacksMind/whereable/blob/master/CHANGELOG.md
+  changelog_uri: https://github.com/MacksMind/whereable/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:

data/lib/whereable.treetop

@@ -1,37 +0,0 @@
-grammar Whereable
-  rule expression
-    disjunction
-  end
-
-  rule disjunction
-    conjunction opt:( _? 'or'i _? conjunction )* <Disjunction>
-  end
-
-  rule conjunction
-    term opt:( _? 'and'i _? term )* <Conjunction>
-  end
-
-  rule term
-    condition / '(' _? expression _? ')' <NestedExpression>
-  end
-
-  rule condition
-    column _? operator _? literal <Condition>
-  end
-
-  rule _
-    [\s]+
-  end
-
-  rule column
-    [a-zA-Z0-9_]+ <Column>
-  end
-
-  rule operator
-    ( 'eq'i / 'ne'i / 'gte'i / 'gt'i / 'lte'i / 'lt'i / '=' / '!=' / '<>' / '>=' / '>' / '<=' / '<' ) <Operator>
-  end
-
-  rule literal
-    ( '"' ( '\"' / [^"] )+ '"' / "'" ( "''" / "\\'" / [^'] )+ "'" / [^\s)]+ ) <Literal>
-  end
-end