groonga-client-rails 0.9.4 → 0.9.5

data/lib/groonga/client/rails/groonga_server_runner.rb

@@ -1,164 +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
-
-require "rbconfig"
-require "fileutils"
-
-module Groonga
-  class Client
-    module Rails
-      class GroongaServerRunner
-        def initialize
-          @pid = nil
-          @using_running_server = false
-          @url = build_url
-          @groonga = find_groonga
-          @tmp_dir = nil
-        end
-
-        def run
-          if groonga_server_running?
-            @using_running_server = true
-          else
-            return if @groonga.nil?
-            @tmp_dir = create_tmp_dir
-            db_path = @tmp_dir + "db"
-            @pid = spawn(@groonga,
-                         "--port", @url.port.to_s,
-                         "--log-path", (@tmp_dir + "groonga.log").to_s,
-                         "--query-log-path", (@tmp_dir + "query.log").to_s,
-                         "--protocol", "http",
-                         "-s",
-                         "-n", db_path.to_s)
-            wait_groonga_ready
-          end
-          sync_schema
-        end
-
-        def stop
-          if @using_running_server
-            Groonga::Client.open do |client|
-              schema = client.schema
-              schema.tables.each do |name, _|
-                client.delete(table: name,
-                              filter: "true")
-              end
-            end
-          else
-            if @pid
-              Groonga::Client.open do |client|
-                client.shutdown
-              end
-              wait_groonga_shutdown
-            end
-            if @tmp_dir
-              FileUtils.rm_rf(@tmp_dir)
-            end
-          end
-        end
-
-        private
-        def build_url
-          default_options = Groonga::Client.default_options
-          url = default_options[:url]
-          if url.nil?
-            host = default_options[:host] || default_options[:address]
-            port = default_options[:port] || 10041
-            path = default_options[:path]
-            url = URI("http://#{host}:#{port}#{path}")
-          end
-          url
-        end
-
-        def groonga_server_running?
-          begin
-            TCPSocket.open(@url.host, @url.port) do
-            end
-          rescue SystemCallError
-            false
-          else
-            true
-          end
-        end
-
-        def sync_schema
-          ::Rails.application.eager_load!
-          ObjectSpace.each_object(Class) do |klass|
-            klass.sync_schema if klass < Searcher
-          end
-        end
-
-        def find_groonga
-          paths = ENV["PATH"].split(File::PATH_SEPARATOR)
-          exeext = RbConfig::CONFIG["EXEEXT"]
-          paths.each do |path|
-            groonga = File.join(path, "groonga#{exeext}")
-            return groonga if File.executable?(groonga)
-          end
-          nil
-        end
-
-        def create_tmp_dir
-          tmpfs_dir = "/dev/shm"
-          if File.directory?(tmpfs_dir)
-            base_tmp_dir = Pathname(tmpfs_dir)
-          else
-            base_tmp_dir = ::Rails.root + "tmp"
-          end
-          tmp_dir = base_tmp_dir + "groonga-client-rails.#{Process.pid}"
-          FileUtils.rm_rf(tmp_dir)
-          FileUtils.mkdir_p(tmp_dir)
-          tmp_dir
-        end
-
-        def wait_groonga_ready
-          n_retried = 0
-          while n_retried <= 20
-            n_retried += 1
-            sleep(0.05)
-            if groonga_server_running?
-              break
-            else
-              begin
-                pid = Process.waitpid(@pid, Process::WNOHANG)
-              rescue SystemCallError
-                @pid = nil
-                break
-              end
-            end
-          end
-        end
-
-        def wait_groonga_shutdown
-          # TODO: Remove me when Groonga 6.0.1 has been released.
-          # Workaround to shutdown as soon as possible.
-          groonga_server_running?
-
-          n_retried = 0
-          while n_retried <= 20
-            n_retried += 1
-            sleep(0.05)
-            pid = Process.waitpid(@pid, Process::WNOHANG)
-            return if pid
-          end
-
-          Process.kill(:KILL, @pid)
-          Process.waitpid(@pid)
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +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
-
-module Groonga
-  class Client
-    class Searcher
-      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/searcher/raw_request.rb

@@ -1,85 +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
-
-module Groonga
-  class Client
-    class Searcher
-      class RawRequest
-        def initialize(command_name, parameters=nil)
-          @command_name = command_name
-          @parameters = parameters
-        end
-
-        def response
-          @reponse ||= Client.open do |client|
-            response = client.execute(@command_name, to_parameters)
-            raise ErrorResponse.new(response) unless response.success?
-            response
-          end
-        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
-
-        private
-        def add_parameter(merger_class, parameter)
-          merger = merger_class.new(@parameters, parameter)
-          create_request(merger)
-        end
-
-        def create_request(parameters)
-          self.class.new(@command_name, parameters)
-        end
-      end
-
-      class RequestParameter
-        def initialize(name, value)
-          @name = name
-          @value = value
-        end
-
-        def to_parameters
-          {
-            @name => @value,
-          }
-        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/searcher/select/request.rb

@@ -1,283 +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
-
-require "active_support/core_ext/object/blank"
-
-require "groonga/client/searcher/raw_request"
-
-module Groonga
-  class Client
-    class Searcher
-      module Select
-        class Request < RawRequest
-          def initialize(table_or_parameters)
-            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("select", parameters)
-          end
-
-          def result_set
-            @result_set ||= create_result_set
-          end
-
-          def match_columns(value)
-            add_parameter(OverwriteMerger,
-                          MatchColumnsParameter.new(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 sortby(value)
-            add_parameter(OverwriteMerger,
-                          SortbyParameter.new(value))
-          end
-          alias_method :sort, :sortby
-
-          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
-
-          private
-          def create_request(parameters)
-            self.class.new(parameters)
-          end
-
-          def create_result_set
-            result_set = ResultSet.new(response)
-            if paginated? and defined?(Kaminari)
-              result_set.extend(Kaminari::ConfigurationMethods::ClassMethods)
-              result_set.extend(Kaminari::PageScopeMethods)
-            end
-            result_set
-          end
-
-          def paginated?
-            parameters = to_parameters
-            parameters.key?(:offset) and parameters.key?(:limit)
-          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 MatchColumnsParameter
-          def initialize(match_columns)
-            @match_columns = match_columns
-          end
-
-          def to_parameters
-            if @match_columns.blank?
-              {}
-            else
-              case @match_columns
-              when ::Array
-                match_columns = @match_columns.join(", ")
-              when Symbol
-                match_columns = @match_columns.to_s
-              else
-                match_columns = @match_columns
-              end
-              {
-                match_columns: match_columns,
-              }
-            end
-          end
-        end
-
-        # @private
-        class FilterParameter
-          def initialize(expression, values)
-            @expression = expression
-            @values = values
-          end
-
-          def to_parameters
-            if @expression.blank?
-              {}
-            else
-              if @values.blank?
-                expression = @expression
-              else
-                escaped_values = {}
-                @values.each do |key, value|
-                  escaped_values[key] = escape_filter_value(value)
-                end
-                expression = @expression % escaped_values
-              end
-              {
-                filter: expression,
-              }
-            end
-          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
-          def initialize(output_columns)
-            @output_columns = output_columns
-          end
-
-          def to_parameters
-            if @output_columns.blank?
-              {}
-            else
-              case @output_columns
-              when ::Array
-                output_columns = @output_columns.join(", ")
-              when Symbol
-                output_columns = @output_columns.to_s
-              else
-                output_columns = @output_columns
-              end
-              parameters = {
-                output_columns: output_columns,
-              }
-              if output_columns.include?("(")
-                parameters[:command_version] = "2"
-              end
-              parameters
-            end
-          end
-        end
-
-        # @private
-        class SortbyParameter
-          def initialize(sortby)
-            @sortby = sortby
-          end
-
-          def to_parameters
-            if @sortby.blank?
-              {}
-            else
-              case @sortby
-              when ::Array
-                sortby = @sortby.collect(&:to_s).join(", ")
-              when Symbol
-                sortby = @sortby.to_s
-              else
-                sortby = @sortby
-              end
-              {
-                sortby: sortby,
-              }
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/groonga/client/searcher/select/result_set.rb

@@ -1,117 +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
-
-module Groonga
-  class Client
-    class Searcher
-      module Select
-        class ResultSet
-          def initialize(response)
-            @response = response
-          end
-
-          def n_hits
-            @response.n_hits
-          end
-          # For Kaminari
-          alias_method :total_count, :n_hits
-
-          # For Kaminari
-          def limit_value
-            (@response.command[:limit] || 10).to_i
-          end
-
-          # For Kaminari
-          def offset_value
-            (@response.command[:offset] || 0).to_i
-          end
-
-          def records
-            @records ||= build_records
-          end
-
-          def sources
-            @sources ||= fetch_sources
-          end
-
-          def drilldowns
-            @response.drilldowns
-          end
-
-          private
-          def build_records
-            @response.records.collect.with_index do |record, i|
-              Record.new(self, i, record)
-            end
-          end
-
-          def fetch_sources
-            source_ids = {}
-            records.collect do |record|
-              model_name, id = record["_key"].split(/-/, 2)
-              source_ids[model_name] ||= []
-              source_ids[model_name] << id
-            end
-            sources = {}
-            source_ids.each do |model_name, ids|
-              model_name.constantize.find(ids).each_with_index do |model, i|
-                sources["#{model_name}-#{ids[i]}"] = model
-              end
-            end
-            records.collect do |record|
-              sources[record["_key"]]
-            end
-          end
-
-          class Record
-            def initialize(result_set, nth, raw_record)
-              @result_set = result_set
-              @nth = nth
-              @raw_record = raw_record
-            end
-
-            def source
-              @result_set.sources[@nth]
-            end
-
-            def [](name)
-              @raw_record[normalize_name(name)]
-            end
-
-            def method_missing(name, *args, &block)
-              return super unless args.empty?
-              return super unless @raw_record.key?(name.to_s)
-
-              self[name]
-            end
-
-            def respond_to_missing?(name, *args, &block)
-              return super unless args.empty?
-              return super unless @raw_record.key?(name.to_s)
-
-              @raw_record.key?(normalize_name(name))
-            end
-
-            private
-            def normalize_name(name)
-              name.to_s
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +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
-
-require "groonga/client/searcher/select/request"
-require "groonga/client/searcher/select/result_set"