search_lingo 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2bdd0cc2315966fc0399d9e24299260dba55e4ed
-  data.tar.gz: 25f6f3aab4dec1fb3a612cda703bdcd3cb42ed77
+  metadata.gz: b4c58f28e8b25ab5ec35bf08089b12ccae7a0f88
+  data.tar.gz: 81bfba3fafebdadbe909ff5a6a4506e2fac965cc
 SHA512:
-  metadata.gz: 8bb20be38c50a3c4307d60bbe9ad95697fb1b9d526a37ae2c6d832f1356fa3913737f87d8ceb2955a2b5901c24208586d7bbfbf9fe55107ae4e7c5b552471288
-  data.tar.gz: e5a96234ad506535a278478306a0b7b9d9f0b4c408c75d4d81b55721af385dfa609648cdf8d887ae4abbd0f8c262027a0d256e83fe279e15475cdc5414a5559c
+  metadata.gz: e8c453f5e4bd238077618415c6fd93840c3583358279793791ac94936d45152b2c3d07ed895a80f17a9076d064775c6e03042e8940cfcacd9c63ffb5a51322d1
+  data.tar.gz: 23077beb4f9a66b6a0f78f84a95939c1abb987d53adddef1650790a7069075fea6b92745a6b3fc44b3aab09699c461fc7eb12098ffa0f9eec99e8f8226f75258

data/.travis.yml

@@ -1,3 +1,4 @@
 language: ruby
 rvm:
+  - 2.1.6
   - 2.2.2

data/README.md

@@ -1,4 +1,4 @@
-# [![Gem Version](https://badge.fury.io/rb/search_lingo.svg)](http://badge.fury.io/rb/search_lingo)
+# [![Gem Version](https://badge.fury.io/rb/search_lingo.svg)](http://badge.fury.io/rb/search_lingo) [![Build Status](https://travis-ci.org/jparker/search_lingo.svg?branch=master)](https://travis-ci.org/jparker/search_lingo)
 
 # SearchLingo
 
@@ -33,7 +33,8 @@ Or install it yourself as:
 
 ## Usage
 
-Here is a simple example.
+Concrete examples of how to use this gem are provided in `examples/` and
+`test/examples/`, but here is a simple example.
 
 ```ruby
 class Task < ActiveRecord::Base
@@ -116,10 +117,8 @@ implementation of `#default_parse` in that class. Register parsers for specific
 types of search tokens using the parser class method.
 
 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 the search
-and return the results.
-
-Take a look at the examples/ directory for more concrete examples.
+which to perform the search. Use the `#results` method to compile and execute
+the search and return the results.
 
 ## How It Works
 
@@ -128,7 +127,7 @@ 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 an operator and a term (e.g., `foo: bar`), the token is
+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
@@ -137,7 +136,7 @@ or an Array that can be splatted and sent to the search scope.
 
 ## Search Classes
 
-Search classes should inherit from `SearchLogic::AbstractSearch`, and they must
+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
@@ -149,15 +148,15 @@ structured.
 ## Tokenization
 
 Queries are comprised of zero or more tokens separated by white space. A token
-has a term and an optional operator. (A simple token has no operator; a
+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. An operator is one or more alphanumeric characters
+baz"` are both single terms. A modifier is one or more alphanumeric characters
 followed by a colon and zero or more spaces.
 
     QUERY    := TOKEN*
-    TOKEN    := (OPERATOR ':' [[:space:]]*)? TERM
-    OPERATOR := [[:alnum:]]+
+    TOKEN    := (MODIFIER ':' [[:space:]]*)? TERM
+    MODIFIER := [[:alnum:]]+
     TERM     := '"' [^"]* '"' | [[:graph:]]+
 
 The following are all examples of tokens:
@@ -168,22 +167,22 @@ The following are all examples of tokens:
 * `foo: "bar baz"`
 
 (If you need a term to equal something that might otherwise be interpreted as
-an operator, you can enclose the term in double quotes, e.g., while `foo: bar`
+a modifier, you can enclose the term in double quotes, e.g., while `foo: bar`
 would be interpreted a single compound token, `"foo:" bar` would be treated as
 two distinct simple tokens, and `"foo: bar"` would be treated as a single
 simple token.)
 
-Tokens are passed to parsers as instances of the SearchLingo::Token class.
-SearchLingo::Token provides `#operator` and `#term` methods, but delegates all
-other behavior to the String class. Consequently, when writing parsers, you
-have the option of either interacting with examining the operator and term
+Tokens are passed to parsers as instances of the `SearchLingo::Token` class.
+`SearchLingo::Token` provides `#modifier` and `#term` methods, but delegates
+all other behavior to the String class. Consequently, when writing parsers, you
+have the option of either interacting with examining the modifier and term
 individually or treating the entire token as a String and processing it
 yourself. The following would produce identical results:
 
 ```ruby
 token = SearchLingo::Token.new('foo: "bar baz"')
 
-if token.operator == 'foo' then token.term end   # => 'bar baz'
+if token.modifier == 'foo' then token.term end   # => 'bar baz'
 token.match(/\Afoo:\s*"?(.+?)"?\z/) { |m| m[1] } # => 'bar baz'
 ```
 
@@ -235,9 +234,9 @@ classes:
 ```ruby
 module Parsers
   class IdParser
-    def initialize(table, operator = nil)
+    def initialize(table, modifier = nil)
       @table = table
-      @prefix = /#{operator}:\s*/ if operator
+      @prefix = /#{modifier}:\s*/ if modifier
     end
 
     def call(token)
@@ -276,8 +275,12 @@ Additionally, there are parsers for handling closed date ranges (e.g.,
 `1/1/15-6/30/15`) as well as open-ended date ranges (e.g., `1/1/15-` and
 `12/31/15`). Look at the files in `lib/search_lingo/parsers` for more details.
 
-As implemented, the date parsers are US-centric. I would like to work on making
-them more flexible when time permits.
+The date parser are specifically designed to work with US-formatted dates. Time
+permitting, I will work on making them more flexible. As implemented they are
+also ActiveRecord-centric; this also needs to be reexamined reexamined, either
+by finding a more agnostic implementation or renaming the parser classes to
+indicate they are ActiveRecord-only implementations. (If going the latter
+route, a Sequel-specific implementation should also be provided.)
 
 ## Development
 

data/examples/complex.rb

@@ -1,13 +1,13 @@
-class Job < ActiveRecord::Base
+class Job < ActiveRecord::Base # :nodoc:
   # Assume this model has attributes: :id, :date, :name
 end
 
-class Receipt < ActiveRecord::Base
+class Receipt < ActiveRecord::Base # :nodoc:
   # Assume this model has attributes: :id, :check_no, :check_date, :post_date, :amount
 end
 
-module Parsers
-  class IdParser
+module Parsers # :nodoc:
+  class IdParser # :nodoc:
     def initialize(table)
       @table = table
     end
@@ -20,7 +20,7 @@ module Parsers
   end
 end
 
-class JobSearch < AbstractSearch
+class JobSearch < SearchLingo::AbstractSearch # :nodoc:
   parser Parsers::IdParser.new Job.table_name
 
   parser SearchLingo::Parsers::DateParser.new Job.table_name,
@@ -35,7 +35,7 @@ class JobSearch < AbstractSearch
   end
 end
 
-class ReceiptSearch < AbstractSearch
+class ReceiptSearch < SearchLingo::AbstractSearch # :nodoc:
   parser Parsers::IdParser.new Receipt.table_name
 
   parser SearchLingo::Parsers::DateParser.new Receipt.table_name,

data/examples/sequel_example.rb

@@ -0,0 +1,64 @@
+require 'sequel'
+require 'sqlite3'
+
+DB = Sequel.sqlite
+
+if ENV['LOG_TO_STDOUT']
+  require 'logger'
+  DB.loggers << Logger.new(STDOUT)
+end
+
+DB.create_table :categories do
+  primary_key :id
+  String :name, null: false, unique: true
+end
+
+DB.create_table :tasks do
+  foreign_key :category_id, :categories
+  String :name, null: false, unique: true
+  Integer :priority, null: false
+  Date :due_date, null: false
+end
+
+class Category < Sequel::Model # :nodoc:
+  one_to_many :tasks
+end
+
+class Task < Sequel::Model # :nodoc:
+  many_to_one :category
+end
+
+class CategoryParser # :nodoc:
+  def call(token)
+    if token.modifier == 'cat'
+      [:where, { category__name: token.term }]
+    end
+  end
+end
+
+class TaskSearch < SearchLingo::AbstractSearch # :nodoc:
+  parser CategoryParser.new
+
+  parser do |token|
+    token.match /\A([<>])([[:digit:]]+)\z/ do |m|
+      [:where, ->{ priority.send m[1], m[2] }]
+    end
+  end
+
+  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
+    end
+  end
+
+  def default_parse(token)
+    [:where, 'tasks.name LIKE ?', "%#{token.term}%"]
+  end
+
+  def scope
+    @scope.eager_graph(:category)
+  end
+end

data/lib/search_lingo/abstract_search.rb

@@ -2,38 +2,86 @@ require 'search_lingo/tokenizer'
 
 module SearchLingo
   class AbstractSearch
+    attr_reader :query
+
+    ##
+    # Instantiates a new search object. +query+ is the string that is to be
+    # parsed and compiled into an actual query. If +query+ is falsey, an empty
+    # string will be used. +scope+ is the object to which the compiled query
+    # should be sent, e.g., an +ActiveRecord+ model.
     def initialize(query, scope)
       @query = query || ''
       @scope = scope
     end
 
-    attr_reader :query
-
+    ##
+    # Returns an list of parsers that have been added to this class.
     def self.parsers
       @parsers ||= []
     end
 
+    ##
+    # Adds a new parser to the list of parsers used by this class.
+    #
+    # The parser to be added can be passed in as an argument which responds to
+    # +#call+ or as a block. Raises +ArgumentError+ if neither a callable
+    # object nor a block is passed in. If both a callable argument and a block
+    # are passed in, a warning will be displayed, the callable argument will be
+    # used as the parser; the block will be ignored.
+    #
+    #   class MyParser
+    #     def call
+    #       # return something
+    #     end
+    #   end
+    #
+    #   class MySearch < SearchLingo::AbstractSearch
+    #     parser MyParser.new
+    #     parser do
+    #       # return something
+    #     end
+    #   end
     def self.parser(callable = nil, &block)
       unless callable || block_given?
         raise ArgumentError, 'parse must be called with callable or block'
       end
       if callable && block_given?
+        # TODO: should this raise an error instead?
         warn "WARNING: parse called with callable and block (#{caller.first}"
       end
 
       parsers << (callable || block)
     end
 
+    ##
+    # Delegates to SearchLingo::AbstractSearch.parsers.
     def parsers
       self.class.parsers
     end
 
+    ##
+    # Returns the results of executing the search.
     def results
       @results ||= conditions.inject(scope) do |query, condition|
         query.public_send(*condition)
       end
     end
 
+    ##
+    # Returns an +Array+ of compiled query parameters.
+    #
+    # @query is broken 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
@@ -47,10 +95,19 @@ module SearchLingo
       end
     end
 
+    ##
+    # Returns a +SearchLingo::Tokenizer+ for @query.
     def tokenizer
       @tokenizer ||= Tokenizer.new query
     end
 
+    ##
+    # Passes +token+ to each parser in turn. If a parser succeeds, throws
+    # +:match+ with the compiled 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)
       parsers.each do |parser|
         result = parser.call token
@@ -58,11 +115,22 @@ module SearchLingo
       end
     end
 
+    ##
+    # Raises +NotImplementedError+. Classes which inherit from
+    # SearchLingo::AbstractSearch must provide their own implementation, and it
+    # should *always* succeed.
     def default_parse(token)
       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

data/lib/search_lingo/constants.rb

@@ -1,4 +1,9 @@
 module SearchLingo
-  OPERATOR  = /[[:alnum:]]+/
-  TERM      = /"[^"]+"|[[:graph:]]+/
+  ##
+  # Pattern for matching modifiers within a token.
+  MODIFIER = /[[:alnum:]]+/
+
+  ##
+  # Pattern for matching terms within a token.
+  TERM = /"[^"]+"|[[:graph:]]+/
 end

data/lib/search_lingo/parsers/date_parser.rb

@@ -1,20 +1,24 @@
 require 'search_lingo/parsers/mdy'
 
 module SearchLingo
-  module Parsers
+  module Parsers # :nodoc:
     class DateParser
       include MDY
 
-      def initialize(table, column, operator = nil, **options)
+      def initialize(table, column, modifier = nil, **options)
         @table    = table
         @column   = column
-        @prefix   = %r{#{operator}:\s*} if operator
+        @prefix   = %r{#{modifier}:\s*} if modifier
 
         post_initialize **options
       end
 
       attr_reader :table, :column, :prefix
 
+      # This implementation is specific to ActiveRecord::Base#where semantics.
+      # Explore an agnostic implementation or rename the DateParser class (and
+      # its descendants) to indicate that it is ActiveRecord-centric. If going
+      # the latter route, provide a Sequel-specific implementation as well.
       def call(token)
         token.match /\A#{prefix}(?<date>#{US_DATE})\z/ do |m|
           date = parse m[:date]
@@ -22,10 +26,10 @@ module SearchLingo
         end
       end
 
-      def post_initialize(**)
+      def post_initialize(**) # :nodoc:
       end
 
-      def inspect
+      def inspect # :nodoc:
         '#<%s:0x%x @table=%s @column=%s @prefix=%s>' %
           [self.class, object_id << 1, table.inspect, column.inspect, prefix.inspect]
       end

data/lib/search_lingo/parsers/date_range_parser.rb

@@ -1,7 +1,7 @@
 require 'search_lingo/parsers/date_parser'
 
 module SearchLingo
-  module Parsers
+  module Parsers # :nodoc:
     class DateRangeParser < DateParser
       def call(token)
         token.match /\A#{prefix}(?<min>#{US_DATE})-(?<max>#{US_DATE})\z/ do |m|

data/lib/search_lingo/parsers/gte_date_parser.rb

@@ -1,8 +1,8 @@
 require 'search_lingo/parsers/open_date_range_parser'
 
 module SearchLingo
-  module Parsers
-    class GTEDateParser < OpenDateRangeParser
+  module Parsers # :nodoc:
+    class GTEDateParser < OpenDateRangeParser # :nodoc:
       def initialize(*)
         warn "DEPRECATION WARNING: use SearchLingo::Parsers::OpenDateRangeParser " \
           "instead of #{self.class} (from #{caller.first})"

data/lib/search_lingo/parsers/lte_date_parser.rb

@@ -1,8 +1,8 @@
 require 'search_lingo/parsers/open_date_range_parser'
 
 module SearchLingo
-  module Parsers
-    class LTEDateParser < OpenDateRangeParser
+  module Parsers # :nodoc:
+    class LTEDateParser < OpenDateRangeParser # :nodoc:
       def initialize(*)
         warn "DEPRECATION WARNING: use SearchLingo::Parsers::OpenDateRangeParser " \
           "instead of #{self.class} (from #{caller.first})"

data/lib/search_lingo/parsers/mdy.rb

@@ -1,22 +1,37 @@
 require 'date'
 
 module SearchLingo
-  module Parsers
+  module Parsers # :nodoc:
     module MDY
+      ##
+      # Pattern for matching US-formatted date strings.
+      #
+      # The year may be two or four digits, or it may be omitted.
       US_DATE = %r{(?<m>\d{1,2})/(?<d>\d{1,2})(?:/(?<y>\d{2}\d{2}?))?}
 
+      ##
+      # Returns a +Date+ object for the date represented by +term+. Returns
+      # +nil+ if +term+ can not be parsed.
+      #
+      # If the year has two digits, it will be expanded into a four-digit by
+      # +Date.parse+.
+      #
+      # If the year is omitted, it will be inferred using +relative_to+ as a
+      # reference date. In this scenario, the resulting date will always be
+      # less than or equal to the reference date. If +relative_to+ omitted, it
+      # defaults to today's date.
+      #
+      # 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]
 
           day   = Integer(m[:d])
           month = Integer(m[:m])
-          year  = begin
-                    if month < relative_to.month || month == relative_to.month && day <= relative_to.day
-                      relative_to.year
-                    else
-                      relative_to.year - 1
-                    end
+          year  = if month < relative_to.month || month == relative_to.month && day <= relative_to.day
+                    relative_to.year
+                  else
+                    relative_to.year - 1
                   end
 
           Date.new year, month, day

data/lib/search_lingo/parsers/open_date_range_parser.rb

@@ -2,37 +2,45 @@ require 'search_lingo/parsers/date_parser'
 require 'forwardable'
 
 module SearchLingo
-  module Parsers
+  module Parsers # :nodoc:
     class OpenDateRangeParser < DateParser
       extend Forwardable
 
-      DATE_RANGE = /(?:-(?<max>#{US_DATE})|(?<min>#{US_DATE})-)/
-
       def call(token)
-        token.match /\A#{prefix}#{DATE_RANGE}\z/ do |m|
-          if m[:max]
-            date = parse m[:max]
+        parse_lte(token) || parse_gte(token)
+      end
+
+      def post_initialize(connection:, **)
+        @connection = connection
+      end
+
+      def_delegators :@connection, :quote_column_name, :quote_table_name
+
+      private
+
+      def parse_lte(token) # :nodoc:
+        token.match /\A#{prefix}-(?<date>#{US_DATE})\z/ do |m|
+          if date = parse(m[:date])
             [
               :where,
               "#{quote_table_name table}.#{quote_column_name column} <= ?",
               date
-            ] if date
-          else
-            date = parse m[:min]
+            ]
+          end
+        end
+      end
+
+      def parse_gte(token) # :nodoc:
+        token.match /\A#{prefix}(?<date>#{US_DATE})-\z/ do |m|
+          if date = parse(m[:date])
             [
               :where,
               "#{quote_table_name table}.#{quote_column_name column} >= ?",
               date
-            ] if date
+            ]
           end
         end
       end
-
-      def post_initialize(connection:, **)
-        @connection = connection
-      end
-
-      def_delegators :@connection, :quote_column_name, :quote_table_name
     end
   end
 end

data/lib/search_lingo/token.rb

@@ -3,23 +3,45 @@ require 'search_lingo/constants'
 
 module SearchLingo
   class Token < DelegateClass(String)
-    STRUCTURE = /\A(?:(#{OPERATOR}):[[:space:]]*)?"?(.+?)"?\z/
+    ##
+    # Pattern for decomposing a token into a modifier and a term.
+    STRUCTURE = /\A(?:(#{MODIFIER}):[[:space:]]*)?"?(.+?)"?\z/
 
-    def operator
+    ##
+    # Returns the modifier portion of the token. Returns +nil+ if token does
+    # not have a modifier.
+    #
+    #   Token.new('foo: bar').modifier # => 'foo'
+    #   Token.new('bar').modifier      # => nil
+    def modifier
       self[STRUCTURE, 1]
     end
 
+    alias_method :operator, :modifier
+
+    ##
+    # Returns the term portion of the token. If the term is wrapped in quotes,
+    # they are removed.
+    #
+    #   Token.new('foo: bar').term  # => 'bar'
+    #   Token.new('bar').term       # => 'bar'
+    #   Token.new('"bar baz"').term # => 'bar baz'
     def term
       self[STRUCTURE, 2]
     end
 
+    ##
+    # Returns +true+ if token has a modifier and +false+ otherwise.
+    #
+    #   Token.new('foo: bar').compound? # => true
+    #   Token.new('bar').compound?      # => false
     def compound?
-      !!operator
+      !!modifier
     end
 
-    def inspect
-      '#<%s String(%s) operator=%s term=%s>' %
-        [self.class, super, operator.inspect, term.inspect]
+    def inspect # :nodoc:
+      '#<%s String(%s) modifier=%s term=%s>' %
+        [self.class, super, modifier.inspect, term.inspect]
     end
   end
 end

data/lib/search_lingo/tokenizer.rb

@@ -8,14 +8,25 @@ module SearchLingo
     include Enumerable
     extend Forwardable
 
+    ##
+    # Pattern for matching a simple token (a term without a modifier).
     SIMPLE_TOKEN   = /#{TERM}/
-    COMPOUND_TOKEN = /(?:#{OPERATOR}:[[:space:]]*)?#{TERM}/
+
+    ##
+    # Pattern for matching a compound token (a term with an optional modifier).
+    COMPOUND_TOKEN = /(?:#{MODIFIER}:[[:space:]]*)?#{TERM}/
+
+    ##
+    # Pattern for matching the delimiter between tokens.
     DELIMITER      = /[[:space:]]*/
 
-    def initialize(query)
+    def initialize(query) # :nodoc:
       @scanner = StringScanner.new query.strip
     end
 
+    ##
+    # Iterates over the query string. If called with a block, it yields each
+    # token. If called without a block, it returns an +Enumerator+.
     def each
       return to_enum(__callee__) unless block_given?
 
@@ -24,6 +35,9 @@ module SearchLingo
       end
     end
 
+    ##
+    # Returns a Token for the next token in the query string. When the end of
+    # the query string is reached raises +StopIteration+.
     def next
       scanner.skip DELIMITER
       token = scanner.scan COMPOUND_TOKEN
@@ -33,6 +47,9 @@ module SearchLingo
 
     def_delegator :scanner, :reset
 
+    ##
+    # Rewinds the query string from the last returned token and returns a
+    # Token for the next simple token.
     def simplify
       scanner.unscan
       Token.new scanner.scan SIMPLE_TOKEN

data/lib/search_lingo/version.rb

@@ -1,3 +1,3 @@
 module SearchLingo
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

data/search_lingo.gemspec

@@ -19,11 +19,14 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.rdoc_options += ['-x', 'examples/', '-x', 'test/']
+
   spec.required_ruby_version = '>= 2.1'
 
   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 'pry'
+  spec.add_development_dependency 'sequel'
+  spec.add_development_dependency 'sqlite3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: search_lingo
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - John Parker
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-06-11 00:00:00.000000000 Z
+date: 2015-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest-focus
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +67,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: sequel
+  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: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -97,7 +111,7 @@ files:
 - bin/console
 - bin/setup
 - examples/complex.rb
-- examples/simple.rb
+- examples/sequel_example.rb
 - lib/search_lingo.rb
 - lib/search_lingo/abstract_search.rb
 - lib/search_lingo/constants.rb
@@ -117,7 +131,11 @@ licenses:
 - MIT
 metadata: {}
 post_install_message: 
-rdoc_options: []
+rdoc_options:
+- "-x"
+- examples/
+- "-x"
+- test/
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -132,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Framework for building simple query languages

data/examples/simple.rb

@@ -1,31 +0,0 @@
-class Task < ActiveRecord::Base
-  # Assume this model has attributes: :id, :due_date, and :name
-end
-
-class TaskSearch < SearchLingo::AbstractSearch
-  parser SearchLingo::Parsers::DateParser.new :tasks,
-    :due_date
-  parser SearchLingo::Parsers::DateRangeParser.new :tasks,
-    :due_date
-  parser SearchLingo::Parsers::LTEDateParser.new :tasks,
-    :due_date, connection: ActiveRecord::Base.connection
-  parser SearchLingo::Parsers::GTEDateParser.new :tasks,
-    :due_date, connection: ActiveRecord::Base.connection
-
-  parser do |token|
-    token.match /\Aid:\s*([[:digit:]]+)\z/ do |m|
-      [:where, { tasks: { id: m[1] } }]
-    end
-  end
-
-  def default_parse(token)
-    [:where, 'tasks.name LIKE ?', "%#{token}%"]
-  end
-end
-
-search = TaskSearch.new('6/4/15 id: 42 foo "bar baz"', Task)
-search.results  # =>  Task
-                #       .where(tasks: { due_date: Date.new(2015, 6, 4) })
-                #       .where(tasks: { id: '42' })
-                #       .where('tasks.name LIKE ?', '%foo%')
-                #       .where('tasks.name LIKE ?', '%bar baz%')