groonga 0.9.1 → 1.0.0

data/lib/groonga.rb

@@ -1,83 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2009  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
-# License version 2.1 as published by the Free Software Foundation.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-require 'pathname'
-
-base_dir = Pathname.new(__FILE__).dirname.dirname
-local_groonga_library_dir = base_dir + "vendor" + "local" + "lib"
-if local_groonga_library_dir.exist?
-  prepend_path = Proc.new do |environment_name, separator|
-    paths = (ENV[environment_name] || '').split(/#{separator}/)
-    unless paths.include?(local_groonga_library_dir.to_s)
-      paths = [local_groonga_library_dir.to_s] + paths
-      ENV[environment_name] = paths.join(separator)
-    end
-  end
-
-  case RUBY_PLATFORM
-  when /mingw|mswin/
-    prepend_path.call("PATH", ";")
-  end
-end
-
-require 'groonga/record'
-require 'groonga/expression-builder'
-require 'groonga.so'
-
-##
-# Ruby/groonga用のネームスペース。Ruby/groongaのクラスやメソッ
-# ドなどはこのモジュール以下に定義される。
-module Groonga
-  class << self
-    ##
-    # BUILD_VERSIONを"."で結合して<tt>"メジャーバージョン.マ
-    # イナーバージョン.マイクロバージョン"</tt>という形式の
-    # 文字列にしたもの。
-    def build_version
-      BUILD_VERSION.join(".")
-    end
-
-    ##
-    # VERSIONを"."で結合して<tt>"メジャーバージョン.マイナー
-    # バージョン.マイクロバージョン"</tt>という形式の文字列に
-    # したもの。
-    def version
-      VERSION.join(".")
-    end
-
-    ##
-    # BINDINGS_VERSIONを"."で結合して<tt>"メジャーバージョン.マ
-    # イナーバージョン.マイクロバージョン"</tt>という形式の文
-    # 字列にしたもの。
-    def bindings_version
-      BINDINGS_VERSION.join(".")
-    end
-
-    ##
-    # call-seq:
-    #   Groonga[name] -> Groonga::Object or nil
-    #   Groonga[id]   -> Groonga::Object or nil
-    #
-    # 便利メソッド。Groonga::Context.default[name]と同じ。
-    def [](name)
-      Context.default[name]
-    end
-  end
-end
-
-require 'groonga/patricia-trie'
-require 'groonga/schema'

data/lib/groonga/expression-builder.rb

@@ -1,285 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2009  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
-# License version 2.1 as published by the Free Software Foundation.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-module Groonga
-  module ExpressionBuildable # :nodoc:
-    attr_reader :table
-    attr_accessor :query
-    attr_accessor :syntax
-    attr_accessor :allow_pragma
-    attr_accessor :allow_column
-    attr_accessor :allow_update
-    attr_accessor :default_column
-
-    def initialize(*args)
-      @table = nil
-      @name = nil
-      @query = nil
-      @syntax = nil
-      @allow_pragma = nil
-      @allow_column = nil
-      @allow_update = nil
-      @default_column = nil
-    end
-
-    def build
-      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
-    end
-
-    def &(other)
-      other
-    end
-
-    def |(other)
-      other
-    end
-
-    private
-    def default_parse_options
-      {
-        :syntax => @syntax,
-        :allow_pragma => @allow_pragma,
-        :allow_column => @allow_column,
-        :allow_update => @allow_update,
-        :default_column => @default_column,
-      }
-    end
-
-    class ExpressionBuilder # :nodoc:
-      def initialize
-        super()
-      end
-
-      def &(other)
-        AndExpressionBuilder.new(self, other)
-      end
-
-      def |(other)
-        OrExpressionBuilder.new(self, other)
-      end
-    end
-
-    class SetExpressionBuilder < ExpressionBuilder # :nodoc:
-      def initialize(operation, *expression_builders)
-        super()
-        @operation = operation
-        @expression_builders = expression_builders
-      end
-
-      def build(expression, variable)
-        return if @expression_builders.empty?
-        @expression_builders.each do |builder|
-          builder.build(expression, variable)
-        end
-        expression.append_operation(@operation, @expression_builders.size)
-      end
-    end
-
-    class AndExpressionBuilder < SetExpressionBuilder # :nodoc:
-      def initialize(*expression_builders)
-        super(Groonga::Operation::AND, *expression_builders)
-      end
-    end
-
-    class OrExpressionBuilder < SetExpressionBuilder # :nodoc:
-      def initialize(*expression_builders)
-        super(Groonga::Operation::OR, *expression_builders)
-      end
-    end
-
-    class BinaryExpressionBuilder < ExpressionBuilder # :nodoc:
-      def initialize(operation, column, value)
-        super()
-        @operation = operation
-        @default_column = column
-        @value = value
-      end
-
-      def build(expression, variable)
-        expression.append_object(variable)
-        if @default_column.is_a?(String)
-          expression.append_constant(@default_column)
-        else
-          expression.append_object(@default_column)
-        end
-        expression.append_operation(Groonga::Operation::GET_VALUE, 2)
-        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)
-      end
-    end
-
-    class MatchExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::MATCH, column, value)
-      end
-    end
-
-    class LessExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::LESS, column, value)
-      end
-    end
-
-    class LessEqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::LESS_EQUAL, column, value)
-      end
-    end
-
-    class GreaterExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::GREATER, column, value)
-      end
-    end
-
-    class GreaterEqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::GREATER_EQUAL, column, value)
-      end
-    end
-
-    class SubExpressionBuilder < ExpressionBuilder # :nodoc:
-      def initialize(query, options)
-        super()
-        @query = query
-        @options = options
-      end
-
-      def build(expression, variable)
-        expression.parse(@query, @options)
-      end
-    end
-  end
-
-  class RecordExpressionBuilder # :nodoc:
-    include ExpressionBuildable
-
-    def initialize(table, name)
-      super()
-      @table = table
-      @name = name
-    end
-
-    def [](name)
-      column = @table.column(name)
-      if column.nil?
-        message = "unknown column <#{name.inspect}> " +
-          "for table <#{@table.inspect}>"
-        raise ArgumentError, message
-      end
-      ColumnExpressionBuilder.new(column, nil, nil,
-                                  :table => @table,
-                                  :column_name => name)
-    end
-
-    def match(query, options_or_default_column={})
-      if options_or_default_column.is_a?(String)
-        options = {:default_column => options_or_default_column}
-      else
-        options = options_or_default_column
-      end
-      options = options.dup
-      options[:syntax] ||= :query
-      SubExpressionBuilder.new(query, options)
-    end
-  end
-
-  class ColumnExpressionBuilder # :nodoc:
-    include ExpressionBuildable
-
-    def initialize(column, name, query, options={})
-      super()
-      @table = options[:table] || column.table
-      @default_column = column
-      @column_name = options[:column_name] || @default_column.local_name
-      @range = @default_column.range
-      @name = name
-      @query = query
-    end
-
-    def ==(other)
-      EqualExpressionBuilder.new(@default_column, 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(@default_column, normalize(other))
-    end
-
-    def <(other)
-      LessExpressionBuilder.new(@default_column, normalize(other))
-    end
-
-    def <=(other)
-      LessEqualExpressionBuilder.new(@default_column, normalize(other))
-    end
-
-    def >(other)
-      GreaterExpressionBuilder.new(@default_column, normalize(other))
-    end
-
-    def >=(other)
-      GreaterEqualExpressionBuilder.new(@default_column, 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
-  end
-end

data/lib/groonga/patricia-trie.rb

@@ -1,53 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2009  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
-# License version 2.1 as published by the Free Software Foundation.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-module Groonga
-  class PatriciaTrie
-    # call-seq:
-    #   patricia_trie.tag_keys(text) {|record, word| ...} -> String
-    #
-    # _text_を走査し、レコードのキーとマッチする部分文字列ごとに
-    # そのレコードが_record_として、その部分文字列が_word_として、
-    # ブロックが呼び出される。ブロックから返された文字列が元の部
-    # 分文字列と置換される。全てのヒットに対してのその置換処理が
-    # 行われた文字列が返される。
-    def tag_keys(text)
-      position = 0
-      result = ''
-      if text.respond_to?(:encoding)
-        encoding = text.encoding
-        bytes = text.dup.force_encoding("ascii-8bit")
-      else
-        encoding = nil
-        bytes = text
-      end
-      scan(text) do |record, word, start, length|
-        previous_text = bytes[position...start]
-        previous_text.force_encoding(encoding) if encoding
-        result << previous_text
-        result << yield(record, word)
-        position = start + length
-      end
-      last_text = bytes[position..-1]
-      unless last_text.empty?
-        last_text.force_encoding(encoding) if encoding
-        result << last_text
-      end
-      result
-    end
-  end
-end

data/lib/groonga/record.rb

@@ -1,276 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2009-2010  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
-# License version 2.1 as published by the Free Software Foundation.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-module Groonga
-  class Record
-    # レコードが所属するテーブル
-    attr_reader :table
-    # レコードのID
-    attr_reader :id
-    # _table_の_id_に対応するレコードを作成する。_values_には各
-    # カラムに設定する値を以下のような形式で指定する。
-    #
-    #   [
-    #    ["カラム名", 値],
-    #    ["カラム名", 値],
-    #    ...,
-    #   ]
-    def initialize(table, id, values=nil)
-      @table = table
-      @id = id
-      if values
-        values.each do |name, value|
-          self[name] = value
-        end
-      end
-    end
-
-    # call-seq:
-    #   record == other -> true/false
-    #
-    # _record_と_other_が同じgroongaのレコードなら+true+を返し、
-    # そうでなければ+false+を返す。
-    def ==(other)
-      self.class == other.class and
-        [table, id] == [other.table, other.id]
-    end
-
-    # call-seq:
-    #   record[column_name] -> 値
-    #
-    # このレコードの_column_name_で指定されたカラムの値を返す。
-    def [](column_name)
-      @table.column_value(@id, column_name, :id => true)
-    end
-
-    # call-seq:
-    #   record[column_name] = 値
-    #
-    # このレコードの_column_name_で指定されたカラムの値を設定す
-    # る。
-    def []=(column_name, value)
-      @table.set_column_value(@id, column_name, value, :id => true)
-    end
-
-    # call-seq:
-    #   record.append(column_name, value)
-    #
-    # このレコードの_column_name_で指定されたカラムの値の最後に
-    # _value_を追加する。
-    def append(column_name, value)
-      column(column_name).append(@id, value)
-    end
-
-    # call-seq:
-    #   record.prepend(column_name, value)
-    #
-    # このレコードの_column_name_で指定されたカラムの値の最初に
-    # _value_を追加する。
-    def prepend(column_name, value)
-      column(column_name).prepend(@id, value)
-    end
-
-    # call-seq:
-    #   record.have_column?(name) -> true/false
-    #
-    # 名前が_name_のカラムがレコードの所属するテーブルで定義され
-    # ているなら+true+を返す。
-    def have_column?(name)
-      column(name).is_a?(Groonga::Column)
-    rescue Groonga::NoSuchColumn
-      false
-    end
-
-    # call-seq:
-    #   record.reference_column?(name) -> true/false
-    #
-    # 名前が_name_のカラムが参照カラムであるなら+true+を返す。
-    def reference_column?(name)
-      column(name).range.is_a?(Groonga::Table)
-    end
-
-    # call-seq:
-    #   record.search(name, query, options={}) -> Groonga::Hash
-    #
-    # 名前が_name_のGroonga::IndexColumnのsearchメソッドを呼ぶ。
-    # _query_と_options_はそのメソッドにそのまま渡される。詳しく
-    # はGroonga::IndexColumn#searchを参照。
-    def search(name, query, options={})
-      column(name).search(query, options)
-    end
-
-    # call-seq:
-    #   record.key -> 主キー
-    #
-    # レコードの主キーを返す。
-    #
-    # _record_が所属するテーブルがGroonga:::Arrayの場合は常
-    # に+nil+を返す。
-    def key
-      if @table.is_a?(Groonga::Array)
-        nil
-      else
-        @key ||= @table.key(@id)
-      end
-    end
-
-    # call-seq:
-    #   record.score -> スコア値
-    #
-    # レコードのスコア値を返す。検索結果として生成されたテーブル
-    # のみに定義される。
-    def score
-      self["._score"]
-    end
-
-    # call-seq:
-    #   record.n_sub_records -> 件数
-    #
-    # 主キーの値が同一であったレコードの件数を返す。検索結果とし
-    # て生成されたテーブルのみに定義される。
-    def n_sub_records
-      self["._nsubrecs"]
-    end
-
-    # call-seq:
-    #   record.value -> 値
-    #
-    # レコードの値を返す。
-    def value
-      @table.value(@id, :id => true)
-    end
-
-    # call-seq:
-    #   record.value = 値
-    #
-    # レコードの値を設定する。既存の値は上書きされる。
-    def value=(value)
-      @table.set_value(@id, value, :id => true)
-    end
-
-    # call-seq:
-    #   record.increment!(name, delta=nil)
-    #
-    # このレコードの_name_で指定されたカラムの値を_delta_だけ増
-    # 加する。_delta_が+nil+の場合は1増加する。
-    def increment!(name, delta=nil)
-      column(name).increment!(@id, delta)
-    end
-
-    # call-seq:
-    #   record.decrement!(name, delta=nil)
-    #
-    # このレコードの_name_で指定されたカラムの値を_delta_だけ減
-    # 少する。_delta_が+nil+の場合は1減少する。
-    def decrement!(name, delta=nil)
-      column(name).decrement!(@id, delta)
-    end
-
-    # call-seq:
-    #   record.columns -> Groonga::Columnの配列
-    #
-    # レコードが所属するテーブルの全てのカラムを返す。
-    def columns
-      @table.columns
-    end
-
-    # call-seq:
-    #   attributes -> Hash
-    #
-    # レコードが所属しているテーブルで定義されているインデックス
-    # 型のカラムでない全カラムを対象とし、カラムの名前をキーとし
-    # たこのレコードのカラムの値のハッシュを返す。
-    def attributes
-      attributes = {"id" => id}
-      _key = key
-      attributes["key"] = _key if _key
-      table_name = @table.name
-      columns.each do |column|
-        next if column.is_a?(Groonga::IndexColumn)
-        value = column[@id]
-        # TODO: support recursive reference.
-        value = value.attributes if value.is_a?(Groonga::Record)
-        attributes[column.local_name] = value
-      end
-      attributes
-    end
-
-    # call-seq:
-    #   record.delete
-    #
-    # レコードを削除する。
-    def delete
-      @table.delete(@id)
-    end
-
-    # call-seq:
-    #   record.lock(options={})
-    #   record.lock(options={}) {...}
-    #
-    # レコードが所属するテーブルをロックする。ロックに失敗した場
-    # 合はGroonga::ResourceDeadlockAvoided例外が発生する。
-    #
-    # ブロックを指定した場合はブロックを抜けたときにunlockする。
-    #
-    # 利用可能なオプションは以下の通り。
-    #
-    # [_:timeout_]
-    #   ロックを獲得できなかった場合は_:timeout_秒間ロックの獲
-    #   得を試みる。_:timeout_秒以内にロックを獲得できなかった
-    #   場合は例外が発生する。
-    def lock(options={}, &block)
-      @table.lock(options.merge(:id => @id), &block)
-    end
-
-    # call-seq:
-    #   record.unlock(options={})
-    #
-    # レコードが所属するテーブルのロックを解除する。
-    #
-    # 利用可能なオプションは現在は無い。
-    def unlock(options={})
-      @table.unlock(options.merge(:id => @id))
-    end
-
-    # call-seq:
-    #   record.clear_lock(options={})
-    #
-    # レコードが所属するテーブルのロックを強制的に解除する。
-    #
-    # 利用可能なオプションは現在は無い。
-    def clear_lock(options={})
-      @table.clear_lock(options.merge(:id => @id))
-    end
-
-    # call-seq:
-    #   record.locked?(options={}) -> true/false
-    #
-    # レコードが所属するテーブルがロックされていれば+true+を返す。
-    #
-    # 利用可能なオプションは現在は無い。
-    def locked?(options={})
-      @table.locked?(options.merge(:id => @id))
-    end
-
-    private
-    def column(name) # :nodoc:
-      _column = @table.column(name.to_s)
-      raise NoSuchColumn, "column(#{name.inspect}) is nil" if _column.nil?
-      _column
-    end
-  end
-end