search_lingo 1.0.3 → 2.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 473413fa017d4fe273ea20952b89c778fd07d98735efaeef1c28954bc70c96ea
-  data.tar.gz: 11df6b8d3f02b8147afc5a7248a548861b038c8e7e9dffd854dca506e185fa7e
+  metadata.gz: e2e54fb0b61c4208e61b6edec4936b1fae5d37c9872c775ed2091f1ebbb0806f
+  data.tar.gz: 3d0f886c18e7f7acf5725d4c1101acd277805e8b8d02eaf0c524bd6f41b222cb
 SHA512:
-  metadata.gz: a6783a0cb4a8d8db96ddaf4a9cff6704484a6421f93351de009202a7f680c46a50d44c62672e7201a7cdaeb3999ac9df7646b1905471cfef43ef2c9c2e6ef87d
-  data.tar.gz: bed0ac621a52ffc67fc50ee32f5dd560f58a3f11444741bc3bae63a9be8f1d0e7e59e0656b5d1cab07cc2a05c1c200889d408c1c7142ceab31416a156edc9d38
+  metadata.gz: bee8e661b253b3e356b14d0a587ea019d4f8f9bcebf3090d7fbb6e12d410ddd85e29ceecaa41735a3b510a924ac119cd770500ad6c9828992c026b0e81e59bd2
+  data.tar.gz: ac76a97eb3ec3fd5c42c975462642b2d35366f7e29a1be7c22c32cf07f8f0442b9e79c7a4d4966826be56b6143cb293d8dd5831201166ff94d4b4fe5e72be579

data/README.md

@@ -15,6 +15,52 @@ project. Although originally designed to work with basic searching with
 ActiveRecord models, it should be usable with other data stores provided they
 let you build complex queries by chaining together simpler queries.
 
+## Upgading
+
+Version 2 introduces a breaking change to the parsing workflow. In older
+versions, parsers were sent one argument (the token), and were expected to
+return an array that would be sent to the scope using `#public_send`. The new
+version sends the token and the filter chain to the parsers, and they are
+expected to append methods to the filter chain and return the result. This
+change makes it possible for parsers to make more than one addition to the
+filter chain.
+
+After upgrading, your parsers should be upgraded as follows:
+
+```ruby
+# Before
+parser do |token|
+  if token.modifier == 'something'
+    [:where, { column: token.term }]
+  end
+end
+
+# After
+parser do |token, chain|
+  if token.modifier == 'something'
+    chain.where column: token.term
+  end
+end
+```
+
+Similar changes will need to be made to your `#default_parse` implementation.
+
+```ruby
+# Before
+def default_parse(token)
+  [:where, { column: token }]
+end
+
+# After
+def default_parse(token, chain)
+  chain.where column: token
+end
+```
+
+If you provided your own implementation of `#scope` in your search class to
+ensure that certain relations were joined, you may want to revisit the decision
+in case the joins can be added only if needed by a particular parser.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -41,17 +87,16 @@ class Task < ActiveRecord::Base
 end
 
 class TaskSearch < SearchLingo::AbstractSearch
-  def default_parse(token)
-    [:where, 'tasks.name LIKE ?', "%#{token}%"]
+  def default_parse(token, chain)
+    chain.where 'name LIKE ?', "%#{token}%"
   end
 end
 
-TaskSearch.new('foo bar', Task).results
-# => Task.where('tasks.name LIKE ?', '%foo%')
-# ->   .where('tasks.name LIKE ?', '%bar%')
+TaskSearch.new('foo bar', Task.all).results
+# => Task.where('name LIKE ?', '%foo%').where('name LIKE ?', '%bar%')
 
-TaskSearch.new('"foo bar"', Task).results
-# => Task.where('tasks.name LIKE ?', '%foo bar%')
+TaskSearch.new('"foo bar"', Task.all).results
+# => Task.where('name LIKE ?', '%foo bar%')
 ```
 
 And here is a more complex example.
@@ -68,91 +113,96 @@ end
 class Task < ActiveRecord::Base
   belongs_to :category
   belongs_to :user
-  enum state: [:incomplete, :complete]
+  enum state: %i[incomplete complete]
 end
 
 class TaskSearch < SearchLingo::AbstractSearch
-  parser do |token|
-    token.match /\Acategory:\s*"?(.*?)"?\z/ do |m|
-      [:where, { categories: { name: m[1] } }]
+  parser do |token, chain|
+    token.match(/\Ais:\s*(?<state>(?:in)?complete)\z/) do |m|
+      # Appends a named scope defined by `enum` to filter chain
+      chain.public_send m[:state].to_sym
     end
   end
 
-  parser do |token|
-    token.match /\Ais:\s*(?<state>(?:in)?complete)\z/ do |m|
-      [m[:state].to_sym]
+  parser do |token, chain|
+    if token.modifier == 'cat'
+      # Appends a join and a where clause to the filter chain.
+      chain.joins(:category).where categories: { name: token.term }
     end
   end
 
-  parser do |token|
-    token.match /\A([<>])([[:digit:]]+)\z/ do |m|
-      [:where, 'tasks.priority #{m[1]} ?', m[2]]
+  parser do |token, chain|
+    token.match(/\A(?<op>[<>])(?<prio>[[:digit:]]+)\z/) do |m|
+      priority = Task.arel_table[:priority]
+      if m[:op] == '<'
+        chain.where priority.lt m[:prio]
+      else
+        chain.where priority.gt m[:prio]
+      end
     end
   end
 
-  def default_parse(token)
-    [:where, 'tasks.name LIKE ?', "%#{token}%"]
-  end
-
-  def scope
-    @scope.includes(:category).references(:category)
+  def default_parse(token, chain)
+    chain.where Task.arel_table[:name].matches "%#{token}%"
   end
 end
 
-TaskSearch.new('category: "foo bar" <2 baz is: incomplete', Task).results
-# => Task.includes(:category).references(:category)
-# ->   .where(categories: { name: 'foo bar' })
-# ->   .where('tasks.priority < ?', 2)
-# ->   .where('tasks.name LIKE ?', '%baz%')
+TaskSearch.new('cat: foo <2 "bar baz" is: incomplete', Task.all).results
+# => Task.all
+# ->   .joins(:category)
+# ->   .where(categories: { name: 'foo' })
+# ->   .where(Task.arel_table[:priority].gt(2))
+# ->   .where(Task.arel_table[:name].matches('%bar baz%'))
 # ->   .incomplete
 
-TaskSearch.new('category: "foo bar"', User.find(42).tasks).results
-# => Task.includes(:category).references(:category)
-# ->   .where(user_id: 42)
-# ->   .where(categories: { name: 'foo bar' })
+user = User.find 42
+TaskSearch.new('is: complete "foo bar"', user.tasks).results
+# => user.tasks.complete.where(Task.arel_table[:name].matches('%foo bar%'))
 ```
 
-Create a class which inherits from `SearchLingo::AbstractSearch`. Provide an
-implementation of `#default_parse` in that class. Register parsers for specific
-types of search tokens using the parser class method.
+A search class should inherit from `SearchLingo::AbstractSearch`, and it should
+provide its own implementation of `#default_parse`. Register additional parsers
+with `.parser` as needed.
 
-Instantiate your search class by passing in the query string and the scope on
-which to perform the search. Use the `#results` method to compile and execute
-the search and return the results.
+Instantiate your search class with a query string and the scope on which to
+search. Send that instance `#results` to compile and execute the search and
+return the results.
 
 ## How It Works
 
-A search is instantiated with a query string and a search scope (commonly an
+A search is instantiated with a query string and a search scope (such as an
 ActiveRecord model). The search breaks the query string down into a series of
-tokens, and each token is processed by a declared series of parsers. If a
-parser succeeds, processing immediately advances to the next token. If none of
-the declared parsers succeeds, and the token is compound — that is, the token
-is composed of a modifier and a term (e.g., `foo: bar`), the token is
-simplified and then processed by the declared parsers again. If the second pass
-also fails, then the (now simplified) token falls through to the
-`#default_parse` method defined by the search class. This method should be
-implemented in such a way that it always "succeeds" — always returning a Symbol
-or an Array that can be splatted and sent to the search scope.
+tokens and parses them, composing the search query by chaining method calls
+onto the initial search scope.
+
+A search class registers zero or more special-case parsers. Processing of each
+token runs through the parsers in the order in which they were registered.
+Parsing of a single token halts when a parser succeeds. When a parser succeeds,
+it should append to the search scope a method call which implements the filter
+for the given token. When a parser fails, it should return a `nil` or `false`.
+
+If all of the registered parsers fail, and the token is compound, it is
+simplified and reprocessed by the same set of parsers (see "Tokenization" for
+more information).
+
+If still no parser has successfully parsed the token, it falls back on the
+`#default_parse`.
 
 ## Search Classes
 
-Search classes should inherit from `SearchLingo::AbstractSearch`, and they must
-provide their own implementation of `#default_parse`. Optionally, a search
-class may also use the parse class method to add specialized parsers for
-handling tokens that match specific patterns. As each token is processed, the
-search class will first run through the specialized parsers. If none of them
-succeed, it will fall back on the `#default_parse` method. See the section
-"Parsing" for more information on how parsers work and how they should be
-structured.
+Search classes should inherit from `SearchLingo::AbstractSearch`. They must
+provide their own implementation of `#default_parse` which should probably, at
+a minimum, return the current filter chain. Custom parsers can be registered
+with the `.parser` class method. Custom parsers are tried in the same order in
+which they are defined. Bear this in mind when defining parsers.
 
 ## Tokenization
 
 Queries are comprised of zero or more tokens separated by white space. A token
-has a term and an optional modifier. (A simple token has no modifier; a
-compound token does.) A term can be a single word or multiple words joined by
-spaces and contained within double quotes. For example `foo` and `"foo bar
-baz"` are both single terms. A modifier is one or more alphanumeric characters
-followed by a colon and zero or more spaces.
+is an optional modifier followed by a term. A modifier is one or more
+alphanumeric characters and is followed by a colon. A term can be a single word
+or multiple words contained within double quotes (both `foo` and `"foo bar
+baz"` are valid single terms).
 
     QUERY    := TOKEN*
     TOKEN    := (MODIFIER ':' [[:space:]]*)? TERM
@@ -190,19 +240,19 @@ token.match(/\Afoo:\s*"?(.+?)"?\z/) { |m| m[1] } # => 'bar baz'
 
 ## Parsers
 
-Any object that can respond to the `#call` method can be used as a parser. If
-the parser succeeds, it should return an Array of arguments that can be sent to
-the query object using `#public_send`, e.g., `[:where, { id: 42 }]`. If the
-parser fails, it should return a falsey value.
+Any object that responds to `#call` can be used as a parser. It will be sent
+two arguments: the token and the current filter chain. If a parser succeeds, it
+should append one or more methods to the filter chain and return the result. If
+a parser fails, it should return a falsey value (usually `nil`).
 
 For very simple parsers which need not be reusable, you can pass the parsing
 logic to the parser method as a block:
 
 ```ruby
 class MySearch < SearchLingo::AbstractSearch
-  parser do |token|
-    token.match /\Aid:[[:space:]]*([[:digit:]]+)\z/ do |m|
-      [:where, { id: m[1] }]
+  parser do |token, chain|
+    token.match(/\Aid:[[:space:]]*([[:digit:]]+)\z/) do |m|
+      chain.where id: m[1]
     end
   end
 end
@@ -212,9 +262,9 @@ If you want to re-use a parser, you could implement it as a lambda:
 
 ```ruby
 module Parsers
-  ID_PARSER = lambda do |token|
-    token.match h/\Aid:[[:space:]]*([[:digit:]]+)\z/ do |m|
-      [:where, { id: m[1] }]
+  ID_PARSER = lambda do |token, chain|
+    token.match(/\Aid:[[:space:]]*([[:digit:]]+)\z/) do |m|
+      chain.where id: m[1]
     end
   end
 end
@@ -228,38 +278,76 @@ class MyOtherSearch < SearchLingo::AbstractSearch
 end
 ```
 
-Finally, for the most complicated cases, you could implement parsers as
-classes:
+For more complex cases, you may choose to implement a parser as its own class.
 
 ```ruby
 module Parsers
-  class IdParser
-    def initialize(table, modifier = nil)
-      @table = table
-      @prefix = /#{modifier}:\s*/ if modifier
+  class DateParser
+    US_DATE = %r{(?<m>\d{1,2})/(?<d>\d{1,2})/(?<y>\d{4})}
+
+    attr_reader :column
+
+    def initialize(column)
+      @column = column
     end
 
-    def call(token)
-      token.match /\A#{@prefix}([[:digit:]]+)\z/ do |m|
-        [:where, { @table => { id: m[1] } }]
+    def call(token, chain)
+      catch :halt do
+        parse_simple_date token, chain
+        parse_date_range token, chain
+        parse_open_date_range token, chain
       end
     end
-  end
-end
 
-class EventSearch < SearchLingo::AbstractSearch
-  # matches "42" and adds events.id=42 as a condition
-  parser Parsers::IdParser.new Event.table_name
+    private
+
+    # Parses simple dates like "10/2/2018"
+    def parse_simple_date(token, chain)
+      token.match(/\A#{US_DATE}\z/) do |m|
+        date = Date.parse '%04d-%02d-%02d' % m.values_at(:y, :m, :d)
+        throw :halt, chain.where(column.eq(date))
+      end
+    rescue ArgumentError
+      # Raised by Date.parse for invalid dates
+    end
+
+    # Parses date ranges like "10/1/2018-10/31/2018"
+    def parse_date_range(token, chain)
+      token.match(/\A#{US_DATE}-#{US_DATE}\z/) do |m|
+        min = Date.parse '%04d-%02d-%02d' % m.values_at(3, 1, 2)
+        max = Date.parse '%04d-%02d-%02d' % m.values_at(6, 4, 3)
+        throw :halt, chain.where(column.in(min..max))
+      end
+    rescue ArgumentError
+      # Raised by Date.parse for invalid dates
+    end
 
-  # matches "category: 42" and adds categories.id as a condition
-  parser Parsers::IdParser.new Category.table_name, 'category'
+    # Parses open-ended date ranges like "10/1/2018-" or "-10/31/2018"
+    def parse_open_date_range(token, chain)
+      token.match(/\A(?<min>#{US_DATE})-|-(?<max>#{US_DATE})\z) do |m|
+        if m[:min]
+          date = Date.parse '%04d-%02d-%02d' % m.values_at(:y, :m, :d)
+          throw :halt, chain.where(column.gteq(date))
+        else
+          date = Date.parse '%04d-%02d-%02d' % m.values_at(:y, :m, :d)
+          throw :halt, chain.where(column.lteq(date))
+        end
+      end
+    rescue ArgumentError
+      # Raised by Date.pares for invalid dates
+    end
+  end
 end
 
-class CategorySearch < SearchLingo::AbstractSearch
-  parser Parsers::IdParser.new :categories
+class EventSearch < SearchLingo::AbstractSearch
+  parser Parsers::DateParser.new
 end
 ```
 
+(Date parsing was a convenient example of a parser complex enough to warrant
+its own class, but a date parser is included with the gem. See "Date Parsers"
+below for more information.)
+
 ### Date Parsers
 
 One of the non-trivial parsing tasks I found myself constantly reimplementing

data/examples/complex.rb

@@ -12,9 +12,9 @@ module Parsers # :nodoc:
       @table = table
     end
 
-    def call(token)
+    def call(token, chain)
       token.match /\Aid:\s*([[:digit:]]+)\z/ do |m|
-        [:where, { @table => { id: m[1] } }]
+        chain.where @table => { id: m[1] }
       end
     end
   end
@@ -24,8 +24,8 @@ class JobSearch < SearchLingo::AbstractSearch # :nodoc:
   parser SearchLingo::Parsers::DateParser.new Job.arel_table[:date]
   parser Parsers::IdParser.new Job.table_name
 
-  def default_parse(token)
-    [:where, Job.arel_table[:name].lower.like("%#{token}%")]
+  def default_parse(token, chain)
+    chain.where Job.arel_table[:name].matches "%#{token}%"
   end
 end
 
@@ -34,26 +34,28 @@ class ReceiptSearch < SearchLingo::AbstractSearch # :nodoc:
   parser SearchLingo::Parsers::DateParser.new Receipt.arel_table[:post_date],
     modifier: 'posted'
 
-  parser do |token|
-    token.match /\Aamount: (\d+(?:\.\d+)?)\z/ do |m|
-      [:where, { receipts: { amount: m[1] } }]
+  parser do |token, chain|
+    token.match(/\Aamount: (\d+(?:\.\d+)?)\z/) do |m|
+      chain.where receipts: { amount: m[1] }
     end
   end
 
-  def default_parse(token)
-    [:where, Receipt.arel_table[:check_no].like(token)]
+  def default_parse(token, chain)
+    chain.where Receipt.arel_table[:check_no].matches token
   end
 end
 
 search = JobSearch.new('6/4/15-6/5/15 id: 42 "foo bar"')
 search.results
-# => Job.where(Job.arel_table[:date].in(Date.new(2015,6,4)..Date.new(2015,6,5)))
-#       .where('jobs' => { id: '42' })
-#       .where(Job.arel_table[:name].lower.like('%foo bar%'))
+# => Job
+#     .where(Job.arel_table[:date].in(Date.new(2015,6,4)..Date.new(2015,6,5)))
+#     .where('jobs' => { id: '42' })
+#     .where(Job.arel_table[:name].matches('%foo bar%'))
 
 search = ReceiptSearch.new('-6/4/15 posted: 6/5/15- amount: 1000 123')
 search.results
-# => Receipt.where(Receipt.arel_table[:check_date].lteq(Date.new(2015,6,4)))
-#           .where(Receipt.arel_table[:post_date].gteq(Date.new(2015,6,5)))
-#           .where(receipts: { amount: '1000' })
-#           .where(Receipt.arel_table[:check_no].matches('123'))
+# => Receipt
+#     .where(Receipt.arel_table[:check_date].lteq(Date.new(2015, 6, 4)))
+#     .where(Receipt.arel_table[:post_date].gteq(Date.new(2015, 6, 5)))
+#     .where(receipts: { amount: '1000' })
+#     .where(Receipt.arel_table[:check_no].matches('123'))

data/examples/sequel_example.rb

@@ -29,9 +29,10 @@ class Task < Sequel::Model # :nodoc:
 end
 
 class CategoryParser # :nodoc:
-  def call(token)
+  def call(token, chain)
     if token.modifier == 'cat'
-      [:where, { Sequel.qualify('category', 'name') => token.term }]
+      chain.eager_graph(:category)
+        .where Sequel.qualify('category', 'name') => token.term
     end
   end
 end
@@ -43,9 +44,10 @@ class TaskSearch < SearchLingo::AbstractSearch # :nodoc:
   #
   # <2 => Categories with priority < 2
   # >5 => Categories with priority > 5
-  parser do |token|
+  parser do |token, chain|
     token.match /\A([<>])([[:digit:]]+)\z/ do |m|
-      [:where, Sequel.expr { priority.send m[1], m[2] }]
+      chain.eager_graph(:category)
+        .where Sequel.expr { priority.send m[1], m[2] }
     end
   end
 
@@ -53,12 +55,14 @@ class TaskSearch < SearchLingo::AbstractSearch # :nodoc:
   #
   # 7/4/1776 => Tasks with due_date == Date.new(1776, 7, 4)
   # 7/4/17   => Tasks with due_date == Date.new(2017, 7, 4)
-  parser do |token|
-    token.match %r{\A(?<m>\d{1,2})/(?<d>\d{1,2})/(?<y>\d{2}\d{2}?)\z} do |m|
-      begin
-        [:where, { due_date: Date.parse("#{m[:y]}/#{m[:m]}/#{m[:d]}") }]
-      rescue ArgumentError
-      end
+  parser do |token, chain|
+    token.match %r{\A(\d{1,2})/(\d{1,2})/(\d{2}\d{2}?)\z} do |m|
+      date = begin
+               Date.parse '%d/%d/%d' % m.values_at(3, 1, 2)
+             rescue ArgumentError
+               return nil
+             end
+      chain.where due_date: date
     end
   end
 
@@ -66,11 +70,7 @@ class TaskSearch < SearchLingo::AbstractSearch # :nodoc:
   #
   # pay bills   => Match tasks with names like "pay bills", "pay bills by today"
   # brush teeth => Match tasks with names like "brush teeth", "brush teeth and floss"
-  def default_parse(token)
-    [:where, Sequel.lit('tasks.name LIKE ?', "%#{token.term}%")]
-  end
-
-  def scope
-    @scope.eager_graph(:category)
+  def default_parse(token, chain)
+    chain.where Sequel.lit 'tasks.name LIKE ?', "%#{token.term}%"
   end
 end

data/lib/search_lingo/abstract_search.rb

@@ -2,7 +2,7 @@ require 'search_lingo/tokenizer'
 
 module SearchLingo
   class AbstractSearch
-    attr_reader :query
+    attr_reader :query, :scope
 
     ##
     # Instantiates a new search object. +query+ is the string that is to be
@@ -62,42 +62,27 @@ module SearchLingo
     end
 
     ##
-    # Constructs and performs the query.
-    def load_results
-      conditions.inject(scope) do |query, condition|
-        query.public_send(*condition)
-      end
-    end
-
-    ##
-    # Returns an +Array+ of compiled query parameters.
+    # Load search results by composing query string tokens into a query chain.
     #
-    # @query is broken down into tokens, and each token is passed through the
+    # @query is borken down into tokens, and each token is passed through the
     # list of defined parsers. If a parser is successful, +:match+ is thrown,
-    # the compiled condition is saved, and processing moves on to the next
-    # token.  If none of the parsers succeeds and the token is compound, that
-    # is, it has both a modifier and a term, the token is simplified, and
-    # reprocessed through the list of parsers. As during the first pass, if a
-    # parser succeeds, +:match+ is thrown, the compiled condition for the now
-    # simplified token is saved, and processing moves on to the next token (the
-    # remains of the original compound token). If none of the parsers succeeds
-    # during the second pass, the now simplified token is finally sent to
-    # +#default_parse+, and whatever it returns will be saved as the compiled
-    # condition.
-    def conditions
-      tokenizer.inject([]) do |conditions, token|
-        conditions << catch(:match) do
-          # 1. Try each parser with the token until :match is thrown.
-          parse token
+    # processing moves on to the next token. If none of the parsers succeed and
+    # the token is compound, the token is simplified and reprocessed as before.
+    # If still no parser succeeds, fall back on +#default_parse+.
+    def load_results
+      tokenizer.reduce(scope) do |chain, token|
+        catch(:match) do
+          # 1. Try each parser with token until :match is thrown.
+          parse token, chain
 
-          # 2. If :match not thrown and token is compound, simplify and try again.
+          # 2. If :match not thrown and token is compund, simplify and retry.
           if token.compound?
             token = tokenizer.simplify
-            parse token
+            parse token, chain
           end
 
-          # 3. If :match still not thrown, fallback on default parser.
-          default_parse token
+          # 3. If :match still not thrown, fall back on default parser.
+          default_parse token, chain
         end
       end
     end
@@ -110,37 +95,29 @@ module SearchLingo
 
     ##
     # Passes +token+ to each parser in turn. If a parser succeeds, throws
-    # +:match+ with the compiled result.
+    # +:match+ with the result.
     #
-    # A parser succeeds if +call+ returns a truthy value. The return value of a
-    # successful parser will be splatted and sent to @scope using
-    # +public_send+.
-    def parse(token)
+    # A parser succeeds if +call+ returns a truthy value. A successful parser
+    # will typically send something to +chain+ and return the result. In this
+    # way, the tokens of the search are reduced into a composed query.
+    def parse(token, chain)
       parsers.each do |parser|
-        result = parser.call token
+        result = parser.call token, chain
         throw :match, result if result
       end
       nil
     end
 
     ##
-    # Raises +NotImplementedError+. Classes which inherit from
-    # SearchLingo::AbstractSearch must provide their own implementation, and it
-    # should *always* succeed.
-    def default_parse(token)
+    # The default way to handle a token which could not be parsed by any of the
+    # other parsers.
+    #
+    # This is a skeletal implementation that raises +NotImplementedError+.
+    # Child classes should provide their own implementation. At a minimum, that
+    # implementation should return +chain+. (Doing so would ignore +token+.)
+    def default_parse(token, chain)
       raise NotImplementedError,
         "#default_parse must be implemented by #{self.class}"
     end
-
-    ##
-    # Returns @scope.
-    #
-    # You may override this method in your search class if you want to ensure
-    # additional messages are sent to search scope before executing the query.
-    # For example, if @scope is an +ActiveRecord+ model, you might want to join
-    # additional tables.
-    def scope
-      @scope
-    end
   end
 end

data/lib/search_lingo/parsers/date_parser.rb

@@ -29,11 +29,13 @@ module SearchLingo
       # Examples of single dates are 7/14, 7/14/17, and 7/14/2017.
       # Examples of closed date ranges are 1/1-6/30 and 7/1/16-6/30/18.
       # Examples of open date ranges are -6/30 and 7/1/17-.
-      def call(token)
-        parse_single_date(token)  ||
-          parse_date_range(token) ||
-          parse_lte_date(token)   ||
-          parse_gte_date(token)
+      def call(token, chain)
+        catch :stop do
+          parse_single_date token, chain
+          parse_date_range  token, chain
+          parse_lte_date    token, chain
+          parse_gte_date    token, chain
+        end
       end
 
       def inspect # :nodoc:
@@ -43,32 +45,32 @@ module SearchLingo
 
       private
 
-      def parse_single_date(token)
-        token.match /\A#{prefix}(?<date>#{US_DATE})\z/ do |m|
+      def parse_single_date(token, chain)
+        token.match(/\A#{prefix}(?<date>#{US_DATE})\z/) do |m|
           date = parse(m[:date]) or return nil
-          [:where, column.eq(date)]
+          throw :stop, chain.where(column.eq(date))
         end
       end
 
-      def parse_date_range(token)
-        token.match /\A#{prefix}(?<min>#{US_DATE})-(?<max>#{US_DATE})\z/ do |m|
+      def parse_date_range(token, chain)
+        token.match(/\A#{prefix}(?<min>#{US_DATE})-(?<max>#{US_DATE})\z/) do |m|
           min = parse(m[:min]) or return nil
           max = parse(m[:max], relative_to: min.next_year) or return nil
-          [:where, column.in(min..max)]
+          throw :stop, chain.where(column.in(min..max))
         end
       end
 
-      def parse_lte_date(token)
-        token.match /\A#{prefix}-(?<date>#{US_DATE})\z/ do |m|
+      def parse_lte_date(token, chain)
+        token.match(/\A#{prefix}-(?<date>#{US_DATE})\z/) do |m|
           date = parse(m[:date]) or return nil
-          [:where, column.lteq(date)]
+          throw :stop, chain.where(column.lteq(date))
         end
       end
 
-      def parse_gte_date(token)
-        token.match /\A#{prefix}(?<date>#{US_DATE})-\z/ do |m|
+      def parse_gte_date(token, chain)
+        token.match(/\A#{prefix}(?<date>#{US_DATE})-\z/) do |m|
           date = parse(m[:date]) or return nil
-          [:where, column.gteq(date)]
+          throw :stop, chain.where(column.gteq(date))
         end
       end
     end

data/lib/search_lingo/parsers/mdy.rb

@@ -24,7 +24,7 @@ module SearchLingo
       # Available as both a class method and an instance method.
       def parse(term, relative_to: Date.today)
         term.match /\A#{US_DATE}\z/ do |m|
-          return Date.parse "#{m[:y]}/#{m[:m]}/#{m[:d]}" if m[:y]
+          return Date.parse '%d/%d/%d' % m.values_at(:y, :m, :d) if m[:y]
 
           ref   = relative_to
           day   = Integer(m[:d])

data/lib/search_lingo/version.rb

@@ -1,3 +1,3 @@
 module SearchLingo
-  VERSION = '1.0.3'
+  VERSION = '2.0.0.pre1'
 end

data/search_lingo.gemspec

@@ -26,6 +26,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.9"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'minitest-focus'
+  spec.add_development_dependency 'mocha'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'sequel', '~> 4.48'
   spec.add_development_dependency 'sqlite3'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: search_lingo
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 2.0.0.pre1
 platform: ruby
 authors:
 - John Parker
@@ -52,6 +52,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-focus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -141,9 +169,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.7