groonga-client 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07f89351f5ba7dc1fbfd0b03c350a124af15dd07
-  data.tar.gz: 0e428a4ca114c09cf9d536f59faa1aa89bfb09db
+  metadata.gz: f47d1a05d48212d7bad001fb9b5a1bfe74f40edc
+  data.tar.gz: 95b2962aa8532fa2a74e617779abed394f05de12
 SHA512:
-  metadata.gz: 38dff0be4468d31c5afe7b8c0597d6c356b95ef8f8b322f726348bfa32a4568bd3dbc436a856f1939e8aa403a003e67930edd9c8f1dffb05ccb747f6f1a41c2a
-  data.tar.gz: b70ced387a66aafc5a7cca4444e337883790af77ea06520abf1f38cf87d7b9f981a88889aeb89db9ce2d189678a5a8deb72be36936611e455966645d157051a0
+  metadata.gz: fd6abe205934d99203e8b87d37ec5e3ae4586e0705f998a07a6d5735b1e3d5f13c7f8ad10f412ab24587c82808417c08eea7c16c9f90297f0a30c078ae8283ea
+  data.tar.gz: 10b410ebf59503342ed22563a7ecc1ff90f7be430c8561acda6e846b8170a5c534201e6d88f6a22e3dcde56445a4a876d7203b2d875d365f563c918fe8ed4c65

data/doc/text/news.md

@@ -1,5 +1,18 @@
 # NEWS
 
+## 0.3.4 - 2016-12-13
+
+### Improvements
+
+  * Added request interface from groonga-client-rails.
+  * Added `Groonga::Client::Response::Schema::Index#full_text_searchable?`.
+  * Added `Groonga::Client::Response::Schema::Column#have_full_text_search_index?`.
+  * Added `Groonga::Client::Response::Schema::Table#have_full_text_search_index?`.
+  * Added `Groonga::Client::Response::Select#slices`.
+  * Added test helper from groonga-client-rails.
+  * Added `Groonga::Client::Response#size` for Kaminari.
+  * Added enumrable interface for `Groonga::Client::Response::Select`.
+
 ## 0.3.3 - 2016-12-07
 
 ### Improvements

data/lib/groonga/client.rb

@@ -23,7 +23,7 @@ require "groonga/client/command"
 require "groonga/client/empty-request"
 require "groonga/client/protocol/gqtp"
 require "groonga/client/protocol/http"
-require "groonga/client/script-syntax"
+require "groonga/client/request"
 
 module Groonga
   class Client

data/lib/groonga/client/request.rb

@@ -0,0 +1,22 @@
+# 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
+
+require "groonga/client/script-syntax"
+
+require "groonga/client/request/base"
+require "groonga/client/request/error"
+
+require "groonga/client/request/select"

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

@@ -0,0 +1,174 @@
+# 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
+
+module Groonga
+  class Client
+    module Request
+      class Base
+        def initialize(parameters=nil, extensions=[])
+          @parameters = parameters
+          @extensions = extensions
+          extend(*@extensions) unless @extensions.empty?
+        end
+
+        def response
+          @reponse ||= create_response
+        end
+
+        def parameter(name, value)
+          add_parameter(OverwriteMerger,
+                        RequestParameter.new(name, value))
+        end
+
+        def to_parameters
+          if @parameters.nil?
+            {}
+          else
+            @parameters.to_parameters
+          end
+        end
+
+        def extensions(*modules, &block)
+          modules << Module.new(&block) if block
+          if modules.empty?
+            self
+          else
+            create_request(@parameters, @extensions | modules)
+          end
+        end
+
+        private
+        def add_parameter(merger_class, parameter)
+          merger = merger_class.new(@parameters, parameter)
+          create_request(merger, @extensions)
+        end
+
+        def create_request(parameters, extensions)
+          self.class.new(parameters, extensions)
+        end
+
+        def create_response
+          open_client do |client|
+            response = client.execute(self.class.command_name, to_parameters)
+            raise ErrorResponse.new(response) unless response.success?
+            response
+          end
+        end
+
+        def open_client
+          Client.open do |client|
+            yield(client)
+          end
+        end
+      end
+
+      class RequestParameter
+        def initialize(name, value)
+          @name = name
+          @value = value
+        end
+
+        def to_parameters
+          case @value
+          when Symbol
+            value = @value.to_s
+          when String
+            return {} if @value.empty?
+            value = @value
+          when NilClass
+            return {}
+          else
+            value = @value
+          end
+          {
+            @name => value,
+          }
+        end
+      end
+
+      class ValuesParameter
+        def initialize(names, values)
+          @names = names
+          @values = values
+        end
+
+        def to_parameters
+          case @values
+          when ::Array
+            return {} if @values.empty?
+            values = @values.collect(&:to_s).join(", ")
+          when Symbol
+            values = @values.to_s
+          when String
+            return {} if /\A\s*\z/ === @values
+            values = @values
+          when NilClass
+            return {}
+          else
+            values = @values
+          end
+          parameters = {}
+          @names.each do |name|
+            parameters[name] = values
+          end
+          parameters
+        end
+      end
+
+      class FlagsParameter
+        def initialize(names, flags)
+          @names = names
+          @flags = flags
+        end
+
+        def to_parameters
+          case @flags
+          when ::Array
+            return {} if @flags.empty?
+            flags = @flags.collect(&:to_s).join("|")
+          when Symbol
+            flags = @flags.to_s
+          when String
+            return {} if /\A\s*\z/ === @flags
+            flags = @flags
+          when NilClass
+            return {}
+          else
+            flags = @flags
+          end
+          parameters = {}
+          @names.each do |name|
+            parameters[name] = flags
+          end
+          parameters
+        end
+      end
+
+      class ParameterMerger
+        def initialize(parameters1, parameters2)
+          @parameters1 = parameters1
+          @parameters2 = parameters2
+        end
+      end
+
+      class OverwriteMerger < ParameterMerger
+        def to_parameters
+          @parameters1.to_parameters.merge(@parameters2.to_parameters)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# 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
+
+require "groonga/client/error"
+
+module Groonga
+  class Client
+    module Request
+      class Error < Client::Error
+      end
+
+      class ErrorResponse < Error
+        attr_reader :response
+        def initialize(response)
+          @response = response
+          command = @response.command
+          status_code = @response.status_code
+          error_message = @response.error_message
+          message = "failed to execute: #{command.name}: #{status_code}: "
+          message << "<#{error_message}>"
+          super(message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,292 @@
+# 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
+
+module Groonga
+  class Client
+    module Request
+      class Select < Base
+        include Enumerable
+
+        class << self
+          def command_name
+            "select"
+          end
+        end
+
+        def initialize(table_or_parameters, extensions=[])
+          if table_or_parameters.respond_to?(:to_parameters)
+            parameters = table_or_parameters
+          else
+            table_name = table_or_parameters
+            parameters = RequestParameter.new(:table, table_name)
+          end
+          super(parameters, extensions)
+        end
+
+        def match_columns(value)
+          add_parameter(OverwriteMerger,
+                        ValuesParameter.new([:match_columns], value))
+        end
+
+        def query(value)
+          add_parameter(QueryMerger,
+                        RequestParameter.new(:query, value))
+        end
+
+        def filter(expression, values=nil)
+          add_parameter(FilterMerger,
+                        FilterParameter.new(expression, values))
+        end
+
+        def output_columns(value)
+          add_parameter(OverwriteMerger,
+                        OutputColumnsParameter.new("", value))
+        end
+
+        def sort_keys(value)
+          add_parameter(OverwriteMerger,
+                        SortKeysParameter.new("", value))
+        end
+        alias_method :sortby, :sort_keys
+        alias_method :sort, :sort_keys
+
+        def offset(value)
+          parameter(:offset, value)
+        end
+
+        def limit(value)
+          parameter(:limit, value)
+        end
+
+        def paginate(page, per_page: 10)
+          page ||= 1
+          page = page.to_i
+          if page <= 0
+            offset = 0
+          else
+            offset = per_page * (page - 1)
+          end
+          offset(offset).limit(per_page)
+        end
+
+        def drilldowns(label)
+          LabeledDrilldown.new(self, label)
+        end
+
+        def each(&block)
+          response.records.each(&block)
+        end
+
+        private
+        def create_response
+          response = super
+          if paginated? and defined?(Kaminari)
+            response.extend(Kaminari::ConfigurationMethods::ClassMethods)
+            response.extend(Kaminari::PageScopeMethods)
+          end
+          response
+        end
+
+        def paginated?
+          parameters = to_parameters
+          parameters.key?(:offset) and parameters.key?(:limit)
+        end
+
+        class LabeledDrilldown
+          def initialize(request, label)
+            @request = request
+            @label = label
+          end
+
+          def keys(value)
+            add_parameter(OverwriteMerger,
+                          ValuesParameter.new([:"#{prefix}keys"], value))
+          end
+
+          def sort_keys(value)
+            add_parameter(OverwriteMerger,
+                          SortKeysParameter.new(prefix, value))
+          end
+          alias_method :sortby, :sort_keys
+          alias_method :sort, :sort_keys
+
+          def output_columns(value)
+            add_parameter(OverwriteMerger,
+                          OutputColumnsParameter.new(prefix, value))
+          end
+
+          def offset(value)
+            @request.parameter(:"#{prefix}offset", value)
+          end
+
+          def limit(value)
+            @request.parameter(:"#{prefix}limit", value)
+          end
+
+          def calc_types(value)
+            add_parameter(OverwriteMerger,
+                          FlagsParameter.new([:"#{prefix}calc_types"], value))
+          end
+
+          def calc_target(value)
+            @request.parameter(:"#{prefix}calc_target", value)
+          end
+
+          private
+          def prefix
+            "drilldowns[#{@label}]."
+          end
+
+          def add_parameter(merger, parameter)
+            @request.__send__(:add_parameter, merger, parameter)
+          end
+        end
+
+        # @private
+        class QueryMerger < ParameterMerger
+          def to_parameters
+            params1 = @parameters1.to_parameters
+            params2 = @parameters2.to_parameters
+            params = params1.merge(params2)
+            query1 = params1[:query]
+            query2 = params2[:query]
+            if query1.present? and query2.present?
+              params[:query] = "(#{query1}) (#{query2})"
+            else
+              params[:query] = (query1 || query2)
+            end
+            params
+          end
+        end
+
+        # @private
+        class FilterMerger < ParameterMerger
+          def to_parameters
+            params1 = @parameters1.to_parameters
+            params2 = @parameters2.to_parameters
+            params = params1.merge(params2)
+            filter1 = params1[:filter]
+            filter2 = params2[:filter]
+            if filter1.present? and filter2.present?
+              params[:filter] = "(#{filter1}) && (#{filter2})"
+            else
+              params[:filter] = (filter1 || filter2)
+            end
+            params
+          end
+        end
+
+        # @private
+        class FilterParameter
+          def initialize(expression, values)
+            @expression = expression
+            @values = values
+          end
+
+          def to_parameters
+            case @expression
+            when String
+              return {} if /\A\s*\z/ === @expression
+              expression = @expression
+            when NilClass
+              return {}
+            else
+              expression = @expression
+            end
+
+            if @values.is_a?(::Hash) and not @values.empty?
+              escaped_values = {}
+              @values.each do |key, value|
+                escaped_values[key] = escape_filter_value(value)
+              end
+              expression = expression % escaped_values
+            end
+
+            {
+              filter: expression,
+            }
+          end
+
+          private
+          def escape_filter_value(value)
+            case value
+            when Numeric
+              value
+            when TrueClass, FalseClass
+              value
+            when NilClass
+              "null"
+            when String
+              ScriptSyntax.format_string(value)
+            when Symbol
+              ScriptSyntax.format_string(value.to_s)
+            when ::Array
+              escaped_value = "["
+              value.each_with_index do |element, i|
+                escaped_value << ", " if i > 0
+                escaped_value << escape_filter_value(element)
+              end
+              escaped_value << "]"
+              escaped_value
+            when ::Hash
+              escaped_value = "{"
+              value.each_with_index do |(k, v), i|
+                escaped_value << ", " if i > 0
+                escaped_value << escape_filter_value(k.to_s)
+                escaped_value << ": "
+                escaped_value << escape_filter_value(v)
+              end
+              escaped_value << "}"
+              escaped_value
+            else
+              value
+            end
+          end
+        end
+
+        # @private
+        class OutputColumnsParameter < ValuesParameter
+          def initialize(prefix, output_columns)
+            super([:"#{prefix}output_columns"], output_columns)
+          end
+
+          def to_parameters
+            parameters = super
+            @names.each do |name|
+              output_columns = parameters[name]
+              if output_columns and output_columns.include?("(")
+                parameters[:command_version] = "2"
+                break
+              end
+            end
+            parameters
+          end
+        end
+
+        # @private
+        class SortKeysParameter < ValuesParameter
+          def initialize(prefix, output_columns)
+            names = [
+              :"#{prefix}sort_keys",
+              :"#{prefix}sortby", # for backward compatibility
+            ]
+            super(names, output_columns)
+          end
+        end
+      end
+    end
+  end
+end