scoped_search 2.7.1 → 3.0.0

data/lib/scoped_search/auto_complete_builder.rb

@@ -1,17 +1,16 @@
 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
 
+    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
+
     attr_reader :ast, :definition, :query, :tokens
 
     # This method will parse the query string and build  suggestion list using the
@@ -174,10 +173,14 @@ module ScopedSearch
       quoted_table  = field.key_klass.connection.quote_table_name(field.key_klass.table_name)
       quoted_field  = field.key_klass.connection.quote_column_name(field.key_field)
       field_name    = "#{quoted_table}.#{quoted_field}"
-      select_clause = "DISTINCT #{field_name}"
-      opts =  value_conditions(field_name, val).merge(:select => select_clause, :limit => 20)
 
-      field.key_klass.all(opts).map(&field.key_field).compact.map{ |f| "#{name}.#{f} "}
+      field.key_klass
+        .where(value_conditions(field_name, val))
+        .select("DISTINCT #{field_name}")
+        .limit(20)
+        .map(&field.key_field)
+        .compact
+        .map { |f| "#{name}.#{f} " }
     end
 
     # this method auto-completes values of fields that have a :complete_value marker
@@ -197,10 +200,13 @@ module ScopedSearch
       return complete_date_value if field.temporal?
       return complete_key_value(field, token, val) if field.key_field
 
-      opts = value_conditions(field.quoted_field, val)
-      opts.merge!(:limit => 20, :select => "DISTINCT #{field.quoted_field}")
-
-      return completer_scope(field).all(opts).map(&field.field).compact.map{|v| v.to_s =~ /\s+/ ? "\"#{v}\"" : v}
+      completer_scope(field)
+        .where(value_conditions(field.quoted_field, val))
+        .select("DISTINCT #{field.quoted_field}")
+        .limit(20)
+        .map(&field.field)
+        .compact
+        .map { |v| v.to_s =~ /\s/ ? "\"#{v}\"" : v }
     end
 
     def completer_scope(field)
@@ -215,7 +221,7 @@ module ScopedSearch
     end
     # date value completer
     def complete_date_value
-      options =[]
+      options = []
       options << '"30 minutes ago"'
       options << '"1 hour ago"'
       options << '"2 hours ago"'
@@ -233,34 +239,34 @@ module ScopedSearch
     # complete values in a key-value schema
     def complete_key_value(field, token, val)
       key_name = token.sub(/^.*\./,"")
-      key_opts = value_conditions(field.quoted_field,val).merge(:conditions => {field.key_field => key_name})
-      key_klass = field.key_klass.first(key_opts)
+      key_klass = field.key_klass.where(field.key_field => key_name).first
       raise ScopedSearch::QueryNotSupported, "Field '#{key_name}' not recognized for searching!" if key_klass.nil?
 
-      opts = {:limit => 20, :select => "DISTINCT #{field.quoted_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)
+      query = completer_scope(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
+        query = query.where(fk => key_klass.id)
       end
-      return completer_scope(field).all(opts).map(&field.field).compact.map{|v| v.to_s =~ /\s+/ ? "\"#{v}\"" : v}
+
+      query
+        .where(value_conditions(field, val))
+        .select("DISTINCT #{field.quoted_field}")
+        .limit(20)
+        .map(&field.field)
+        .compact
+        .map { |v| v.to_s =~ /\s/ ? "\"#{v}\"" : v }
     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.gsub("'","''")}%'".tr_s('%*', '%')}
+    # This method returns conditions for selecting completion from partial value
+    def value_conditions(field, val)
+      val.blank? ? nil : "#{field.quoted_field} LIKE '#{val.gsub("'","''")}%'".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

@@ -84,7 +84,11 @@ module ScopedSearch
           if klass.columns_hash.has_key?(field.to_s)
             klass.columns_hash[field.to_s]
           else
-            raise ActiveRecord::UnknownAttributeError, "#{klass.inspect} doesn't have column #{field.inspect}."
+            if "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}".to_f < 4.1
+              raise ActiveRecord::UnknownAttributeError, "#{klass.inspect} doesn't have column #{field.inspect}."
+            else
+              raise ActiveRecord::UnknownAttributeError.new( klass, field )
+            end
           end
         end
       end
@@ -243,8 +247,6 @@ module ScopedSearch
       definition = self
       if @klass.ancestors.include?(ActiveRecord::Base)
         case ActiveRecord::VERSION::MAJOR
-        when 2
-          @klass.named_scope(:search_for, lambda { |*args| ScopedSearch::QueryBuilder.build_query(definition, args[0], args[1]) })
         when 3
           @klass.scope(:search_for, lambda { |*args|
             find_options = ScopedSearch::QueryBuilder.build_query(definition, args[0], args[1])
@@ -258,7 +260,7 @@ module ScopedSearch
         when 4
           @klass.scope(:search_for, lambda { |*args|
             find_options = ScopedSearch::QueryBuilder.build_query(definition, args[0], args[1])
-            search_scope = @klass.all
+            search_scope = @klass
             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.references(find_options[:include]) if find_options[:include]
@@ -270,7 +272,7 @@ module ScopedSearch
           raise "This ActiveRecord version is currently not supported!"
         end
       else
-        raise "Currently, only ActiveRecord 2.1 or higher is supported!"
+        raise "Currently, only ActiveRecord 3 or newer is supported!"
       end
     end
 

data/lib/scoped_search/query_builder.rb

@@ -479,20 +479,6 @@ module ScopedSearch
     # The MysqlAdapter makes sure that case sensitive comparisons are used
     # when using the (not) equals operator, regardless of the field's
     # collation setting.
-    class MysqlAdapter < ScopedSearch::QueryBuilder
-
-      # Patches the default <tt>sql_operator</tt> method to add
-      # <tt>BINARY</tt> after the equals and not equals operator to force
-      # case-sensitive comparisons.
-      def sql_operator(operator, field)
-        if [:ne, :eq].include?(operator) && field.textual?
-          "#{SQL_OPERATORS[operator]} BINARY"
-        else
-          super(operator, field)
-        end
-      end
-    end
-
     class Mysql2Adapter < ScopedSearch::QueryBuilder
        # Patches the default <tt>sql_operator</tt> method to add
       # <tt>BINARY</tt> after the equals and not equals operator to force
@@ -506,6 +492,8 @@ module ScopedSearch
       end
     end
 
+    MysqlAdapter = Mysql2Adapter
+
     # The PostgreSQLAdapter make sure that searches are case sensitive when
     # using the like/unlike operators, by using the PostrgeSQL-specific
     # <tt>ILIKE operator</tt> instead of <tt>LIKE</tt>.
@@ -525,7 +513,7 @@ module ScopedSearch
         end
       end
 
-      # Switches out the default LIKE operator in the default <tt>sql_operator</tt> 
+      # Switches out the default LIKE operator in the default <tt>sql_operator</tt>
       # method for ILIKE or @@ if full text searching is enabled.
       def sql_operator(operator, field)
         raise ScopedSearch::QueryNotSupported, "the operator '#{operator}' is not supported for field type '#{field.type}'" if [:like, :unlike].include?(operator) and !field.textual?
@@ -548,25 +536,6 @@ module ScopedSearch
         sql
       end
     end
-
-    # The Oracle adapter also requires some tweaks to make the case insensitive LIKE work.
-    class OracleEnhancedAdapter < ScopedSearch::QueryBuilder
-
-      def sql_test(field, operator, value, lhs, &block) # :yields: finder_option_type, value
-        if field.key_field
-          yield(:parameter, lhs.sub(/^.*\./,''))
-        end
-        if field.textual? && [:like, :unlike].include?(operator)
-          yield(:parameter, (value !~ /^\%|\*/ && value !~ /\%|\*$/) ? "%#{value}%" : value.to_s.tr_s('%*', '%'))
-          return "LOWER(#{field.to_sql(operator, &block)}) #{self.sql_operator(operator, field)} LOWER(?)"
-        elsif field.temporal?
-          return datetime_test(field, operator, value, &block)
-        else
-          yield(:parameter, value)
-          return "#{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ?"
-        end
-      end
-    end
   end
 
   # Include the modules into the corresponding classes

data/lib/scoped_search/query_language.rb

@@ -31,8 +31,5 @@ module ScopedSearch::QueryLanguage
       compiler = self.new(str)
       compiler.tokenize
     end
-
   end
 end
-
-

data/lib/scoped_search/rails_helper.rb

@@ -1,4 +1,3 @@
-
 module ScopedSearch
   module RailsHelper
     # Creates a link that alternates between ascending and descending.
@@ -36,7 +35,7 @@ module ScopedSearch
 
       if selected
         css_classes = html_options[:class] ? html_options[:class].split(" ") : []
-        if new_sort == ascend 
+        if new_sort == ascend
           options[:as] = "▲ #{options[:as]}"
           css_classes << "ascending"
         else
@@ -124,52 +123,51 @@ module ScopedSearch
     end
 
     def auto_complete_field_jquery(method, url, options = {})
-      function = <<-EOF
-      $.widget( "custom.catcomplete", $.ui.autocomplete, {
-        _renderMenu: function( ul, items ) {
-          var self = this,
-          currentCategory = "";
-          $.each( items, function( index, item ) {
-            if ( item.category != undefined && item.category != currentCategory ) {
-              ul.append( "<li class='ui-autocomplete-category'>" + item.category + "</li>" );
-              currentCategory = item.category;
-            }
-            if ( item.error != undefined ) {
-              ul.append( "<li class='ui-autocomplete-error'>" + item.error + "</li>" );
-            }
-            if( item.completed != undefined ) {
-              $( "<li></li>" ).data( "item.autocomplete", item )
-				      .append( "<a>" + "<strong class='ui-autocomplete-completed'>" + item.completed + "</strong>" + item.part + "</a>" )
-				      .appendTo( ul );
-            } else {
-              if(typeof(self._renderItemData) === "function") {
-                self._renderItemData( ul, item );
+      function = <<-JAVASCRIPT
+        $.widget( "custom.catcomplete", $.ui.autocomplete, {
+          _renderMenu: function( ul, items ) {
+            var self = this,
+            currentCategory = "";
+            $.each( items, function( index, item ) {
+              if ( item.category != undefined && item.category != currentCategory ) {
+                ul.append( "<li class='ui-autocomplete-category'>" + item.category + "</li>" );
+                currentCategory = item.category;
+              }
+              if ( item.error != undefined ) {
+                ul.append( "<li class='ui-autocomplete-error'>" + item.error + "</li>" );
+              }
+              if( item.completed != undefined ) {
+                $( "<li></li>" ).data( "item.autocomplete", item )
+  				      .append( "<a>" + "<strong class='ui-autocomplete-completed'>" + item.completed + "</strong>" + item.part + "</a>" )
+  				      .appendTo( ul );
               } else {
-                self._renderItem( ul, item );
+                if(typeof(self._renderItemData) === "function") {
+                  self._renderItemData( ul, item );
+                } else {
+                  self._renderItem( ul, item );
+                }
               }
-            }
-          });
-        }
-      });
-
-      $("##{method}")
-      .catcomplete({
-			source: function( request, response ) {	$.getJSON( "#{url}", { #{method}: request.term }, response );	},
-			minLength: #{options[:min_length] || 0},
-      delay: #{options[:delay] || 200},
-      select: function(event, ui) { $( this ).catcomplete( "search" , ui.item.value); },
-      search: function(event, ui) { $(".auto_complete_clear").hide(); },
-      open: function(event, ui) { $(".auto_complete_clear").show(); }
-      });
-
-      $("##{method}").bind( "focus", function( event ) {
-        if( $( this )[0].value == "" ) {
-					$( this ).catcomplete( "search" );
-        }
-			});
-
- EOF
-
+            });
+          }
+        });
+
+        $("##{method}")
+        .catcomplete({
+  			source: function( request, response ) {	$.getJSON( "#{url}", { #{method}: request.term }, response );	},
+  			minLength: #{options[:min_length] || 0},
+        delay: #{options[:delay] || 200},
+        select: function(event, ui) { $( this ).catcomplete( "search" , ui.item.value); },
+        search: function(event, ui) { $(".auto_complete_clear").hide(); },
+        open: function(event, ui) { $(".auto_complete_clear").show(); }
+        });
+
+        $("##{method}").bind( "focus", function( event ) {
+          if( $( this )[0].value == "" ) {
+  					$( this ).catcomplete( "search" );
+          }
+  			});
+
+      JAVASCRIPT
 
       javascript_tag(function)
     end
@@ -218,6 +216,7 @@ module ScopedSearch
       text_field_tag(method, val, options) + auto_complete_clear_value_button(method) +
           auto_complete_field_jquery(method, url, completion_options)
     end
+    deprecate :auto_complete_field_tag_jquery, :auto_complete_field_tag, :auto_complete_result
 
   end
 end

data/lib/scoped_search/railtie.rb

@@ -1,8 +1,13 @@
-if defined?(ActionController)
-  require "scoped_search/rails_helper"
-  ActionController::Base.helper(ScopedSearch::RailsHelper)
-end
+require 'scoped_search/engine'
+
+module ScopedSearch
+  class Railtie < ::Rails::Railtie
 
-if defined?(::Rails::Engine)
-  require 'scoped_search/engine'
+    initializer "scoped_search.setup_rails_helper" do |app|
+      ActiveSupport.on_load :action_controller do
+        require "scoped_search/rails_helper"
+        ActionController::Base.helper(ScopedSearch::RailsHelper)
+      end
+    end
+  end
 end

data/lib/scoped_search/version.rb

@@ -1,3 +1,3 @@
 module ScopedSearch
-  VERSION = "2.7.1"
+  VERSION = "3.0.0"
 end

data/scoped_search.gemspec

@@ -12,26 +12,27 @@ Gem::Specification.new do |gem|
   gem.summary       = %q{Easily search you ActiveRecord models with a simple query language using a named scope}
   gem.description   = <<-EOS
     Scoped search makes it easy to search your ActiveRecord-based models.
-    
+
     It will create a named scope :search_for that can be called with a query string. It will build an SQL query using
     the provided query string and a definition that specifies on what fields to search. Because the functionality is
     built on named_scope, the result of the search_for call can be used like any other named_scope, so it can be
     chained with another scope or combined with will_paginate.
-    
+
     Because it uses standard SQL, it does not require any setup, indexers or daemons. This makes scoped_search
     suitable to quickly add basic search functionality to your application with little hassle. On the other hand,
     it may not be the best choice if it is going to be used on very large datasets or by a large user base.
   EOS
-  
+
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_runtime_dependency('activerecord', '>= 2.1.0')
-  gem.add_development_dependency('rspec', '~> 2.0')
-  gem.add_development_dependency('rake')  
+  gem.required_ruby_version = '>= 1.9.3'
+  gem.add_runtime_dependency('activerecord', '>= 3.0.0')
+  gem.add_development_dependency('rspec', '~> 3.0')
+  gem.add_development_dependency('rake')
 
   gem.rdoc_options << '--title' << gem.name << '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'
-  gem.extra_rdoc_files = ['README.rdoc']
+  gem.extra_rdoc_files = ['README.rdoc', 'CHANGELOG.rdoc', 'CONTRIBUTING.rdoc', 'LICENSE']
 end

data/spec/integration/api_spec.rb

@@ -44,54 +44,15 @@ describe ScopedSearch, "API" do
       @class.should respond_to(:search_for)
     end
 
-    if ActiveRecord::VERSION::MAJOR == 2
-      
-      it "should return a ActiveRecord::NamedScope::Scope instance" do
-        @class.search_for('query').class.should eql(ActiveRecord::NamedScope::Scope)
-      end
-      
-    elsif ActiveRecord::VERSION::MAJOR == 3
-      
+    if ActiveRecord::VERSION::MAJOR == 3
       it "should return a ActiveRecord::Relation instance" do
         @class.search_for('query').class.should eql(ActiveRecord::Relation)
       end
-      
+
     elsif ActiveRecord::VERSION::MAJOR == 4
-      
       it "should return a ActiveRecord::Relation instance" do
         @class.search_for('query').class.superclass.should eql(ActiveRecord::Relation)
       end
-      
     end
   end
-
-  context 'having backwards compatibility' do
-
-    before(:each) do
-      class ::Foo < ActiveRecord::Base
-        belongs_to :bar
-      end
-    end
-
-    after(:each) do
-      Object.send :remove_const, :Foo
-    end
-
-    it "should respond to :searchable_on" do
-      Foo.should respond_to(:searchable_on)
-    end
-
-    it "should create a Field instance for every argument" do
-      ScopedSearch::Definition::Field.should_receive(:new).exactly(3).times
-      Foo.searchable_on(:field_1, :field_2, :field_3)
-    end
-
-    it "should create a Field with a valid relation when using the underscore notation" do
-      ScopedSearch::Definition::Field.should_receive(:new).with(
-          instance_of(ScopedSearch::Definition), hash_including(:in => :bar, :on => :related_field))
-      Foo.searchable_on(:bar_related_field)
-    end
-
-  end
-
 end