scoped_search 2.2.1 → 2.3.0

data/.gitignore

@@ -6,4 +6,7 @@ scoped_search-*.gem
 /coverage
 /classes
 /files
-/spec/database.yml
+/spec/database.yml
+.bundle/
+Gemfile.lock
+.idea/

data/.infinity_test

@@ -0,0 +1,8 @@
+infinity_test do
+  
+  use :rubies => %w(1.8.7 1.9.2 ree jruby rbx), :test_framework => :rspec
+  
+  before(:each_ruby) do |environment|
+    environment.system('bundle install')
+  end
+end

data/Gemfile

@@ -0,0 +1,15 @@
+source :rubygems
+gemspec
+
+# ScopedSearch is always tested on a sqlite3 memory database.
+# Uncomment the following gems to test scoped search on other RDBMSs.
+# You can specify the databasde connection details in spec/database.yml
+
+gem 'mysql2', '~> 0.2.6' # preferred over 'mysql'
+#gem 'mysql'
+# gem 'postgresql'
+
+# # JDBC connections
+# gem 'activerecord-jdbcsqlite3-adapter'
+# gem 'activerecord-jdbcmysql-adapter'
+# gem 'activerecord-jdbcpostgresql-adapter'

data/lib/scoped_search/auto_complete_builder.rb

@@ -0,0 +1,251 @@
+module ScopedSearch
+
+
+  LOGICAL_INFIX_OPERATORS  = ScopedSearch::QueryLanguage::Parser::LOGICAL_INFIX_OPERATORS
+  LOGICAL_PREFIX_OPERATORS = ScopedSearch::QueryLanguage::Parser::LOGICAL_PREFIX_OPERATORS
+  NULL_PREFIX_OPERATORS    = ScopedSearch::QueryLanguage::Parser::NULL_PREFIX_OPERATORS
+  NULL_PREFIX_COMPLETER    = ['has']
+  COMPARISON_OPERATORS     = ScopedSearch::QueryLanguage::Parser::COMPARISON_OPERATORS
+  PREFIX_OPERATORS         = LOGICAL_PREFIX_OPERATORS + NULL_PREFIX_OPERATORS
+
+  # The AutoCompleteBuilder class builds suggestions to complete query based on
+  # the query language syntax.
+  class AutoCompleteBuilder
+
+    attr_reader :ast, :definition, :query, :tokens
+
+    # This method will parse the query string and build  suggestion list using the
+    # search query.
+    def self.auto_complete(definition, query)
+      return [] if (query.nil? or definition.nil? or !definition.respond_to?(:fields))
+
+      new(definition, query).build_autocomplete_options
+    end
+
+    # Initializes the instance by setting the relevant parameters
+    def initialize(definition, query)
+      @definition = definition
+      @ast        = ScopedSearch::QueryLanguage::Compiler.parse(query)
+      @query      = query
+      @tokens     = tokenize
+    end
+
+    # Test the validity of the current query and suggest possible completion
+    def build_autocomplete_options
+      # First parse to find illegal syntax in the existing query,
+      # this method will throw exception on bad syntax.
+      is_query_valid
+
+      # get the completion options
+      node = last_node
+      completion = complete_options(node)
+
+      suggestions = []
+      suggestions += complete_keyword        if completion.include?(:keyword)
+      suggestions += LOGICAL_INFIX_OPERATORS if completion.include?(:logical_op)
+      suggestions += LOGICAL_PREFIX_OPERATORS + NULL_PREFIX_COMPLETER if completion.include?(:prefix_op)
+      suggestions += complete_operator(node) if completion.include?(:infix_op)
+      suggestions += complete_value          if completion.include?(:value)
+
+      build_suggestions(suggestions, completion.include?(:value))
+    end
+
+    # parse the query and return the complete options
+    def complete_options(node)
+
+      return [:keyword] + [:prefix_op] if tokens.empty?
+
+      #prefix operator
+      return [:keyword] if last_token_is(PREFIX_OPERATORS)
+
+      # left hand
+      if is_left_hand(node)
+        if (tokens.size == 1 || last_token_is(PREFIX_OPERATORS + LOGICAL_INFIX_OPERATORS) ||
+            last_token_is(PREFIX_OPERATORS + LOGICAL_INFIX_OPERATORS, 2))
+          options = [:keyword]
+          options += [:prefix_op]  unless last_token_is(PREFIX_OPERATORS)
+        else
+          options = [:logical_op]
+        end
+        return options
+      end
+
+      if is_right_hand
+        # right hand
+        return [:value]
+      else
+        # comparison operator completer
+        return [:infix_op]
+      end
+    end
+
+    # Test the validity of the existing query, this method will throw exception on illegal
+    # query syntax.
+    def is_query_valid
+      # skip test for null prefix operators if in the process of completing the field name.
+      return if(last_token_is(NULL_PREFIX_OPERATORS, 2) && !(query =~ /(\s|\)|,)$/))
+      QueryBuilder.build_query(definition, query)
+    end
+
+    def is_left_hand(node)
+      field = definition.field_by_name(node.value)
+      lh = field.nil? || field.key_field && !(query.end_with?(' '))
+      lh = lh || last_token_is(NULL_PREFIX_OPERATORS, 2)
+      lh = lh && !is_right_hand
+      lh
+    end
+
+    def is_right_hand
+      rh = last_token_is(COMPARISON_OPERATORS)
+      if(tokens.size > 1 && !(query.end_with?(' ')))
+        rh = rh || last_token_is(COMPARISON_OPERATORS, 2)
+      end
+      rh
+    end
+
+    def last_node
+      last = ast
+      while (last.kind_of?(ScopedSearch::QueryLanguage::AST::OperatorNode) && !(last.children.empty?)) do
+        last = last.children.last
+      end
+      last
+    end
+
+    def last_token_is(list,index = 1)
+      if tokens.size >= index
+        return list.include?(tokens[tokens.size - index])
+      end
+      return false
+    end
+
+    def tokenize
+      tokens = ScopedSearch::QueryLanguage::Compiler.tokenize(query)
+      # skip parenthesis, it is not needed for the auto completer.
+      tokens.delete_if {|t| t == :lparen || t == :rparen }
+      tokens
+    end
+
+    def build_suggestions(suggestions, is_value)
+      return [] if (suggestions.blank?)
+
+      q=query
+      unless q =~ /(\s|\)|,)$/
+        val = Regexp.escape(tokens.last.to_s).gsub('\*', '.*')
+        suggestions = suggestions.map {|s| s if s.to_s =~ /^#{val}/i}.compact
+        q.chomp!(tokens.last.to_s)
+      end
+
+      # for doted field names compact the suggestions list to be one suggestion
+      # unless the user has typed the relation name entirely or the suggestion list
+      # is short.
+      if (suggestions.size > 10 && (tokens.empty? || !(tokens.last.to_s.include?('.')) ) && !(is_value))
+        suggestions = suggestions.map {|s|
+          (s.to_s.split('.')[0].end_with?(tokens.last)) ? s.to_s : s.to_s.split('.')[0]
+        }
+      end
+
+      suggestions.uniq.map {|m| "#{q} #{m}".gsub(/\s+/," ")}
+    end
+
+    # suggest all searchable field names.
+    # in relations suggest only the long format relation.field.
+    def complete_keyword
+      keywords = []
+      definition.fields.each do|f|
+        if (f[1].key_field)
+          keywords += complete_key(f[0], f[1], tokens.last)
+        else
+          keywords << f[0].to_s+' '
+        end
+      end
+      keywords.sort
+    end
+
+    #this method completes the keys list in a key-value schema in the format table.keyName
+    def complete_key(name, field, val)
+      return ["#{name}."] if !val || !val.is_a?(String) || !(val.include?('.'))
+      val = val.sub(/.*\./,'')
+
+      field_name = field.key_field
+      opts =  value_conditions(field.key_field, val).merge(:limit => 20, :select => field_name, :group => field_name )
+
+      field.key_klass.all(opts).map(&field_name).compact.map{ |f| "#{name}.#{f} "}
+    end
+
+    # this method auto-completes values of fields that have a :complete_value marker 
+    def complete_value
+      if last_token_is(COMPARISON_OPERATORS)
+        token = tokens[tokens.size-2]
+        val = ''
+      else
+        token = tokens[tokens.size-3]
+        val = tokens[tokens.size-1]
+      end
+
+      field = definition.field_by_name(token)
+      return [] unless field && field.complete_value
+
+      return complete_set(field) if field.set?
+      return complete_date_value if field.temporal?
+      return complete_key_value(field, token, val) if field.key_field
+
+      opts = value_conditions(field.field, val)
+      opts.merge!(:limit => 20, :select => "DISTINCT #{field.field}")
+      return field.klass.all(opts).map(&field.field).compact.map{|v| v.to_s =~ /\s+/ ? "\"#{v}\"" : v}
+    end
+
+    # set value completer
+    def complete_set(field)
+      field.complete_value.keys
+    end
+    # date value completer
+    def complete_date_value
+      options =[]
+      options << '"30 minutes ago"'
+      options << '"1 hour ago"'
+      options << '"2 hours ago"'
+      options << 'Today'
+      options << 'Yesterday'
+      options << 2.days.ago.strftime('%A')
+      options << 3.days.ago.strftime('%A')
+      options << 4.days.ago.strftime('%A')
+      options << 5.days.ago.strftime('%A')
+      options << '"6 days ago"'
+      options << 7.days.ago.strftime('"%b %d,%Y"')
+      options
+    end
+
+    # complete values in a key-value schema
+    def complete_key_value(field, token, val)
+      key_name = token.sub(/^.*\./,"")
+      key_opts = value_conditions(field.field,val).merge(:conditions => {field.key_field => key_name})
+      key_klass = field.key_klass.first(key_opts)
+      raise ScopedSearch::QueryNotSupported, "Field '#{key_name}' not recognized for searching!" if key_klass.nil?
+
+      opts = {:select => "DISTINCT #{field.field}"}
+      if(field.key_klass != field.klass)
+        key  = field.key_klass.to_s.gsub(/.*::/,'').underscore.to_sym
+        fk   = field.klass.reflections[key].association_foreign_key.to_sym
+        opts.merge!(:conditions => {fk => key_klass.id})
+      else
+        opts.merge!(key_opts)
+      end
+      return field.klass.all(opts.merge(:limit => 20)).map(&field.field)
+    end
+
+    #this method returns conditions for selecting completion from partial value
+    def value_conditions(field_name, val)
+      return val.blank? ? {} : {:conditions => "#{field_name} LIKE '#{val}%'".tr_s('%*', '%')}
+    end
+
+    # This method complete infix operators by field type
+    def complete_operator(node)
+      definition.operator_by_field_name(node.value)
+    end
+
+  end
+
+end
+
+# Load lib files
+require 'scoped_search/query_builder'

data/lib/scoped_search/definition.rb

@@ -15,11 +15,24 @@ module ScopedSearch
     # class, so you should not create instances of this class yourself.
     class Field
 
-      attr_reader :definition, :field, :only_explicit, :relation
+      attr_reader :definition, :field, :only_explicit, :relation, :key_relation,
+                  :key_field, :complete_value, :offset, :word_size, :ext_method, :operators
 
       # The ActiveRecord-based class that belongs to this field.
       def klass
         if relation
+          related = definition.klass.reflections[relation]
+          raise ScopedSearch::QueryNotSupported, "relation '#{relation}' not one of #{definition.klass.reflections.keys.join(', ')} " if related.nil?
+          related.klass
+        else
+          definition.klass
+        end
+      end
+      # The ActiveRecord-based class that belongs the key field in a key-value pair.
+      def key_klass
+         if key_relation
+          definition.klass.reflections[key_relation].klass
+        elsif relation
           definition.klass.reflections[relation].klass
         else
           definition.klass
@@ -62,6 +75,11 @@ module ScopedSearch
         [:string, :text].include?(type)
       end
 
+      # Returns true if this is a set.
+      def set?
+        complete_value.is_a?(Hash)
+      end
+
       # Returns the default search operator for this field.
       def default_operator
         @default_operator ||= case type
@@ -70,12 +88,20 @@ module ScopedSearch
         end
       end
 
+      def default_order(options)
+        return nil if options[:default_order].nil?
+        field_name = options[:on] unless options[:rename]
+        field_name = options[:rename] if options[:rename]
+        order = (options[:default_order].to_s.downcase.include?('desc')) ? "DESC" : "ASC"
+        return "#{field_name} #{order}"
+      end
       # Initializes a Field instance given the definition passed to the
       # scoped_search call on the ActiveRecord-based model class.
       def initialize(definition, options = {})
         @definition = definition
         @definition.profile = options[:profile] if options[:profile]
-        
+        @definition.default_order ||= default_order(options)
+
         case options
         when Symbol, String
           @field = field.to_sym
@@ -83,18 +109,26 @@ module ScopedSearch
           @field = options.delete(:on)
 
           # Set attributes from options hash
+          @complete_value   = options[:complete_value]
           @relation         = options[:in]
+          @key_relation     = options[:in_key]
+          @key_field        = options[:on_key]
+          @offset           = options[:offset]
+          @word_size        = options[:word_size] || 1
+          @ext_method       = options[:ext_method]
+          @operators        = options[:operators]
           @only_explicit    = !!options[:only_explicit]
           @default_operator = options[:default_operator] if options.has_key?(:default_operator)
         end
 
         # Store this field is the field array
-        definition.fields[@field] ||= self
-        definition.unique_fields   << self
+        definition.fields[@field]                  ||= self unless options[:rename]
+        definition.fields[options[:rename].to_sym] ||= self if     options[:rename]
+        definition.unique_fields                   << self
 
         # Store definition for alias / aliases as well
-        definition.fields[options[:alias]] ||= self                    if options[:alias]
-        options[:aliases].each { |al| definition.fields[al] ||= self } if options[:aliases]
+        definition.fields[options[:alias].to_sym]                  ||= self   if options[:alias]
+        options[:aliases].each { |al| definition.fields[al.to_sym] ||= self } if options[:aliases]
       end
     end
 
@@ -110,10 +144,13 @@ module ScopedSearch
       @profile_fields        = {:default => {}}
       @profile_unique_fields = {:default => []}
 
+
       register_named_scope! unless klass.respond_to?(:search_for)
+      register_complete_for! unless klass.respond_to?(:complete_for)
+
     end
-    
-    attr_accessor :profile
+   
+    attr_accessor :profile, :default_order
     
     def fields
       @profile ||= :default
@@ -125,6 +162,25 @@ module ScopedSearch
       @profile_unique_fields[@profile] ||= []
     end
 
+    # this method return definitions::field object from string
+    def field_by_name(name)
+      field = fields[name.to_sym]
+      field ||= fields[name.to_s.split('.')[0].to_sym]
+      field
+    end
+
+    # this method is used by the syntax auto completer to suggest operators.
+    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?
+      raise ScopedSearch::QueryNotSupported, "could not verify '#{name}' type, this can be a result of a definition error"
+    end
+
     NUMERICAL_REGXP = /^\-?\d+(\.\d+)?$/
 
     # Returns a list of appropriate fields to search in given a search keyword and operator.
@@ -133,9 +189,20 @@ module ScopedSearch
       column_types  = []
       column_types += [:string, :text]                      if [nil, :like, :unlike, :ne, :eq].include?(operator)
       column_types += [:integer, :double, :float, :decimal] if value =~ NUMERICAL_REGXP
-      column_types += [:datetime, :date, :timestamp]        if (DateTime.parse(value) rescue nil)
+      column_types += [:datetime, :date, :timestamp]        if (parse_temporal(value))
 
-      default_fields.select { |field| column_types.include?(field.type) }
+      default_fields.select { |field| column_types.include?(field.type) && !field.set? }
+    end
+
+    # Try to parse a string as a datetime.
+    # Supported formats are Today, Yesterday, Sunday, '1 day ago', '2 hours ago', '3 months ago','Jan 23, 2004'
+    # And many more formats that are documented in Ruby DateTime API Doc.
+    def parse_temporal(value)
+      return Date.current if value =~ /\btoday\b/i
+      return 1.day.ago.to_date if value =~ /\byesterday\b/i
+      return (eval(value.strip.gsub(/\s+/,'.').downcase)).to_datetime if value =~ /\A\s*\d+\s+\bhours?|minutes?\b\s+\bago\b\s*\z/i
+      return (eval(value.strip.gsub(/\s+/,'.').downcase)).to_date if value =~ /\A\s*\d+\s+\b(days?|weeks?|months?|years?)\b\s+\bago\b\s*\z/i
+      DateTime.parse(value, true) rescue nil
     end
 
     # Returns a list of fields that should be searched on by default.
@@ -165,6 +232,9 @@ module ScopedSearch
             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]
+            search_scope = search_scope.joins(find_options[:joins]) if find_options[:joins]
+            search_scope = search_scope.order(find_options[:order]) if find_options[:order]
+            search_scope = search_scope.group(find_options[:group]) if find_options[:group]
             search_scope
           })
         else
@@ -176,3 +246,13 @@ module ScopedSearch
     end
   end
 end
+
+# Registers the complete_for method within the class that is used for searching.
+ def register_complete_for! # :nodoc
+@klass.class_eval do
+  def self.complete_for (query)
+    search_options = ScopedSearch::AutoCompleteBuilder.auto_complete(@scoped_search , query)
+    search_options
+    end
+  end
+ end