rroonga 0.9.4 → 0.9.5

data/html/index.html

@@ -42,7 +42,7 @@
 
 	<h3>rroongaの最新リリース</h3>
 	<p>
-	  2010-04-22にリリースされた0.9.4が最新です。
+	  2010-07-29にリリースされた0.9.5が最新です。
         </p>
 
 	<h3 id="install-rroonga">rroongaのインストール</h3>
@@ -97,13 +97,38 @@
 	  <li><a href="active_groonga/">ActiveGroongaのリファレンスマニュアル</a></li>
 	</ul>
 
+	<h2 id="about-racknga">racknga</h2>
+	<p>
+	  racknga（らくんが）はRackベースのWebアプリケーションでrroongaを便利に使うための機能（ミドルウェアなど）を提供するライブラリです。
+	</p>
+
+	<h3>rackngaの最新リリース</h3>
+	<p>
+	  2010-07-04にリリースされた0.9.0が最新です。
+        </p>
+
+	<h3 id="install-racknga">rackngaのインストール</h3>
+	<p>
+	  rackngaもRubyGemsでインストールできます。
+        </p>
+        <pre class="command">% sudo gem install racknga</pre>
+
+	<h3>racknagのドキュメント</h3>
+	<p>
+	  rackngaのドキュメントはそれほどありません。
+          これから徐々に追加されていく予定です。
+        </p>
+	<ul>
+	  <li><a href="racknga/">rackngaのリファレンスマニュアル</a></li>
+	</ul>
+
 	<h2>ライセンス</h2>
 	<p>
-	  rroongaおよびActiveGroongaはフリーソフトウェアです。あなたは、 Free Software Foundationが公表した<a href="http://www.gnu.org/licenses/lgpl-2.1.txt">GNU Lesser General Public License 2.1</a>に定める条項に従って本プログラムを再頒布または変更することができます。
+	  rroonga、ActiveGroonga、rackngaはフリーソフトウェアです。あなたは、 Free Software Foundationが公表した<a href="http://www.gnu.org/licenses/lgpl-2.1.txt">GNU Lesser General Public License 2.1</a>に定める条項に従って本プログラムを再頒布または変更することができます。
         </p>
 
         <p>
-          rroongaおよびActiveGroongaは有用とは思いますが、頒布にあたっては、市場性及び特定目的適合性についての暗黙の保証を含めて、いかなる保証も行ないません。詳細については<a href="http://www.gnu.org/licenses/lgpl-2.1.txt">GNU Lesser General Public License 2.1</a>をお読みください。
+          rroonga、ActiveGroonga、rackngaは有用とは思いますが、頒布にあたっては、市場性及び特定目的適合性についての暗黙の保証を含めて、いかなる保証も行ないません。詳細については<a href="http://www.gnu.org/licenses/lgpl-2.1.txt">GNU Lesser General Public License 2.1</a>をお読みください。
       </div>
 
       <div class="sidebar">
@@ -123,6 +148,11 @@
           <img src="rubyforge.png" width="120" height="24" border="0" alt="ラングバプロジェクトはRubyForge.orgにホスティングしてもらっています。" />
         </a>
       </p>
+      <p id="sponsor-github">
+        <a href="http://github.com/ranguba/">
+          ラングバプロジェクトはGitHubにホスティングしてもらっています。
+        </a>
+      </p>
       <p id="sponsor-tango">
 	<a href="http://tango.freedesktop.org/">
           <img width="120" height="53" border="0" alt="Tango Desktop Projectのアイコンを利用しています。" src="tango-logo.png" />

data/lib/groonga.rb

@@ -31,12 +31,7 @@ if local_groonga_bin_dir.exist?
     end
   end
 
-  case RUBY_PLATFORM
-  when /mingw|mswin/
-    prepend_path.call("PATH", ";")
-  when /cygwin/
-    prepend_path.call("PATH", ":")
-  end
+  prepend_path.call("PATH", File::PATH_SEPARATOR)
 end
 
 require 'groonga/view-record'
@@ -50,7 +45,7 @@ rescue LoadError
 end
 
 ##
-# Ruby/groonga用のネームスペース。Ruby/groongaのクラスやメソッ
+# rroonga用のネームスペース。rroongaのクラスやメソッ
 # ドなどはこのモジュール以下に定義される。
 module Groonga
   class << self
@@ -93,3 +88,4 @@ end
 require 'groonga/context'
 require 'groonga/patricia-trie'
 require 'groonga/schema'
+require 'groonga/pagination'

data/lib/groonga/context.rb

@@ -36,19 +36,12 @@ module Groonga
       select.exec
     end
 
-    class SelectResult < Struct.new(:return_code, :start_time, :elapsed,
-                                    :error_message,
-                                    :n_hits, :columns, :values,
+    class SelectResult < Struct.new(:n_hits, :columns, :values,
                                     :drill_down)
       class << self
         def parse(json, drill_down_keys)
-          status, (select_result, *drill_down_results) = parse_json(json)
+          select_result, *drill_down_results = parse_json(json)
           result = new
-          return_code, start_time, elapsed, error_message = status
-          result.return_code = return_code
-          result.start_time = Time.at(start_time)
-          result.elapsed = elapsed
-          result.error_message = error_message
           n_hits, columns, values = extract_result(select_result)
           result.n_hits = n_hits
           result.columns = columns
@@ -118,10 +111,6 @@ module Groonga
         @records ||= self.class.create_records(columns, values)
       end
 
-      def success?
-        return_code.zero?
-      end
-
       class DrillDownResult < Struct.new(:n_hits, :columns, :values)
         def records
           @records ||= SelectResult.create_records(columns, values)

data/lib/groonga/expression-builder.rb

@@ -38,29 +38,10 @@ module Groonga
       @default_column = nil
     end
 
-    def build
+    def build(&block)
       expression = Expression.new(:name => @name)
       variable = expression.define_variable(:domain => @table)
-
-      builder = nil
-      builder = match(@query, default_parse_options) if @query
-      if block_given?
-        if builder
-          builder &= yield(self)
-        else
-          builder = yield(self)
-        end
-      end
-      if builder.nil? or builder == self
-        expression.append_constant(1)
-        expression.append_constant(1)
-        expression.append_operation(Groonga::Operation::OR, 2)
-      else
-        builder.build(expression, variable)
-      end
-
-      expression.compile
-      expression
+      build_expression(expression, variable, &block)
     end
 
     def &(other)
@@ -82,6 +63,37 @@ module Groonga
       }
     end
 
+    def build_expression(expression, variable)
+      builders = []
+      builders << match(@query, default_parse_options) if @query
+      if block_given?
+        custom_builder = yield(self)
+        if custom_builder.is_a?(::Array)
+          builders.concat(custom_builder)
+        else
+          builders << custom_builder
+        end
+      end
+
+      if builders.empty? or builders == [self]
+        expression.append_constant(1)
+        expression.append_constant(1)
+        expression.append_operation(Groonga::Operation::OR, 2)
+      else
+        combined_builder = builders.inject(nil) do |previous, builder|
+          if previous.nil?
+            builder
+          else
+            previous & builder
+          end
+        end
+        combined_builder.build(expression, variable)
+      end
+
+      expression.compile
+      expression
+    end
+
     class ExpressionBuilder # :nodoc:
       def initialize
         super()
@@ -124,60 +136,215 @@ module Groonga
       end
     end
 
-    class BinaryExpressionBuilder < ExpressionBuilder # :nodoc:
-      def initialize(operation, column, value)
+    class ColumnValueExpressionBuilder < ExpressionBuilder # :nodoc:
+      def initialize(column, options={})
         super()
-        @operation = operation
-        @default_column = column
-        @value = value
+        @table = options[:table] || column.table
+        @column = column
+        @column_name = options[:column_name] || @column.local_name
+        @range = options[:range] || @column.range
+        @name = options[:name]
       end
 
       def build(expression, variable)
         expression.append_object(variable)
-        if @default_column.is_a?(String)
-          expression.append_constant(@default_column)
+        if @column.is_a?(String)
+          expression.append_constant(@column)
+        else
+          expression.append_object(@column)
+        end
+        expression.append_operation(Groonga::Operation::GET_VALUE, 2)
+      end
+
+      def ==(other)
+        EqualExpressionBuilder.new(self, normalize(other))
+      end
+
+      def =~(other)
+        if other.nil?
+          full_column_name = "#{@table.name}.#{@column_name}"
+          raise ArgumentError,
+                 "match word should not be nil: #{full_column_name}"
+        end
+        MatchExpressionBuilder.new(self, normalize(other))
+      end
+
+      def <(other)
+        LessExpressionBuilder.new(self, normalize(other))
+      end
+
+      def <=(other)
+        LessEqualExpressionBuilder.new(self, normalize(other))
+      end
+
+      def >(other)
+        GreaterExpressionBuilder.new(self, normalize(other))
+      end
+
+      def >=(other)
+        GreaterEqualExpressionBuilder.new(self, normalize(other))
+      end
+
+      def +(other)
+        PlusExpressionBuilder.new(self, normalize(other))
+      end
+
+      def -(other)
+        MinusExpressionBuilder.new(self, normalize(other))
+      end
+
+      def *(other)
+        StarExpressionBuilder.new(self, normalize(other))
+      end
+
+      def /(other)
+        SlashExpressionBuilder.new(self, normalize(other))
+      end
+
+      def %(other)
+        ModExpressionBuilder.new(self, normalize(other))
+      end
+
+      def match(query, options={})
+        options = options.dup
+        options[:syntax] ||= :query
+        options[:default_column] = @column_name
+        SubExpressionBuilder.new(query, options)
+      end
+
+      private
+      def normalize(other)
+        if @range.is_a?(Groonga::Table) and other.is_a?(Integer)
+          Groonga::Record.new(@range, other)
+        else
+          other
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        return super if block
+        return super unless args.empty?
+        if VALID_COLUMN_NAME_RE =~ name.to_s
+          RecordExpressionBuilder.new(@table, @name)["#{@column_name}.#{name}"]
+        else
+          super
+        end
+      end
+    end
+
+    class MatchTargetColumnExpressionBuilder < ColumnValueExpressionBuilder # :nodoc:
+      def build(expression, variable)
+        if @column.is_a?(String)
+          expression.append_constant(@column)
         else
-          expression.append_object(@default_column)
+          expression.append_object(@column)
         end
+      end
+
+      private
+      def normalize(other)
+        other
+      end
+    end
+
+    class MatchTargetExpressionBuilder < ExpressionBuilder # :nodoc:
+      def initialize(target)
+        super()
+        @target = target
+      end
+
+      def build(expression, variable)
+        expression.append_object(variable)
+        expression.append_object(@target)
         expression.append_operation(Groonga::Operation::GET_VALUE, 2)
+      end
+
+      def =~(query)
+        if query.nil?
+          raise ArgumentError, "match word should not be nil"
+        end
+        MatchExpressionBuilder.new(self, query)
+      end
+    end
+
+    class BinaryExpressionBuilder < ExpressionBuilder # :nodoc:
+      def initialize(operation, column_value_builder, value)
+        super()
+        @operation = operation
+        @column_value_builder = column_value_builder
+        @value = value
+      end
+
+      def build(expression, variable)
+        @column_value_builder.build(expression, variable)
         expression.append_constant(@value)
         expression.append_operation(@operation, 2)
       end
     end
 
     class EqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::EQUAL, column, value)
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::EQUAL, column_value_builder, value)
       end
     end
 
     class MatchExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::MATCH, column, value)
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::MATCH, column_value_builder, value)
       end
     end
 
     class LessExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::LESS, column, value)
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::LESS, column_value_builder, value)
       end
     end
 
     class LessEqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::LESS_EQUAL, column, value)
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::LESS_EQUAL, column_value_builder, value)
       end
     end
 
     class GreaterExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::GREATER, column, value)
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::GREATER, column_value_builder, value)
       end
     end
 
     class GreaterEqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::GREATER_EQUAL, column, value)
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::GREATER_EQUAL, column_value_builder, value)
+      end
+    end
+
+    class PlusExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::PLUS, column_value_builder, value)
+      end
+    end
+
+    class MinusExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::MINUS, column_value_builder, value)
+      end
+    end
+
+    class StarExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::STAR, column_value_builder, value)
+      end
+    end
+
+    class SlashExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::SLASH, column_value_builder, value)
+      end
+    end
+
+    class ModExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::MOD, column_value_builder, value)
       end
     end
 
@@ -210,9 +377,7 @@ module Groonga
           "for table <#{@table.inspect}>"
         raise ArgumentError, message
       end
-      ColumnExpressionBuilder.new(column, nil, nil,
-                                  :table => @table,
-                                  :column_name => name)
+      column_expression_builder(column, name)
     end
 
     def id
@@ -231,7 +396,7 @@ module Groonga
       self["_nsubrecs"]
     end
 
-    def match(query, options_or_default_column={})
+    def match(query, options_or_default_column={}, &block)
       if options_or_default_column.is_a?(String)
         options = {:default_column => options_or_default_column}
       else
@@ -239,10 +404,30 @@ module Groonga
       end
       options = options.dup
       options[:syntax] ||= :query
+      if block_given? and options[:default_column].nil?
+        options[:default_column] = build_match_target(&block)
+      end
       SubExpressionBuilder.new(query, options)
     end
 
+    def match_target(&block)
+      MatchTargetExpressionBuilder.new(build_match_target(&block))
+    end
+
     private
+    def build_match_target(&block)
+      sub_builder = MatchTargetRecordExpressionBuilder.new(@table, nil)
+      sub_builder.build do |record|
+        block.call(record)
+      end
+    end
+
+    def column_expression_builder(column, name)
+      ColumnValueExpressionBuilder.new(column,
+                                       :table => @table,
+                                       :column_name => name)
+    end
+
     def method_missing(name, *args, &block)
       return super if block
       return super unless args.empty?
@@ -254,6 +439,15 @@ module Groonga
     end
   end
 
+  class MatchTargetRecordExpressionBuilder < RecordExpressionBuilder # :nodoc:
+    private
+    def column_expression_builder(column, name)
+      MatchTargetColumnExpressionBuilder.new(column,
+                                             :table => @table,
+                                             :column_name => name)
+    end
+  end
+
   class ColumnExpressionBuilder # :nodoc:
     include ExpressionBuildable
 
@@ -268,54 +462,66 @@ module Groonga
     end
 
     def ==(other)
-      EqualExpressionBuilder.new(@default_column, normalize(other))
+      column_value_builder == other
     end
 
     def =~(other)
-      if other.nil?
-        full_column_name = "#{@table.name}.#{@column_name}"
-        raise ArgumentError, "match word should not be nil: #{full_column_name}"
-      end
-      MatchExpressionBuilder.new(@default_column, normalize(other))
+      column_value_builder =~ other
     end
 
     def <(other)
-      LessExpressionBuilder.new(@default_column, normalize(other))
+      column_value_builder < other
     end
 
     def <=(other)
-      LessEqualExpressionBuilder.new(@default_column, normalize(other))
+      column_value_builder <= other
     end
 
     def >(other)
-      GreaterExpressionBuilder.new(@default_column, normalize(other))
+      column_value_builder > other
     end
 
     def >=(other)
-      GreaterEqualExpressionBuilder.new(@default_column, normalize(other))
+      column_value_builder >= other
     end
 
-    def match(query, options={})
-      options = options.dup
-      options[:syntax] ||= :query
-      options[:default_column] = @column_name
-      SubExpressionBuilder.new(query, options)
+    def +(other)
+      column_value_builder + other
+    end
+
+    def -(other)
+      column_value_builder - other
+    end
+
+    def *(other)
+      column_value_builder * other
+    end
+
+    def /(other)
+      column_value_builder / other
+    end
+
+    def %(other)
+      column_value_builder % other
+    end
+
+    def match(query, options={}, &block)
+      column_value_builder.match(query, options, &block)
     end
 
     private
-    def normalize(other)
-      if @range.is_a?(Groonga::Table) and other.is_a?(Integer)
-        Groonga::Record.new(@range, other)
-      else
-        other
-      end
+    def column_value_builder
+      ColumnValueExpressionBuilder.new(@default_column,
+                                       :table => @table,
+                                       :column_name => @column_name,
+                                       :range => @range)
     end
 
     def method_missing(name, *args, &block)
       return super if block
       return super unless args.empty?
       if VALID_COLUMN_NAME_RE =~ name.to_s
-        RecordExpressionBuilder.new(@table, @name)["#{@column_name}.#{name}"]
+        column_value_builder.send(name)
       else
         super
       end