rroonga 2.0.4 → 2.0.5

data/ext/groonga/rb-groonga.c

@@ -136,6 +136,7 @@ Init_groonga (void)
     rb_grn_init_column(mGrn);
     rb_grn_init_accessor(mGrn);
     rb_grn_init_view_accessor(mGrn);
+    rb_grn_init_geo_point(mGrn);
     rb_grn_init_record(mGrn);
     rb_grn_init_view_record(mGrn);
     rb_grn_init_variable(mGrn);

data/lib/groonga.rb

@@ -34,6 +34,7 @@ if local_groonga_bin_dir.exist?
   prepend_path.call("PATH", File::PATH_SEPARATOR)
 end
 
+require 'groonga/geo-point'
 require 'groonga/view-record'
 require 'groonga/record'
 require 'groonga/expression-builder'
@@ -90,6 +91,7 @@ module Groonga
 end
 
 require 'groonga/context'
+require 'groonga/database'
 require 'groonga/patricia-trie'
 require 'groonga/dumper'
 require 'groonga/schema'

data/lib/groonga/command.rb

@@ -20,7 +20,9 @@ module Groonga
     class Builder
       class << self
         def escape_value(value)
-          escaped_value = value.to_s.gsub(/"/, '\\"')
+          escaped_value = value.to_s.gsub(/[\\"]/) do |matched|
+            "\\#{matched}"
+          end
           "\"#{escaped_value}\""
         end
       end

data/lib/groonga/database.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012  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 Database
+    # @return [Array<Groonga::Table] tables defined in the database
+    def tables
+      find_all do |object|
+        object.is_a?(Groonga::Table)
+      end
+    end
+  end
+end

data/lib/groonga/dumper.rb

@@ -18,6 +18,17 @@
 require 'stringio'
 
 module Groonga
+  module Dumper
+    module_function
+    def default_output
+      StringIO.new(utf8_string)
+    end
+
+    def utf8_string
+      ""
+    end
+  end
+
   # データベースの内容をgrn式形式の文字列として出力するクラス。
   class DatabaseDumper
     def initialize(options={})
@@ -27,7 +38,8 @@ module Groonga
     def dump
       options = @options.dup
       have_output = !@options[:output].nil?
-      options[:output] ||= StringIO.new
+      options[:output] ||= Dumper.default_output
+      options[:error_output] ||= Dumper.default_output
       if options[:database].nil?
         options[:context] ||= Groonga::Context.default
         options[:database] = options[:context].database
@@ -50,7 +62,7 @@ module Groonga
     private
     def dump_plugins(options)
       plugin_paths = {}
-      options[:database].each(:order_by => :id) do |object|
+      options[:database].each(each_options(:order_by => :id)) do |object|
         next unless object.is_a?(Groonga::Procedure)
         next if object.builtin?
         path = object.path
@@ -68,7 +80,7 @@ module Groonga
 
     def dump_tables(options)
       first_table = true
-      options[:database].each(:order_by => :key) do |object|
+      options[:database].each(each_options(:order_by => :key)) do |object|
         next unless object.is_a?(Groonga::Table)
         next if object.size.zero?
         next if target_table?(options[:exclude_tables], object, false)
@@ -99,6 +111,10 @@ module Groonga
         name === table.name
       end
     end
+
+    def each_options(options)
+      {:ignore_missing_object => true}.merge(options)
+    end
   end
 
   # スキーマの内容をRubyスクリプトまたはgrn式形式の文字列と
@@ -118,7 +134,7 @@ module Groonga
 
       output = @options[:output]
       have_output = !output.nil?
-      output ||= StringIO.new
+      output ||= Dumper.default_output
       result = syntax(database, output).dump
       if have_output
         result
@@ -154,23 +170,30 @@ module Groonga
       end
 
       def dump_schema
-        @database.each(:order_by => :key) do |object|
+        dump_tables
+        dump_reference_columns
+        dump_index_columns
+      end
+
+      def dump_tables
+        each_options = {:order_by => :key, :ignore_missing_object => true}
+        @database.each(each_options) do |object|
           create_table(object) if object.is_a?(Groonga::Table)
         end
+      end
 
-        @reference_columns.group_by do |column|
-          column.table
-        end.each do |table, columns|
+      def dump_reference_columns
+        group_columns(@reference_columns).each do |table, columns|
           change_table(table) do
             columns.each do |column|
               define_reference_column(table, column)
             end
           end
         end
+      end
 
-        @index_columns.group_by do |column|
-          column.table
-        end.each do |table, columns|
+      def dump_index_columns
+        group_columns(@index_columns).each do |table, columns|
           change_table(table) do
             columns.each do |column|
               define_index_column(table, column)
@@ -192,6 +215,26 @@ module Groonga
         write("")
       end
 
+      def group_columns(columns)
+        grouped_columns = columns.group_by do |column|
+          column.table
+        end
+        sort_grouped_columns(grouped_columns)
+      end
+
+      def sort_grouped_columns(grouped_columns)
+        grouped_columns = grouped_columns.collect do |table, columns|
+          sorted_columns = columns.sort_by do |column|
+            column.local_name
+          end
+          [table, sorted_columns]
+        end
+        grouped_columns.sort_by do |table, columns|
+          _ = columns
+          table.name
+        end
+      end
+
       def table_separator
         write("\n")
       end
@@ -445,7 +488,8 @@ module Groonga
       @options = options
       @output = @options[:output]
       @have_output = !@output.nil?
-      @output ||= StringIO.new
+      @output ||= Dumper.default_output
+      @error_output = @options[:error_output]
     end
 
     def dump
@@ -462,6 +506,11 @@ module Groonga
       @output.write(content)
     end
 
+    def error_write(content)
+      return if @error_output.nil?
+      @error_output.write(content)
+    end
+
     def dump_load_command
       write("load --table #{@table.name}\n")
       write("[\n")
@@ -482,17 +531,17 @@ module Groonga
       @table.each(:order_by => @options[:order_by]) do |record|
         write(",\n")
         values = columns.collect do |column|
-          resolve_value(column[record.id])
+          resolve_value(record, column, column[record.id])
         end
         write(values.to_json)
       end
     end
 
-    def resolve_value(value)
+    def resolve_value(record, column, value)
       case value
       when ::Array
         value.collect do |v|
-          resolve_value(v)
+          resolve_value(record, column, v)
         end
       when Groonga::Record
         if value.support_key?
@@ -500,7 +549,7 @@ module Groonga
         else
           value = value.id
         end
-        resolve_value(value)
+        resolve_value(record, column, value)
       when Time
         # TODO: groonga should support UTC format literal
         # value.utc.strftime("%Y-%m-%d %H:%M:%S.%6N")
@@ -510,8 +559,38 @@ module Groonga
         # doesn't accept null.
         ""
       else
-        value
+        return value unless value.respond_to?(:valid_encoding?)
+        sanitized_value = ""
+        value = fix_encoding(value)
+        value.each_char do |char|
+          if char.valid_encoding?
+            sanitized_value << char
+          else
+            table_name = record.table.name
+            record_id = record.record_id
+            column_name = column.local_name
+            error_write("warning: ignore invalid encoding character: " +
+                          "<#{table_name}[#{record_id}].#{column_name}>: " +
+                          "<#{inspect_invalid_char(char)}>: " +
+                          "before: <#{sanitized_value}>\n")
+          end
+        end
+        sanitized_value
+      end
+    end
+
+    def fix_encoding(value)
+      if value.encoding == ::Encoding::ASCII_8BIT
+        value.force_encoding(@table.context.ruby_encoding)
+      end
+      value
+    end
+
+    def inspect_invalid_char(char)
+      bytes_in_hex = char.bytes.collect do |byte|
+        "%#0x" % byte
       end
+      bytes_in_hex.join(" ")
     end
 
     def available_columns

data/lib/groonga/geo-point.rb

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012  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 GeoPointValueConverter
+    module_function
+
+    MSEC_PER_SEC = 1000 * 1000
+    N_SIGNIFICANT_DIGITS = (Math.log10(MSEC_PER_SEC) + 1).truncate
+    def msec_to_degree(msec)
+      degree_integer_part, degree_fraction_part = msec.divmod(3600 * 1000)
+      degree = degree_integer_part + (degree_fraction_part.to_f / (3600 * 1000))
+      round(degree, N_SIGNIFICANT_DIGITS)
+    end
+
+    def degree_to_msec(degree)
+      round(degree * 3600 * 1000)
+    end
+
+    def msec?(value)
+      value.is_a?(Integer)
+    end
+
+    def degree?(value)
+      value.is_a?(Float)
+    end
+
+    def to_degree(value)
+      return value if degree?(value)
+      msec_to_degree(value)
+    end
+
+    def to_msec(value)
+      return value if msec?(value)
+      degree_to_msec(value)
+    end
+
+    def parse(value)
+      if /\A[-+]?\d+\z/ =~ value
+        value.to_i
+      else
+        value.to_f
+      end
+    end
+
+    if Numeric.instance_method(:round).arity.zero?
+      def round(number, n_digits=0)
+        if n_digits.zero?
+          number.round
+        else
+          base = 10 ** n_digits
+          (number * base).round / base.to_f
+        end
+      end
+    else
+      def round(number, n_digits=0)
+        number.round(n_digits)
+      end
+    end
+  end
+
+  class GeoPoint
+    class << self
+      def parse(string)
+        # TODO: validation
+        latitude, longitude = string.split(/[x,]/, 2)
+        new(GeoPointValueConverter.parse(latitude),
+            GeoPointValueConverter.parse(longitude))
+      end
+    end
+
+    attr_accessor :latitude, :longitude
+    # TODO: write document
+    # @overload initialize(geo_point_in_string)
+    # @overload initialize(latitude, longitude)
+    def initialize(*arguments)
+      if arguments.size == 1
+        if arguments.first.is_a?(String)
+          geo_point = self.class.parse(arguments.first)
+        else
+          geo_point = arguments.first
+          geo_point = coerce(geo_point)
+        end
+        @latitude = geo_point.latitude
+        @longitude = geo_point.longitude
+      else
+        # TODO: check # of arguments
+        @latitude, @longitude, = arguments
+      end
+    end
+
+    def degree?
+      GeoPointValueConverter.degree?(latitude) and
+        GeoPointValueConverter.degree?(longitude)
+    end
+
+    def msec?
+      GeoPointValueConverter.msec?(latitude) and
+        GeoPointValueConverter.msec?(longitude)
+    end
+
+    def to_degree
+      return self if degree?
+      self.class.new(GeoPointValueConverter.to_degree(latitude),
+                     GeoPointValueConverter.to_degree(longitude))
+    end
+
+    def to_msec
+      return self if msec?
+      self.class.new(GeoPointValueConverter.to_msec(latitude),
+                     GeoPointValueConverter.to_msec(longitude))
+    end
+
+    def to_s
+      "#{latitude}x#{longitude}"
+    end
+
+    def inspect
+      "#<#{self.class} #{to_s}>"
+    end
+
+    def ==(other)
+      case other
+      when String
+        to_s == otehr
+      when GeoPoint
+        normalized_self = to_msec
+        normalized_other = coerce(other).to_msec
+        [normalized_self.latitude, normalized_self.longitude] ==
+          [normalized_other.latitude, normalized_other.longitude]
+      else
+        false
+      end
+    end
+  end
+
+  class TokyoGeoPoint < GeoPoint
+    def to_tokyo
+      self
+    end
+
+    # TODO: write document
+    #
+    # TokyoGeoPoint <-> WGS84GeoPoint is based on
+    # http://www.jalan.net/jw/jwp0200/jww0203.do
+    #
+    #   jx: longitude in degree in Tokyo Geodetic System.
+    #   jy: latitude in degree in Tokyo Geodetic System.
+    #   wx: longitude in degree in WGS 84.
+    #   wy: latitude in degree in WGS 84.
+    #
+    #   jy = wy * 1.000106961 - wx * 0.000017467 - 0.004602017
+    #   jx = wx * 1.000083049 + wy * 0.000046047 - 0.010041046
+    #
+    #   wy = jy - jy * 0.00010695 + jx * 0.000017464 + 0.0046017
+    #   wx = jx - jy * 0.000046038 - jx * 0.000083043 + 0.010040
+    def to_wgs84
+      in_degree = to_degree
+      wgs84_latitude_in_degree =
+        in_degree.latitude -
+        in_degree.latitude * 0.00010695 +
+        in_degree.longitude * 0.000017464 +
+        0.0046017
+      wgs84_longitude_in_degree =
+        in_degree.longitude -
+        in_degree.latitude * 0.000046038 -
+        in_degree.longitude * 0.000083043 +
+        0.010040
+      WGS84GeoPoint.new(wgs84_latitude_in_degree, wgs84_longitude_in_degree)
+    end
+
+    private
+    def coerce(other_geo_point)
+      other_geo_point.to_tokyo
+    end
+  end
+
+  class WGS84GeoPoint < GeoPoint
+    # @see TokyoGeoPoint#to_wgs84
+    def to_tokyo
+      in_degree = to_degree
+      tokyo_latitude_in_degree =
+        in_degree.latitude * 1.000106961 -
+        in_degree.longitude * 0.000017467 -
+        0.004602017
+      tokyo_longitude_in_degree =
+        in_degree.longitude * 1.000083049 +
+        in_degree.latitude  * 0.000046047 -
+        0.010041046
+      TokyoGeoPoint.new(tokyo_latitude_in_degree, tokyo_longitude_in_degree)
+    end
+
+    def to_wgs84
+      self
+    end
+
+    private
+    def coerce(other_geo_point)
+      other_geo_point.to_wgs84
+    end
+  end
+end