scoped_search 2.3.6 → 2.3.7

data/lib/scoped_search/definition.rb

@@ -149,9 +149,9 @@ module ScopedSearch
       register_complete_for! unless klass.respond_to?(:complete_for)
 
     end
-   
+
     attr_accessor :profile, :default_order
-    
+
     def fields
       @profile ||= :default
       @profile_fields[@profile] ||= {}
@@ -176,11 +176,11 @@ module ScopedSearch
     def operator_by_field_name(name)
       field = field_by_name(name)
       return [] if field.nil?
-      return field.operators                        if field.operators
-      return ['= ', '!= ']                          if field.set?
-      return ['= ', '> ', '< ', '<= ', '>= ','!= '] if field.numerical?
-      return ['= ', '!= ', '~ ', '!~ ']             if field.textual?
-      return ['= ', '> ', '< ']                     if field.temporal?
+      return field.operators                                   if field.operators
+      return ['= ', '!= ']                                     if field.set?
+      return ['= ', '> ', '< ', '<= ', '>= ','!= ', '^ ', '!^ '] if field.numerical?
+      return ['= ', '!= ', '~ ', '!~ ', '^ ', '!^ ']             if field.textual?
+      return ['= ', '> ', '< ']                                if field.temporal?
       raise ScopedSearch::QueryNotSupported, "could not verify '#{name}' type, this can be a result of a definition error"
     end
 
@@ -230,8 +230,8 @@ module ScopedSearch
         when 2
           @klass.named_scope(:search_for, lambda { |*args| ScopedSearch::QueryBuilder.build_query(self, args[0], args[1]) })
         when 3
-          @klass.scope(:search_for, lambda { |*args| 
-            find_options = ScopedSearch::QueryBuilder.build_query(self, args[0], args[1]) 
+          @klass.scope(:search_for, lambda { |*args|
+            find_options = ScopedSearch::QueryBuilder.build_query(self, args[0], args[1])
             search_scope = @klass.scoped
             search_scope = search_scope.where(find_options[:conditions]) if find_options[:conditions]
             search_scope = search_scope.includes(find_options[:include]) if find_options[:include]

data/lib/scoped_search/query_builder.rb

@@ -101,7 +101,8 @@ module ScopedSearch
 
     # A hash that maps the operators of the query language with the corresponding SQL operator.
     SQL_OPERATORS = { :eq =>'=',  :ne => '<>', :like => 'LIKE', :unlike => 'NOT LIKE',
-                      :gt => '>', :lt =>'<',   :lte => '<=',    :gte => '>=' }
+                      :gt => '>', :lt =>'<',   :lte => '<=',    :gte => '>=',
+                      :in => 'IN',:notin => 'NOT IN' }
 
     # Return the SQL operator to use given an operator symbol and field definition.
     #
@@ -170,9 +171,16 @@ module ScopedSearch
     end
 
     # Validate the key name is in the set and translate the value to the set value.
+    def translate_value(field, value)
+      translated_value = field.complete_value[value.to_sym]
+      raise ScopedSearch::QueryNotSupported, "'#{field.field}' should be one of '#{field.complete_value.keys.join(', ')}', but the query was '#{value}'" if translated_value.nil?
+      translated_value
+    end
+
+    # A 'set' is group of possible values, for example a status might be "on", "off" or "unknown" and the database representation
+    # could be for example a numeric value. This method will validate the input and translate it into the database representation.
     def set_test(field, operator,value, &block)
-      set_value = field.complete_value[value.to_sym]
-      raise ScopedSearch::QueryNotSupported, "'#{field.field}' should be one of '#{field.complete_value.keys.join(', ')}', but the query was '#{value}'" if set_value.nil?
+      set_value = translate_value(field, value)
       raise ScopedSearch::QueryNotSupported, "Operator '#{operator}' not supported for '#{field.field}'" unless [:eq,:ne].include?(operator)
       negate = ''
       if [true,false].include?(set_value)
@@ -205,6 +213,10 @@ module ScopedSearch
       if [:like, :unlike].include?(operator)
         yield(:parameter, (value !~ /^\%|\*/ && value !~ /\%|\*$/) ? "%#{value}%" : value.tr_s('%*', '%'))
         return "#{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ?"
+      elsif [:in, :notin].include?(operator)
+        value.split(',').collect { |v| yield(:parameter, field.set? ? translate_value(field, v) : v.strip) }
+        value = value.split(',').collect { "?" }.join(",")
+        return "#{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} (#{value})"
       elsif field.temporal?
         return datetime_test(field, operator, value, &block)
       elsif field.set?
@@ -408,7 +420,7 @@ module ScopedSearch
       # Defines the to_sql method for AST AND/OR operators
       module LogicalOperatorNode
         def to_sql(builder, definition, &block)
-          fragments = children.map { |c| c.to_sql(builder, definition, &block) }.compact.map { |sql| "(#{sql})" }
+          fragments = children.map { |c| c.to_sql(builder, definition, &block) }.map { |sql| "(#{sql})" unless sql.blank? }.compact
           fragments.empty? ? nil : "#{fragments.join(" #{operator.to_s.upcase} ")}"
         end
       end

data/lib/scoped_search/query_language/parser.rb

@@ -11,7 +11,7 @@ module ScopedSearch::QueryLanguage::Parser
   LOGICAL_INFIX_OPERATORS  = [:and, :or]
   LOGICAL_PREFIX_OPERATORS = [:not]
   NULL_PREFIX_OPERATORS    = [:null, :notnull]
-  COMPARISON_OPERATORS = [:eq, :ne, :gt, :gte, :lt, :lte, :like, :unlike]
+  COMPARISON_OPERATORS = [:eq, :ne, :gt, :gte, :lt, :lte, :like, :unlike, :in, :notin]
   ALL_INFIX_OPERATORS = LOGICAL_INFIX_OPERATORS + COMPARISON_OPERATORS
   ALL_PREFIX_OPERATORS = LOGICAL_PREFIX_OPERATORS + COMPARISON_OPERATORS + NULL_PREFIX_OPERATORS
 
@@ -99,11 +99,25 @@ module ScopedSearch::QueryLanguage::Parser
     end
   end
 
-  # Parses a single value.
+  # Parse values in the format (val, val, val)
+  def parse_multiple_values
+    next_token if  peek_token == :lparen #skip :lparen
+    value = []
+    value << current_token if String === next_token until peek_token.nil? || peek_token == :rparen
+    next_token if peek_token == :rparen  # consume the :rparen
+    value.join(',')
+  end
+
   # This can either be a constant value or a field name.
   def parse_value
-    raise ScopedSearch::QueryNotSupported, "Value expected but found #{peek_token.inspect}" unless String === peek_token
-    ScopedSearch::QueryLanguage::AST::LeafNode.new(next_token)
+    if String === peek_token
+      ScopedSearch::QueryLanguage::AST::LeafNode.new(next_token)
+    elsif ([:in, :notin].include? current_token)
+      value = parse_multiple_values()
+      ScopedSearch::QueryLanguage::AST::LeafNode.new(value)
+    else
+      raise ScopedSearch::QueryNotSupported, "Value expected but found #{peek_token.inspect}"
+    end
   end
 
   protected

data/lib/scoped_search/query_language/tokenizer.rb

@@ -7,7 +7,7 @@ module ScopedSearch::QueryLanguage::Tokenizer
 
   # Every operator the language supports.
   OPERATORS = { '&' => :and, '|' => :or, '&&' => :and, '||' => :or, '-'=> :not, '!' => :not, '~' => :like, '!~' => :unlike,
-      '=' => :eq, '==' => :eq, '!=' => :ne, '<>' => :ne, '>' => :gt, '<' => :lt, '>=' => :gte, '<=' => :lte }
+      '=' => :eq, '==' => :eq, '!=' => :ne, '<>' => :ne, '>' => :gt, '<' => :lt, '>=' => :gte, '<=' => :lte, '^' => :in, '!^' => :notin }
 
   # Tokenizes the string and returns the result as an array of tokens.
   def tokenize
@@ -41,7 +41,7 @@ module ScopedSearch::QueryLanguage::Tokenizer
       when '(';  yield(:lparen)
       when ')';  yield(:rparen)
       when ',';  yield(:comma)
-      when /\&|\||=|<|>|!|~|-/;  tokenize_operator(&block)
+      when /\&|\||=|<|>|\^|!|~|-/;  tokenize_operator(&block)
       when '"';                  tokenize_quoted_keyword(&block)
       else;                      tokenize_keyword(&block)
       end

data/lib/scoped_search.rb

@@ -14,7 +14,7 @@ module ScopedSearch
 
   # The current scoped_search version. Do not change thisvalue by hand,
   # because it will be updated automatically by the gem release script.
-  VERSION = "2.3.6"
+  VERSION = "2.3.7"
 
   # The ClassMethods module will be included into the ActiveRecord::Base class
   # to add the <tt>ActiveRecord::Base.scoped_search</tt> method and the

data/scoped_search.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   
   # Do not change the version and date fields by hand. This will be done
   # automatically by the gem release script.
-  s.version = "2.3.6"
-  s.date    = "2011-11-13"
+  s.version = "2.3.7"
+  s.date    = "2012-04-30"
 
   s.summary = "Easily search you ActiveRecord models with a simple query language using a named scope."
   s.description = <<-EOS
@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency('activerecord', '>= 2.1.0')
   s.add_development_dependency('rspec', '~> 2.0')
+  s.add_development_dependency('rake')
   
   s.add_development_dependency('sqlite3-ruby')  
 

data/spec/integration/auto_complete_spec.rb

@@ -47,11 +47,11 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
       end
 
       it "should complete the string comparators" do
-        Foo.complete_for('string ').should =~ (["string  != ", "string  !~ ", "string  = ", "string  ~ "])
+        Foo.complete_for('string ').should =~ (["string  != ", "string  !^ ", "string  !~ ", "string  = ", "string  ^ ", "string  ~ "])
       end
 
       it "should complete the numerical comparators" do
-        Foo.complete_for('int ').should =~ (["int  != ", "int  < ", "int  <= ", "int  = ", "int  > ", "int  >= "])
+        Foo.complete_for('int ').should =~ (["int  != ", "int  !^ ", "int  < ", "int  <= ", "int  = ", "int  > ", "int  >= ", "int  ^ "])
       end
 
       it "should complete the temporal (date) comparators" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: scoped_search
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 13
   prerelease: false
   segments: 
   - 2
   - 3
-  - 6
-  version: 2.3.6
+  - 7
+  version: 2.3.7
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -16,12 +16,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-13 00:00:00 +02:00
+date: 2012-04-30 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: activerecord
-  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -34,10 +32,10 @@ dependencies:
         - 0
         version: 2.1.0
   type: :runtime
+  name: activerecord
+  prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rspec
-  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -49,10 +47,10 @@ dependencies:
         - 0
         version: "2.0"
   type: :development
+  name: rspec
+  prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: sqlite3-ruby
-  prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -63,7 +61,23 @@ dependencies:
         - 0
         version: "0"
   type: :development
+  name: rake
+  prerelease: false
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  name: sqlite3-ruby
+  prerelease: false
+  version_requirements: *id004
 description: "    Scoped search makes it easy to search your ActiveRecord-based models.\n    \n    It will create a named scope :search_for that can be called with a query string. It will build an SQL query using\n    the provided query string and a definition that specifies on what fields to search. Because the functionality is\n    built on named_scope, the result of the search_for call can be used like any other named_scope, so it can be\n    chained with another scope or combined with will_paginate.\n    \n    Because it uses standard SQL, it does not require any setup, indexers or daemons. This makes scoped_search\n    suitable to quickly add basic search functionality to your application with little hassle. On the other hand,\n    it may not be the best choice if it is going to be used on very large datasets or by a large user base.\n"
 email: 
 - willem@railsdoctors.com