scoped_search 2.6.5 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3bb6838588ce385873a180ec0e875deedde5fcde
-  data.tar.gz: efbe17ef6dd34eadea7ac3251b3fbf5225e4e2c5
+  metadata.gz: 7053f29622ce510229c05ba561ce8a1e275942cf
+  data.tar.gz: e28a7d2541cc4e586b2bcbde23ea4742fa7a5671
 SHA512:
-  metadata.gz: aa3ed52f60b294fba0ef10b2299882e820d985b26dd03dfdcb0c91b93fb2445c5fe21817e80a4d452eb5f169f68626f4a672e7abb8f7e542a94516a794bcd979
-  data.tar.gz: c43a5e3d499f854bf01ae594387650bf46deaf4e4770ed44047949b2fcd0ca46bcd8ab8312970430fbe58ff9bebea86125a5862c9e840bde4821c94d960bfb05
+  metadata.gz: 7e3fac5a915408137d1ae6eb7194ddb43f75501407e13dd7203da779dc8e23fc011b0f55f2b7a1b6c461fb799e3afd376881bd001d6cc7276443d96ce8f2e7cd
+  data.tar.gz: 7b8643f0e611d089409b34f87f0102ef856ec9079d2f07e0ce1458ded6402f1d7c08d251ab4d609c29489e4eb5d5a673390e99948ce429eea663c3ef1638c85b

data/.gitignore

@@ -8,5 +8,5 @@ scoped_search-*.gem
 /files
 /spec/database.yml
 .bundle/
-Gemfile.lock
+Gemfile*.lock
 .idea/

data/.travis.yml

@@ -5,28 +5,26 @@ before_script:
   - mysql -e 'create database scoped_search_test;'
 rvm:
   - 1.8.7
-  - 1.9.2
   - 1.9.3
   - 2.0.0
+  - 2.1.1
   - ruby-head
-  - ree
   - jruby-18mode
   - jruby-19mode
   - jruby-head
 gemfile:
  - Gemfile.activerecord2
  - Gemfile.activerecord3
+ - Gemfile.activerecord4
 matrix:
   include:
-    - rvm: 1.9.3
-      gemfile: Gemfile.activerecord4
-    - rvm: 2.0.0
-      gemfile: Gemfile.activerecord4
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head
-    - rvm: jruby-18mode
-    - rvm: jruby-19mode
+    - rvm: 2.0.0
+      gemfile: Gemfile.activerecord2
+    - rvm: 2.1.1
+      gemfile: Gemfile.activerecord2
   exclude:
     - rvm: jruby-18mode
       gemfile: Gemfile.activerecord2
@@ -34,6 +32,7 @@ matrix:
       gemfile: Gemfile.activerecord2
     - rvm: jruby-head
       gemfile: Gemfile.activerecord2
-    - rvm: jruby-head
-      gemfile: Gemfile.activerecord2
-    - rvm: ree
+    - rvm: 1.8.7
+      gemfile: Gemfile.activerecord4
+    - rvm: jruby-18mode
+      gemfile: Gemfile.activerecord4

data/lib/scoped_search.rb

@@ -17,19 +17,23 @@ module ScopedSearch
   # <tt>ActiveRecord::Base.search_for</tt> named scope.
   module ClassMethods
 
+    def self.extended(base)
+      base.class_attribute :scoped_search_definition
+    end
+
     # Export the scoped_search method fo defining the search options.
     # This method will create a definition instance for the class if it does not yet exist,
     # and use the object as block argument and retun value.
     def scoped_search(*definitions)
-      @scoped_search ||= ScopedSearch::Definition.new(self)
+      self.scoped_search_definition ||= ScopedSearch::Definition.new(self)
       definitions.each do |definition|
         if definition[:on].kind_of?(Array)
-          definition[:on].each { |field| @scoped_search.define(definition.merge(:on => field)) }
+          definition[:on].each { |field| self.scoped_search_definition.define(definition.merge(:on => field)) }
         else
-          @scoped_search.define(definition)
+          self.scoped_search_definition.define(definition)
         end
       end
-      return @scoped_search
+      return self.scoped_search_definition
     end
   end
 

data/lib/scoped_search/auto_complete_builder.rb

@@ -137,13 +137,13 @@ module ScopedSearch
         q.chomp!(quoted[1]) if quoted
       end
 
-      # for doted field names compact the suggestions list to be one suggestion
+      # for dotted 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]
-        }
+      if (suggestions.size > 10 && (tokens.empty? || !tokens.last.to_s.include?('.')) && !is_value)
+        suggestions = suggestions.map  do |s|
+          s.to_s.split('.')[0].end_with?(tokens.last.to_s) ? s.to_s : s.to_s.split('.')[0]
+        end
       end
 
       suggestions.uniq.map {|m| "#{q} #{m}"}
@@ -158,7 +158,7 @@ module ScopedSearch
         if (f[1].key_field)
           keywords += complete_key(f[0], f[1], tokens.last)
         else
-          keywords << f[0].to_s+' '
+          keywords << f[0].to_s + ' '
         end
       end
       keywords.sort
@@ -182,11 +182,11 @@ module ScopedSearch
     # 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]
+        token = tokens[tokens.size - 2]
         val = ''
       else
-        token = tokens[tokens.size-3]
-        val = tokens[tokens.size-1]
+        token = tokens[tokens.size - 3]
+        val = tokens[tokens.size - 1]
       end
 
       field = definition.field_by_name(token)

data/lib/scoped_search/definition.rb

@@ -234,13 +234,14 @@ module ScopedSearch
 
     # Registers the search_for named scope within the class that is used for searching.
     def register_named_scope! # :nodoc
+      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(self, args[0], args[1]) })
+          @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(self, args[0], args[1])
+            find_options = ScopedSearch::QueryBuilder.build_query(definition, 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]
@@ -250,7 +251,7 @@ module ScopedSearch
           })
         when 4
           @klass.scope(:search_for, lambda { |*args|
-            find_options = ScopedSearch::QueryBuilder.build_query(self, args[0], args[1])
+            find_options = ScopedSearch::QueryBuilder.build_query(definition, args[0], args[1])
             search_scope = @klass.all
             search_scope = search_scope.where(find_options[:conditions]) if find_options[:conditions]
             search_scope = search_scope.includes(find_options[:include]) if find_options[:include]
@@ -269,11 +270,13 @@ module ScopedSearch
 
     # 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, options = {})
-          ScopedSearch::AutoCompleteBuilder.auto_complete(@scoped_search , query, options)
-        end
-      end
+      @klass.extend(ScopedSearch::AutoCompleteClassMethods)
+    end
+  end
+
+  module AutoCompleteClassMethods
+    def complete_for(query, options = {})
+      ScopedSearch::AutoCompleteBuilder.auto_complete(scoped_search_definition, query, options)
     end
   end
 end

data/lib/scoped_search/query_builder.rb

@@ -89,19 +89,20 @@ module ScopedSearch
     def order_by(order, &block)
       order ||= definition.default_order
       return nil if order.blank?
-      field = definition.field_by_name(order.to_s.split(' ')[0])
-      raise ScopedSearch::QueryNotSupported, "the field '#{order.to_s.split(' ')[0]}' in the order statement is not valid field for search" unless field
+      field_name, direction_name = order.to_s.split(/\s+/, 2)
+      field = definition.field_by_name(field_name)
+      raise ScopedSearch::QueryNotSupported, "the field '#{field_name}' in the order statement is not valid field for search" unless field
       sql = field.to_sql(&block)
-      direction = (order.to_s.downcase.include?('desc')) ? " DESC" : " ASC"
+      direction = (!direction_name.nil? && direction_name.downcase.eql?('desc')) ? " DESC" : " ASC"
       order = sql + direction
 
       return order
     end
 
     # 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 => '>=',
-                      :in => 'IN',:notin => 'NOT IN' }
+    SQL_OPERATORS = { :eq => '=',  :ne => '<>', :like => 'LIKE', :unlike => 'NOT LIKE',
+                      :gt => '>',  :lt =>'<',   :lte => '<=',    :gte => '>=',
+                      :in => 'IN', :notin => 'NOT IN' }
 
     # Return the SQL operator to use given an operator symbol and field definition.
     #
@@ -223,13 +224,14 @@ module ScopedSearch
       elsif field.definition.klass.reflections[field.relation].try(:macro) == :has_many
         value = value.to_i if field.offset
         yield(:parameter, value)
-        primary_key = "#{field.definition.klass.quoted_table_name}.#{field.definition.klass.primary_key}"
+        connection = field.definition.klass.connection
+        primary_key = "#{connection.quote_table_name(field.definition.klass.table_name)}.#{connection.quote_column_name(field.definition.klass.primary_key)}"
         if field.definition.klass.reflections[field.relation].options.has_key?(:through)
           join = has_many_through_join(field)
           return "#{primary_key} IN (SELECT #{primary_key} FROM #{join} WHERE #{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ? )"
         else
-          foreign_key = field.reflection_keys(field.definition.klass.reflections[field.relation])[1]
-          return "#{primary_key} IN (SELECT #{foreign_key} FROM #{field.klass.quoted_table_name} WHERE #{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ? )"
+          foreign_key = connection.quote_column_name(field.reflection_keys(field.definition.klass.reflections[field.relation])[1])
+          return "#{primary_key} IN (SELECT #{foreign_key} FROM #{connection.quote_table_name(field.klass.table_name)} WHERE #{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ? )"
         end
       else
         value = value.to_i if field.offset
@@ -241,23 +243,27 @@ module ScopedSearch
     def has_many_through_join(field)
       many_class = field.definition.klass
       through = many_class.reflections[field.relation].options[:through]
-      #table names
+      connection = many_class.connection
+
+      # table names
       endpoint_table_name = field.klass.table_name
       many_table_name = many_class.table_name
       middle_table_name = many_class.reflections[through].klass.table_name
-      #primary and foreign keys + optional condition for the many to middle join
+
+      # primary and foreign keys + optional condition for the many to middle join
       pk1, fk1   = field.reflection_keys(many_class.reflections[through])
       condition1 = field.reflection_conditions(field.klass.reflections[many_table_name.to_sym])
-      #primary and foreign keys + optional condition for the endpoint to middle join
+
+      # primary and foreign keys + optional condition for the endpoint to middle join
       pk2, fk2   = field.reflection_keys(field.klass.reflections[middle_table_name.to_sym])
       condition2 = field.reflection_conditions(many_class.reflections[field.relation])
 
       <<-SQL
-        #{many_table_name}
-        INNER JOIN #{middle_table_name}
-        ON #{many_table_name}.#{pk1} = #{middle_table_name}.#{fk1} #{condition1}
-        INNER JOIN #{endpoint_table_name}
-        ON #{middle_table_name}.#{fk2} = #{endpoint_table_name}.#{pk2} #{condition2}
+        #{connection.quote_table_name(many_table_name)}
+        INNER JOIN #{connection.quote_table_name(middle_table_name)}
+        ON #{connection.quote_table_name(many_table_name)}.#{connection.quote_column_name(pk1)} = #{connection.quote_table_name(middle_table_name)}.#{connection.quote_column_name(fk1)} #{condition1}
+        INNER JOIN #{connection.quote_table_name(endpoint_table_name)}
+        ON #{connection.quote_table_name(middle_table_name)}.#{connection.quote_column_name(fk2)} = #{connection.quote_table_name(endpoint_table_name)}.#{connection.quote_column_name(pk2)} #{condition2}
       SQL
     end
 
@@ -277,13 +283,13 @@ module ScopedSearch
         if key_relation
           yield(:joins, construct_join_sql(key_relation, num) )
           yield(:keycondition, "#{key_klass.table_name}_#{num}.#{connection.quote_column_name(key_field.to_s)} = ?")
-          klass_table_name = relation ? "#{klass.table_name}_#{num}" : connection.quote_table_name(klass.table_name)
-          return "#{klass_table_name}.#{connection.quote_column_name(field.to_s)}"
+          klass_table_name = relation ? "#{klass.table_name}_#{num}" : klass.table_name
+          return "#{connection.quote_table_name(klass_table_name)}.#{connection.quote_column_name(field.to_s)}"
         elsif key_field
           yield(:joins, construct_simple_join_sql(num))
           yield(:keycondition, "#{key_klass.table_name}_#{num}.#{connection.quote_column_name(key_field.to_s)} = ?")
-          klass_table_name = relation ? "#{klass.table_name}_#{num}" : connection.quote_table_name(klass.table_name)
-          return "#{klass_table_name}.#{connection.quote_column_name(field.to_s)}"
+          klass_table_name = relation ? "#{klass.table_name}_#{num}" : klass.table_name
+          return "#{connection.quote_table_name(klass_table_name)}.#{connection.quote_column_name(field.to_s)}"
         elsif relation
           yield(:include, relation)
         end
@@ -340,7 +346,7 @@ module ScopedSearch
         main_table = definition.klass.table_name
         main_table_pk, value_table_fk_main = reflection_keys(definition.klass.reflections[relation])
 
-        join_sql = "\n  INNER JOIN #{connection.quote_table_name(key_value_table)} #{key_value_table}_#{num} ON (#{connection.quote_table_name(main_table)}.#{main_table_pk} = #{key_value_table}_#{num}.#{value_table_fk_main})"
+        join_sql = "\n  INNER JOIN #{connection.quote_table_name(key_value_table)} #{key_value_table}_#{num} ON (#{connection.quote_table_name(main_table)}.#{connection.quote_column_name(main_table_pk)} = #{key_value_table}_#{num}.#{connection.quote_column_name(value_table_fk_main)})"
         return join_sql
       end
 

data/lib/scoped_search/rails_helper.rb

@@ -7,11 +7,13 @@ module ScopedSearch
     #
     #   sort @search, :by => :username
     #   sort @search, :by => :created_at, :as => "Created"
+    #   sort @search, :by => :created_at, :default => "DESC"
     #
     # This helper accepts the following options:
     #
     # * <tt>:by</tt> - the name of the named scope. This helper will prepend this value with "ascend_by_" and "descend_by_"
     # * <tt>:as</tt> - the text used in the link, defaults to whatever is passed to :by
+    # * <tt>:default</tt> - default sorting order, DESC or ASC
     def sort(field, options = {}, html_options = {})
 
       unless options[:as]
@@ -21,14 +23,20 @@ module ScopedSearch
 
       ascend  = "#{field} ASC"
       descend = "#{field} DESC"
-
-      ascending = params[:order] == ascend
-      new_sort = ascending ? descend : ascend
       selected = [ascend, descend].include?(params[:order])
 
+      case params[:order]
+        when ascend
+          new_sort = descend
+        when descend
+          new_sort = ascend
+        else
+          new_sort = ["ASC", "DESC"].include?(options[:default]) ? "#{field} #{options[:default]}" : ascend
+      end
+
       if selected
         css_classes = html_options[:class] ? html_options[:class].split(" ") : []
-        if ascending
+        if new_sort == ascend 
           options[:as] = "&#9650;&nbsp;#{options[:as]}"
           css_classes << "ascending"
         else

data/lib/scoped_search/version.rb

@@ -1,3 +1,3 @@
 module ScopedSearch
-  VERSION = "2.6.5"
+  VERSION = "2.7.0"
 end

data/spec/database.jruby.yml

@@ -1,15 +1,15 @@
 sqlite:
-  adapter: "jdbcsqlite3"
+  adapter: jdbcsqlite3
   database: ":memory:"
 
 mysql:
-  adapter: "jdbcmysql"
-  host: "localhost"
-  username: "root"
-  database: "scoped_search_test"
+  adapter: jdbcmysql
+  host: localhost
+  username: root
+  database: scoped_search_test
 
 postgresql:
-  adapter: "jdbcpostgresql"
-  host: "localhost"
-  username: "postgres"
-  database: "scoped_search_test"
+  adapter: jdbcpostgresql
+  host: localhost
+  username: postgres
+  database: scoped_search_test

data/spec/database.ruby.yml

@@ -1,16 +1,18 @@
 sqlite:
-  adapter: "sqlite3"
+  adapter: sqlite3
   database: ":memory:"
 
-# mysql:
-#   adapter: "mysql2"
-#   host: "127.0.0.1"
-#   port: 13306
-#   username: "root"
-#   database: "scoped_search_test"
+mysql:
+  adapter: mysql2
+  host: localhost
+  port: 3306
+  username: root
+  database: scoped_search_test
+  encoding: utf8
 
-# postgresql:
-#   adapter: "postgresql"
-#   host: "127.0.0.1"
-#   port: 5432
-#   database: "scoped_search_test"
+postgresql:
+  adapter: postgresql
+  host: localhost
+  username: postgres
+  port: 5432
+  database: scoped_search_test

data/spec/integration/auto_complete_spec.rb

@@ -38,6 +38,9 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         scoped_search :on => :related, :in => :bars, :rename => 'bars.related'.to_sym
       end
 
+      class ::Infoo < ::Foo
+      end
+
       @foo_1 = Foo.create!(:string => 'foo', :another => 'temp 1', :explicit => 'baz', :int => 9  , :date => 'February 8, 2011' , :unindexed => 10)
       Foo.create!(:string => 'bar', :another => 'temp 2', :explicit => 'baz', :int => 9  , :date => 'February 10, 2011', :unindexed => 10)
       Foo.create!(:string => 'baz', :another => nil,      :explicit => nil  , :int => nil, :date => nil                 , :unindexed => nil)
@@ -52,6 +55,7 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
 
       Object.send :remove_const, :Foo
       Object.send :remove_const, :Bar
+      Object.send :remove_const, :Infoo
 
       ScopedSearch::RSpec::Database.close_connection
     end
@@ -104,7 +108,12 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
       it "should not contain deprecated field in autocompleter" do
         Foo.complete_for(' ').should_not contain("  deprecated")
       end
+    end
 
+    context 'inherited auto completer' do
+      it "should complete the field name" do
+        Infoo.complete_for('str').should =~ ([' string '])
+      end
     end
 
     context 'using an aliased field' do

data/spec/integration/relation_querying_spec.rb

@@ -14,6 +14,26 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
       ScopedSearch::RSpec::Database.close_connection
     end
 
+    context 'querying a subclass' do
+      before do
+        ActiveRecord::Migration.create_table(:supers) { |t| t.string :name }
+        class Super < ActiveRecord::Base
+          scoped_search :on => :name
+        end
+        class Sub < Super; end
+
+        @super_record = Super.create!(:name => 'test')
+      end
+
+      after do
+        ScopedSearch::RSpec::Database.drop_model(Super)
+      end
+
+      it "should find records when searching the subclass" do
+        Sub.search_for('test').should have(1).item
+      end
+    end
+
     context 'querying a :belongs_to relation' do
 
       before do

data/spec/integration/string_querying_spec.rb

@@ -9,15 +9,21 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
     before(:all) do
       ScopedSearch::RSpec::Database.establish_named_connection(db)
     
-      @class = ScopedSearch::RSpec::Database.create_model(:string => :string, :another => :string, :explicit => :string) do |klass|
+      @class = ScopedSearch::RSpec::Database.create_model(
+          :string => :string,
+          :another => :string,
+          :explicit => :string,
+          :description => :string
+          ) do |klass|
         klass.scoped_search :on => :string
         klass.scoped_search :on => :another,  :default_operator => :eq, :alias => :alias, :default_order => :desc
         klass.scoped_search :on => :explicit, :only_explicit => true
+        klass.scoped_search :on => :description
       end
 
-      @class.create!(:string => 'foo', :another => 'temp 1', :explicit => 'baz')
-      @class.create!(:string => 'bar', :another => 'temp 2', :explicit => 'baz')
-      @class.create!(:string => 'baz', :another => nil,      :explicit => nil)
+      @class.create!(:string => 'foo', :another => 'temp 1', :explicit => 'baz', :description => '1 - one')
+      @class.create!(:string => 'bar', :another => 'temp 2', :explicit => 'baz', :description => '2 - two')
+      @class.create!(:string => 'baz', :another => nil,      :explicit => nil,   :description => '3 - three')
     end
 
     after(:all) do
@@ -202,7 +208,15 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         @class.search_for('',:order => 'string DESC').first.string.should eql('foo')
       end
 
-       it "default order by another DESC" do
+      it "sort by description ASC" do
+        @class.search_for('',:order => 'description ASC').first.description.should eql('1 - one')
+      end
+
+      it "sort by description DESC" do
+        @class.search_for('',:order => 'description DESC').first.description.should eql('3 - three')
+      end
+
+      it "default order by another DESC" do
         @class.search_for('').first.string.should eql('bar')
       end
 
@@ -212,6 +226,10 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
 
         Set.new(distinct_search.map(&:explicit)).should == Set['baz', nil]
       end
+
+      it 'should order using symbol' do
+        @class.search_for('',:order => :string).first.string.should eql('bar')
+      end
     end
   end
 end

data/spec/unit/rails_helper_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+require "scoped_search/rails_helper"
+
+module ActionViewHelperStubs
+  def html_escape(str)
+    str
+  end
+
+  def tag_options(options)
+    ""
+  end
+end
+
+describe ScopedSearch::RailsHelper do
+  include ScopedSearch::RailsHelper
+  include ActionViewHelperStubs
+
+  let(:params) { HashWithIndifferentAccess.new(:controller => "resources", :action => "search") }
+
+  it "should generate a link with the order param set" do
+    should_receive(:url_for).with(
+      "controller" => "resources",
+      "action" => "search",
+      "order" => "field ASC"
+    ).and_return("/example")
+
+    sort("field")
+  end
+
+  it "should generate a link with order param set to alternative default sorting order" do
+    should_receive(:url_for).with(
+      "controller" => "resources",
+      "action" => "search",
+      "order" => "field DESC"
+    ).and_return("/example")
+
+    sort("field", :default => "DESC")
+  end
+
+  it "should generate a link with the order param inverted" do
+    should_receive(:url_for).with(
+      "controller" => "resources",
+      "action" => "search",
+      "order" => "field DESC"
+    ).and_return("/example")
+
+    params[:order] = "field ASC"
+    sort("field")
+  end
+
+  it "should generate a link with other parameters retained" do
+    should_receive(:url_for).with(
+      "controller" => "resources",
+      "action" => "search",
+      "walrus" => "unicorns",
+      "order" => "field ASC"
+    ).and_return("/example")
+
+    params[:walrus] = "unicorns"
+    sort("field")
+  end
+
+  it "should replace the current sorting order" do
+    should_receive(:url_for).with(
+      "controller" => "resources",
+      "action" => "search",
+      "order" => "other ASC"
+    ).and_return("/example")
+
+    params[:order] = "field ASC"
+    sort("other")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scoped_search
 version: !ruby/object:Gem::Version
-  version: 2.6.5
+  version: 2.7.0
 platform: ruby
 authors:
 - Amos Benari
@@ -10,48 +10,48 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-10 00:00:00.000000000 Z
+date: 2014-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: "    Scoped search makes it easy to search your ActiveRecord-based models.\n
@@ -74,8 +74,8 @@ extensions: []
 extra_rdoc_files:
 - README.rdoc
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - Gemfile.activerecord2
 - Gemfile.activerecord3
@@ -120,33 +120,34 @@ files:
 - spec/unit/definition_spec.rb
 - spec/unit/parser_spec.rb
 - spec/unit/query_builder_spec.rb
+- spec/unit/rails_helper_spec.rb
 - spec/unit/tokenizer_spec.rb
 homepage: https://github.com/wvanbergen/scoped_search/wiki
 licenses: []
 metadata: {}
 post_install_message: 
 rdoc_options:
-- --title
+- "--title"
 - scoped_search
-- --main
+- "--main"
 - README.rdoc
-- --line-numbers
-- --inline-source
+- "--line-numbers"
+- "--inline-source"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Easily search you ActiveRecord models with a simple query language using
@@ -171,4 +172,5 @@ test_files:
 - spec/unit/definition_spec.rb
 - spec/unit/parser_spec.rb
 - spec/unit/query_builder_spec.rb
+- spec/unit/rails_helper_spec.rb
 - spec/unit/tokenizer_spec.rb