wherewolf 0.4.1 → 0.5.0

data/README.rdoc

@@ -40,7 +40,29 @@ Then for every model that you want to by queryable, do this:
       has_query_parsing
     end
 
-This will add the "where_query" method, which you pass your query string in to.
+This will add the "where_query" and "order_query" methods, which you pass your query string in to.
+
+has_query_parsing can take two options: whitelist and blacklist which allow you to set which columns consumers can search against
+
+Setting whitelist will mean ONLY those columns will be searchable
+
+    class Player < ActiveRecord::Base
+      has_query_parsing :whitelist => [ :name ]   # Only name will be searchable
+    end
+
+Setting blacklist will remove those columns from the list
+
+    class Player < ActiveRecord::Base
+      has_query_parsing :blacklist => [ :name ]   # Name will not be searchable
+    end
+
+Both whitelist and blacklist can take a proc if you want to lazy evaluate
+
+    class Player < ActiveRecord::Base
+      has_query_parsing :whitelist => proc { |model| model.accessible_attributes }
+    end
+
+would restrict the searchable columns to those exposed by accessible_attributes
 
 == Example
 
@@ -79,7 +101,7 @@ You can also supply an order_query to handle ordering
     player = Player.order_query("name desc, position desc")
     # You can also have multiple order columns
 
-Of course you can nest them...
+Of course, you can nest them...
 
     player = Player.where_query("first_cap != null").order_query('name desc')
 
@@ -114,9 +136,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 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
 
 == Contributing to wherewolf

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.4.1"
+  gem.version = "0.5.0"
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new

data/lib/wherewolf.rb

@@ -12,6 +12,12 @@ module Wherewolf
   
   module ClassMethods
     def has_query_parsing(options = {})
+      self.class_eval <<-EOV
+        def self.wherewolf_options
+          #{options}
+        end
+      EOV
+
       self.class_eval do
         scope :where_query, lambda { |query| Wherewolf::Where::Processor.parse(self, query) }
         scope :order_query, lambda { |query| Wherewolf::Order::Processor.parse(self, query) }

data/lib/wherewolf/order/processor.rb

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

data/lib/wherewolf/processor.rb

@@ -1,12 +1,36 @@
 module Wherewolf
   class Processor
+    attr_accessor :model
+    def initialize(model, options = {})
+      @model = model
+      @options = options
+    end
   protected
     def check_column!(value, table)
-      unless table.columns.map(&:name).include?(value.to_sym)
+      unless columns(table).include?(value.to_sym)
         source = Parslet::Source.new(value.to_s)
         cause = Parslet::Cause.new('Column not found', source, value.offset, [])
         raise Parslet::ParseFailed.new('Column not found', cause) 
       end
     end
+
+    def columns(table)
+      columns = table.columns.map(&:name)
+      columns = columns & whitelist if whitelist
+      columns -= blacklist if blacklist
+      columns
+    end
+
+    def whitelist
+      return @options[:whitelist].call if @options[:whitelist].is_a?(Proc)
+      return @options[:whitelist] if @options[:whitelist]
+      return nil
+    end
+
+    def blacklist
+      return @options[:blacklist].call if @options[:blacklist].is_a?(Proc)
+      return @options[:blacklist] if @options[:blacklist]
+      return nil
+    end
   end
 end

data/lib/wherewolf/where/processor.rb

@@ -4,15 +4,15 @@ module Wherewolf
   module Where
     class Processor < Wherewolf::Processor
       def self.parse(model, query)
-        instance = self.new
-        instance.parse(model, query)
+        instance = self.new(model, model.wherewolf_options)
+        instance.parse(query)
       end
 
-      def parse(model, query)
+      def parse(query)
         begin
           ast = Wherewolf::Where::Parser.new.parse(query)
           table = model.arel_table
-          model.where(process(ast, table))
+          self.model.where(process(ast, table))
         rescue Parslet::ParseFailed => error
           raise Wherewolf::ParseError, error
         end

data/test/helper.rb

@@ -44,11 +44,16 @@ class AddUsers < ActiveRecord::Migration
     create_table :teams do |t|
       t.string :team
     end
+    
+    create_table :countries do |t|
+      t.string :team
+    end
   end
 
   def down
     drop_table :users
     drop_table :teams
+    drop_table :countries
   end
 end
 
@@ -59,6 +64,10 @@ end
 class Team < ActiveRecord::Base
 end
 
+class Country < ActiveRecord::Base
+  has_query_parsing :whitelist => [ :name ]
+end
+
 class Test::Unit::TestCase
   def setup_fixtures
     Player.create!(:name => "Patrick 'Paddy' Carew", :position => 'lock', :first_cap => '1899-06-24', :active => false)

data/test/processor_test.rb

@@ -14,9 +14,51 @@ class ProcessorTest < Test::Unit::TestCase
         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)
+          Wherewolf::Processor.new(Player).send(:check_column!, value, Player.arel_table)
         end
       end
     end
+
+    context 'columns' do
+      should 'return all the ARel table columns if options[:whitelist] and options[:blacklist] are not set' do
+        assert_equal Player.arel_table.columns.map(&:name), Wherewolf::Processor.new(Player).send(:columns, Player.arel_table)
+      end
+
+      should 'return just the columns in the intersection of columns and whitelist if whitelist is set' do
+        assert_equal [ :id, :name ], Wherewolf::Processor.new(Player, :whitelist => [ :not_in_column_set, :id, :name ]).send(:columns, Player.arel_table)
+      end
+      
+      should 'return columns minus items in options[:blacklist] if options[:blacklist] is set' do
+        assert_equal [ :name, :position, :active ], Wherewolf::Processor.new(Player, :blacklist => [ :id, :first_cap ]).send(:columns, Player.arel_table)
+      end
+    end
+
+    context 'whitelist' do
+      should 'return nil of options[:whitelist] is not set' do
+        assert_equal nil, Wherewolf::Processor.new(Player).send(:whitelist)
+      end
+      
+      should 'return options[:whitelist] if set' do
+        assert_equal [ :name, :type ], Wherewolf::Processor.new(Player, :whitelist => [ :name, :type ]).send(:whitelist)
+      end
+
+      should 'evaluate options[:whitelist] if is a proc' do
+        assert_equal [ :name, :type ], Wherewolf::Processor.new(Player, :whitelist => proc { return [ :name, :type ] }).send(:whitelist)
+      end
+    end
+  
+    context 'blacklist' do
+      should 'return nil of options[:blacklist] is not set' do
+        assert_equal nil, Wherewolf::Processor.new(Player).send(:blacklist)
+      end
+      
+      should 'return options[:blacklist] if set' do
+        assert_equal [ :name, :type ], Wherewolf::Processor.new(Player, :blacklist => [ :name, :type ]).send(:blacklist)
+      end
+
+      should 'evaluate options[:blacklist] if is a proc' do
+        assert_equal [ :name, :type ], Wherewolf::Processor.new(Player, :blacklist => proc { return [ :name, :type ] }).send(:blacklist)
+      end
+    end
   end
 end

data/test/railtie_test.rb

@@ -6,7 +6,19 @@ class RailtieTest < Test::Unit::TestCase
       setup_database
       setup_fixtures
     end
+
+    should 'not enable wherewolf_options if has_query_parsing is not called' do
+      assert_equal false, Team.respond_to?(:wherewolf_options)
+    end
     
+    should 'enable wherewolf_options if has_query_parsing is called' do
+      assert_equal true, Player.respond_to?(:wherewolf_options)
+    end
+
+    should 'set wherewolf_options' do
+      assert_equal({ :whitelist => [ :name ] }, Country.wherewolf_options)
+    end
+
     should 'not enable where_query if has_query_parsing is not called' do
       assert_equal false, Team.respond_to?(:where_query)
     end

data/wherewolf.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "wherewolf"
-  s.version = "0.4.1"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Myles Eftos"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wherewolf
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: arel
-  requirement: &70304497147180 !ruby/object:Gem::Requirement
+  requirement: &70293403498180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70304497147180
+  version_requirements: *70293403498180
 - !ruby/object:Gem::Dependency
   name: parslet
-  requirement: &70304497162220 !ruby/object:Gem::Requirement
+  requirement: &70293403497160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70304497162220
+  version_requirements: *70293403497160
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &70304497160940 !ruby/object:Gem::Requirement
+  requirement: &70293403496160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70304497160940
+  version_requirements: *70293403496160
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &70304497159820 !ruby/object:Gem::Requirement
+  requirement: &70293403495640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70304497159820
+  version_requirements: *70293403495640
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70304497158780 !ruby/object:Gem::Requirement
+  requirement: &70293403494940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70304497158780
+  version_requirements: *70293403494940
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &70304497157580 !ruby/object:Gem::Requirement
+  requirement: &70293403451080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70304497157580
+  version_requirements: *70293403451080
 - !ruby/object:Gem::Dependency
   name: guard
-  requirement: &70304497458900 !ruby/object:Gem::Requirement
+  requirement: &70293403450480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70304497458900
+  version_requirements: *70293403450480
 - !ruby/object:Gem::Dependency
   name: guard-test
-  requirement: &70304497457480 !ruby/object:Gem::Requirement
+  requirement: &70293403449820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +98,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70304497457480
+  version_requirements: *70293403449820
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &70304497455240 !ruby/object:Gem::Requirement
+  requirement: &70293403448900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -109,10 +109,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70304497455240
+  version_requirements: *70293403448900
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70304497453700 !ruby/object:Gem::Requirement
+  requirement: &70293403448020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -120,10 +120,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70304497453700
+  version_requirements: *70293403448020
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70304497452400 !ruby/object:Gem::Requirement
+  requirement: &70293403446960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -131,10 +131,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70304497452400
+  version_requirements: *70293403446960
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70304497451180 !ruby/object:Gem::Requirement
+  requirement: &70293403446380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -142,7 +142,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70304497451180
+  version_requirements: *70293403446380
 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.
@@ -192,7 +192,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -548541850773955983
+      hash: -2148443602705417876
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: