scoped_search 2.0.1 → 2.2.0

data/.gitignore

@@ -6,3 +6,4 @@ scoped_search-*.gem
 /coverage
 /classes
 /files
+/spec/database.yml

data/README.rdoc

@@ -10,20 +10,37 @@ and build a query based on the search string they enter. If you want to build a
 more complex search form with multiple fields, searchlogic (see
 http://github.com/binarylogic/searchlogic) may be a good choice for you.
 
+=== Usage
+
+If you include a :profile parameter in scoped_search, the fields specified will only
+be search when you pass :profile into the search_for command:
+
+  class User < ActiveRecord::Base
+    scoped_search :on => :public_information
+    scoped_search :on => :private_information, :profile => :members
+  end
+  
+This will only search the :public_information column:
+
+  User.search_for('blah blah blah')
+  
+And this will only search the :private_information column:
+
+  User.search_for('blah blah blah', :profile => :members)
 
 == Installing
 
-The recommended method to enable scoped_search in your project is adding the scoped_search gem to your environment. Add the following code to your Rails configuration in <tt>config/environment.rb</tt>:
+The recommended method to enable scoped search in your project is adding the
+scoped_search gem to your environment. Add the following code to your Rails
+configuration in <tt>config/environment.rb</tt>, and run <tt>rake
+gems:install</tt> to install the gem.:
 
   Rails::Initializer.run do |config|
     ...
-    config.gem 'wvanbergen-scoped_search', :lib => 'scoped_search',
-                   :source => 'http://gems.github.com/'
+    config.gem 'scoped_search'
   end
 
-Run <tt>sudo rake gems:install</tt> to install the gem.
-
-Alternatively, install scoped_search as a Rails plugin:
+Alternatively, install scoped search as a Rails plugin (*deprecated*):
 
   script/plugin install git://github.com/wvanbergen/scoped_search.git
 
@@ -95,9 +112,9 @@ For more info, see the the project wiki: http://wiki.github.com/wvanbergen/scope
 
 == Additional resources
 
-* Source code: http://github.com/wvanbergen/scoped_search/tree/master
+* Source code: http://github.com/wvanbergen/scoped_search/tree
 * Project wiki: http://wiki.github.com/wvanbergen/scoped_search
-* RDoc documentation: http://wvanbergen.github.com/scoped_search
+* RDoc documentation: http://rdoc.info/projects/wvanbergen/scoped_search
 * wvanbergen's blog posts: http://techblog.floorplanner.com/tag/scoped_search
 
 == License

data/lib/scoped_search.rb

@@ -12,7 +12,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.0.1"
+  VERSION = "2.2.0"
 
   # The ClassMethods module will be included into the ActiveRecord::Base class
   # to add the <tt>ActiveRecord::Base.scoped_search</tt> method and the

data/lib/scoped_search/definition.rb

@@ -74,6 +74,8 @@ module ScopedSearch
       # scoped_search call on the ActiveRecord-based model class.
       def initialize(definition, options = {})
         @definition = definition
+        @definition.profile = options[:profile] if options[:profile]
+        
         case options
         when Symbol, String
           @field = field.to_sym
@@ -96,18 +98,32 @@ module ScopedSearch
       end
     end
 
-    attr_reader :klass, :fields, :unique_fields
+    attr_reader :klass
 
     # Initializes a ScopedSearch definition instance.
     # This method will also setup a database adapter and create the :search_for
     # named scope if it does not yet exist.
     def initialize(klass)
-      @klass         = klass
-      @fields        = {}
-      @unique_fields = []
+      @klass                 = klass
+      @fields                = {}
+      @unique_fields         = []
+      @profile_fields        = {:default => {}}
+      @profile_unique_fields = {:default => []}
 
       register_named_scope! unless klass.respond_to?(:search_for)
     end
+    
+    attr_accessor :profile
+    
+    def fields
+      @profile ||= :default
+      @profile_fields[@profile] ||= {}
+    end
+
+    def unique_fields
+      @profile ||= :default
+      @profile_unique_fields[@profile] ||= []
+    end
 
     NUMERICAL_REGXP = /^\-?\d+(\.\d+)?$/
 
@@ -139,7 +155,24 @@ module ScopedSearch
 
     # Registers the search_for named scope within the class that is used for searching.
     def register_named_scope! # :nodoc
-      @klass.named_scope(:search_for, lambda { |*args| ScopedSearch::QueryBuilder.build_query(args[1] || self, args[0]) })
+      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]) })
+        when 3
+          @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]
+            search_scope
+          })
+        else
+          raise "This ActiveRecord version is currently not supported!"
+        end
+      else
+        raise "Currently, only ActiveRecord 2.1 or higher is supported!"
+      end
     end
   end
 end

data/lib/scoped_search/query_builder.rb

@@ -14,12 +14,15 @@ module ScopedSearch
     # This method will parse the query string and build an SQL query using the search
     # query. It will return an ampty hash if the search query is empty, in which case
     # the scope call will simply return all records.
-    def self.build_query(definition, query)
+    def self.build_query(definition, *args)
+      query = args[0]
+      options = args[1] || {}
+      
       query_builder_class = self.class_for(definition)
       if query.kind_of?(ScopedSearch::QueryLanguage::AST::Node)
-        return query_builder_class.new(definition, query).build_find_params
+        return query_builder_class.new(definition, query, options[:profile]).build_find_params
       elsif query.kind_of?(String)
-        return query_builder_class.new(definition, ScopedSearch::QueryLanguage::Compiler.parse(query)).build_find_params
+        return query_builder_class.new(definition, ScopedSearch::QueryLanguage::Compiler.parse(query), options[:profile]).build_find_params
       elsif query.nil?
         return { }
       else
@@ -36,8 +39,8 @@ module ScopedSearch
     end
 
     # Initializes the instance by setting the relevant parameters
-    def initialize(definition, ast)
-      @definition, @ast = definition, ast
+    def initialize(definition, ast, profile)
+      @definition, @ast, @definition.profile = definition, ast, profile
     end
 
     # Actually builds the find parameters hash that should be used in the search_for
@@ -63,7 +66,7 @@ module ScopedSearch
       find_attributes = {}
       find_attributes[:conditions] = [sql] + parameters unless sql.nil?
       find_attributes[:include]    = includes.uniq      unless includes.empty?
-      find_attributes # Uncomment for debugging
+      # p find_attributes # Uncomment for debugging
       return find_attributes
     end
 
@@ -107,7 +110,7 @@ module ScopedSearch
           # fall inside/outside the range of timestamps of that day.
           yield(:parameter, timestamp)
           yield(:parameter, timestamp + 1)
-          negate    = (operator == :ne) ? 'NOT' : ''
+          negate    = (operator == :ne) ? 'NOT ' : ''
           field_sql = field.to_sql(operator, &block)
           return "#{negate}(#{field_sql} >= ? AND #{field_sql} < ?)"
 
@@ -165,10 +168,10 @@ module ScopedSearch
       # This function may yield an :include that should be used in the
       # ActiveRecord::Base#find call, to make sure that the field is avalable
       # for the SQL query.
-      def to_sql(builder, operator = nil, &block) # :yields: finder_option_type, value
+      def to_sql(operator = nil, &block) # :yields: finder_option_type, value
         yield(:include, relation) if relation
-        definition.klass.connection.quote_table_name(klass.table_name) + "." +
-            definition.klass.connection.quote_column_name(field)
+        definition.klass.connection.quote_table_name(klass.table_name.to_s) + "." +
+            definition.klass.connection.quote_column_name(field.to_s)
       end
     end
 
@@ -182,16 +185,21 @@ module ScopedSearch
           fragments = definition.default_fields_for(value).map do |field|
             builder.sql_test(field, field.default_operator, value, &block)
           end
-          "(#{fragments.join(' OR ')})"
+
+          case fragments.length
+            when 0 then nil
+            when 1 then fragments.first
+            else "#{fragments.join(' OR ')}"
+          end
         end
       end
 
       # Defines the to_sql method for AST operator nodes
       module OperatorNode
 
-        # Returns a NOT(...)  SQL fragment that negates the current AST node's children
+        # Returns a NOT (...)  SQL fragment that negates the current AST node's children
         def to_not_sql(builder, definition, &block)
-          "(NOT(#{rhs.to_sql(builder, definition, &block)}) OR #{rhs.to_sql(builder, definition, &block)} IS NULL)"
+          "NOT COALESCE(#{rhs.to_sql(builder, definition, &block)}, 0)"
         end
 
         # Returns an IS (NOT) NULL SQL fragment
@@ -213,7 +221,11 @@ module ScopedSearch
           fragments = definition.default_fields_for(rhs.value, operator).map { |field|
                           builder.sql_test(field, operator, rhs.value, &block) }.compact
 
-          fragments.empty? ? nil : "(#{fragments.join(' OR ')})"
+          case fragments.length
+            when 0 then nil
+            when 1 then fragments.first
+            else "#{fragments.join(' OR ')}"
+          end
         end
 
         # Explicit field name given, run the operator on the specified field only
@@ -246,8 +258,8 @@ 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
-          fragments.empty? ? nil : "(#{fragments.join(" #{operator.to_s.upcase} ")})"
+          fragments = children.map { |c| c.to_sql(builder, definition, &block) }.compact.map { |sql| "(#{sql})" }
+          fragments.empty? ? nil : "#{fragments.join(" #{operator.to_s.upcase} ")}"
         end
       end
     end
@@ -284,6 +296,19 @@ module ScopedSearch
         end
       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, &block) # :yields: finder_option_type, value
+        if field.textual? && [:like, :unlike].include?(operator)
+          yield(:parameter, (value !~ /^\%/ && value !~ /\%$/) ? "%#{value}%" : value)
+          return "LOWER(#{field.to_sql(operator, &block)}) #{self.sql_operator(operator, field)} LOWER(?)"
+        else
+          return super(field, operator, value, &block)
+        end
+      end
+    end
   end
 
   # Include the modules into the corresponding classes

data/scoped_search.gemspec

@@ -3,20 +3,20 @@ 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.0.1"
-  s.date    = "2009-10-02"
+  s.version = "2.2.0"
+  s.date    = "2010-05-26"
 
-  s.summary = "A Rails plugin to search your models with a simple query language, implemented using a named_scope"
-  s.description = <<EOS
+  s.summary = "Easily search you ActiveRecord models with a simple query language using a named scope."
+  s.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."
-EOS
+  EOS
 
   s.authors  = ['Willem van Bergen', 'Wes Hays']
-  s.email    = ['willem@vanbergen.org', 'weshays@gbdev.com']
+  s.email    = ['willem@railsdoctors.com', 'weshays@gbdev.com']
   s.homepage = 'http://wiki.github.com/wvanbergen/scoped_search'
 
   s.add_runtime_dependency('activerecord', '>= 2.1.0')
@@ -27,6 +27,6 @@ EOS
 
   # Do not change the files and test_files fields by hand. This will be done
   # automatically by the gem release script.
-  s.files      = %w(spec/spec_helper.rb spec/integration/string_querying_spec.rb spec/integration/relation_querying_spec.rb .gitignore spec/lib/mocks.rb scoped_search.gemspec lib/scoped_search/query_language/parser.rb LICENSE spec/lib/matchers.rb lib/scoped_search/definition.rb init.rb spec/unit/tokenizer_spec.rb spec/unit/parser_spec.rb spec/unit/ast_spec.rb lib/scoped_search/query_language/ast.rb spec/lib/database.rb Rakefile tasks/github-gem.rake spec/unit/query_builder_spec.rb lib/scoped_search/query_language.rb lib/scoped_search/query_builder.rb README.rdoc spec/unit/definition_spec.rb spec/database.yml spec/integration/api_spec.rb spec/integration/ordinal_querying_spec.rb lib/scoped_search/query_language/tokenizer.rb lib/scoped_search.rb)
-  s.test_files = %w(spec/integration/string_querying_spec.rb spec/integration/relation_querying_spec.rb spec/unit/tokenizer_spec.rb spec/unit/parser_spec.rb spec/unit/ast_spec.rb spec/unit/query_builder_spec.rb spec/unit/definition_spec.rb spec/integration/api_spec.rb spec/integration/ordinal_querying_spec.rb)
+  s.files      = %w(spec/spec_helper.rb spec/integration/string_querying_spec.rb lib/scoped_search/definition.rb spec/lib/mocks.rb scoped_search.gemspec lib/scoped_search/query_language/parser.rb spec/lib/matchers.rb .gitignore LICENSE spec/unit/ast_spec.rb spec/database.yml init.rb Rakefile spec/unit/tokenizer_spec.rb spec/unit/parser_spec.rb spec/integration/api_spec.rb lib/scoped_search/query_language/ast.rb lib/scoped_search/query_language.rb lib/scoped_search/query_builder.rb README.rdoc spec/unit/definition_spec.rb spec/lib/database.rb spec/integration/profile_querying_spec.rb tasks/github-gem.rake spec/unit/query_builder_spec.rb lib/scoped_search.rb spec/integration/relation_querying_spec.rb spec/integration/ordinal_querying_spec.rb lib/scoped_search/query_language/tokenizer.rb)
+  s.test_files = %w(spec/integration/string_querying_spec.rb spec/unit/ast_spec.rb spec/unit/tokenizer_spec.rb spec/unit/parser_spec.rb spec/integration/api_spec.rb spec/unit/definition_spec.rb spec/integration/profile_querying_spec.rb spec/unit/query_builder_spec.rb spec/integration/relation_querying_spec.rb spec/integration/ordinal_querying_spec.rb)
 end

data/spec/database.yml

@@ -13,13 +13,13 @@ sqlite3:
 mysql:
   adapter: "mysql"
   host: "localhost"
-  user: "root"
+  username: "root"
   password:
   database: "scoped_search_test"
  
-postgresql:
-  adapter: "postgresql"
-  host: "localhost"
-  username: "scoped_search"
-  password: "scoped_search"
-  database: "scoped_search_test"
+# postgresql:
+#   adapter: "postgresql"
+#   host: "localhost"
+#   username: "scoped_search"
+#   password: "scoped_search"
+#   database: "scoped_search_test"

data/spec/integration/api_spec.rb

@@ -44,8 +44,18 @@ describe ScopedSearch, "API" do
       @class.should respond_to(:search_for)
     end
 
-    it "should return an ActiveRecord::NamedScope::Scope when :search_for is called" do
-      @class.search_for('query').class.should eql(ActiveRecord::NamedScope::Scope)
+    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
+      
+      it "should return a ActiveRecord::Relation instance" do
+        @class.search_for('query').class.should eql(ActiveRecord::Relation)
+      end
+      
     end
   end
 

data/spec/integration/profile_querying_spec.rb

@@ -0,0 +1,61 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+# These specs will run on all databases that are defined in the spec/database.yml file.
+# Comment out any databases that you do not have available for testing purposes if needed.
+ScopedSearch::Spec::Database.test_databases.each do |db|
+
+  describe ScopedSearch, "using a #{db} database" do
+
+    before(:all) do
+      ScopedSearch::Spec::Database.establish_named_connection(db)
+    
+      @class = ScopedSearch::Spec::Database.create_model(:public => :string, :private => :string, :useless => :string) do |klass|
+        klass.scoped_search :on => :public
+        klass.scoped_search :on => :private, :profile => :private_profile
+        klass.scoped_search :on => :useless, :profile => :another_profile
+      end
+
+      @item1 = @class.create!(:public => 'foo', :private => 'bar', :useless => 'boo')
+      @item2 = @class.create!(:public => 'qwerty', :private => 'foo', :useless => 'cool')
+      @item3 = @class.create!(:public => 'asdf', :private => 'blargh', :useless => 'foo')
+    end
+
+    after(:all) do
+      ScopedSearch::Spec::Database.drop_model(@class)
+      ScopedSearch::Spec::Database.close_connection
+    end
+
+    context "searching without profile specified" do
+      before(:each) do
+        @results = @class.search_for('foo')
+      end
+      
+      it "should find results on column specified" do
+        @results.should include(@item1)
+      end
+        
+      it "should not find results on columns only specified with a given profile" do
+        @results.should_not include(@item2)
+      end
+    end
+
+    context "searching with profile specified" do
+      before(:each) do
+        @results = @class.search_for('foo', :profile => :private_profile)
+      end
+      
+      # it "should find results on columns indexed w/o profile" do
+      #   @results.should include(@item1)
+      # end
+      
+      it "should find results on column indexed with specified profile" do
+        @results.should include(@item2)
+      end
+      
+      it "should not find results on a column indexed with a different profile" do
+        @results.should_not include(@item3)
+      end
+    end
+
+  end
+end

data/spec/integration/string_querying_spec.rb

@@ -17,7 +17,7 @@ ScopedSearch::Spec::Database.test_databases.each do |db|
 
       @class.create!(:string => 'foo', :another => 'temp 1', :explicit => 'baz')
       @class.create!(:string => 'bar', :another => 'temp 2', :explicit => 'baz')
-      @class.create!(:string => 'baz', :another => 'temp 3', :explicit => nil)
+      @class.create!(:string => 'baz', :another => nil,      :explicit => nil)
     end
 
     after(:all) do
@@ -30,7 +30,7 @@ ScopedSearch::Spec::Database.test_databases.each do |db|
         @class.search_for('foo').should have(1).item
       end
 
-      it "should find the opther two records using NOT with an exact string match" do
+      it "should find the other two records using NOT with an exact string match" do
         @class.search_for('-foo').should have(2).item
       end
 
@@ -133,11 +133,15 @@ ScopedSearch::Spec::Database.test_databases.each do |db|
       end
 
       it "should find a partial match when the like operator is given" do
-        @class.search_for('~ temp').should have(3).item
+        @class.search_for('~ temp').should have(2).item
+      end
+      
+      it "should find a negation of partial match when the like operator is give with an explicit NOT operator" do
+        @class.search_for('!(~ temp)').should have(1).item
       end
 
       it "should find a partial match when the like operator and the field name is given" do
-        @class.search_for('another ~ temp').should have(3).item
+        @class.search_for('another ~ temp').should have(2).item
       end
     end
 

data/spec/lib/mocks.rb

@@ -7,7 +7,9 @@ module ScopedSearch::Spec::Mocks
   def mock_activerecord_class
     ar_mock = mock('ActiveRecord::Base')
     ar_mock.stub!(:named_scope).with(:search_for, anything)
+    ar_mock.stub!(:scope).with(:search_for, anything)
     ar_mock.stub!(:connection).and_return(mock_database_connection)
+    ar_mock.stub!(:ancestors).and_return([ActiveRecord::Base])
     return ar_mock
   end
 

data/spec/unit/definition_spec.rb

@@ -8,17 +8,35 @@ describe ScopedSearch::Definition do
     @definition.stub!(:setup_adapter)
   end
 
+
   describe '#initialize' do
 
-    it "should create the named scope when" do
-      @klass.should_receive(:named_scope).with(:search_for, instance_of(Proc))
-      ScopedSearch::Definition.new(@klass)
-    end
+    if ActiveRecord::VERSION::MAJOR == 2
+      
+      it "should create the named scope when" do
+        @klass.should_receive(:named_scope).with(:search_for, instance_of(Proc))
+        ScopedSearch::Definition.new(@klass)
+      end
+
+      it "should not create the named scope if it already exists" do
+        @klass.stub!(:search_for)
+        @klass.should_not_receive(:named_scope)
+        ScopedSearch::Definition.new(@klass)
+      end
+      
+    elsif ActiveRecord::VERSION::MAJOR == 3
+      
+      it "should create the named scope when" do
+        @klass.should_receive(:scope).with(:search_for, instance_of(Proc))
+        ScopedSearch::Definition.new(@klass)
+      end
 
-    it "should not create the named scope if it already exists" do
-      @klass.stub!(:search_for)
-      @klass.should_not_receive(:named_scope)
-      ScopedSearch::Definition.new(@klass)
+      it "should not create the named scope if it already exists" do
+        @klass.stub!(:search_for)
+        @klass.should_not_receive(:scope)
+        ScopedSearch::Definition.new(@klass)
+      end
+      
     end
   end
 end

data/spec/unit/query_builder_spec.rb

@@ -5,6 +5,8 @@ describe ScopedSearch::QueryBuilder do
   before(:each) do
     @definition = mock('ScopedSearch::Definition')
     @definition.stub!(:klass).and_return(Class.new(ActiveRecord::Base))
+    @definition.stub!(:profile).and_return(:default)
+    @definition.stub!(:profile=).and_return(true)
   end
 
   it "should return empty conditions if the search query is nil" do

data/tasks/github-gem.rake

@@ -119,23 +119,43 @@ module GithubGem
         checks = [:check_current_branch, :check_clean_status, :check_not_diverged, :check_version]
         checks.unshift('spec:basic') if has_specs?
         checks.unshift('test:basic') if has_tests?
-        checks.push << [:check_rubyforge] if gemspec.rubyforge_project
+        # checks.push << [:check_rubyforge] if gemspec.rubyforge_project
 
         desc "Perform all checks that would occur before a release"
         task(:release_checks => checks)
 
-        release_tasks = [:release_checks, :set_version, :build, :github_release]
-        release_tasks << [:rubyforge_release] if gemspec.rubyforge_project
+        release_tasks = [:release_checks, :set_version, :build, :github_release, :gemcutter_release]
+        # release_tasks << [:rubyforge_release] if gemspec.rubyforge_project
 
-        desc "Release a new verison of the gem"
+        desc "Release a new version of the gem using the VERSION environment variable"
         task(:release => release_tasks) { release_task }
+        
+        namespace(:release) do
+          desc "Release the next version of the gem, by incrementing the last version segment by 1"
+          task(:next => [:next_version] + release_tasks) { release_task }
 
-        task(:check_rubyforge)   { check_rubyforge_task }
-        task(:rubyforge_release) { rubyforge_release_task }
+          desc "Release the next version of the gem, using a bump increment (0.0.1)"
+          task(:bump => [:next_bump_version] + release_tasks) { release_task }
+
+          desc "Release the next version of the gem, using a minor increment (0.1.0)"
+          task(:minor => [:next_minor_version] + release_tasks) { release_task }
+
+          desc "Release the next version of the gem, using a major increment (1.0.0)"
+          task(:major => [:next_major_version] + release_tasks) { release_task }
+        end
+
+        # task(:check_rubyforge)   { check_rubyforge_task }
+        # task(:rubyforge_release) { rubyforge_release_task }
+        task(:gemcutter_release) { gemcutter_release_task }
         task(:github_release => [:commit_modified_files, :tag_version]) { github_release_task }
         task(:tag_version) { tag_version_task }
         task(:commit_modified_files) { commit_modified_files_task }
 
+        task(:next_version)       { next_version_task }
+        task(:next_bump_version)  { next_version_task(:bump) }
+        task(:next_minor_version) { next_version_task(:minor) }
+        task(:next_major_version) { next_version_task(:major) }
+        
         desc "Updates the gem release tasks with the latest version on Github"
         task(:update_tasks) { update_tasks_task }
       end
@@ -159,6 +179,32 @@ module GithubGem
       sh "mv #{gemspec.name}-#{gemspec.version}.gem pkg/#{gemspec.name}-#{gemspec.version}.gem"
     end
 
+    def newest_version
+      git.tags.map { |tag| tag.name.split('-').last }.compact.map { |v| Gem::Version.new(v) }.max || Gem::Version.new('0.0.0')
+    end
+
+    def next_version(increment = nil)
+      next_version = newest_version.segments
+      increment_index = case increment
+        when :micro then 3
+        when :bump  then 2
+        when :minor then 1
+        when :major then 0
+        else next_version.length - 1
+      end
+      
+      next_version[increment_index] ||= 0
+      next_version[increment_index] = next_version[increment_index].succ
+      ((increment_index + 1)...next_version.length).each { |i| next_version[i] = 0 }
+      
+      Gem::Version.new(next_version.join('.'))
+    end
+
+    def next_version_task(increment = nil)
+      ENV['VERSION'] = next_version(increment).version
+      puts "Releasing version #{ENV['VERSION']}..."
+    end
+
     # Updates the version number in the gemspec file, the VERSION constant in the main
     # include file and the contents of the VERSION file.
     def version_task
@@ -172,9 +218,7 @@ module GithubGem
     def check_version_task
       raise "#{ENV['VERSION']} is not a valid version number!" if ENV['VERSION'] && !Gem::Version.correct?(ENV['VERSION'])
       proposed_version = Gem::Version.new(ENV['VERSION'] || gemspec.version)
-      # Loads the latest version number using the created tags
-      newest_version   = git.tags.map { |tag| tag.name.split('-').last }.compact.map { |v| Gem::Version.new(v) }.max
-      raise "This version (#{proposed_version}) is not higher than the highest tagged version (#{newest_version})" if newest_version && newest_version >= proposed_version
+      raise "This version (#{proposed_version}) is not higher than the highest tagged version (#{newest_version})" if newest_version >= proposed_version
     end
 
     # Checks whether the current branch is not diverged from the remote branch
@@ -215,18 +259,22 @@ module GithubGem
       git.push(remote, remote_branch, true)
     end
 
-    # Checks whether Rubyforge is configured properly
-    def check_rubyforge_task
-      # Login no longer necessary when using rubyforge 2.0.0 gem
-      # raise "Could not login on rubyforge!" unless `rubyforge login 2>&1`.strip.empty?
-      output = `rubyforge names`.split("\n")
-      raise "Rubyforge group not found!"   unless output.any? { |line| %r[^groups\s*\:.*\b#{Regexp.quote(gemspec.rubyforge_project)}\b.*] =~ line }
-      raise "Rubyforge package not found!" unless output.any? { |line| %r[^packages\s*\:.*\b#{Regexp.quote(gemspec.name)}\b.*] =~ line }
-    end
-
-    # Task to release the .gem file toRubyforge.
-    def rubyforge_release_task
-      sh 'rubyforge', 'add_release', gemspec.rubyforge_project, gemspec.name, gemspec.version.to_s, "pkg/#{gemspec.name}-#{gemspec.version}.gem"
+    # # Checks whether Rubyforge is configured properly
+    # def check_rubyforge_task
+    #   # Login no longer necessary when using rubyforge 2.0.0 gem
+    #   # raise "Could not login on rubyforge!" unless `rubyforge login 2>&1`.strip.empty?
+    #   output = `rubyforge names`.split("\n")
+    #   raise "Rubyforge group not found!"   unless output.any? { |line| %r[^groups\s*\:.*\b#{Regexp.quote(gemspec.rubyforge_project)}\b.*] =~ line }
+    #   raise "Rubyforge package not found!" unless output.any? { |line| %r[^packages\s*\:.*\b#{Regexp.quote(gemspec.name)}\b.*] =~ line }
+    # end
+
+    # # Task to release the .gem file toRubyforge.
+    # def rubyforge_release_task
+    #   sh 'rubyforge', 'add_release', gemspec.rubyforge_project, gemspec.name, gemspec.version.to_s, "pkg/#{gemspec.name}-#{gemspec.version}.gem"
+    # end
+    
+    def gemcutter_release_task
+      sh "gem push pkg/#{gemspec.name}-#{gemspec.version}.gem"
     end
 
     # Gem release task.

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: scoped_search
 version: !ruby/object:Gem::Version 
-  version: 2.0.1
+  prerelease: false
+  segments: 
+  - 2
+  - 2
+  - 0
+  version: 2.2.0
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -10,32 +15,40 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-02 00:00:00 +02:00
+date: 2010-05-26 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 1
+        - 0
         version: 2.1.0
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 4
         version: 1.1.4
-    version: 
+  type: :development
+  version_requirements: *id002
 description: "    Scoped search makes it easy to search your ActiveRecord-based models.\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"
 email: 
-- willem@vanbergen.org
+- willem@railsdoctors.com
 - weshays@gbdev.com
 executables: []
 
@@ -46,32 +59,33 @@ extra_rdoc_files:
 files: 
 - spec/spec_helper.rb
 - spec/integration/string_querying_spec.rb
-- spec/integration/relation_querying_spec.rb
-- .gitignore
+- lib/scoped_search/definition.rb
 - spec/lib/mocks.rb
 - scoped_search.gemspec
 - lib/scoped_search/query_language/parser.rb
-- LICENSE
 - spec/lib/matchers.rb
-- lib/scoped_search/definition.rb
+- .gitignore
+- LICENSE
+- spec/unit/ast_spec.rb
+- spec/database.yml
 - init.rb
+- Rakefile
 - spec/unit/tokenizer_spec.rb
 - spec/unit/parser_spec.rb
-- spec/unit/ast_spec.rb
+- spec/integration/api_spec.rb
 - lib/scoped_search/query_language/ast.rb
-- spec/lib/database.rb
-- Rakefile
-- tasks/github-gem.rake
-- spec/unit/query_builder_spec.rb
 - lib/scoped_search/query_language.rb
 - lib/scoped_search/query_builder.rb
 - README.rdoc
 - spec/unit/definition_spec.rb
-- spec/database.yml
-- spec/integration/api_spec.rb
+- spec/lib/database.rb
+- spec/integration/profile_querying_spec.rb
+- tasks/github-gem.rake
+- spec/unit/query_builder_spec.rb
+- lib/scoped_search.rb
+- spec/integration/relation_querying_spec.rb
 - spec/integration/ordinal_querying_spec.rb
 - lib/scoped_search/query_language/tokenizer.rb
-- lib/scoped_search.rb
 has_rdoc: true
 homepage: http://wiki.github.com/wvanbergen/scoped_search
 licenses: []
@@ -90,28 +104,31 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: A Rails plugin to search your models with a simple query language, implemented using a named_scope
+summary: Easily search you ActiveRecord models with a simple query language using a named scope.
 test_files: 
 - spec/integration/string_querying_spec.rb
-- spec/integration/relation_querying_spec.rb
+- spec/unit/ast_spec.rb
 - spec/unit/tokenizer_spec.rb
 - spec/unit/parser_spec.rb
-- spec/unit/ast_spec.rb
-- spec/unit/query_builder_spec.rb
-- spec/unit/definition_spec.rb
 - spec/integration/api_spec.rb
+- spec/unit/definition_spec.rb
+- spec/integration/profile_querying_spec.rb
+- spec/unit/query_builder_spec.rb
+- spec/integration/relation_querying_spec.rb
 - spec/integration/ordinal_querying_spec.rb