groonga-client 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3dd4add841527a3ebe6c5e9a0e9cc83bb618a973
-  data.tar.gz: 3946ccfce7f6e1aa7e3105760fa0a305885ca629
+  metadata.gz: 6f33db5326ba66ef34f99764539597e287337df5
+  data.tar.gz: ba050f7b65edc1889f843cef883e1784b29c1b8a
 SHA512:
-  metadata.gz: 7a131ca1ab2cb04af14a5bb43e83dbac2f793e040c777354125bad17399453cdf26ef17390e931ce60b241b3cb3806131589cdd2fe836ec683ebb696ccf1ebe9
-  data.tar.gz: '080dec40f5d1b28a4b55c3d6e30e7c48261a6f0db3bffccdd7c55b755f2e59ac77bdb8dd909d4f1a53f901cf4d0f36c5eb1d0278c3d2872902a1cda7c7daa182'
+  metadata.gz: a7869a7e5ac081ed34339ae21665ff97802ed473eb765cb7ef388420319ee5396ab95bde8162a37e0fc434a989aa0a3daa9808d9072b239f34d7704875230afb
+  data.tar.gz: 44ffaaa3ec83082d908db61985675827684cb8e850317a9363ddebecf1fe84cc1cd52eb96ed7dd27f299fbe90ddd7aefcf0c2efe763a1a67de8c3c7a7f4bce92

data/doc/text/news.md

@@ -1,5 +1,37 @@
 # NEWS
 
+## 0.5.0 - 2017-05-08
+
+### Improvements
+
+  * `Groonga::Client::Request::Select::Filter#between`: Added a
+    convenience method to add a popular filter condition. You can
+    use this method by
+    `filter.between(:age, 19, "include", 32, "include")`.
+
+  * `Groonga::Client::Request::Select::Filter#geo_in_circle`:
+    Added a convenience method to add a popular filter condition.
+    You can use this method by
+    `filter.geo_in_circle(:location, "100x100", 300, "rectangle")`.
+
+  * `Groonga::Client::Request::Select::Filter#geo_in_rectangle`:
+    Added a convenience method to add a popular filter condition.
+    You can use this method by
+    `filter.geo_in_rectangle(:location, "0x100", "100x0")`.
+
+  * `Groonga::Client::Request::Select#filter`: Changed how to handle
+    `Symbol` to identifier in Groonga script syntax expression from
+    string literal in Groonga script syntax expression. It's a
+    backward incompatible change. Some methods keep compatibility as
+    much as possible but some methods may break compatibility
+    unexpectedly. If you find any incompatibility what you think
+    unexpected, please report to us.
+
+### Fixes
+
+  * `groonga-client`: Fixed a bug that `load --values` input causes an
+    error.
+
 ## 0.4.3 - 2017-04-21
 
 ### Improvements
@@ -185,8 +217,8 @@
 
   * Supported command version 3.
 
-  * Added {Groonga::Client::Response#return_code}.
-    {Groonga::Client::Response#status_code} is deprecated. Use
+  * Added `Groonga::Client::Response#return_code`.
+    `Groonga::Client::Response#status_code` is deprecated. Use
     `#return_code` instead.
 
   * `select` response: Supported vector of `Time`.
@@ -251,10 +283,11 @@
     [GitHub#7][Patch by Masafumi Yokoyama]
 
   * HTTP: Supported HTTPS by passing `:use_tls => true` option to
-    {Groonga::Client.new}.
+    {Groonga::Client#initialize}.
     [GitHub#8][Patch by KITAITI Makoto]
 
-  * Supported URI as server information in {Groonga::Client.new}.
+  * Supported URI as server information in
+    {Groonga::Client#initialize}.
 
   * Required groonga-command 1.2.0 or later.
 
@@ -413,7 +446,7 @@
   * select: Supported auto time value conversion.
   * select: Renamed to {Groonga::Client::Response::Select#n_hits}
     from #n_records. It is a backward incompatible change.
-  * Added {Groonga::Client::Connection::Error} as an abstracted error.
+  * Added `Groonga::Client::Connection::Error` as an abstracted error.
   * Required groonga-command 1.0.4 or later.
 
 ## 0.0.2 - 2013-07-08

data/lib/groonga/client/cli.rb

@@ -190,7 +190,7 @@ module Groonga
 
           parser.on_load_complete do |command|
             if command[:values]
-              run_command(client, command)
+              run_command(command)
             else
               consume_load_values(command)
             end

data/lib/groonga/client/request/select.rb

@@ -50,9 +50,9 @@ module Groonga
         # Adds a script syntax condition. If the request already has
         # any filter condition, they are combined by AND.
         #
-        # @example: Multiple filters
+        # @example Multiple filters
         #    request.
-        #      filter("user", "alice").
+        #      filter(:user, "alice").
         #        # -> --filter 'user == "alice"'
         #      filter("tags @ %{tag}", tag: "Ruby")
         #        # -> --filter '(user == "alice") && (tags @ "Ruby")'
@@ -63,7 +63,7 @@ module Groonga
         # @overload filter(column_name, value)
         #   Adds a `#{column_name} == #{value}` condition.
         #
-        #   @param column_name [String, Symbol] The target column name.
+        #   @param column_name [Symbol] The target column name.
         #
         #   @param value [Object] The column value. It's escaped
         #     automatically.
@@ -88,31 +88,59 @@ module Groonga
         #   Returns a request object for filter condition. It provides
         #   convenient methods to add a popular filter condition.
         #
-        #   @example: Use in_values function
+        #   @example Use in_values function
         #      request.
-        #        filter.in_values("tags", "tag1", "tag2")
+        #        filter.in_values(:tags, "tag1", "tag2")
         #          # -> --filter 'in_values(tags, "tag1", "tag2")'
         #
+        #   @example: Use geo_in_rectangle function
+        #      request.
+        #        filter.geo_in_rectangle(:location, "0x100", "100x0")
+        #          # -> --filter 'geo_in_rectangle(location, "0x100", "100x0")'
+        #
+        #   @example Use geo_in_circle function
+        #      request.
+        #        filter.geo_in_circle(:location, "100x100", 300)
+        #          # -> --filter 'geo_in_circle(location, "100x100", 300, "rectangle")'
+        #
+        #   @example Use between function
+        #      request.
+        #        filter.between(:age, 19, "include", 32, "include")
+        #          # -> --filter 'between(age, 19, "include", 32, "include")'
+        #
         #   @return [Groonga::Client::Request::Select::Filter]
         #     The new request object for setting a filter condition.
         #
         #   @since 0.4.3
-        def filter(expression_or_column_name=nil, values_or_value=nil)
-          if expression_or_column_name.nil? and values_or_value.nil?
-            return Filter.new(self)
-          end
-
-          if expression_or_column_name.is_a?(Symbol)
-            parameter = FilterEqualParameter.new(expression_or_column_name,
-                                                 values_or_value)
-          elsif values_or_value.nil? or values_or_value.is_a?(::Hash)
-            parameter = FilterExpressionParameter.new(expression_or_column_name,
-                                                      values_or_value)
+        def filter(*args)
+          n_args = args.size
+          case n_args
+          when 0
+            Filter.new(self)
+          when 1, 2
+            expression_or_column_name, values_or_value = *args
+
+            if values_or_value.nil? or values_or_value.is_a?(::Hash)
+              expression = expression_or_column_name
+              values = values_or_value
+            else
+              expression = "%{column} == %{value}"
+              column_name = expression_or_column_name
+              column_name = Filter.column_namify(column_name,
+                                                 "first",
+                                                 "#{self.class}\##{__method__}")
+              values = {
+                column: column_name,
+                value: values_or_value,
+              }
+            end
+            parameter = FilterExpressionParameter.new(expression, values)
+            add_parameter(FilterMerger, parameter)
           else
-            parameter = FilterEqualParameter.new(expression_or_column_name,
-                                                 values_or_value)
+            message =
+              "wrong number of arguments (given #{n_args}, expected 0..2)"
+            raise ArgumentError, message
           end
-          add_parameter(FilterMerger, parameter)
         end
 
         def output_columns(value)
@@ -176,42 +204,275 @@ module Groonga
           parameters.key?(:offset) and parameters.key?(:limit)
         end
 
-        # @since 0.4.3
         class Filter
+          class << self
+            # @private
+            def column_namify(column_name, ith, signature)
+              return column_name unless column_name.is_a?(String)
+
+              message = "column name (the #{ith} argument) of #{signature} "
+              message << "should be Symbol: #{column_name.inspect}: "
+              message << caller(2, 1)[0]
+              warn(message)
+              column_name.to_sym
+            end
+          end
+
           def initialize(request)
             @request = request
           end
 
-          # Adds a `in_values` condition then return a new `select`
+          # Adds a `geo_in_rectangle` condition then return a new `select`
+          # request object.
+          #
+          # @see http://groonga.org/docs/reference/functions/geo_in_rectangle.html
+          #   geo_in_rectangle function in the Groonga document
+          #
+          # @overload geo_in_rectangle(column_name, top_left, bottom_right)
+          #
+          #   @example: Basic usage
+          #      request.
+          #        filter.geo_in_rectangle(:location, "0x100", "100x0").
+          #          # -> --filter 'geo_in_rectangle(location, "0x100", "100x0")'
+          #
+          #   @param column_name [Symbol] The column name to be checked.
+          #
+          #   @!macro [new] geo_in_rectangle
+          #
+          #     @param top_left [String] The top left of the condition rectangle.
+          #        `"#{LONGITUDE}x#{LATITUDE}"` is the point format.
+          #
+          #     @param bottom_right [String] The bottom right of the condition rectangle.
+          #        `"#{LONGITUDE}x#{LATITUDE}"` is the point format.
+          #
+          #     @return [Groonga::Client::Request::Select]
+          #        The new request with the given condition.
+          #
+          #   @macro geo_in_rectangle
+          #
+          # @overload geo_in_rectangle(point, top_left, bottom_right)
+          #
+          #   @example Basic usage
+          #      request.
+          #        filter.geo_in_rectangle("50x50", "0x100", "100x0").
+          #          # -> --filter 'geo_in_rectangle("50x50", "0x100", "100x0")'
+          #
+          #   @param point [String] The point to be checked.
+          #      `"#{LONGITUDE}x#{LATITUDE}"` is the point format.
+          #
+          #   @macro geo_in_rectangle
+          #
+          # @since 0.5.0
+          def geo_in_rectangle(column_name_or_point,
+                               top_left, bottom_right)
+            expression = "geo_in_rectangle(%{column_name_or_point}"
+            expression << ", %{top_left}"
+            expression << ", %{bottom_right}"
+            expression << ")"
+            @request.filter(expression,
+                            column_name_or_point: column_name_or_point,
+                            top_left: top_left,
+                            bottom_right: bottom_right)
+          end
+
+          # Adds a `geo_in_circle` condition then returns a new `select`
+          # request object.
+          #
+          # @see http://groonga.org/docs/reference/functions/geo_in_circle.html
+          #   geo_in_circle function in the Groonga document
+          #
+          # @overload geo_in_circle(column_name, center, radius, approximate_type="rectangle")
+          #
+          #   @example Basic usage
+          #      request.
+          #        filter.geo_in_circle(:location, "100x100", 300).
+          #          # -> --filter 'geo_in_circle(location, "100x100", 300, "rectangle")'
+          #
+          #   @param column_name [Symbol] The column name to be checked.
+          #
+          #   @!macro [new] geo_in_circle_common
+          #
+          #     @param center [String] The center point of the condition circle.
+          #        `"#{LONGITUDE}x#{LATITUDE}"` is the point format.
+          #
+          #     @param radius [Integer] The radius of the condition circle.
+          #
+          #     @param approximate_type
+          #        ["rectangle", "sphere", "ellipsoid"]
+          #        ("rectangle")
+          #
+          #        How to approximate geography to compute radius.
+          #
+          #        The default is `"rectangle"`.
+          #
+          #     @return [Groonga::Client::Request::Select]
+          #       The new request with the given condition.
+          #
+          #   @macro geo_in_circle_common
+          #
+          # @overload geo_in_circle(point, center, radius, approximate_type="rectangle")
+          #
+          #   @example Basic usage
+          #      request.
+          #        filter.geo_in_circle("0x0", "100x100", 300).
+          #          # -> --filter 'geo_in_circle("0x0", "100x100", 300, "rectangle")'
+          #
+          #   @param point [String] The point to be checked.
+          #      `"#{LONGITUDE}x#{LATITUDE}"` is the point format.
+          #
+          #   @macro geo_in_circle_common
+          #
+          #
+          # @since 0.5.0
+          def geo_in_circle(column_name_or_point,
+                            center,
+                            radius_or_point,
+                            approximate_type="rectangle")
+            expression = "geo_in_circle(%{column_name_or_point}"
+            expression << ", %{center}"
+            expression << ", %{radius_or_point}"
+            expression << ", %{approximate_type}"
+            expression << ")"
+            @request.filter(expression,
+                            column_name_or_point: column_name_or_point,
+                            center: center,
+                            radius_or_point: radius_or_point,
+                            approximate_type: approximate_type)
+          end
+
+          # Adds a `between` condition then returns a new `select`
+          # request object.
+          #
+          # @see http://groonga.org/docs/reference/functions/between.html
+          #   between function in the Groonga document
+          #
+          # @return [Groonga::Client::Request::Select]
+          #   The new request with the given condition.
+          #
+          # @overload between(column_name, min, max, min_border: "include", max_border: "include")
+          #
+          #   @example Basic usage
+          #      request.
+          #        filter.between(:age, 19, 32)
+          #          # -> --filter 'between(age, 19, "include", 32, "exclude")'
+          #
+          #   @!macro [new] between_common
+          #
+          #     @param column_name [Symbol] The target column name.
+          #
+          #     @param min [Integer] The minimal value of the
+          #        condition range.
+          #
+          #     @param max [Integer] The maximum value of the
+          #        condition range.
+          #
+          #     @param min_border ["include", "exclude"] Whether `min` is
+          #        included or not. If `"include"` is specified, `min` is
+          #        included. If `"exclude"` is specified, `min` isn't
+          #        included.
+          #
+          #     @param max_border ["include", "exclude"] Whether `max` is
+          #        included or not. If `"include"` is specified, `max` is
+          #        included. If `"exclude"` is specified, `max` isn't
+          #        included.
+          #
+          #   @macro between_common
+          #
+          #   @since 0.5.0
+          #
+          # @overload between(column_name, min, min_border, max, max_border)
+          #
+          #   @example Basic usage
+          #      request.
+          #        filter.between(:age, 19, "include", 32, "exclude")
+          #          # -> --filter 'between(age, 19, "include", 32, "exclude")'
+          #
+          #   @macro between_common
+          #
+          #   @since 0.4.4
+          def between(*args)
+            n_args = args.size
+            case n_args
+            when 3
+              column_name, min, max = args
+              min_border = "include"
+              max_border = "include"
+            when 4
+              column_name, min, max, options = args
+              min_border = options[:min_border] || "include"
+              max_border = options[:max_border] || "include"
+            when 5
+              column_name, min, min_border, max, max_border = args
+            else
+              message =
+                "wrong number of arguments (given #{n_args}, expected 3..5)"
+              raise ArgumentError, message
+            end
+
+            # TODO: Accept not only column name but also literal as
+            # the first argument.
+            column_name =
+              self.class.column_namify(column_name,
+                                       "first",
+                                       "#{self.class}\##{__method__}")
+            expression = "between(%{column_name}"
+            expression << ", %{min}"
+            expression << ", %{min_border}"
+            expression << ", %{max}"
+            expression << ", %{max_border}"
+            expression << ")"
+            @request.filter(expression,
+                            column_name: column_name,
+                            min: min,
+                            min_border: min_border,
+                            max: max,
+                            max_border: max_border)
+          end
+
+          # Adds a `in_values` condition then returns a new `select`
           # request object.
           #
-          # @example: Multiple conditions
+          # @example Multiple conditions
           #    request.
-          #      filter.in_values("tags", "tag1", "tag2").
+          #      filter.in_values(:tags, "tag1", "tag2").
           #        # -> --filter 'in_values(tags, "tag1", "tag2")'
           #      filter("user", "alice")
           #        # -> --filter '(in_values(tags, "tag1", "tag2")) && (user == "alice")'
           #
-          # @example: Ignore no values case
+          # @example Ignore no values case
           #    request.
-          #      filter.in_values("tags")
+          #      filter.in_values(:tags)
           #        # -> --filter ''
           #
-          # @param column_name [String, Symbol] The target column name.
+          # @see http://groonga.org/docs/reference/functions/in_values.html
+          #   `in_values` function in the Groonga document
+          #
+          # @param column_name [Symbol] The target column name.
           #
           # @param values [Object] The column values that cover target
           #   column values.
           #
           # @return [Groonga::Client::Request::Select]
           #   The new request with the given condition.
+          #
+          # @since 0.4.3
           def in_values(column_name, *values)
-            parameter = FilterInValuesParameter.new(column_name, *values)
-            add_parameter(FilterMerger, parameter)
-          end
-
-          private
-          def add_parameter(merger, parameter)
-            @request.__send__(:add_parameter, merger, parameter)
+            return @request if values.empty?
+
+            # TODO: Accept not only column name but also literal as
+            # the first argument.
+            column_name =
+              self.class.column_namify(column_name,
+                                       "first",
+                                       "#{self.class}\##{__method__}")
+            expression_values = {column_name: column_name}
+            expression = "in_values(%{column_name}"
+            values.each_with_index do |value, i|
+              expression << ", %{value#{i}}"
+              expression_values[:"value#{i}"] = value
+            end
+            expression << ")"
+            @request.filter(expression, expression_values)
           end
         end
 
@@ -385,7 +646,11 @@ module Groonga
             when String
               ScriptSyntax.format_string(value)
             when Symbol
-              ScriptSyntax.format_string(value.to_s)
+              if valid_script_syntax_identifier?(value)
+                value.to_s
+              else
+                ScriptSyntax.format_string(value.to_s)
+              end
             when ::Array
               escaped_value = "["
               value.each_with_index do |element, i|
@@ -408,6 +673,13 @@ module Groonga
               value
             end
           end
+
+          identifier_part = "[a-zA-Z_][a-zA-Z0-9_]*"
+          VALID_SCRIPT_SYNTAX_IDENTIFIER_PATTERN =
+            /\A#{identifier_part}(?:\.#{identifier_part})*\z/
+          def valid_script_syntax_identifier?(value)
+            VALID_SCRIPT_SYNTAX_IDENTIFIER_PATTERN === value.to_s
+          end
         end
 
         # @private
@@ -457,42 +729,6 @@ module Groonga
           end
         end
 
-        # @private
-        class FilterInValuesParameter
-          include ScriptSyntaxValueEscapable
-
-          def initialize(column_name, *values)
-            @column_name = column_name
-            @values = values
-          end
-
-          def to_parameters
-            return {} if @values.empty?
-
-            escaped_values = @values.collect do |value|
-              escape_script_syntax_value(value)
-            end
-            {
-              filter: "in_values(#{@column_name}, #{escaped_values.join(", ")})",
-            }
-          end
-        end
-
-        class FilterEqualParameter
-          include ScriptSyntaxValueEscapable
-
-          def initialize(column_name, value)
-            @column_name = column_name
-            @value = value
-          end
-
-          def to_parameters
-            {
-              filter: "#{@column_name} == #{escape_script_syntax_value(@value)}",
-            }
-          end
-        end
-
         # @private
         class OutputColumnsParameter < ValuesParameter
           def initialize(prefix, output_columns)

data/lib/groonga/client/version.rb

@@ -16,6 +16,6 @@
 
 module Groonga
   class Client
-    VERSION = "0.4.3"
+    VERSION = "0.5.0"
   end
 end

data/test/request/select/test-filter.rb

@@ -0,0 +1,318 @@
+# Copyright (C) 2016-2017  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 as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+class TestRequestSelectFilter < Test::Unit::TestCase
+  setup do
+    @request = Groonga::Client::Request::Select.new("posts")
+  end
+
+  def filter(*args)
+    @request.filter(*args).to_parameters
+  end
+
+  sub_test_case("expression") do
+    def test_nil
+      assert_equal({
+                     :table => "posts",
+                   },
+                   filter(nil))
+    end
+
+    def test_string
+      assert_equal({
+                     :table => "posts",
+                     :filter => "age <= 20",
+                   },
+                   filter("age <= 20"))
+    end
+
+    def test_empty_string
+      assert_equal({
+                     :table => "posts",
+                   },
+                   filter(""))
+    end
+  end
+
+  sub_test_case("values") do
+    test("String") do
+      filter = <<-'FILTER'.strip
+title == "[\"He\\ llo\"]"
+      FILTER
+      assert_equal({
+                     :table => "posts",
+                     :filter => filter,
+                   },
+                   filter("title == %{value}",
+                          :value => "[\"He\\ llo\"]"))
+    end
+
+    sub_test_case("Symbol") do
+      test("valid ID") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "title == \"Hello\"",
+                     },
+                     filter("%{column} == %{value}",
+                            :column => :title,
+                            :value => "Hello"))
+      end
+
+      test("invalid ID") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "title == \"Hello World\"",
+                     },
+                     filter("title == %{value}",
+                            :value => :"Hello World"))
+      end
+    end
+
+    test("Numeric") do
+      assert_equal({
+                     :table => "posts",
+                     :filter => "age <= 29",
+                   },
+                   filter("age <= %{value}",
+                          :value => 29))
+    end
+
+    test("true") do
+      assert_equal({
+                     :table => "posts",
+                     :filter => "published == true",
+                   },
+                   filter("published == %{value}",
+                          :value => true))
+    end
+
+    test("false") do
+      assert_equal({
+                     :table => "posts",
+                     :filter => "published == false",
+                   },
+                   filter("published == %{value}",
+                          :value => false))
+    end
+
+    test("nil") do
+      assert_equal({
+                     :table => "posts",
+                     :filter => "function(null)",
+                   },
+                   filter("function(%{value})",
+                          :value => nil))
+    end
+
+    test("Array") do
+      assert_equal({
+                     :table => "posts",
+                     :filter => "function([\"a\", 29])",
+                   },
+                   filter("function(%{arg})", :arg => ["a", 29]))
+    end
+
+    test("Hash") do
+      assert_equal({
+                     :table => "posts",
+                     :filter => "function({\"string\": \"value\", \"number\": 29})",
+                   },
+                   filter("function(%{options})",
+                          :options => {
+                            "string" => "value",
+                            "number" => 29
+                          }))
+    end
+  end
+
+  test("column name") do
+    assert_equal({
+                   :table => "posts",
+                   :filter => "_key == 29",
+                 },
+                 filter(:_key, 29))
+  end
+
+  sub_test_case("value") do
+    test("String") do
+      filter = <<-'FILTER'.strip
+title == "[\"He\\ llo\"]"
+      FILTER
+      assert_equal({
+                     :table => "posts",
+                     :filter => filter,
+                   },
+                   filter(:title, "[\"He\\ llo\"]"))
+    end
+
+    sub_test_case("Symbol") do
+      test("valid ID") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "title == normalized_title",
+                     },
+                     filter(:title, :normalized_title))
+      end
+
+      test("invalid ID") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "title == \"Hello World\"",
+                     },
+                     filter(:title, :"Hello World"))
+      end
+    end
+
+    test("Numeric") do
+      assert_equal({
+                     :table => "posts",
+                     :filter => "age == 29",
+                   },
+                   filter(:age, 29))
+    end
+
+    test("true") do
+      assert_equal({
+                     :table => "posts",
+                     :filter => "published == true",
+                   },
+                   filter(:published, true))
+    end
+
+    test("false") do
+      assert_equal({
+                     :table => "posts",
+                     :filter => "published == false",
+                   },
+                   filter(:published, false))
+    end
+  end
+
+  sub_test_case("Filter") do
+    sub_test_case("#geo_in_rectangle") do
+      def geo_in_rectangle(*args)
+        @request.filter.geo_in_rectangle(*args).to_parameters
+      end
+
+      test("column") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "geo_in_rectangle(location, \"0x100\", \"100x0\")",
+                     },
+                     geo_in_rectangle(:location, "0x100", "100x0"))
+      end
+
+      test("point") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "geo_in_rectangle(\"50x50\", \"0x100\", \"100x0\")",
+                     },
+                     geo_in_rectangle("50x50", "0x100", "100x0"))
+      end
+    end
+
+    sub_test_case("#geo_in_circle") do
+      def geo_in_circle(*args)
+        @request.filter.geo_in_circle(*args).to_parameters
+      end
+
+      test("column") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "geo_in_circle(location, \"140x250\", 300, \"rectangle\")",
+                     },
+                     geo_in_circle(:location, "140x250", 300))
+      end
+
+      test("point") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "geo_in_circle(\"100x100\", \"140x250\", 300, \"rectangle\")",
+                     },
+                     geo_in_circle("100x100", "140x250", 300))
+      end
+
+      test("approximate type") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "geo_in_circle(\"100x100\", \"140x250\", 300, \"sphere\")",
+                     },
+                     geo_in_circle("100x100", "140x250", 300, "sphere"))
+      end
+    end
+
+    sub_test_case("#between") do
+      def between(*args)
+        @request.filter.between(*args).to_parameters
+      end
+
+      test("min and max") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "between(ages, 2, \"include\", 29, \"include\")",
+                     },
+                     between(:ages, 2, 29))
+      end
+
+      test("min, max and options") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "between(ages, 2, \"exclude\", 29, \"exclude\")",
+                     },
+                     between(:ages, 2, 29,
+                             min_border: "exclude",
+                             max_border: "exclude"))
+      end
+
+      test("all") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "between(ages, 2, \"include\", 29, \"exclude\")",
+                     },
+                     between(:ages, 2, "include", 29, "exclude"))
+      end
+    end
+
+    sub_test_case("#in_values") do
+      def in_values(column_name, *values)
+        @request.filter.in_values(column_name, *values).to_parameters
+      end
+
+      test("numbers") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "in_values(ages, 2, 29)",
+                     },
+                     in_values(:ages, 2, 29))
+      end
+
+      test("strings") do
+        assert_equal({
+                       :table => "posts",
+                       :filter => "in_values(tags, \"groonga\", \"have \\\"double\\\" quote\")",
+                     },
+                     in_values(:tags, "groonga", "have \"double\" quote"))
+      end
+
+      test("no values") do
+        assert_equal({
+                       :table => "posts",
+                     },
+                     in_values(:tags))
+      end
+    end
+  end
+end

data/test/request/test-select.rb

@@ -19,109 +19,6 @@ class TestRequestSelect < Test::Unit::TestCase
     @request = Groonga::Client::Request::Select.new("posts")
   end
 
-  sub_test_case("#filter") do
-    def filter(*args)
-      @request.filter(*args).to_parameters
-    end
-
-    test("Numeric") do
-      assert_equal({
-                     :table => "posts",
-                     :filter => "rate == 5",
-                   },
-                   filter("rate == %{rate}", :rate => 5))
-    end
-
-    test("true") do
-      assert_equal({
-                     :table => "posts",
-                     :filter => "published == true",
-                   },
-                   filter("published == %{published}", :published => true))
-    end
-
-    test("false") do
-      assert_equal({
-                     :table => "posts",
-                     :filter => "published == false",
-                   },
-                   filter("published == %{published}", :published => false))
-    end
-
-    test("nil") do
-      assert_equal({
-                     :table => "posts",
-                     :filter => "function(null)",
-                   },
-                   filter("function(%{arg})", :arg => nil))
-    end
-
-    test("String") do
-      assert_equal({
-                     :table => "posts",
-                     :filter => "title == \"Hello\"",
-                   },
-                   filter("title == %{title}", :title => "Hello"))
-    end
-
-    test("Symbol") do
-      assert_equal({
-                     :table => "posts",
-                     :filter => "title == \"Hello\"",
-                   },
-                   filter("title == %{title}", :title => :Hello))
-    end
-
-    test("Array") do
-      assert_equal({
-                     :table => "posts",
-                     :filter => "function([\"a\", 29])",
-                   },
-                   filter("function(%{arg})", :arg => ["a", 29]))
-    end
-
-    test("Hash") do
-      assert_equal({
-                     :table => "posts",
-                     :filter => "function({\"string\": \"value\", \"number\": 29})",
-                   },
-                   filter("function(%{options})",
-                          :options => {
-                            "string" => "value",
-                            "number" => 29
-                          }))
-    end
-
-    sub_test_case("#in_values") do
-      def in_values(column_name, *values)
-        @request.filter.in_values(column_name, *values).to_parameters
-      end
-
-      test("numbers") do
-        assert_equal({
-                       :table => "posts",
-                       :filter => "in_values(ages, 2, 29)",
-                     },
-                     in_values("ages", 2, 29))
-      end
-
-      test("strings") do
-        assert_equal({
-                       :table => "posts",
-                       :filter => "in_values(tags, \"groonga\", \"have \\\"double\\\" quote\")",
-                     },
-                     in_values("tags", "groonga", "have \"double\" quote"))
-      end
-
-      test("no values") do
-        assert_equal({
-                       :table => "posts",
-                     },
-                     in_values("tags"))
-      end
-    end
-  end
-
   sub_test_case("#drilldowns") do
     def drilldown
       @request.drilldowns("label")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: groonga-client
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Haruka Yoshihara
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-24 00:00:00.000000000 Z
+date: 2017-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gqtp
@@ -224,8 +224,7 @@ files:
 - test/protocol/test-gqtp.rb
 - test/protocol/test-http.rb
 - test/request/select/test-backward-compatible-sort-keys-parameter.rb
-- test/request/select/test-filter-equal-parameter.rb
-- test/request/select/test-filter-expression-parameter.rb
+- test/request/select/test-filter.rb
 - test/request/select/test-output-columns-parameter.rb
 - test/request/select/test-sort-keys-parameter.rb
 - test/request/select/test-values-parameter.rb
@@ -270,38 +269,37 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Groonga-client is a client for Groonga (http://groonga.org/) implemented
   with pure Ruby. You can use it without Groonga.
 test_files:
-- test/results/test-table-list.rb
-- test/results/test-column-list.rb
-- test/request/test-generic.rb
-- test/request/test-merger.rb
-- test/request/test-select.rb
-- test/request/select/test-values-parameter.rb
-- test/request/select/test-backward-compatible-sort-keys-parameter.rb
-- test/request/select/test-output-columns-parameter.rb
-- test/request/select/test-filter-equal-parameter.rb
-- test/request/select/test-sort-keys-parameter.rb
-- test/request/select/test-filter-expression-parameter.rb
-- test/response/test-status.rb
+- test/run-test.rb
 - test/response/test-error.rb
-- test/response/test-load.rb
+- test/response/test-select-command-version3.rb
+- test/response/test-select-command-version1.rb
 - test/response/test-table-create.rb
 - test/response/helper.rb
+- test/response/test-status.rb
+- test/response/test-column-list.rb
+- test/response/test-schema.rb
 - test/response/test-table-list.rb
+- test/response/test-load.rb
 - test/response/test-base.rb
 - test/response/test-table-remove.rb
-- test/response/test-select-command-version3.rb
-- test/response/test-column-list.rb
-- test/response/test-select-command-version1.rb
-- test/response/test-schema.rb
-- test/run-test.rb
 - test/test-script-syntax.rb
-- test/protocol/test-gqtp.rb
 - test/protocol/test-http.rb
+- test/protocol/test-gqtp.rb
+- test/results/test-column-list.rb
+- test/results/test-table-list.rb
 - test/test-command.rb
+- test/request/select/test-values-parameter.rb
+- test/request/select/test-filter.rb
+- test/request/select/test-output-columns-parameter.rb
+- test/request/select/test-sort-keys-parameter.rb
+- test/request/select/test-backward-compatible-sort-keys-parameter.rb
+- test/request/test-merger.rb
+- test/request/test-generic.rb
+- test/request/test-select.rb
 - test/test-client.rb

data/test/request/select/test-filter-equal-parameter.rb

@@ -1,82 +0,0 @@
-# Copyright (C) 2016  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 as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-class TestRequestSelectFilterEqualParmater < Test::Unit::TestCase
-  def filter_parameter(column_name, value)
-    Groonga::Client::Request::Select::FilterEqualParameter.new(column_name,
-                                                               value)
-  end
-
-  def to_parameters(column_name, value)
-    filter_parameter(column_name, value).to_parameters
-  end
-
-  sub_test_case("column name") do
-    def test_string
-      assert_equal({
-                     :filter => "_key == 29",
-                   },
-                   to_parameters("_key", 29))
-    end
-
-    def test_symbol
-      assert_equal({
-                     :filter => "_key == 29",
-                   },
-                   to_parameters(:_key, 29))
-    end
-  end
-
-  sub_test_case("value") do
-    def test_string
-      filter = <<-'FILTER'.strip
-title == "[\"He\\ llo\"]"
-      FILTER
-      assert_equal({
-                     :filter => filter,
-                   },
-                   to_parameters("title", "[\"He\\ llo\"]"))
-    end
-
-    def test_symbol
-      assert_equal({
-                     :filter => "title == \"Hello\"",
-                   },
-                   to_parameters("title", :Hello))
-    end
-
-    def test_number
-      assert_equal({
-                     :filter => "age == 29",
-                   },
-                   to_parameters("age", 29))
-    end
-
-    def test_true
-      assert_equal({
-                     :filter => "published == true",
-                   },
-                   to_parameters("published", true))
-    end
-
-    def test_false
-      assert_equal({
-                     :filter => "published == false",
-                   },
-                   to_parameters("published", false))
-    end
-  end
-end

data/test/request/select/test-filter-expression-parameter.rb

@@ -1,98 +0,0 @@
-# Copyright (C) 2016  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 as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-class TestRequestSelectFilterExpressionParmater < Test::Unit::TestCase
-  def filter_parameter(expression, values=nil)
-    Groonga::Client::Request::Select::FilterExpressionParameter.new(expression,
-                                                                    values)
-  end
-
-  def to_parameters(expression, values=nil)
-    filter_parameter(expression, values).to_parameters
-  end
-
-  sub_test_case("expression") do
-    def test_nil
-      assert_equal({},
-                   to_parameters(nil))
-    end
-
-    def test_string
-      assert_equal({
-                     :filter => "age <= 20",
-                   },
-                   to_parameters("age <= 20"))
-    end
-
-    def test_empty_string
-      assert_equal({},
-                   to_parameters(""))
-    end
-  end
-
-  sub_test_case("values") do
-    def test_string
-      filter = <<-'FILTER'.strip
-title == "[\"He\\ llo\"]"
-      FILTER
-      assert_equal({
-                     :filter => filter,
-                   },
-                   to_parameters("title == %{value}",
-                                 :value => "[\"He\\ llo\"]"))
-    end
-
-    def test_symbol
-      assert_equal({
-                     :filter => "title == \"Hello\"",
-                   },
-                   to_parameters("title == %{value}",
-                                 :value => :Hello))
-    end
-
-    def test_number
-      assert_equal({
-                     :filter => "age <= 29",
-                   },
-                   to_parameters("age <= %{value}",
-                                 :value => 29))
-    end
-
-    def test_true
-      assert_equal({
-                     :filter => "published == true",
-                   },
-                   to_parameters("published == %{value}",
-                                 :value => true))
-    end
-
-    def test_false
-      assert_equal({
-                     :filter => "published == false",
-                   },
-                   to_parameters("published == %{value}",
-                                 :value => false))
-    end
-
-    def test_nil
-      assert_equal({
-                     :filter => "function(null)",
-                   },
-                   to_parameters("function(%{value})",
-                                 :value => nil))
-    end
-  end
-end