wherewolf 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+gem "arel"
+gem "parslet"
+
+group :development do
+  gem "shoulda"
+  gem "rdoc"
+  gem "bundler"
+  gem "jeweler"
+  gem "guard"
+  gem "guard-test"
+  gem "simplecov", :require => false
+  gem "sqlite3"
+  gem "rails"
+  gem "wherewolf", :path => "./"
+end

data/Gemfile.lock

@@ -0,0 +1,140 @@
+PATH
+  remote: ./
+  specs:
+    wherewolf (0.1.0)
+      arel
+      parslet
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.2.8)
+      actionpack (= 3.2.8)
+      mail (~> 2.4.4)
+    actionpack (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.3)
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+    activerecord (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    blankslate (2.1.2.4)
+    builder (3.0.3)
+    erubis (2.7.0)
+    ffi (1.1.5)
+    git (1.2.5)
+    guard (1.3.2)
+      listen (>= 0.4.2)
+      thor (>= 0.14.6)
+    guard-test (0.5.0)
+      guard (>= 1.1.0)
+      test-unit (~> 2.2)
+    hike (1.2.1)
+    i18n (0.6.1)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    journey (1.0.4)
+    json (1.7.5)
+    listen (0.4.7)
+      rb-fchange (~> 0.0.5)
+      rb-fsevent (~> 0.9.1)
+      rb-inotify (~> 0.8.8)
+    mail (2.4.4)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.19)
+    multi_json (1.3.6)
+    parslet (1.4.0)
+      blankslate (~> 2.0)
+    polyglot (0.3.3)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (3.2.8)
+      actionmailer (= 3.2.8)
+      actionpack (= 3.2.8)
+      activerecord (= 3.2.8)
+      activeresource (= 3.2.8)
+      activesupport (= 3.2.8)
+      bundler (~> 1.0)
+      railties (= 3.2.8)
+    railties (3.2.8)
+      actionpack (= 3.2.8)
+      activesupport (= 3.2.8)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (0.9.2.2)
+    rb-fchange (0.0.5)
+      ffi
+    rb-fsevent (0.9.1)
+    rb-inotify (0.8.8)
+      ffi (>= 0.5.0)
+    rdoc (3.12)
+      json (~> 1.4)
+    shoulda (3.3.0)
+      shoulda-context (~> 1.0)
+      shoulda-matchers (~> 1.4)
+    shoulda-context (1.0.0)
+    shoulda-matchers (1.4.0)
+      activesupport (>= 3.0.0)
+    simplecov (0.6.4)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    sprockets (2.1.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.6)
+    test-unit (2.5.2)
+    thor (0.16.0)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  arel
+  bundler
+  guard
+  guard-test
+  jeweler
+  parslet
+  rails
+  rdoc
+  shoulda
+  simplecov
+  sqlite3
+  wherewolf!

data/Guardfile

@@ -0,0 +1,4 @@
+guard :test do
+  watch(%r{^lib/wherewolf/(.+)\.rb$})           { |m| "test/#{m[1]}_test.rb" }
+  watch(%r{^test/(.+)_test\.rb$})                    { |m| "lib/wherewolf/#{m[1]}.rb" }
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Myles Eftos
+
+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.rdoc

@@ -0,0 +1,72 @@
+= wherewolf
+
+== Problem
+
+Most RESTful APIs expose a "/index" endpoint that return all of objects at a given endpoint. That is fine until you need the ability to filter them.
+
+Consider the following scenario:
+
+    /companies.json Return all the companies.
+
+But what if I want only companies that are active? Most developers would simply add a query parameter like so:
+
+    /companies.json?active=true
+
+Ok, now what if you only want companies created after the first of January 2012? Maybe:
+
+    /companies.json?created_after=2012-01-01
+
+Yeah, great - but it doesn't really scale. Wouldn't if be better if we could do something like this?
+
+    /companies.json?where=active%20%3D%20true%20%26%26%20created_at%20%3E%3D%202012-01-01
+
+Ok, it doesn't read amazingly, but this is an API, so encoding that stuff is trivial for the client. For those of you that doesn't speak URI-coded string that is the same as:
+
+    active = true && created_at >= 2012-01-01
+
+Wherewolf will take that string and converts it in to AREL, so your clients can run arbitary queries against your API.
+
+== Get started
+
+The easiest way is to use Bundler:
+
+    gem 'wherewolf'
+
+== Where we are at
+
+What Works:
+    
+* &&
+* ||
+* =
+* !=
+* <
+* <=
+* >
+* >=
+* Parenthesis
+
+Need to implement:
+    
+* Aliases such for operators, such as 'and', 'or' etc
+* Allow from_query to nested (ie Player.where('first_cap < 2000-01-01').from_query('active = true')
+* More edge case testing
+
+== Example
+
+    player = Player.from_query("(position = wing || position = lock) && first_cap < 1905-01-01").order('first_cap')
+
+== Contributing to wherewolf
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Myles Eftos. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "wherewolf"
+  gem.homepage = "http://github.com/madpilot/wherewolf"
+  gem.license = "MIT"
+  gem.summary = %Q{Query parser that converts search terms to AREL for use in APIs}
+  gem.description = %Q{Wherewolf allows you to consume search terms as strings without worrying about database injections. It parses the query and converts it into AREL. It's great for creating filterable REST APIs}
+  gem.email = "myles@madpilot.com.au"
+  gem.authors = ["Myles Eftos"]
+  gem.version = "0.1.0"
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "wherewolf #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/wherewolf/parser.rb

@@ -0,0 +1,53 @@
+require 'parslet'
+
+module Wherewolf
+  class Parser < Parslet::Parser  
+    rule(:space) { match('\s').repeat(1) }
+    rule(:space?) { space.maybe }
+    rule(:left_parenthesis) { str('(') }
+    rule(:right_parenthesis) { str(')') }
+
+    # Comparisons
+    rule(:eq) { str('=') }
+    rule(:not_eq) { str('!=') }
+    rule(:lt) { str('<') }
+    rule(:lteq) { str('<=') }
+    rule(:gt) { str('>') }
+    rule(:gteq) { str('>=') }
+
+    # Operators
+    rule(:and_operator) { str('&&') }
+    rule(:or_operator) { str('||') }
+
+    # Operand
+    rule(:null) { str("null").as(:nil) }
+    rule(:boolean) { str("true").as(:boolean) | str("false").as(:boolean) }
+    rule(:number) { match('[-+]?([0-9]*\.)?[0-9]').repeat(1).as(:number) }
+    rule(:double_quote_string) do
+      str('"') >>
+      (
+        (str('\\') >> any) |
+        (str('"').absent? >> any)
+      ).repeat.as(:string) >>
+      str('"')
+    end
+    rule(:literal) { match('[a-zA-Z0-9\-_]').repeat(1) }
+    rule(:identifier) { null | boolean | number | double_quote_string | literal.as(:string) }
+
+    # Grammar
+    rule(:compare_eq) { (literal.as(:left) >> space? >> eq >> space? >> identifier.as(:right)).as(:eq) }
+    rule(:compare_not_eq) { (literal.as(:left) >> space? >> not_eq >> space? >> identifier.as(:right)).as(:not_eq) }
+    rule(:compare_lt) { (literal.as(:left) >> space? >> lt >> space? >> identifier.as(:right)).as(:lt) }
+    rule(:compare_lteq) { (literal.as(:left) >> space? >> lteq >> space? >> identifier.as(:right)).as(:lteq) }
+    rule(:compare_gt) { (literal.as(:left) >> space? >> gt >> space? >> identifier.as(:right)).as(:gt) }
+    rule(:compare_gteq) { (literal.as(:left) >> space? >> gteq >> space? >> identifier.as(:right)).as(:gteq) }
+   
+    rule(:compare) { compare_eq | compare_not_eq | compare_lteq | compare_lt | compare_gteq | compare_gt }
+
+    rule(:primary) { left_parenthesis >> space? >> or_operation >> space? >> right_parenthesis | compare }
+    rule(:and_operation) { (primary.as(:left) >> space? >> and_operator >> space? >> and_operation.as(:right)).as(:and) | primary }
+    rule(:or_operation) { (and_operation.as(:left) >> space? >> or_operator >> space? >> or_operation.as(:right)).as(:or) | and_operation }
+    
+    root :or_operation
+  end
+end

data/lib/wherewolf/processor.rb

@@ -0,0 +1,66 @@
+require 'arel'
+
+module Wherewolf
+  class Processor
+    def self.parse(model, query)
+      instance = self.new
+      instance.parse(model, query)
+    end
+
+    def parse(model, query)
+      ast = Wherewolf::Parser.new.parse(query)
+      table = model.arel_table
+      model.where(process(ast, table))
+    end
+
+    def process(ast, table)
+      operation = ast.keys.first
+      self.send("process_#{operation}".to_sym, ast[operation], table) if self.respond_to?("process_#{operation}".to_sym)
+    end
+
+protected
+    def process_and(ast, table)
+      process(ast[:left], table).and(process(ast[:right], table))     
+    end
+
+    def process_or(ast, table)
+      process(ast[:left], table).or(process(ast[:right], table))     
+    end
+
+    def process_eq(ast, table)
+      table[ast[:left].to_sym].eq(parse_value(ast[:right]))
+    end
+
+    def process_not_eq(ast, table)
+      table[ast[:left].to_sym].not_eq(parse_value(ast[:right]))
+    end
+
+    def process_lt(ast, table)
+      table[ast[:left].to_sym].lt(parse_value(ast[:right]))
+    end
+
+    def process_lteq(ast, table)
+      table[ast[:left].to_sym].lteq(parse_value(ast[:right]))
+    end
+
+    def process_gt(ast, table)
+      table[ast[:left].to_sym].gt(parse_value(ast[:right]))
+    end
+
+    def process_gteq(ast, table)
+      table[ast[:left].to_sym].gteq(parse_value(ast[:right]))
+    end
+
+    def parse_value(value)
+      type = value.keys.first
+      case type
+      when :nil
+        return nil
+      when :boolean
+        return value[:boolean] == "true"
+      else
+        return value[type].to_s
+      end
+    end
+  end
+end

data/lib/wherewolf/railtie.rb

@@ -0,0 +1,9 @@
+module Wherewolf
+  class Railtie < Rails::Railtie
+    initializer 'wherewolf' do |app|
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Base.send :include, Wherewolf
+      end
+    end
+  end
+end

data/lib/wherewolf.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), 'wherewolf', 'parser.rb')
+require File.join(File.dirname(__FILE__), 'wherewolf', 'processor.rb')
+
+module Wherewolf
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+  
+  module ClassMethods
+    def has_query_parsing(options = {})
+      self.extend QueryMethods
+    end
+  end
+
+  module QueryMethods
+    def from_query(query)
+      Wherewolf::Processor.parse(self, query)
+    end
+  end
+end
+
+require File.join(File.dirname(__FILE__), 'wherewolf', 'railtie.rb') if defined?(Rails::Railtie)

data/test/helper.rb

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'simplecov'
+SimpleCov.command_name 'Unit Tests'
+SimpleCov.start do
+  add_filter "/test/" 
+end
+
+require 'test/unit'
+require 'shoulda'
+
+require 'thread'
+require 'rails/all'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'wherewolf'
+
+class TestApp < Rails::Application
+  config.root = File.dirname(__FILE__)
+end
+
+Rails.application = TestApp
+Wherewolf::Railtie.initializers.first.run(Rails.application)
+ActiveRecord::Migration.verbose = false
+
+class AddUsers < ActiveRecord::Migration
+  def up
+    create_table :players do |t|
+      t.string :name
+      t.string :position
+      t.boolean :active
+      t.date :first_cap
+    end
+
+    create_table :teams do |t|
+      t.string :team
+    end
+  end
+
+  def down
+    drop_table :users
+    drop_table :teams
+  end
+end
+
+class Player < ActiveRecord::Base
+  has_query_parsing 
+end
+
+class Team < ActiveRecord::Base
+end
+
+class Test::Unit::TestCase
+end

data/test/parser_test.rb

@@ -0,0 +1,214 @@
+require 'helper'
+
+class ParserTest < Test::Unit::TestCase
+  context 'Parser' do
+    setup do
+      @parser = Wherewolf::Parser.new
+    end
+
+    context "operands" do
+       should 'parse [op1]=[literal]' do
+        result = @parser.parse('name=Myles')
+        assert_equal( { :eq => { :left => "name", :right => { :string => "Myles" } } }, result)
+      end
+      should 'parse [op1]="[string]"' do
+        result = @parser.parse('name="Myles Eftos"') 
+        assert_equal( { :eq => { :left => "name", :right => { :string => "Myles Eftos" } } }, result)
+      end
+      should 'parse [op1]=null' do
+        result = @parser.parse('name=null') 
+        assert_equal( { :eq => { :left => "name", :right => { :nil => "null" } } }, result)
+      end
+      should 'parse [op1]=true' do
+        result = @parser.parse('active=true') 
+        assert_equal( { :eq => { :left => "active", :right => { :boolean => "true" } } }, result)
+      end
+      should 'parse [op1]=false' do
+        result = @parser.parse('active=false') 
+        assert_equal( { :eq => { :left => "active", :right => { :boolean => "false" } } }, result)
+      end
+      should 'parse [op1]=[integer]' do
+        result = @parser.parse('count=10') 
+        assert_equal( { :eq => { :left => "count", :right => { :number => "10" } } }, result)
+      end
+      should 'parse [op1]=[float]' do
+        result = @parser.parse('count=-10.3') 
+        assert_equal( { :eq => { :left => "count", :right => { :number => "-10.3" } } }, result)
+      end
+    end
+
+    context "comparators" do
+      context "equals" do
+        should 'parse [op1]=[op2]' do
+          result = @parser.parse('name="Myles"')
+          assert_equal( { :eq => { :left => "name", :right => { :string => "Myles" } } }, result)
+        end
+        should 'parse [op1] =[op2]' do
+          result = @parser.parse('name ="Myles"') 
+          assert_equal( { :eq => { :left => "name", :right => { :string => "Myles" } } }, result)
+        end
+        should 'parse [op1]= [op2]' do
+          result = @parser.parse('name= "Myles"') 
+          assert_equal( { :eq => { :left => "name", :right => { :string => "Myles" } } }, result)
+        end
+        should 'parse [op1] = [op2]' do
+          result = @parser.parse('name = "Myles"') 
+          assert_equal( { :eq => { :left => "name", :right => { :string => "Myles" } } }, result)
+        end
+      end
+    
+      context "not equals" do
+        should 'parse [op1]!=[op2]' do
+          result = @parser.parse('name!="Myles Eftos"') 
+          assert_equal( { :not_eq => { :left => "name", :right => { :string => 'Myles Eftos' } } }, result)
+        end
+        should 'parse [op1] !=[op2]' do
+          result = @parser.parse('name !="Myles Eftos"') 
+          assert_equal( { :not_eq => { :left => "name", :right => { :string => 'Myles Eftos' } } }, result)
+        end
+        should 'parse [op1]!= [op2]' do
+          result = @parser.parse('name!= "Myles Eftos"') 
+          assert_equal( { :not_eq => { :left => "name", :right => { :string => 'Myles Eftos' } } }, result)
+        end
+        should 'parse [op1] != [op2]' do
+          result = @parser.parse('name != "Myles Eftos"') 
+          assert_equal( { :not_eq => { :left => "name", :right => { :string => 'Myles Eftos' } } }, result)
+        end
+      end
+
+      context "less than" do
+        should 'parse [op1]<[op2]' do
+          result = @parser.parse("size<12") 
+          assert_equal( { :lt => { :left => "size", :right => { :number => "12" } } }, result)
+        end
+        should 'parse [op1] <[op2]' do
+          result = @parser.parse("size <12") 
+          assert_equal( { :lt => { :left => "size", :right => { :number => "12" } } }, result)
+        end
+        should 'parse [op1]< [op2]' do
+          result = @parser.parse("size< 12") 
+          assert_equal( { :lt => { :left => "size", :right => { :number => "12" } } }, result)
+        end
+        should 'parse [op1] < [op2]' do
+          result = @parser.parse("size < 12") 
+          assert_equal( { :lt => { :left => "size", :right => { :number => "12" } } }, result)
+        end
+      end
+
+      context "less than or equal to" do
+        should 'parse [op1]<=[op2]' do
+          result = @parser.parse("size<=12") 
+          assert_equal( { :lteq => { :left => "size", :right => { :number => '12' } } }, result)
+        end
+        should 'parse [op1] <=[op2]' do
+          result = @parser.parse("size <=12") 
+          assert_equal( { :lteq => { :left => "size", :right => { :number => '12' } } }, result)
+        end
+        should 'parse [op1]<= [op2]' do
+          result = @parser.parse("size<= 12") 
+          assert_equal( { :lteq => { :left => "size", :right => { :number => '12' } } }, result)
+        end
+        should 'parse [op1] <= [op2]' do
+          result = @parser.parse("size <= 12") 
+          assert_equal( { :lteq => { :left => "size", :right => { :number => '12' } } }, result)
+        end
+      end
+
+      context "greater than" do
+        should 'parse [op1]>[op2]' do
+          result = @parser.parse("size>12") 
+          assert_equal( { :gt => { :left => "size", :right => { :number => '12' } } }, result)
+        end
+        should 'parse [op1] >[op2]' do
+          result = @parser.parse("size >12") 
+          assert_equal( { :gt => { :left => "size", :right => { :number => '12' } } }, result)
+        end
+        should 'parse [op1]> [op2]' do
+          result = @parser.parse("size> 12") 
+          assert_equal( { :gt => { :left => "size", :right => { :number => '12' } } }, result)
+        end
+        should 'parse [op1] > [op2]' do
+          result = @parser.parse("size > 12") 
+          assert_equal( { :gt => { :left => "size", :right => { :number => '12' } } }, result)
+        end
+      end
+
+      context "greater than or equal to" do
+        should 'parse [op1]>=[op2]' do
+          result = @parser.parse("size>=12") 
+          assert_equal( { :gteq => { :left => "size", :right => { :number => '12' } } }, result)
+        end
+        should 'parse [op1] >=[op2]' do
+          result = @parser.parse("size >=12") 
+          assert_equal( { :gteq => { :left => "size", :right => { :number => '12' } } }, result)
+        end
+        should 'parse [op1]>= [op2]' do
+          result = @parser.parse("size>= 12") 
+          assert_equal( { :gteq => { :left => "size", :right => { :number => '12' } } }, result)
+        end
+        should 'parse [op1] >= [op2]' do
+          result = @parser.parse("size >= 12") 
+          assert_equal( { :gteq => { :left => "size", :right => { :number => '12' } } }, result)
+        end
+      end
+    end
+
+    context 'operators' do
+      context 'and' do
+        should 'parse [comp]&&[comp]' do
+          result = @parser.parse("name=myles&&size>=12") 
+          assert_equal( { :and => { :left => { :eq => { :left => 'name', :right => { :string => 'myles' } } }, :right => { :gteq => { :left => 'size', :right => { :number => '12'  } } } } }, result)
+        end
+      
+        should 'parse [comp] &&[comp]' do
+          result = @parser.parse("name=myles &&size>=12") 
+          assert_equal( { :and => { :left => { :eq => { :left => 'name', :right => { :string => 'myles' } } }, :right => { :gteq => { :left => 'size', :right => { :number => '12' } } } } }, result)
+        end
+
+        should 'parse [comp]&& [comp]' do
+          result = @parser.parse("name=myles&& size>=12") 
+          assert_equal( { :and => { :left => { :eq => { :left => 'name', :right => { :string => 'myles' } } }, :right => { :gteq => { :left => 'size', :right => { :number => '12' } } } } }, result)
+        end
+        
+        should 'parse [comp] && [comp]' do
+          result = @parser.parse("name=myles && size>=12") 
+          assert_equal( { :and => { :left => { :eq => { :left => 'name', :right => { :string => 'myles' } } }, :right => { :gteq => { :left => 'size', :right => { :number => '12' } } } } }, result)
+        end
+      end
+
+      context 'or' do
+        should 'parse [comp]||[comp]' do
+          result = @parser.parse("name=myles||size>=12") 
+          assert_equal( { :or => { :left => { :eq => { :left => 'name', :right => { :string => 'myles' } } }, :right => { :gteq => { :left => 'size', :right => { :number => '12' } } } } }, result)
+        end
+      
+        should 'parse [comp] ||[comp]' do
+          result = @parser.parse("name=myles ||size>=12") 
+          assert_equal( { :or => { :left => { :eq => { :left => 'name', :right => { :string => 'myles' } } }, :right => { :gteq => { :left => 'size', :right => { :number => '12' } } } } }, result)
+        end
+
+        should 'parse [comp]|| [comp]' do
+          result = @parser.parse("name=myles|| size>=12") 
+          assert_equal( { :or => { :left => { :eq => { :left => 'name', :right => { :string => 'myles' } } }, :right => { :gteq => { :left => 'size', :right => { :number => '12' } } } } }, result)
+        end
+        
+        should 'parse [comp] || [comp]' do
+          result = @parser.parse("name=myles || size>=12") 
+          assert_equal( { :or => { :left => { :eq => { :left => 'name', :right => { :string => 'myles' } } }, :right => { :gteq => { :left => 'size', :right => { :number => '12' } } } } }, result)
+        end
+      end
+    end
+
+    context 'group' do
+      should 'parse ([op] || [op])' do
+        result = @parser.parse("(name=myles || size>=12)") 
+        assert_equal( { :or => { :left => { :eq => { :left => 'name', :right => { :string => 'myles' } } }, :right => { :gteq => { :left => 'size', :right => { :number => '12' } } } } }, result)
+      end
+      
+      should 'parse [op] || ([op] && [op])' do
+        result = @parser.parse("name=myles || (job=programmer && size>=12)") 
+        assert_equal( { :or => { :left => { :eq => { :left => 'name', :right => { :string => 'myles' } } }, :right => { :and => { :left => { :eq => { :left => 'job', :right => { :string => 'programmer' } } }, :right => { :gteq => { :left => 'size', :right => { :number => '12' } } } } } } }, result)
+      end
+    end
+  end
+end

data/test/processor_test.rb

@@ -0,0 +1,102 @@
+require 'helper'
+
+class ProcessorTest < Test::Unit::TestCase
+  def setup_fixtures
+    Player.create!(:name => "Patrick 'Paddy' Carew", :position => 'lock', :first_cap => '1899-06-24', :active => false)
+    Player.create!(:name => "Charlie Ellis", :position => 'flanker', :first_cap => '1899-06-24', :active => false)
+    Player.create!(:name => "Arthur Corfe", :position => 'flanker', :first_cap => '1899-07-22', :active => false)
+    Player.create!(:name => "Syd Miller", :position => 'wing', :first_cap => '1899-08-05', :active => false)
+    Player.create!(:name => "Charlie Redwood", :position => 'wing', :first_cap => '1903-08-15', :active => false)
+    Player.create!(:name => "Patrick 'Pat' Walsh", :position => 'no. 8', :first_cap => '1904-07-02', :active => false)
+    Player.create!(:name => "John Manning", :position => 'fly-half', :first_cap => '1904-07-23', :active => false)
+    Player.create!(:name => "Dally Messenger", :position => 'wing', :first_cap => '1907-08-03', :active => false)
+    Player.create!(:name => "Salesi Ma'afu", :position => 'prop', :first_cap => '2010-06-05', :active => true)
+    Player.create!(:name => "James Slipper", :position => 'prop', :first_cap => nil, :active => true)
+  end
+
+  context 'Processor' do
+    setup do
+      ActiveRecord::Base.establish_connection({
+        :adapter => 'sqlite3',
+        :database => ':memory:',
+        :verbosity => 'quiet'
+      })
+      Arel::Table.engine = Arel::Sql::Engine.new(ActiveRecord::Base)
+      AddUsers.migrate(:up)
+      setup_fixtures
+    end
+  
+    context 'Parsing' do
+      should 'construct simple boolean statements' do
+        player = Player.from_query('name = "Charlie Ellis"')
+        assert_equal 1, player.count
+        assert_equal 'Charlie Ellis', player.first.name
+      end
+
+      should 'construct two boolean statments' do
+        player = Player.from_query('position=lock && first_cap < 2010-01-01')
+        assert_equal 1, player.count
+        assert_equal "Patrick 'Paddy' Carew", player.first.name
+      end
+
+      should 'contruct nested brackets' do
+        player = Player.from_query("(position = wing || position = lock) && first_cap <= 1905-01-01").order('first_cap')
+        assert_equal 3, player.count
+        assert_equal "Patrick 'Paddy' Carew", player[0].name
+        assert_equal "Syd Miller", player[1].name
+        assert_equal "Charlie Redwood", player[2].name
+      end
+
+      should 'handle nulls' do
+        player = Player.from_query("first_cap = null")
+        assert_equal 1, player.count
+        assert_equal "James Slipper", player.first.name
+      end
+
+      should 'handle booleans' do
+        player = Player.from_query("active = true")
+        assert_equal 2, player.count
+        player = Player.from_query("active = false")
+        assert_equal 8, player.count
+      end
+
+      should 'handle dates' do
+        player = Player.from_query("first_cap > 2000-01-01")
+        assert_equal 1, player.count
+        assert_equal "Salesi Ma'afu", player.first.name
+      end
+
+      should 'process =' do
+        player = Player.from_query('name = "Charlie Ellis"')
+        assert_equal 1, player.count
+        assert_equal 'Charlie Ellis', player.first.name
+      end
+      
+      should 'process !=' do
+        player = Player.from_query('name != "Charlie Ellis"')
+        assert_equal 9, player.count
+        assert_equal false, player.map(&:name).include?('Charlie Ellis')
+      end
+      
+      should 'process >' do
+        player = Player.from_query('first_cap > 1907-08-03')
+        assert_equal 1, player.count
+      end
+      
+      should 'process >=' do
+        player = Player.from_query('first_cap >= 1907-08-03')
+        assert_equal 2, player.count
+      end
+
+      should 'process <' do
+        player = Player.from_query('first_cap < 1907-08-03')
+        assert_equal 7, player.count
+      end
+      
+      should 'process <=' do
+        player = Player.from_query('first_cap <= 1907-08-03')
+        assert_equal 8, player.count
+      end
+    end
+  end
+end

data/test/railtie_test.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+class RailtieTest < Test::Unit::TestCase
+  context 'Railtie' do
+    should 'not enable from_query if has_query_parsing is not called' do
+      assert_equal false, Team.respond_to?(:from_query)
+    end
+    
+    should 'enable from_query if has_query_parsing is called' do
+      assert_equal true, Player.respond_to?(:from_query)
+    end
+  end
+end

data/wherewolf.gemspec

@@ -0,0 +1,88 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "wherewolf"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Myles Eftos"]
+  s.date = "2012-10-10"
+  s.description = "Wherewolf allows you to consume search terms as strings without worrying about database injections. It parses the query and converts it into AREL. It's great for creating filterable REST APIs"
+  s.email = "myles@madpilot.com.au"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "Guardfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "lib/wherewolf.rb",
+    "lib/wherewolf/parser.rb",
+    "lib/wherewolf/processor.rb",
+    "lib/wherewolf/railtie.rb",
+    "test/helper.rb",
+    "test/parser_test.rb",
+    "test/processor_test.rb",
+    "test/railtie_test.rb",
+    "wherewolf.gemspec"
+  ]
+  s.homepage = "http://github.com/madpilot/wherewolf"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.15"
+  s.summary = "Query parser that converts search terms to AREL for use in APIs"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<arel>, [">= 0"])
+      s.add_runtime_dependency(%q<parslet>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<guard>, [">= 0"])
+      s.add_development_dependency(%q<guard-test>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<rails>, [">= 0"])
+      s.add_development_dependency(%q<wherewolf>, [">= 0"])
+    else
+      s.add_dependency(%q<arel>, [">= 0"])
+      s.add_dependency(%q<parslet>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<rdoc>, [">= 0"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<guard>, [">= 0"])
+      s.add_dependency(%q<guard-test>, [">= 0"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<rails>, [">= 0"])
+      s.add_dependency(%q<wherewolf>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<arel>, [">= 0"])
+    s.add_dependency(%q<parslet>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<rdoc>, [">= 0"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<guard>, [">= 0"])
+    s.add_dependency(%q<guard-test>, [">= 0"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<rails>, [">= 0"])
+    s.add_dependency(%q<wherewolf>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,200 @@
+--- !ruby/object:Gem::Specification
+name: wherewolf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Myles Eftos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: arel
+  requirement: &70230035647040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70230035647040
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: &70230035645880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70230035645880
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &70230035645020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70230035645020
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &70230035658520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70230035658520
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70230035655100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70230035655100
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70230035654260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70230035654260
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &70230035653240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70230035653240
+- !ruby/object:Gem::Dependency
+  name: guard-test
+  requirement: &70230035681240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70230035681240
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70230035677480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70230035677480
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70230035689500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70230035689500
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70230035685280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70230035685280
+- !ruby/object:Gem::Dependency
+  name: wherewolf
+  requirement: &70230035683060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70230035683060
+description: Wherewolf allows you to consume search terms as strings without worrying
+  about database injections. It parses the query and converts it into AREL. It's great
+  for creating filterable REST APIs
+email: myles@madpilot.com.au
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- lib/wherewolf.rb
+- lib/wherewolf/parser.rb
+- lib/wherewolf/processor.rb
+- lib/wherewolf/railtie.rb
+- test/helper.rb
+- test/parser_test.rb
+- test/processor_test.rb
+- test/railtie_test.rb
+- wherewolf.gemspec
+homepage: http://github.com/madpilot/wherewolf
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3955971048555964075
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Query parser that converts search terms to AREL for use in APIs
+test_files: []