droonga-client 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8624d5def9e15c15e068add4c8f60f007fcb6d21
-  data.tar.gz: 5ae5c17b038077337bf1653de18243c39afe7250
+  metadata.gz: 1425d0688ad70bf175cc34babb4a93fe23d7d0d7
+  data.tar.gz: cab9ce24171ee59feb0c95097bf21b9c3917dc2e
 SHA512:
-  metadata.gz: 3cf44081bdd4f97c0cab49adbd8d64be5270465608f291dcc492441eae82d6eb522aa694e790dfedad7d6db46b77a04ed1c75e5df75771e7ab918a47b9b482c4
-  data.tar.gz: a7e2fd87920b468f14beb8169fef80490351d0cbf8e151cedce15f74fdb50dddff724739215a56027afc035d028175c2b5f639a9d778a4be748369b659c33c31
+  metadata.gz: afdf8921e65d0d48c5ce50634ec2da10fc6adffa909308955b621bfa1f36af981470264133bca566f8b5906de9034fa5216f1761fe6c9e74ffaa9c7280b1fccc
+  data.tar.gz: 2990e9883d037f64c12de491bbd05bc26ce5be990112598c09e6e588f06452acce43774610f585f72aad319a538b94fdbd01b86cfc6c6013fab9f3401531fc2a

data/.gitignore

@@ -1,3 +1,4 @@
 /Gemfile.lock
 /.yardoc/
 /doc/reference/
+/pkg/

data/doc/text/news.md

@@ -1,5 +1,19 @@
 # News
 
+## 0.1.1: 2014-01-29
+
+### Improvements
+
+  * droonga-protocol: Removed needless `statusCode` parameter from request.
+  * droonga-protocol: Renamed {Droonga::Client#execute} to
+    {Droonga::Client#request}. This is incompatible change.
+  * droonga-protocol: Removed {Droonga::Client#search} because it is
+    not useful.
+  * droonga-protocol: Changed to use `Socket.gethostname` as the
+    default receiver host instead of `0.0.0.0`.
+  * Added {Droonga::Client#subscribe} for PubSub style messaging.
+  * http: Started to support HTTP.
+
 ## 0.1.0: 2013-12-29
 
 ### Improvements

data/droonga-client.gemspec

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2013 Droonga Project
+# Copyright (C) 2013-2014 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -36,6 +36,8 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "msgpack"
   spec.add_runtime_dependency "fluent-logger"
+  spec.add_runtime_dependency "rack"
+  spec.add_runtime_dependency "yajl-ruby"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/lib/droonga/client.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2013 Droonga Project
+# Copyright (C) 2013-2014 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -17,6 +17,7 @@
 
 require "droonga/client/version"
 require "droonga/client/error"
+require "droonga/client/connection/http"
 require "droonga/client/connection/droonga_protocol"
 
 module Droonga
@@ -52,15 +53,27 @@ module Droonga
     #   The host name or IP address of the Droonga Engine to be connected.
     # @option options [Integer] :port (24224)
     #   The port number of the Droonga Engine to be connected.
+    # @option options [String] :receiver_host (Socket.gethostname)
+    #   The host name or IP address to receive response from the Droonga Engine.
+    # @option options [Integer] :receiver_port (0)
+    #   The port number to receive response from the Droonga Engine.
     # @option options [Integer] :timeout (5)
     #   The timeout value for connecting to, writing to and reading
     #   from Droonga Engine.
     def initialize(options={})
-      @connection = Connection::DroongaProtocol.new(options)
+      @connection = create_connection(options)
     end
 
-    def search(body)
-      @connection.search(body)
+    def send(message, options={}, &block)
+      @connection.send(message, options, &block)
+    end
+
+    def request(message, options={}, &block)
+      @connection.request(message, options, &block)
+    end
+
+    def subscribe(message, options={}, &block)
+      @connection.subscribe(message, options, &block)
     end
 
     # Close the connection used by the client. You can't send any
@@ -70,5 +83,15 @@ module Droonga
     def close
       @connection.close
     end
+
+    private
+    def create_connection(options)
+      case options[:protocol] || :droonga
+      when :http
+        Connection::HTTP.new(options)
+      when :droonga
+        Connection::DroongaProtocol.new(options)
+      end
+    end
   end
 end

data/lib/droonga/client/connection/droonga_protocol.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2013 Droonga Project
+# Copyright (C) 2013-2014 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -36,47 +36,34 @@ module Droonga
 
         def initialize(options={})
           default_options = {
-            :tag             => "droonga",
-            :host            => "127.0.0.1",
-            :port            => 24224,
-            :connect_timeout => 1,
-            :read_timeout    => 0.1,
+            :tag     => "droonga",
+            :host    => "127.0.0.1",
+            :port    => 24224,
+            :timeout => 1,
           }
-          options = default_options.merge(options)
-          @logger = Fluent::Logger::FluentLogger.new(options.delete(:tag),
-                                                     options)
-          @connect_timeout = options[:connect_timeout]
-          @read_timeout = options[:read_timeout]
+          @options = default_options.merge(options)
+          @logger = Fluent::Logger::FluentLogger.new(@options.delete(:tag),
+                                                     @options)
+          @timeout = @options[:timeout]
         end
 
-        def search(body, &block)
-          envelope = {
-            "id"         => Time.now.to_f.to_s,
-            "date"       => Time.now,
-            "statusCode" => 200,
-            "type"       => "search",
-            "body"       => body,
-          }
-          execute(envelope, &block)
-        end
-
-        # Sends a request message and receives one ore more response
+        # Sends a request message and receives one or more response
         # messages.
         #
-        # @overload execute(message, options={})
-        #   Executes the request message synchronously.
+        # @overload request(message, options={})
+        #   This is synchronously version.
         #
         #   @param message [Hash] Request message.
-        #   @param options [Hash] The options to executes a request.
+        #   @param options [Hash] The options.
         #      TODO: WRITE ME
         #
         #   @return [Object] The response. TODO: WRITE ME
         #
-        # @overload execute(message, options={}, &block)
-        #   Executes the passed request message asynchronously.
+        # @overload request(message, options={}, &block)
+        #   This is asynchronously version.
         #
         #   @param message [Hash] Request message.
-        #   @param options [Hash] The options to executes a request.
+        #   @param options [Hash] The options.
         #      TODO: WRITE ME
         #   @yield [response]
         #      The block is called when response is received.
@@ -84,30 +71,81 @@ module Droonga
         #      The response.
         #
         #   @return [Request] The request object.
-        def execute(message, options={}, &block)
-          receiver = Receiver.new
+        def request(message, options={}, &block)
+          receiver = create_receiver
           message = message.dup
           message["replyTo"] = "#{receiver.host}:#{receiver.port}/droonga"
           send(message, options)
 
-          connect_timeout = options[:connect_timeout] || @connect_timeout
-          read_timeout = options[:read_timeout] || @read_timeout
+          sync = block.nil?
+          if sync
+            responses = []
+            receive(receiver, options) do |response|
+              responses << response
+            end
+            if responses.size > 1
+              responses
+            else
+              responses.first
+            end
+          else
+            thread = Thread.new do
+              receive(receiver, options, &block)
+            end
+            Request.new(thread)
+          end
+        end
+
+        # Subscribes something and receives zero or more published
+        # messages.
+        #
+        # @overload subscribe(message, options={})
+        #   This is enumerator version.
+        #
+        #   @param message [Hash] Subscribe message.
+        #   @param options [Hash] The options.
+        #      TODO: WRITE ME
+        #
+        #   @return [Enumerator] You can get a published message by
+        #     #next. You can also use #each to get published messages.
+        #
+        # @overload subscribe(message, options={}, &block)
+        #   This is asynchronously version.
+        #
+        #   @param message [Hash] Subscribe message.
+        #   @param options [Hash] The options.
+        #      TODO: WRITE ME
+        #   @yield [message]
+        #      The block is called when a published message is received.
+        #      The block may be called zero or more times.
+        #   @yieldparam [Object] message
+        #      The published message.
+        #
+        #   @return [Request] The request object.
+        def subscribe(message, options={}, &block)
+          receiver = create_receiver
+          message = message.dup
+          message["from"] = "#{receiver.host}:#{receiver.port}/droonga"
+          send(message, options)
+
           receive_options = {
-            :connect_timeout => connect_timeout,
-            :read_timeout    => read_timeout
+            :timeout => nil,
           }
           sync = block.nil?
           if sync
-            begin
-              receiver.receive(receive_options)
-            ensure
-              receiver.close
+            Enumerator.new do |yielder|
+              loop do
+                receiver.receive(receive_options) do |object|
+                  yielder << object
+                end
+              end
             end
           else
             thread = Thread.new do
               begin
-                response = receiver.receive(receive_options)
-                yield(response) if response
+                loop do
+                  receiver.receive(receive_options, &block)
+                end
               ensure
                 receiver.close
               end
@@ -119,12 +157,16 @@ module Droonga
         # Sends low level request. Normally, you should use other
         # convenience methods.
         #
-        # @param envelope [Hash] Request envelope.
+        # @param message [Hash] Request message.
         # @param options [Hash] The options to send request.
         #   TODO: WRITE ME
         # @return [void]
-        def send(envelope, options={}, &block)
-          @logger.post("message", envelope)
+        def send(message, options={}, &block)
+          if message["id"].nil? or message["date"].nil?
+            message = message.merge("id"   => Time.now.to_f.to_s,
+                                    "date" => Time.now)
+          end
+          @logger.post("message", message)
         end
 
         # Close the connection. This connection can't be used anymore.
@@ -134,18 +176,41 @@ module Droonga
           @logger.close
         end
 
+        private
+        def create_receiver
+          Receiver.new(:host => @options[:receiver_host],
+                       :port => @options[:receiver_port])
+        end
+
+        def receive(receiver, options)
+          timeout = options[:timeout] || @timeout
+
+          receive_options = {
+            :timeout => timeout,
+          }
+          begin
+            receiver.receive(receive_options) do |response|
+              yield(response)
+            end
+          ensure
+            receiver.close
+          end
+        end
+
         class Receiver
           def initialize(options={})
-            default_options = {
-              :host            => "0.0.0.0",
-              :port            => 0,
-            }
-            options = default_options.merge(options)
-            @socket = TCPServer.new(options[:host], options[:port])
+            host = options[:host] || Socket.gethostname
+            port = options[:port] || 0
+            @socket = TCPServer.new(host, port)
+            @read_ios = [@socket]
+            @client_handlers = {}
           end
 
           def close
             @socket.close
+            @client_handlers.each_key do |client|
+              client.close
+            end
           end
 
           def host
@@ -157,37 +222,48 @@ module Droonga
           end
 
           BUFFER_SIZE = 8192
-          def receive(options={})
-            responses = []
-            select(@socket, options[:connect_timeout]) do
-              client = @socket.accept
-              unpacker = MessagePack::Unpacker.new
-              select(client, options[:read_timeout]) do
-                data = client.read_nonblock(BUFFER_SIZE)
-                unpacker.feed_each(data) do |object|
-                  responses << object
+          def receive(options={}, &block)
+            timeout = options[:timeout]
+            catch do |tag|
+              loop do
+                start = Time.new
+                readable_ios, = IO.select(@read_ios, nil, nil, timeout)
+                break if readable_ios.nil?
+                if timeout
+                  timeout -= (Time.now - start)
+                  timeout = 0 if timeout < 0
+                end
+                readable_ios.each do |readable_io|
+                  on_readable(readable_io) do |object|
+                    begin
+                      yield(object)
+                    rescue LocalJumpError
+                      throw(tag)
+                    end
+                  end
                 end
               end
-              client.close
             end
-            # TODO: ENABLE ME
-            # if responses.size >= 2
-            #   responses
-            # else
-              responses.first
-            # end
           end
 
           private
-          def select(input, timeout)
-            loop do
-              start = Time.now
-              readables, = IO.select([input], nil, nil, timeout)
-              timeout -= (Time.now - start)
-              timeout /= 2.0
-              timeout = 0 if timeout < 0
-              break if readables.nil?
-              yield(timeout)
+          def on_readable(io)
+            case io
+            when @socket
+              client = @socket.accept
+              @read_ios << client
+              @client_handlers[client] = lambda do
+                unpacker = MessagePack::Unpacker.new
+                data = client.read_nonblock(BUFFER_SIZE)
+                unpacker.feed_each(data) do |object|
+                  yield(object)
+                end
+                client.close
+                @read_ios.delete(client)
+                @client_handlers.delete(client)
+              end
+            else
+              @client_handlers[io].call
             end
           end
         end

data/lib/droonga/client/connection/error.rb

@@ -23,16 +23,6 @@ module Droonga
       # The top error class of connection module.
       class Error < Client::Error
       end
-
-      # The error class for invalid response type is specified.
-      class InvalidResponseType < Error
-        attr_reader :type
-        def initialize(type)
-          @type = type
-          super("Unknown response type: <#{@type}>. " +
-                  "Available types: [:none, :one]")
-        end
-      end
     end
   end
 end

data/lib/droonga/client/connection/http.rb

@@ -0,0 +1,186 @@
+# Copyright (C) 2014 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "net/http"
+require "thread"
+
+require "rack"
+
+require "yajl"
+
+require "droonga/client/connection/error"
+
+module Droonga
+  class Client
+    module Connection
+      class HTTP
+        # The error class for invalid HTTP method case
+        class InvalidHTTPMethodError < Error
+          attr_reader :http_method
+          attr_reader :request_message
+          def initialize(http_method, request_message)
+            @http_method     = http_method
+            @request_message = request_message
+            super("Unsupport HTTP Method: <#{@http_method}>: " +
+                    "<#{@request_message.inspect}>")
+          end
+        end
+
+        class Request
+          def initialize(thread)
+            @thread = thread
+          end
+
+          def wait
+            @thread.join
+          end
+        end
+
+        def initialize(options={})
+          @host    = options[:host] || "127.0.0.1"
+          @port    = options[:port] || 80
+          @timeout = options[:timeout] || 1
+        end
+
+        # Sends a request message and receives one or more response
+        # messages.
+        #
+        # @overload request(message, options={})
+        #   This is synchronously version.
+        #
+        #   @param message [Hash] Request message.
+        #   @param options [Hash] The options.
+        #      TODO: WRITE ME
+        #
+        #   @return [Object] The response. TODO: WRITE ME
+        #
+        # @overload request(message, options={}, &block)
+        #   This is asynchronously version.
+        #
+        #   @param message [Hash] Request message.
+        #   @param options [Hash] The options.
+        #      TODO: WRITE ME
+        #   @yield [response]
+        #      The block is called when response is received.
+        #   @yieldparam [Object] response
+        #      The response.
+        #
+        #   @return [Request] The request object.
+        def request(message, options={}, &block)
+          sync = block.nil?
+          if sync
+            send(message, options) do |response|
+              response.body
+            end
+          else
+            thread = Thread.new do
+              send(message, options) do |response|
+                yield(response.body)
+              end
+            end
+            Request.new(thread)
+          end
+        end
+
+        # Subscribes something and receives zero or more published
+        # messages.
+        #
+        # @overload subscribe(message, options={}, &block)
+        #   This is asynchronously version.
+        #
+        #   @param message [Hash] Subscribe message.
+        #   @param options [Hash] The options.
+        #      TODO: WRITE ME
+        #   @yield [message]
+        #      The block is called when a published message is received.
+        #      The block may be called zero or more times.
+        #   @yieldparam [Object] message
+        #      The published message.
+        #
+        #   @return [Request] The request object.
+        def subscribe(message, options={}, &block)
+          thread = Thread.new do
+            json_parser = Yajl::Parser.new
+            json_parser.on_parse_complete = block
+            send(message, options.merge(:read_timeout => nil)) do |response|
+              response.read_body do |chunk|
+                json_parser << chunk
+              end
+            end
+          end
+          Request.new(thread)
+        end
+
+        # Sends low level request. Normally, you should use other
+        # convenience methods.
+        #
+        # @param envelope [Hash] Request envelope.
+        # @param options [Hash] The options to send request.
+        #   TODO: WRITE ME
+        # @return [void]
+        def send(message, options={}, &block)
+          http = Net::HTTP.new(@host, @port)
+          open_timeout = @timeout
+          read_timeout = @timeout
+          open_timeout = options[:open_timeout] if options.key?(:open_timeout)
+          read_timeout = options[:read_timeout] if options.key?(:read_timeout)
+          http.open_timeout = open_timeout
+          http.read_timeout = read_timeout
+          request = build_request(message)
+          http.start do
+            http.request(request) do |response|
+              yield(response)
+            end
+          end
+        end
+
+        # Close the connection. This connection can't be used anymore.
+        #
+        # @return [void]
+        def close
+        end
+
+        private
+        def build_request(message)
+          http_method = message["method"] || "GET"
+          http_headers = message["headers"] || {}
+          case http_method
+          when "POST"
+            request = Net::HTTP::Post.new(build_path(message, {}),
+                                          http_headers)
+            request.body = JSON.generate(message["body"])
+            request
+          when "GET"
+            parameters = message["body"] || {}
+            Net::HTTP::Get.new(build_path(message, parameters),
+                               http_headers)
+          else
+            raise InvalidHTTPMethodError.new(http_method, message)
+          end
+        end
+
+        def build_path(message, parameters)
+          type = message["type"]
+          base_path = message["path"] || "/#{type}"
+          if parameters.empty?
+            base_path
+          else
+            "#{base_path}?#{Rack::Utils.build_nested_query(parameters)}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/droonga/client/version.rb

@@ -17,6 +17,6 @@
 
 module Droonga
   class Client
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

data/sample/droonga-request.rb

@@ -0,0 +1,111 @@
+# Copyright (C) 2014 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "optparse"
+require "json"
+
+require "droonga/client"
+
+options = {
+  :host                => "localhost",
+  :port                => 24224,
+  :tag                 => "droonga",
+  :protocol            => :droonga,
+  :timeout             => 1,
+  :exit_on_response    => true,
+  :receiver_host       => "localhost",
+  :receiver_port       => 0,
+  :report_elapsed_time => true,
+}
+
+parser = OptionParser.new
+parser.banner += " REQUEST_JSON_FILE"
+parser.separator("")
+parser.separator("Connect:")
+parser.on("--host=HOST",
+          "Host name to be connected.",
+          "(#{options[:host]})") do |host|
+  options[:host] = host
+end
+parser.on("--port=PORT", Integer,
+          "Port number to be connected.",
+          "(#{options[:port]})") do |port|
+  options[:port] = port
+end
+parser.on("--tag=TAG",
+          "Tag name to be used to communicate with Droonga system.",
+          "(#{options[:tag]})") do |tag|
+  options[:tag] = tag
+end
+available_protocols = [:droonga, :http]
+parser.on("--protocol=PROTOCOL", available_protocols,
+          "Protocol to be used to communicate with Droonga system.",
+          "[#{available_protocols.join('|')}",
+          "(#{options[:protocol]})") do |protocol|
+  options[:protocol] = protocol
+end
+parser.separator("")
+parser.separator("Timeout:")
+parser.on("--timeout=TIMEOUT", Integer,
+          "Timeout for operations.",
+          "(#{options[:timeout]})") do |timeout|
+  options[:timeout] = timeout
+end
+parser.on("--[no-]exit-on-response",
+          "Exit when a response is received.",
+          "(#{options[:exit_on_response]})") do |exit_on_response|
+  options[:exit_on_response] = exit_on_response
+end
+parser.separator("")
+parser.separator("Droonga protocol:")
+parser.on("--receiver-host=HOST",
+          "Host name to be received a response from Droonga engine.",
+          "(#{options[:receiver_host]})") do |host|
+  options[:receiver_host] = host
+end
+parser.on("--receiver-port=PORT", Integer,
+          "Port number to be received a response from Droonga engine.",
+          "(#{options[:receiver_port]})") do |port|
+  options[:receiver_port] = port
+end
+parser.separator("")
+parser.separator("Report:")
+parser.on("--[no-]report-elapsed-time",
+          "Reports elapsed time.",
+          "(#{options[:report_elapsed_time]})") do |report_elapsed_time|
+  options[:report_elapsed_time] = report_elapsed_time
+end
+*rest = parser.parse!(ARGV)
+
+if rest.size < 1
+  puts("request JSON file is missing.")
+  exit(false)
+end
+
+request_json_file = rest.first
+
+client = Droonga::Client.new(options)
+request_message = JSON.parse(File.read(request_json_file))
+start = Time.now
+request = client.request(request_message) do |response|
+  puts("Elapsed time: #{Time.now - start}") if options[:report_elapsed_time]
+  begin
+    puts(JSON.pretty_generate(response))
+  rescue
+    p(response)
+  end
+  break if options[:exit_on_response]
+end
+request.wait

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: droonga-client
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Droonga Project
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-29 00:00:00.000000000 Z
+date: 2014-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -38,6 +38,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -98,8 +126,10 @@ files:
 - lib/droonga/client.rb
 - lib/droonga/client/connection/droonga_protocol.rb
 - lib/droonga/client/connection/error.rb
+- lib/droonga/client/connection/http.rb
 - lib/droonga/client/error.rb
 - lib/droonga/client/version.rb
+- sample/droonga-request.rb
 homepage: https://github.com/droonga/droonga-client-ruby
 licenses:
 - LGPL-2.1