activegroonga 1.0.4 → 1.0.5

data/lib/active_groonga/railtie.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2010  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2010-2011  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -23,14 +23,15 @@ module ActiveGroonga
   class Railtie < Rails::Railtie
     config.active_groonga = ActiveSupport::OrderedOptions.new
 
-    config.generators.orm(:active_groonga,
-                          :migration => true,
-                          :timestamps => true)
+    config.app_generators.orm(:active_groonga,
+                              :migration => true,
+                              :timestamps => true)
 
     config.before_configuration do
       application_config = Rails.application.config
       application_config.extend(Railties::Configurable)
-      application_config.paths.config.groonga("config/groonga.yml")
+      application_config.paths.add("config/groonga",
+                                   :with => "config/groonga.yml")
     end
 
     rake_tasks do

data/lib/active_groonga/railties/groonga.rake

@@ -1,6 +1,6 @@
 # -*- ruby -*-
 #
-# Copyright (C) 2010  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2010-2011  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -121,15 +121,16 @@ namespace :groonga do
   desc('Load the seed data from db/groonga/seeds/#{RAILS_ENV}.grn, ' +
        'db/groonga/seeds/#{RAILS_ENV}.rb, db/groonga/seeds.grn or ' +
        'db/groonga/seeds.rb')
-  task :seed => :load_config do
+  task :seed => :environment do
     base_dir = Rails.root + "db" + "groonga"
     candidates = [base_dir + "seeds" + "#{Rails.env}.grn",
                   base_dir + "seeds" + "#{Rails.env}.rb",
                   base_dir + "seeds.grn",
                   base_dir + "seeds.rb"]
     seed_file_path = candidates.find(&:exist?)
-    break unless seed_file_path
-    case seed_file_path.extname
+    extension = nil
+    extension = seed_file_path.extname if seed_file_path
+    case extension
     when /\A\.grn\z/i
       ActiveGroonga::Base.database.ensure_available
       context = ActiveGroonga::Base.context
@@ -143,6 +144,9 @@ namespace :groonga do
       end
     when /\A\.rb\z/i
       load(seed_file_path)
+    when nil
+      candidate_paths = candidates.collect(&:to_s)
+      raise "seed file doesn't exist. candidates: #{candidate_paths.inspect}"
     else
       raise "unsupported seed file type: <#{seed_file_path}>"
     end

data/lib/active_groonga/result_set.rb

@@ -27,21 +27,122 @@ module ActiveGroonga
         @expression = @records.expression
       end
       @n_records = options[:n_records] || @records.size
+      @default_sort_keys = options[:default_sort_keys]
+      @default_limit = options[:default_limit]
       compute_n_key_nested
     end
 
-    def paginate(sort_keys, options={})
-      options[:page] = normalize_page_value(options[:page])
+    # Paginates the result set.
+    #
+    # @overload paginate(sort_keys, options={})
+    #   @param [Array<Array<String, Symbol>>] sort_keys
+    #     The array of sort key for paginating. Each sort
+    #     key is an array of sort key column name and order.
+    #   @option options [Integer] :size The page size.
+    #     {Base.limit} is used as the default value.
+    #   @option options [Integer] :page The target page.
+    #     The page is 1 origin not 0 origin. 1 is used as
+    #     the default value.
+    #   @return [ResultSet] paginated result set.
+    #
+    #   @example
+    #     result_set = User.all
+    #     # Paginates by sorting by "name" column value in
+    #     # ascending order. The paginated result set has
+    #     # less than or equal 10 records. And the returned
+    #     # page is user requested page. If user doesn't
+    #     # specify page, the first page is returned.
+    #     result_set.paginate([["name", :ascending]],
+    #                         :size => 10,
+    #                         :page => param[:page])
+    #
+    # @overload paginate(options={})
+    #   @option options [Integer] :size The page size.
+    #     {Base.limit} is used as the default value.
+    #   @option options [Integer] :page The target page.
+    #     1 is used as the default value.
+    #   @return [ResultSet] paginated result set.
+    #
+    #   @example
+    #     # The default sort keys.
+    #     User.sort_keys = [["name", :ascending]]
+    #     result_set = User.all
+    #     # Paginates by sorting by "name" column value in
+    #     # ascending order because it is the default sort
+    #     # keys. The paginated result set has
+    #     # less than or equal 10 records. And the returned
+    #     # page is user requested page. If user doesn't
+    #     # specify page, the first page is returned.
+    #     result_set.paginate(:size => 10,
+    #                         :page => param[:page])
+    #
+    #   {Base.sort_keys} is used as the sort keys.
+    def paginate(sort_keys=nil, options={})
+      if sort_keys.is_a?(Hash) and options.empty?
+        options = sort_keys
+        sort_keys = nil
+      end
+      options[:size] = normalize_limit(options[:size])
+      options[:page] = normalize_page(options[:page])
+      sort_keys = normalize_sort_keys(sort_keys)
       records = @records.paginate(sort_keys, options)
-      set = self.class.new(records, @klass,
-                           :expression => @expression)
+      set = create_result_set(records)
       set.extend(PaginationProxy)
       set
     end
 
-    def sort(keys, options={})
-      self.class.new(@records.sort(keys, options), @klass,
-                     :expression => @expression)
+    # Sorts the result set.
+    #
+    # @overload sort(keys, options={})
+    #   @param [Array<Array<String, Symbol>>] keys
+    #     The array of sort key for sort. Each sort
+    #     key is an array of sort key column name and order.
+    #   @option options [Integer] :limit The max number of records.
+    #     {Base.limit} is used as the default value.
+    #     If {Base.limit} is nil, all records are returned.
+    #   @option options [Integer] :offset The record start offset.
+    #     Offset is 0-origin not 1-origin.
+    #     The default value is 0.
+    #   @return [ResultSet] sorted result set.
+    #
+    #   @example
+    #     result_set = User.all
+    #     # Sorts by "name" column value in
+    #     # ascending order. The sorted result set has
+    #     # from the 5th records to the 14th records.
+    #     result_set.paginate([["name", :ascending]],
+    #                         :limit => 10,
+    #                         :offset => 4)
+    #
+    # @overload sort(options={})
+    #   @option options [Integer] :limit The max number of records.
+    #     {Base.limit} is used as the default value.
+    #     If {Base.limit} is nil, all records are returned.
+    #   @option options [Integer] :offset The record start offset.
+    #     Offset is 0-origin not 1-origin.
+    #     The default value is 0.
+    #   @return [ResultSet] sorted result set.
+    #
+    #   @example
+    #     # The default sort keys.
+    #     User.sort_keys = [["name", :ascending]]
+    #     result_set = User.all
+    #     # Sorts by "name" column value in
+    #     # ascending order because it is the default sort
+    #     # keys. The sorted result set has
+    #     # from the 5th records to the 14th records.
+    #     result_set.paginate(:limit => 10,
+    #                         :offset => 4)
+    #
+    #   {Base.sort_keys} is used as the sort keys.
+    def sort(keys=nil, options={})
+      if keys.is_a?(Hash) and options.empty?
+        options = keys
+        keys = nil
+      end
+      keys = normalize_sort_keys(keys)
+      options[:limit] = normalize_limit(options[:limit]) || @n_records
+      create_result_set(@records.sort(keys, options))
     end
 
     def group(key)
@@ -82,7 +183,18 @@ module ActiveGroonga
       end
     end
 
-    def normalize_page_value(page)
+    def normalize_limit(limit)
+      unless limit.blank?
+        begin
+          Integer(limit)
+        rescue
+          limit = nil
+        end
+      end
+      limit || @default_limit
+    end
+
+    def normalize_page(page)
       if page.blank?
         1
       else
@@ -94,6 +206,19 @@ module ActiveGroonga
       end
     end
 
+    def normalize_sort_keys(keys)
+      keys = @default_sort_keys if keys.blank?
+      keys = [["_id", :ascending]] if keys.blank?
+      keys
+    end
+
+    def create_result_set(records)
+      self.class.new(records, @klass,
+                     :default_sort_keys => @default_sort_keys,
+                     :default_limit => @default_limit,
+                     :expression => @expression)
+    end
+
     module PaginationProxy
       Groonga::Pagination.instance_methods.each do |method_name|
         define_method(method_name) do

data/lib/active_groonga/version.rb

@@ -17,7 +17,7 @@ module ActiveGroonga
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY  = 4
+    TINY  = 5
 
     STRING = [MAJOR, MINOR, TINY].join(".")
   end

data/test/active-groonga-test-utils.rb

@@ -208,6 +208,12 @@ module ActiveGroongaTestUtils
                       "fulltext search engine",
                       "<html><body>groonga</body></html>")
 
+    @bookmark_records[:rroonga] =
+      create_bookmark(@user_records[:daijiro],
+                      "http://groonga.rubyforge.org/",
+                      "The Ruby bindings for groonga",
+                      "<html><body>rroonga</body></html>")
+
     @bookmark_records[:cutter] =
       create_bookmark(@user_records[:gunyarakun],
                       "http://cutter.sourceforge.net/",

data/test/run-test.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #
-# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2011  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -20,21 +20,12 @@
 require 'pathname'
 require 'shellwords'
 
+require "rubygems"
+gem "test-unit"
+require "test/unit"
+require "test/unit/notify"
+
 base_dir = Pathname(__FILE__).dirname.parent.expand_path
-test_unit_dir = base_dir + "test-unit"
-test_unit_notify_dir = base_dir + "test-unit-notify"
-test_unit_repository_base = "http://test-unit.rubyforge.org/svn"
-unless test_unit_dir.exist?
-  system("svn", "co", "#{test_unit_repository_base}/trunk",
-         test_unit_dir.to_s)
-end
-unless test_unit_notify_dir.exist?
-  test_unit_notify_repository = "#{test_unit_repository_base}/extensions/test-unit-notify/trunk/"
-  system("svn", "co",
-         test_unit_notify_repository.to_s,
-         test_unit_notify_dir.to_s) or exit(false)
-  system("svn", "up", test_unit_dir.to_s) or exit(false)
-end
 
 rroonga_dir = base_dir.parent + "rroonga"
 lib_dir = base_dir + "lib"
@@ -55,16 +46,9 @@ if rroonga_dir.exist?
   $LOAD_PATH.unshift(rroonga_dir + "lib")
 end
 
-$LOAD_PATH.unshift(test_unit_notify_dir + "lib")
-$LOAD_PATH.unshift(test_unit_dir + "lib")
-
 ENV["TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"] = "10000"
 
-require 'test/unit'
-require 'test/unit/notify'
-
-ARGV.unshift("--priority-mode")
-ARGV.unshift("--notify")
+Test::Unit::Priority.enable
 
 $LOAD_PATH.unshift(lib_dir)
 
@@ -75,4 +59,7 @@ Dir.glob("test/**/test{_,-}*.rb") do |file|
   require file.sub(/\.rb$/, '')
 end
 
-exit Test::Unit::AutoRunner.run(false)
+success = Test::Unit::AutoRunner.run do |runner|
+  runner.runner_options[:show_detail_immediately] = true
+end
+exit(success)

data/test/test-base.rb

@@ -19,7 +19,9 @@ class TestBase < Test::Unit::TestCase
 
   def test_select
     bookmarks = Bookmark.select
-    assert_equal(["http://groonga.org/", "http://cutter.sourceforge.net/"].sort,
+    assert_equal(["http://groonga.org/",
+                  "http://groonga.rubyforge.org/",
+                  "http://cutter.sourceforge.net/"].sort,
                  bookmarks.collect(&:uri).sort)
   end
 
@@ -158,14 +160,17 @@ class TestBase < Test::Unit::TestCase
     bookmarks = Bookmark.select do |record|
       record.user == daijiro
     end
-    assert_equal([Bookmark.find(@bookmark_records[:groonga].id), google],
+    assert_equal([Bookmark.find(@bookmark_records[:groonga].id),
+                  Bookmark.find(@bookmark_records[:rroonga].id),
+                  google],
                  bookmarks.to_a)
   end
 
   def test_find_reference_by_id
     daijiro = @user_records[:daijiro]
     bookmarks = Bookmark.select {|record| record.user == daijiro}
-    assert_equal([Bookmark.find(@bookmark_records[:groonga])],
+    assert_equal([Bookmark.find(@bookmark_records[:groonga]),
+                  Bookmark.find(@bookmark_records[:rroonga])],
                  bookmarks.to_a)
   end
 
@@ -225,7 +230,8 @@ class TestBase < Test::Unit::TestCase
       end
       target =~ "groonga"
     end
-    assert_equal([["http://groonga.org/", 10]],
+    assert_equal([["http://groonga.org/", 10],
+                  ["http://groonga.rubyforge.org/", 5]],
                  bookmarks.collect {|bookmark| [bookmark.uri, bookmark.score]})
   end
 end

data/test/test-result-set.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2010  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2010-2011  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -17,15 +17,127 @@
 class TestResultSet < Test::Unit::TestCase
   include ActiveGroongaTestUtils
 
-  def test_paginate
-    bookmarks = Bookmark.select
-    assert_equal(["http://cutter.sourceforge.net/"].sort,
-                 bookmarks.paginate(["uri"], :size => 1).collect(&:uri))
+  def teardown
+    Bookmark.sort_keys = nil
+    Bookmark.limit = nil
   end
 
-  def test_sort
-    bookmarks = Bookmark.select
-    assert_equal(["http://cutter.sourceforge.net/"].sort,
-                 bookmarks.sort(["uri"], :limit => 1).collect(&:uri))
+  class TestPaginate < self
+    def test_explicit
+      bookmarks = Bookmark.select
+      assert_equal(["http://cutter.sourceforge.net/"].sort,
+                   bookmarks.paginate(["uri"], :size => 1).collect(&:uri))
+    end
+  end
+
+  class TestPaginateSortKeys < self
+    def test_implicit
+      Bookmark.sort_keys = ["uri"]
+      bookmarks = Bookmark.select
+      assert_equal(["http://cutter.sourceforge.net/"].sort,
+                   bookmarks.paginate(:size => 1).collect(&:uri))
+    end
+
+    def test_explicit
+      Bookmark.sort_keys = ["uri"]
+      bookmarks = Bookmark.select
+      assert_equal([User.find(@user_records[:daijiro].id)].sort,
+                   bookmarks.paginate(["user"], :size => 1).collect(&:user))
+    end
+  end
+
+  class TestPaginateLimit < self
+    def test_implicit
+      Bookmark.limit = 2
+      bookmarks = Bookmark.select
+      assert_equal(["http://cutter.sourceforge.net/",
+                    "http://groonga.org/"].sort,
+                   bookmarks.paginate(["uri"]).collect(&:uri))
+    end
+
+    def test_explicit
+      Bookmark.limit = 2
+      bookmarks = Bookmark.select
+      assert_equal(["http://cutter.sourceforge.net/"].sort,
+                   bookmarks.paginate(["uri"], :size => 1).collect(&:uri))
+    end
+  end
+
+  class TestPaginateAll < self
+    def test_implicit
+      Bookmark.sort_keys = ["uri"]
+      Bookmark.limit = 2
+      bookmarks = Bookmark.select
+      assert_equal(["http://cutter.sourceforge.net/"].sort,
+                   bookmarks.paginate(:size => 1).collect(&:uri))
+    end
+
+    def test_explicit
+      Bookmark.sort_keys = ["uri"]
+      Bookmark.limit = 2
+      bookmarks = Bookmark.select
+      assert_equal([User.find(@user_records[:daijiro].id)].sort,
+                   bookmarks.paginate(["user"], :size => 1).collect(&:user))
+    end
+  end
+
+  class TestSort < self
+    def test_explicit
+      bookmarks = Bookmark.select
+      assert_equal(["http://cutter.sourceforge.net/"].sort,
+                   bookmarks.sort(["uri"], :limit => 1).collect(&:uri))
+    end
+  end
+
+  class TestSortSortKeys < self
+    def test_implicit
+      Bookmark.sort_keys = ["uri"]
+      bookmarks = Bookmark.select
+      assert_equal(["http://cutter.sourceforge.net/"].sort,
+                   bookmarks.sort(:limit => 1).collect(&:uri))
+    end
+
+    def test_explicit
+      Bookmark.sort_keys = ["uri"]
+      bookmarks = Bookmark.select
+      assert_equal([User.find(@user_records[:daijiro].id)].sort,
+                   bookmarks.sort(["user"], :limit => 1).collect(&:user))
+    end
+  end
+
+  class TestSortLimit < self
+    def test_implicit
+      Bookmark.limit = 2
+      bookmarks = Bookmark.select
+      assert_equal(["http://cutter.sourceforge.net/",
+                    "http://groonga.org/",].sort,
+                   bookmarks.sort(["uri"]).collect(&:uri))
+    end
+
+    def test_explicit
+      Bookmark.limit = 2
+      bookmarks = Bookmark.select
+      assert_equal(["http://cutter.sourceforge.net/"].sort,
+                   bookmarks.sort(["uri"], :limit => 1).collect(&:uri))
+    end
+  end
+
+  class TestSortAll < self
+    def test_implicit
+      Bookmark.sort_keys = ["uri"]
+      Bookmark.limit = 2
+      bookmarks = Bookmark.select
+      assert_equal(["http://cutter.sourceforge.net/",
+                    "http://groonga.org/"].sort,
+                   bookmarks.sort.collect(&:uri))
+    end
+
+    def test_explicit
+      Bookmark.sort_keys = ["uri"]
+      Bookmark.limit = 2
+      bookmarks = Bookmark.select
+      assert_equal([User.find(@user_records[:daijiro].id)].sort,
+                   bookmarks.sort(["user"], :limit => 1).collect(&:user))
+    end
   end
 end