search_lingo 1.0.0.beta2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3dfc725892e1b65db47327257cd8c082536dd74b
+  data.tar.gz: 78e4297906559efcb5cedc54b003cf2abfaf4ac1
+SHA512:
+  metadata.gz: 5359eff62098245796f55f5abe4d3e663e0e56677b7925ba1267bf0e00dda71cfefa84d87c416a57a6b7f21699ca7b2b9914d96b74f37b02fa0597a35c32b931
+  data.tar.gz: aaa8f3414ebf996194ce415e0270fa2321290900ac98092ea34d2dcb43608e3f6df4e62146fea960814063f753ca7b05fd9fb8a3637399dd1459fe786c7700aa

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in search_lingo.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 John Parker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,177 @@
+# SearchLingo
+
+SearchLingo is a framework for defining simple, user-friendly query languages
+and translating them into their underlying queries.
+
+It was originally designed after I found myself implementing the same basic
+query parsing over and over again across different projects. I wanted a way to
+simplify the process without having to worry about application-specific aspects
+of searching.
+
+The way the searches themselves are performed lies outside the scope of this
+project. Although originally designed to work with basic searching with
+ActiveRecord models, it should be usable with other data stores provided they
+let you chain queries together onto a single object.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'search_lingo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install search_lingo
+
+## Usage
+
+Create a class which inherits from SearchLingo::AbstractSearch. Provide an
+implementation of <code>#default_parse</code> in that class. Register parsers
+for specific types of search tokens using the <code>parser</code> class method.
+
+Instantiate your search class by passing in the query string and the scope on
+which to perform the search. Use the <code>#results</code> method to compile
+the search and return the results.
+
+Take a look at the examples/ directory for more concrete examples.
+
+## How It Works
+
+A search is instantiated with a query string and a search scope (commonly 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, the process immediately terminates and 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 simplified and then processed by the declared parsers again. If
+the second pass also fails, then the (now simplified) token falls through to
+the <code>#default_parse</code> method defined by the search class. (It is
+important that this method be implemented in such a way that it always
+succeeds.)
+
+## Search Classes
+
+Search classes should inherit from SearchLingo::AbstractSearch and they should
+override the <code>#default_parse</code> instance method. It is important that
+this method be defined in such a way that it always succeeds, as the results
+will be sent to the query object via <code>#public_send</code>. In addtion, the
+class method <code>parser</code> can be used to declare additional parsers that
+should be used by the search class. (See the section "Parsing" for more
+information on what makes a suitable parser.)
+
+## Parsers
+
+Any object that can respond to the <code>#call</code> 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 <code>#public_send</code>, e.g.,
+<code>[:where, { id: 42 }]</code>. If the parser fails, it should return a
+falsey value (typically nil).
+
+For very simple parsers which need not be reusable, you can pass the
+parsing logic to the <code>parser</code> method as a block:
+
+    class MySearch < SearchLingo::AbstractSearch
+      parser do |token|
+        token.match /\Aid:[[:space:]]*([[:digit:]]+)\z/ do |m|
+          [:where, { id: m[1] }]
+        end
+      end
+    end
+
+Parsers can also be implemented as lambdas:
+
+    module Parsers
+      ID_PARSER = lambda do |token|
+        token.match h/\Aid:[[:space:]]*([[:digit:]]+)\z/ do |m|
+          [:where, { id: m[1] }]
+        end
+      end
+    end
+
+    class MySearch < SearchLingo::AbstractSearch
+      parser Parsers::ID_PARSER
+    end
+
+    class MyOtherSearch < SearchLingo::AbstractSearch
+      parser Parsers::ID_PARSER
+    end
+
+Finally, for the most complicated cases, you could implement parsers as
+classes:
+
+    module Parsers
+      class IdParser
+        def initialize(table, operator = nil)
+          @table = table
+          @prefix = /#{operator}:\s*/ if operator
+        end
+
+        def call(token)
+          token.match /\A#{@prefix}([[:digit:]]+)\z/ do |m|
+            [:where, { @table => { id: m[1] } }]
+          end
+        end
+      end
+    end
+
+    class EventSearch < SearchLingo::AbstractSearch
+      parser Parsers::IdParser.new :events                 # => match "42"
+      parser Parsers::IdParser.new :categories, 'category' # => match "category: 42"
+    end
+
+    class CategorySearch < SearchLingo::AbstractSearch
+      parser Parsers::IdParser.new :categories
+    end
+
+## Tokenization
+
+Queries are comprised of one or more tokens separated by spaces. A simple token
+is a term which can be a single word (or date, number, etc.) or multiple terms
+within a pair of double quotes. A compound token is a simple token preceded by
+an operator followed by zero or more spaces.
+
+    QUERY          := TOKEN*
+    TOKEN          := COMPOUND_TOKEN | TERM
+    COMPOUND_TOKEN := OPERATOR TERM
+    OPERATOR       := [[:graph:]]+:
+    TERM           := "[^"]*" | [[:graph:]]+
+
+Terms can be things like:
+
+* foo
+* "foo bar"
+* 6/14/15
+* 1000.00
+
+Operators can be things like:
+
+* foo:
+* bar_baz:
+
+(If you want to perform a query with a term that could potentially be parsed as
+an operator, you would place the term in quotes, i.e., "foo:".)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release` to create a git tag for the version, push git
+commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/jparker/search_lingo/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/test_*.rb'
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "search_lingo"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+
+# require "irb"
+# IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/complex.rb

@@ -0,0 +1,83 @@
+class Job < ActiveRecord::Base
+  # Assume this model has attributes: :id, :date, :name
+end
+
+class Receipt < ActiveRecord::Base
+  # Assume this model has attributes: :id, :check_no, :check_date, :post_date, :amount
+end
+
+module Parsers
+  class IdParser
+    def initialize(table)
+      @table = table
+    end
+
+    def call(token)
+      token.match /\Aid:\s*([[:digit:]]+)\z/ do |m|
+        [:where, { @table => { id: m[1] } }]
+      end
+    end
+  end
+end
+
+class JobSearch < AbstractSearch
+  parser Parsers::IdParser.new Job.table_name
+
+  parser SearchLingo::Parsers::DateParser.new Job.table_name,
+    :date
+  parser SearchLingo::Parsers::DateRangeParser.new Job.table_name,
+    :date
+  parser SearchLingo::Parsers::LTEDateParser.new Job.table_name,
+    :date, connection: Job.connection
+  parser SearchLingo::Parsers::GTEDateParser.new Job.table_name,
+    :date, connection: Job.connection
+
+  def default_parse(token)
+    [:where, 'jobs.name LIKE ?', "%#{token}%"]
+  end
+end
+
+class ReceiptSearch < AbstractSearch
+  parser Parsers::IdParser.new Receipt.table_name
+
+  parser SearchLingo::Parsers::DateParser.new Receipt.table_name,
+    :check_date
+  parser SearchLingo::Parsers::DateRangeParser.new Receipt.table_name,
+    :check_date
+  parser SearchLingo::Parsers::LTEDateParser.new Receipt.table_name,
+    :check_date, connection: Receipt.connection
+  parser SearchLingo::Parsers::GTEDateParser.new Receipt.table_name,
+    :check_date, connection: Receipt.connection
+
+  parser SearchLingo::Parsers::DateParser.new Receipt.table_name,
+    :post_date, 'posted'
+  parser SearchLingo::Parsers::DateRangeParser.new Receipt.table_name,
+    :post_date, 'posted'
+  parser SearchLingo::Parsers::LTEDateParser.new Receipt.table_name,
+    :post_date, 'posted', connection: Receipt.connection
+  parser SearchLingo::Parsers::GTEDateParser.new Receipt.table_name,
+    :post_date, 'posted', connection: Receipt.connection
+
+  parser do |token|
+    token.match /\Aamount: (\d+(?:\.\d+)?)\z/ do |m|
+      [:where, { receipts: { amount: m[1] } }]
+    end
+  end
+
+  def default_parse(token)
+    [:where, 'receipts.check_no LIKE ?', token]
+  end
+end
+
+search = JobSearch.new('6/4/15-6/5/15 id: 42 "foo bar"')
+search.results  # =>  Job
+                #       .where('jobs' => { date: Date.new(2015, 6, 4)..Date.new(2015, 6, 5) })
+                #       .where('jobs' => { id: '42' })
+                #       .where('jobs.name LIKE ?', '%foo bar%')
+
+search = ReceiptSearch.new('-6/4/15 posted: 6/5/15- amount: 1000 123')
+search.results  # =>  Receipt
+                #       .where('"receipts"."check_date" <= ?', Date.new(2015, 6, 4))
+                #       .where('"receipts"."post_date" >= ?', Date.new(2015, 6, 5))
+                #       .where(receipts: { amount: '1000' })
+                #       .where('receipts.check_no LIKE ?', 123)

data/examples/simple.rb

@@ -0,0 +1,31 @@
+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%')

data/lib/search_lingo/abstract_search.rb

@@ -0,0 +1,63 @@
+require 'search_lingo/tokenizer'
+
+module SearchLingo
+  class AbstractSearch
+    def initialize(query, scope, tokenizer: Tokenizer)
+      @query = query || ''
+      @scope = scope
+      @tokenizer = tokenizer.new @query
+    end
+
+    attr_reader :query, :scope, :tokenizer
+
+    def self.parsers
+      @parsers ||= []
+    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?
+        warn "WARNING: parse called with callable and block (#{caller.first}"
+      end
+
+      parsers << (callable || block)
+    end
+
+    def parsers
+      self.class.parsers
+    end
+
+    def results
+      @results ||= conditions.inject(scope) do |query, condition|
+        query.public_send(*condition)
+      end
+    end
+
+    def conditions
+      tokenizer.inject([]) do |conditions, token|
+        conditions << catch(:match) do
+          parse token
+          if token.compound?
+            token = tokenizer.simplify
+            parse token
+          end
+          default_parse token
+        end
+      end
+    end
+
+    def parse(token)
+      parsers.each do |parser|
+        result = parser.call token
+        throw :match, result if result
+      end
+    end
+
+    def default_parse(token)
+      raise NotImplementedError,
+        "#default_parse must be implemented by #{self.class}"
+    end
+  end
+end

data/lib/search_lingo/parsers/date_parser.rb

@@ -0,0 +1,34 @@
+require 'search_lingo/parsers/mdy'
+
+module SearchLingo
+  module Parsers
+    class DateParser
+      include MDY
+
+      def initialize(table, column, operator = nil, **options)
+        @table    = table
+        @column   = column
+        @prefix   = %r{#{operator}:\s*} if operator
+
+        post_initialize **options
+      end
+
+      attr_reader :table, :column, :prefix
+
+      def call(token)
+        token.match /\A#{prefix}(?<date>#{US_DATE})\z/ do |m|
+          date = parse m[:date]
+          [:where, { table => { column => date } }] if date
+        end
+      end
+
+      def post_initialize(**)
+      end
+
+      def inspect
+        '#<%s:0x%x @table=%s @column=%s @prefix=%s>' %
+          [self.class, object_id << 1, table.inspect, column.inspect, prefix.inspect]
+      end
+    end
+  end
+end

data/lib/search_lingo/parsers/date_range_parser.rb

@@ -0,0 +1,15 @@
+require 'search_lingo/parsers/date_parser'
+
+module SearchLingo
+  module Parsers
+    class DateRangeParser < DateParser
+      def call(token)
+        token.match /\A#{prefix}(?<min>#{US_DATE})-(?<max>#{US_DATE})\z/ do |m|
+          min = parse m[:min]
+          max = parse m[:max], relative_to: min.next_year if min
+          [:where, { table => { column => min..max } }] if min && max
+        end
+      end
+    end
+  end
+end

data/lib/search_lingo/parsers/gte_date_parser.rb

@@ -0,0 +1,25 @@
+require 'search_lingo/parsers/date_parser'
+require 'forwardable'
+
+module SearchLingo
+  module Parsers
+    class GTEDateParser < DateParser
+      extend Forwardable
+
+      def call(token)
+        token.match /\A#{prefix}(?<date>#{US_DATE})-\z/ do |m|
+          date = parse m[:date]
+          if date
+            [:where, "#{quote_table_name table}.#{quote_column_name column} >= ?", 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/parsers/lte_date_parser.rb

@@ -0,0 +1,25 @@
+require 'search_lingo/parsers/date_parser'
+require 'forwardable'
+
+module SearchLingo
+  module Parsers
+    class LTEDateParser < DateParser
+      extend Forwardable
+
+      def call(token)
+        token.match /\A#{prefix}-(?<date>#{US_DATE})\z/ do |m|
+          date = parse m[:date]
+          if date
+            [:where, "#{quote_table_name table}.#{quote_column_name column} <= ?", 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/parsers/mdy.rb

@@ -0,0 +1,30 @@
+require 'date'
+
+module SearchLingo
+  module Parsers
+    module MDY
+      US_DATE = %r{(?<m>\d{1,2})/(?<d>\d{1,2})(?:/(?<y>\d{2}\d{2}?))?}
+
+      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
+                  end
+
+          Date.new year, month, day
+        end
+      rescue ArgumentError
+      end
+
+      module_function :parse
+    end
+  end
+end

data/lib/search_lingo/token.rb

@@ -0,0 +1,23 @@
+require 'delegate'
+
+module SearchLingo
+  class Token < DelegateClass(String)
+    FORMAT = %r{\A(?:(\S+):\s*)?"?(.+?)"?\z}
+
+    def operator
+      self[FORMAT, 1]
+    end
+
+    def term
+      self[FORMAT, 2]
+    end
+
+    def compound?
+      !!operator
+    end
+
+    def inspect
+      '#<%s %s operator=%s term=%s>' % [self.class, super, operator.inspect, term.inspect]
+    end
+  end
+end

data/lib/search_lingo/tokenizer.rb

@@ -0,0 +1,44 @@
+require 'forwardable'
+require 'strscan'
+require 'search_lingo/token'
+
+module SearchLingo
+  class Tokenizer
+    include Enumerable
+    extend Forwardable
+
+    SIMPLE    = %r{"[^"]*"|[[:graph:]]+}
+    COMPOUND  = %r{(?:[[:graph:]]+:[[:space:]]*)?#{SIMPLE}}
+    DELIMITER = %r{[[:space:]]*}
+
+    def initialize(query)
+      @scanner = StringScanner.new query.strip
+    end
+
+    def enum
+      Enumerator.new do |yielder|
+        until scanner.eos?
+          token = scanner.scan COMPOUND
+          if token
+            yielder << Token.new(token)
+          end
+          scanner.skip DELIMITER
+        end
+      end
+    end
+
+    def_delegator :scanner, :reset
+    def_delegators :enum, :each, :next
+
+    def simplify
+      scanner.unscan
+      Token.new(scanner.scan(SIMPLE)).tap do
+        scanner.skip DELIMITER
+      end
+    end
+
+    private
+
+    attr_reader :scanner
+  end
+end

data/lib/search_lingo/version.rb

@@ -0,0 +1,3 @@
+module SearchLingo
+  VERSION = '1.0.0.beta2'
+end

data/lib/search_lingo.rb

@@ -0,0 +1,7 @@
+require 'search_lingo/version'
+require 'search_lingo/abstract_search'
+
+require 'search_lingo/parsers/date_parser'
+require 'search_lingo/parsers/date_range_parser'
+require 'search_lingo/parsers/gte_date_parser'
+require 'search_lingo/parsers/lte_date_parser'

data/search_lingo.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'search_lingo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "search_lingo"
+  spec.version       = SearchLingo::VERSION
+  spec.authors       = ["John Parker"]
+  spec.email         = ["jparker@urgetopunt.com"]
+
+  spec.summary       = %q{Framework for building simple query languages}
+  spec.description   = %q{Framework for building simple query language for converting user queries into database queries.}
+  spec.homepage      = "https://github.com/jparker/search_lingo"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  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'
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: search_lingo
+version: !ruby/object:Gem::Version
+  version: 1.0.0.beta2
+platform: ruby
+authors:
+- John Parker
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: 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: pry
+  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'
+description: Framework for building simple query language for converting user queries
+  into database queries.
+email:
+- jparker@urgetopunt.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/complex.rb
+- examples/simple.rb
+- lib/search_lingo.rb
+- lib/search_lingo/abstract_search.rb
+- lib/search_lingo/parsers/date_parser.rb
+- lib/search_lingo/parsers/date_range_parser.rb
+- lib/search_lingo/parsers/gte_date_parser.rb
+- lib/search_lingo/parsers/lte_date_parser.rb
+- lib/search_lingo/parsers/mdy.rb
+- lib/search_lingo/token.rb
+- lib/search_lingo/tokenizer.rb
+- lib/search_lingo/version.rb
+- search_lingo.gemspec
+homepage: https://github.com/jparker/search_lingo
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.7
+signing_key: 
+specification_version: 4
+summary: Framework for building simple query languages
+test_files: []