wherewolf 0.3.0 → 0.4.0

data/Gemfile

@@ -13,5 +13,5 @@ group :development do
   gem "simplecov", :require => false
   gem "sqlite3"
   gem "rails"
-  gem "wherewolf", :path => "./"
+  gem "mocha"
 end

data/Gemfile.lock

@@ -1,10 +1,3 @@
-PATH
-  remote: ./
-  specs:
-    wherewolf (0.3.0)
-      arel
-      parslet
-
 GEM
   remote: http://rubygems.org/
   specs:
@@ -64,7 +57,10 @@ GEM
       i18n (>= 0.4.0)
       mime-types (~> 1.16)
       treetop (~> 1.4.8)
+    metaclass (0.0.1)
     mime-types (1.19)
+    mocha (0.12.4)
+      metaclass (~> 0.0.1)
     multi_json (1.3.6)
     parslet (1.4.0)
       blankslate (~> 2.0)
@@ -131,10 +127,10 @@ DEPENDENCIES
   guard
   guard-test
   jeweler
+  mocha
   parslet
   rails
   rdoc
   shoulda
   simplecov
   sqlite3
-  wherewolf!

data/README.rdoc

@@ -40,28 +40,44 @@ Then for every model that you want to by queryable, do this:
       has_query_parsing
     end
 
-This will add the "from_query" method, which you pass your query string in to.
+This will add the "where_query" method, which you pass your query string in to.
 
 == Example
 
 For a real-life, running example, check out: http://wherewolf.herokuapp.com/
 
-    player = Player.from_query("(position = wing || position = lock) && first_cap < 1905-01-01").order('first_cap')
+    player = Player.where_query("(position = wing || position = lock) && first_cap < 1905-01-01").order('first_cap')
     # Returns all players that play 'wing' or 'lock', and played before 1905-01-01
 
-    player = Player.from_query('name = "John Eales"')
+    player = Player.where_query('name = "John Eales"')
     # Returns all players names 'John Eales'
 
-    player = Player.from_query("first_cap >= 1905-01-01 && active = false")
+    player = Player.where_query("first_cap >= 1905-01-01 && active = false")
     # Returns all inactitve players that played after 1905-01-01.
 
-    player = Player.from_query("first_cap != null")
+    player = Player.where_query("first_cap != null")
     # Returns all players who have received their first cap (ie first_cap is NOT nil)
     
-    player = Player.from_query('name ~= "Peter%"')
+    player = Player.where_query('name ~= "Peter%"')
     # Returns all players who's name starts with Peter
 
-As you can see, from_query returns an ARel object, so you chain other statements to it. Please note, though: at the moment from_query needs to be the first in the chain. 
+As you can see, where_query returns an ARel object, so you chain other statements to it. Please note, though: at the moment where_query needs to be the first in the chain. 
+
+== Order
+
+You can also supply an order_query to handle ordering
+
+    player = Player.order_query("name asc")
+    # Order by name asc
+    
+    player = Player.order_query("name desc")
+    # Order by name desc
+    
+    player = Player.order_query("name")
+    # By default ordering is ascending
+
+    player = Player.order_query("name desc, position desc")
+    # You can also have multiple order columns
 
 == Errors
 
@@ -72,7 +88,7 @@ At the moment, error handling is very primitive. Just capture
 You can print out a simple error message like so
 
     begin
-      Player.from_query('name ~= "Patrick%" || (position = "fail)')
+      Player.where_query('name ~= "Patrick%" || (position = "fail)')
     rescue Wherewolf::ParseError => e
       puts e.error_message
     end
@@ -84,7 +100,7 @@ Will print out
 You can get the character number by:
 
     begin
-      Player.from_query('name ~= "Patrick%" || (position = "fail)')
+      Player.where_query('name ~= "Patrick%" || (position = "fail)')
     rescue Wherewolf::ParseError => e
       e.position # This value will be 28
     end
@@ -94,7 +110,7 @@ You can get the character number by:
 * Better error messages (Give a clue as to why parsing failed)
 * Aliases such for operators, such as 'and', 'or' etc
 * Allow single quotes around strings
-* Allow from_query to nested (ie Player.where('first_cap < 2000-01-01').from_query('active = true')
+* Allow where_query to nested (ie Player.where('first_cap < 2000-01-01').where_query('active = true')
 * More edge case testing
 * Abillity to filter columns that are searchable
 * Ability to call named scopes

data/Rakefile

@@ -22,7 +22,7 @@ Jeweler::Tasks.new do |gem|
   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.3.0"
+  gem.version = "0.4.0"
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new
@@ -30,7 +30,7 @@ Jeweler::RubygemsDotOrgTasks.new
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
-  test.pattern = 'test/*_test.rb'
+  test.pattern = 'test/**/*_test.rb'
   test.verbose = true
 end
 

data/lib/wherewolf.rb

@@ -1,5 +1,8 @@
-require File.join(File.dirname(__FILE__), 'wherewolf', 'parser.rb')
 require File.join(File.dirname(__FILE__), 'wherewolf', 'processor.rb')
+require File.join(File.dirname(__FILE__), 'wherewolf', 'where', 'parser.rb')
+require File.join(File.dirname(__FILE__), 'wherewolf', 'where', 'processor.rb')
+require File.join(File.dirname(__FILE__), 'wherewolf', 'order', 'parser.rb')
+require File.join(File.dirname(__FILE__), 'wherewolf', 'order', 'processor.rb')
 require File.join(File.dirname(__FILE__), 'wherewolf', 'parse_error.rb')
 
 module Wherewolf
@@ -14,8 +17,12 @@ module Wherewolf
   end
 
   module QueryMethods
-    def from_query(query)
-      Wherewolf::Processor.parse(self, query)
+    def where_query(query)
+      Wherewolf::Where::Processor.parse(self, query)
+    end
+
+    def order_query(query)
+      Wherewolf::Order::Processor.parse(self, query)
     end
   end
 end

data/lib/wherewolf/order/parser.rb

@@ -0,0 +1,20 @@
+require 'parslet'
+
+module Wherewolf
+  module Order
+    class Parser < Parslet::Parser
+      rule(:space) { match('\s').repeat(1) }
+      rule(:space?) { space.maybe }
+      rule(:comma) { str(',') >> space? }
+      
+      rule(:literal) { match('[a-zA-Z0-9\-_]').repeat(1).as(:column) >> space? }
+      rule(:direction) { str('asc') | str('desc') }
+
+      rule(:order) { literal >> direction.maybe.as(:direction) }
+      rule(:multiple) { order >> (comma >> order).repeat }
+      rule(:expression) { multiple | order }
+      
+      root :expression
+    end
+  end
+end

data/lib/wherewolf/order/processor.rb

@@ -0,0 +1,32 @@
+require 'arel'
+
+module Wherewolf
+  module Order
+    class Processor < Wherewolf::Processor
+      def self.parse(model, query)
+        instance = self.new
+        instance.parse(model, query)
+      end
+
+      def parse(model, query)
+        begin
+          ast = Wherewolf::Order::Parser.new.parse(query)
+          process(ast, model)
+        rescue Parslet::ParseFailed => error
+          raise Wherewolf::ParseError, error
+        end
+      end
+
+      def process(ast, model)
+        ast = [ast] unless ast.is_a?(Array)
+        table = model.arel_table
+        ast.each do |order|
+          check_column!(order[:column], table)
+          direction = (order[:direction] || 'asc').to_sym
+          model = model.order(table[order[:column].to_sym].send(direction))
+        end
+        model
+      end
+    end
+  end
+end

data/lib/wherewolf/processor.rb

@@ -1,71 +1,6 @@
-require 'arel'
-
 module Wherewolf
   class Processor
-    def self.parse(model, query)
-      instance = self.new
-      instance.parse(model, query)
-    end
-
-    def parse(model, query)
-      begin
-        ast = Wherewolf::Parser.new.parse(query)
-        table = model.arel_table
-        model.where(process(ast, table))
-      rescue Parslet::ParseFailed => error
-        raise Wherewolf::ParseError, error
-      end
-    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)
-      check_column!(ast[:left], table)
-      table[ast[:left].to_sym].eq(parse_value(ast[:right]))
-    end
-
-    def process_not_eq(ast, table)
-      check_column!(ast[:left], table)
-      table[ast[:left].to_sym].not_eq(parse_value(ast[:right]))
-    end
-
-    def process_matches(ast, table)
-      check_column!(ast[:left], table)
-      table[ast[:left].to_sym].matches(parse_value(ast[:right]))
-    end
-
-    def process_lt(ast, table)
-      check_column!(ast[:left], table)
-      table[ast[:left].to_sym].lt(parse_value(ast[:right]))
-    end
-
-    def process_lteq(ast, table)
-      check_column!(ast[:left], table)
-      table[ast[:left].to_sym].lteq(parse_value(ast[:right]))
-    end
-
-    def process_gt(ast, table)
-      check_column!(ast[:left], table)
-      table[ast[:left].to_sym].gt(parse_value(ast[:right]))
-    end
-
-    def process_gteq(ast, table)
-      check_column!(ast[:left], table)
-      table[ast[:left].to_sym].gteq(parse_value(ast[:right]))
-    end
-
+  protected
     def check_column!(value, table)
       unless table.columns.map(&:name).include?(value.to_sym)
         source = Parslet::Source.new(value.to_s)
@@ -73,17 +8,5 @@ protected
         raise Parslet::ParseFailed.new('Column not found', cause) 
       end
     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/where/parser.rb

@@ -0,0 +1,57 @@
+require 'parslet'
+
+module Wherewolf
+  module Where
+    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(:matches) { 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_matches) { (literal.as(:left) >> space? >> matches >> space? >> identifier.as(:right)).as(:matches) }
+      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_matches | 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
+end

data/lib/wherewolf/where/processor.rb

@@ -0,0 +1,83 @@
+require 'arel'
+
+module Wherewolf
+  module Where
+    class Processor < Wherewolf::Processor
+      def self.parse(model, query)
+        instance = self.new
+        instance.parse(model, query)
+      end
+
+      def parse(model, query)
+        begin
+          ast = Wherewolf::Where::Parser.new.parse(query)
+          table = model.arel_table
+          model.where(process(ast, table))
+        rescue Parslet::ParseFailed => error
+          raise Wherewolf::ParseError, error
+        end
+      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)
+        check_column!(ast[:left], table)
+        table[ast[:left].to_sym].eq(parse_value(ast[:right]))
+      end
+
+      def process_not_eq(ast, table)
+        check_column!(ast[:left], table)
+        table[ast[:left].to_sym].not_eq(parse_value(ast[:right]))
+      end
+
+      def process_matches(ast, table)
+        check_column!(ast[:left], table)
+        table[ast[:left].to_sym].matches(parse_value(ast[:right]))
+      end
+
+      def process_lt(ast, table)
+        check_column!(ast[:left], table)
+        table[ast[:left].to_sym].lt(parse_value(ast[:right]))
+      end
+
+      def process_lteq(ast, table)
+        check_column!(ast[:left], table)
+        table[ast[:left].to_sym].lteq(parse_value(ast[:right]))
+      end
+
+      def process_gt(ast, table)
+        check_column!(ast[:left], table)
+        table[ast[:left].to_sym].gt(parse_value(ast[:right]))
+      end
+
+      def process_gteq(ast, table)
+        check_column!(ast[:left], 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
+end

data/test/helper.rb

@@ -15,6 +15,7 @@ end
 
 require 'test/unit'
 require 'shoulda'
+require 'mocha'
 
 require 'thread'
 require 'rails/all'
@@ -59,4 +60,26 @@ class Team < ActiveRecord::Base
 end
 
 class 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
+
+  def setup_database
+    ActiveRecord::Base.establish_connection({
+      :adapter => 'sqlite3',
+      :database => ':memory:',
+      :verbosity => 'quiet'
+    })
+    Arel::Table.engine = Arel::Sql::Engine.new(ActiveRecord::Base)
+    AddUsers.migrate(:up)
+  end
 end

data/test/order/parser_test.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+class OrderParserTest < Test::Unit::TestCase
+  context 'OrderParser' do
+    setup do
+      @parser = Wherewolf::Order::Parser.new
+    end
+
+    context "operands" do
+      should 'parse column name' do
+        result = @parser.parse('name')
+        assert_equal({ :column => "name", :direction => nil }, result)
+      end
+
+      should 'parse column with desc' do
+        result = @parser.parse('name desc')
+        assert_equal({ :column => "name", :direction => "desc" }, result)
+      end
+
+      should 'parse column with asc' do
+        result = @parser.parse('name asc')
+        assert_equal({ :column => "name", :direction => "asc" }, result)
+      end
+      
+      should 'parse multiple comma seperated order expressions' do
+        result = @parser.parse('name asc, age desc')
+        assert_equal([ { :column => "name", :direction => "asc" }, { :column => "age", :direction => "desc" } ], result)
+      end
+    end
+  end
+end

data/test/order/processor_test.rb

@@ -0,0 +1,62 @@
+require 'helper'
+
+class OrderProcessorTest < 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 'OrderProcessor' do
+    setup do
+      setup_database
+      setup_fixtures
+    end
+ 
+    should 'be a Wherewolf::Processor' do
+      Wherewolf::Order::Processor.is_a?(Wherewolf::Processor)
+    end
+
+    context 'Parsing' do
+      context 'Error' do
+        should 'be raised is there is a parser error' do
+          assert_raise Wherewolf::ParseError do
+            Player.order_query('name up')
+          end
+        end
+
+        should 'check that the column is in the list' do
+          Wherewolf::Order::Processor.any_instance.expects(:check_column!).once
+          Player.order_query('name asc')
+        end
+      end
+
+      should 'construct an asc sort' do
+        players = Player.order_query('name asc')
+        assert_equal Player.order('name asc').all.map(&:name), players.all.map(&:name)
+      end
+      
+      should 'construct an desc sort' do
+        players = Player.order_query('name desc')
+        assert_equal Player.order('name desc').all.map(&:name), players.all.map(&:name)
+      end
+
+      should 'default to asc' do
+        players = Player.order_query('name')
+        assert_equal Player.order('name asc').all.map(&:name), players.all.map(&:name)
+      end
+
+      should 'handle multiple sorts' do
+        players = Player.order_query('name asc, position asc')
+        assert_equal Player.order('name asc, position asc').all.map(&:name), players.all.map(&:name)
+      end
+    end
+  end
+end

data/test/processor_test.rb

@@ -1,153 +1,21 @@
 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
+  context 'WhereProcessor' 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_database
       setup_fixtures
     end
   
-    context 'Parsing' do
-      context 'Error' do
-        should 'be raised is there is a parser error' do
-          assert_raise Wherewolf::ParseError do
-            Player.from_query('name ~= "Patrick%" || (position = "fail)')
-          end
-        end
-
-        should 'allow retrieval of the error position' do
-          begin
-            Player.from_query('name ~= "Patrick%" || (position = "fail)')
-          rescue Wherewolf::ParseError => e
-            assert_equal 28, e.position
-          end
-        end
-
-        should 'show a nice debug error' do
-          begin
-            Player.from_query('name ~= "Patrick%" || (position = "fail)')
-          rescue Wherewolf::ParseError => e
-            assert_equal "Parsing error occured at character 28", e.error_message
-          end
-        end
-      
-        should 'to_s should print out nice error' do
-          begin
-            Player.from_query('name ~= "Patrick%" || (position = "fail)')
-          rescue Wherewolf::ParseError => e
-            assert_equal "Parsing error occured at character 28", e.to_s
-          end
-        end
-        
-        should 'be raised if the requested column is not in the list' do
-          assert_raise Wherewolf::ParseError do
-            Player.from_query('shoe_size > 10')
-          end
+    context 'check_column!' do
+      should 'raise a ParseError if column is not in the mode' do
+        value = mock
+        value.stubs(:to_sym).returns(:show_size)
+        value.stubs(:to_s).returns('show_size')
+        value.stubs(:offset).returns(0)
+        assert_raise Parslet::ParseFailed do
+          Wherewolf::Processor.new.send(:check_column!, value, Player.arel_table)
         end
-
-        should 'show a nice debug error if the requested column is not in the list' do
-          begin
-            Player.from_query('shoe_size > 10')
-          rescue Wherewolf::ParseError => e
-            assert_equal "Parsing error occured at character 0", e.to_s
-          end
-        end
-      end
-
-      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 matches' do
-        player = Player.from_query('name ~= "James%"')
-        assert_equal 1, player.count
-        assert_equal "James Slipper", player.first.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

data/test/railtie_test.rb

@@ -2,12 +2,12 @@ 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)
+    should 'not enable where_query if has_query_parsing is not called' do
+      assert_equal false, Team.respond_to?(:where_query)
     end
     
-    should 'enable from_query if has_query_parsing is called' do
-      assert_equal true, Player.respond_to?(:from_query)
+    should 'enable where_query if has_query_parsing is called' do
+      assert_equal true, Player.respond_to?(:where_query)
     end
   end
 end

data/test/{parser_test.rb → where/parser_test.rb}

@@ -1,9 +1,9 @@
 require 'helper'
 
-class ParserTest < Test::Unit::TestCase
-  context 'Parser' do
+class WhereParserTest < Test::Unit::TestCase
+  context 'WhereParser' do
     setup do
-      @parser = Wherewolf::Parser.new
+      @parser = Wherewolf::Where::Parser.new
     end
 
     context "operands" do

data/test/where/processor_test.rb

@@ -0,0 +1,140 @@
+require 'helper'
+
+class WhereProcessorTest < Test::Unit::TestCase
+  context 'WhereProcessor' do
+    setup do
+      setup_database
+      setup_fixtures
+    end
+  
+    should 'be a Wherewolf::Processor' do
+      Wherewolf::Where::Processor.is_a?(Wherewolf::Processor)
+    end
+    
+    context 'Parsing' do
+      context 'Error' do
+        should 'be raised is there is a parser error' do
+          assert_raise Wherewolf::ParseError do
+            Player.where_query('name ~= "Patrick%" || (position = "fail)')
+          end
+        end
+
+        should 'allow retrieval of the error position' do
+          begin
+            Player.where_query('name ~= "Patrick%" || (position = "fail)')
+          rescue Wherewolf::ParseError => e
+            assert_equal 28, e.position
+          end
+        end
+
+        should 'show a nice debug error' do
+          begin
+            Player.where_query('name ~= "Patrick%" || (position = "fail)')
+          rescue Wherewolf::ParseError => e
+            assert_equal "Parsing error occured at character 28", e.error_message
+          end
+        end
+      
+        should 'to_s should print out nice error' do
+          begin
+            Player.where_query('name ~= "Patrick%" || (position = "fail)')
+          rescue Wherewolf::ParseError => e
+            assert_equal "Parsing error occured at character 28", e.to_s
+          end
+        end
+        
+        should 'be raised if the requested column is not in the list' do
+          assert_raise Wherewolf::ParseError do
+            Player.where_query('shoe_size > 10')
+          end
+        end
+
+        should 'check to see if the column is allowed' do
+          Wherewolf::Where::Processor.any_instance.expects(:check_column!).once
+          begin
+            Player.where_query('shoe_size > 10')
+          rescue Wherewolf::ParseError => e
+            assert_equal "Parsing error occured at character 0", e.to_s
+          end
+        end
+      end
+
+      should 'construct simple boolean statements' do
+        player = Player.where_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.where_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.where_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 matches' do
+        player = Player.where_query('name ~= "James%"')
+        assert_equal 1, player.count
+        assert_equal "James Slipper", player.first.name
+      end
+
+      should 'handle nulls' do
+        player = Player.where_query("first_cap = null")
+        assert_equal 1, player.count
+        assert_equal "James Slipper", player.first.name
+      end
+
+      should 'handle booleans' do
+        player = Player.where_query("active = true")
+        assert_equal 2, player.count
+        player = Player.where_query("active = false")
+        assert_equal 8, player.count
+      end
+
+      should 'handle dates' do
+        player = Player.where_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.where_query('name = "Charlie Ellis"')
+        assert_equal 1, player.count
+        assert_equal 'Charlie Ellis', player.first.name
+      end
+      
+      should 'process !=' do
+        player = Player.where_query('name != "Charlie Ellis"')
+        assert_equal 9, player.count
+        assert_equal false, player.map(&:name).include?('Charlie Ellis')
+      end
+      
+      should 'process >' do
+        player = Player.where_query('first_cap > 1907-08-03')
+        assert_equal 1, player.count
+      end
+      
+      should 'process >=' do
+        player = Player.where_query('first_cap >= 1907-08-03')
+        assert_equal 2, player.count
+      end
+
+      should 'process <' do
+        player = Player.where_query('first_cap < 1907-08-03')
+        assert_equal 7, player.count
+      end
+      
+      should 'process <=' do
+        player = Player.where_query('first_cap <= 1907-08-03')
+        assert_equal 8, player.count
+      end
+    end
+  end
+end

data/wherewolf.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "wherewolf"
-  s.version = "0.3.0"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Myles Eftos"]
@@ -25,21 +25,27 @@ Gem::Specification.new do |s|
     "README.rdoc",
     "Rakefile",
     "lib/wherewolf.rb",
+    "lib/wherewolf/order/parser.rb",
+    "lib/wherewolf/order/processor.rb",
     "lib/wherewolf/parse_error.rb",
-    "lib/wherewolf/parser.rb",
     "lib/wherewolf/processor.rb",
     "lib/wherewolf/railtie.rb",
+    "lib/wherewolf/where/parser.rb",
+    "lib/wherewolf/where/processor.rb",
     "test/helper.rb",
+    "test/order/parser_test.rb",
+    "test/order/processor_test.rb",
     "test/parse_error_test.rb",
-    "test/parser_test.rb",
     "test/processor_test.rb",
     "test/railtie_test.rb",
+    "test/where/parser_test.rb",
+    "test/where/processor_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.rubygems_version = "1.8.24"
   s.summary = "Makes filtering and searching to your REST API crazy easy."
 
   if s.respond_to? :specification_version then
@@ -57,7 +63,7 @@ Gem::Specification.new do |s|
       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"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
     else
       s.add_dependency(%q<arel>, [">= 0"])
       s.add_dependency(%q<parslet>, [">= 0"])
@@ -70,7 +76,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<simplecov>, [">= 0"])
       s.add_dependency(%q<sqlite3>, [">= 0"])
       s.add_dependency(%q<rails>, [">= 0"])
-      s.add_dependency(%q<wherewolf>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
     end
   else
     s.add_dependency(%q<arel>, [">= 0"])
@@ -84,7 +90,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<simplecov>, [">= 0"])
     s.add_dependency(%q<sqlite3>, [">= 0"])
     s.add_dependency(%q<rails>, [">= 0"])
-    s.add_dependency(%q<wherewolf>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wherewolf
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: arel
-  requirement: &70231215234580 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70231215234580
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: parslet
-  requirement: &70231215233400 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70231215233400
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &70231215232100 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +53,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70231215232100
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &70231215230020 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +69,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70231215230020
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70231215244520 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +85,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70231215244520
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &70231215243640 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +101,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70231215243640
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: guard
-  requirement: &70231215242880 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +117,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70231215242880
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-test
-  requirement: &70231215242000 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +133,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70231215242000
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &70231215240760 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -109,10 +149,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70231215240760
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70231215239680 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -120,10 +165,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70231215239680
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70231215238260 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -131,10 +181,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70231215238260
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: wherewolf
-  requirement: &70231215253700 !ruby/object:Gem::Requirement
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -142,7 +197,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70231215253700
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 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.
@@ -161,15 +221,21 @@ files:
 - README.rdoc
 - Rakefile
 - lib/wherewolf.rb
+- lib/wherewolf/order/parser.rb
+- lib/wherewolf/order/processor.rb
 - lib/wherewolf/parse_error.rb
-- lib/wherewolf/parser.rb
 - lib/wherewolf/processor.rb
 - lib/wherewolf/railtie.rb
+- lib/wherewolf/where/parser.rb
+- lib/wherewolf/where/processor.rb
 - test/helper.rb
+- test/order/parser_test.rb
+- test/order/processor_test.rb
 - test/parse_error_test.rb
-- test/parser_test.rb
 - test/processor_test.rb
 - test/railtie_test.rb
+- test/where/parser_test.rb
+- test/where/processor_test.rb
 - wherewolf.gemspec
 homepage: http://github.com/madpilot/wherewolf
 licenses:
@@ -186,7 +252,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 730622563305472605
+      hash: 3659032346363356481
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -195,7 +261,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Makes filtering and searching to your REST API crazy easy.

data/lib/wherewolf/parser.rb

@@ -1,55 +0,0 @@
-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(:matches) { 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_matches) { (literal.as(:left) >> space? >> matches >> space? >> identifier.as(:right)).as(:matches) }
-    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_matches | 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