pipe_rpc 0.3.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d06d3d11acca99089b43065d1ad56988c0d3113
-  data.tar.gz: 39649de0d7021a175a9537e1e9749a20f2240da6
+  metadata.gz: db3929008eaf1ac0b4d3d3d2f54ca17ea82ffa9c
+  data.tar.gz: 7737ad82b6cc89bb348179659b64617f28a5b1a1
 SHA512:
-  metadata.gz: 2807e8f2f0594d408a8839f1e7297027222508fea89454bb02d56fa4b444cb80a0cfc72ca2f286ccdd3ad1bf2fbec634ad12acbabad58a9624d5b5e004cdfff5
-  data.tar.gz: e04c2e989be39d481123c98c636cef5699ced3d47821c6fe5b2020378b6191dccec7747bfecaec05aadffae6b21e49a8713d434a8d36770f1f0d835d5a95462a
+  metadata.gz: 5a70e27fe8b73c7630c1101f4234d78d991254965c598839622763bd5f37197294bbef0dbdaad93f0f3b35c5659f36f88157fbba6a9d8f5b0a809b8b96f0f70d
+  data.tar.gz: a4ebe6276e87fb6d8613c4f8f721c59c001e6f8635a029848ef0c3be912aaafe44c5f6015c7691af1400557c2d275b0fc2af09d1d7615f0f90c0c317947ff545

data/lib/pipe_rpc/client.rb

@@ -1,22 +1,13 @@
 module PipeRpc
   class Client < BasicObject
-    def initialize(hub, args = {})
+    def initialize(server = :default, hub)
+      @server = server.to_sym
       @hub = hub
-      @server = args.fetch(:server, :default).to_sym
     end
 
     def method_missing(method, *args)
-      backtrace = ::Kernel.respond_to?(:caller) ? ::Kernel.caller(1) : []
-
-      @hub.request(server: @server, method: method, arguments: args) do |result|
-        if result.is_a? ::StandardError
-          result.set_backtrace(result.backtrace.to_a + backtrace.to_a) if result.respond_to? :set_backtrace
-          ::Kernel.raise result
-        else
-          result
-        end
-      end
-      # Method won't return until we got a result because @hub.request starts a loop and blocks!
+      request = Client::Request.new(server: @server, method: method, arguments: args)
+      @hub.requests.evaluate(request)
     end
 
     def to_s

data/lib/pipe_rpc/client_request.rb

@@ -0,0 +1,24 @@
+class PipeRpc::Request; end
+
+module PipeRpc
+  class Client::Request < Request
+    def initialize(*args)
+      super
+      # discard first three entries mentioning Client::Request#initialize,
+      # Client::Request.new and Client#method_missing in stacktrace
+      @stacktrace = Kernel.respond_to?(:caller) ? Kernel.caller(3).to_a : []
+      @result = Result.new(self)
+    end
+
+    attr_reader :stacktrace, :result
+
+    def id=(id)
+      raise 'id already set' if @id
+      @id = id
+    end
+
+    def id
+      @id or raise 'id not set'
+    end
+  end
+end

data/lib/pipe_rpc/client_request_error_response.rb

@@ -0,0 +1,53 @@
+class PipeRpc::ErrorResponse; end
+
+module PipeRpc
+  class Client::Request::ErrorResponse < ErrorResponse
+    def initialize(request, body)
+      @request = request
+      super body
+    end
+
+    def to_result
+      case @code
+      when -32601 then no_method_error
+      when -32602 then argument_error
+      when -32603 then internal_error
+      when -32604 then no_server_error
+      when -32605 then reflected_error
+      else unknown_error
+      end
+    end
+
+    private
+
+    def no_method_error
+      method = @data.fetch(:method)
+      args = @data.fetch(:args)
+      NoMethodError.new("undefined method `#{method}' for <Client:#{@request.server}>", method, args)
+    end
+
+    def argument_error
+      ArgumentError.new(@data.fetch(:message))
+    end
+
+    def no_server_error
+      NoServerError.new("undefined server `#{@request.server}'")
+    end
+
+    def internal_error
+      InternalError.new(@data[:message]).tap do |error|
+        error.set_backtrace(@data[:backtrace]) if error.respond_to? :set_backtrace
+      end
+    end
+
+    def reflected_error
+      ReflectedError.new(@data[:message]).tap do |error|
+        error.set_backtrace(@data[:backtrace]) if error.respond_to? :set_backtrace
+      end
+    end
+
+    def unknown_error
+      UnknownError.new(@data[:message])
+    end
+  end
+end

data/lib/pipe_rpc/client_request_response.rb

@@ -0,0 +1,26 @@
+module PipeRpc
+  class Client::Request
+    class Response
+      def initialize(hub, body)
+        @hub = hub
+        @body = body
+      end
+
+      attr_reader :body
+
+      def result?
+        @body.has_key? :result
+      end
+
+      def error?
+        @body.has_key? :error
+      end
+
+      def handle
+        type = result? ? ResultResponse : ErrorResponse
+        result = type.new(@hub.requests[@body[:id]], @body).to_result
+        @hub.requests.inject_result_for(@body[:id], result)
+      end
+    end
+  end
+end

data/lib/pipe_rpc/client_request_result.rb

@@ -0,0 +1,25 @@
+module PipeRpc
+  class Client::Request::Result
+    def initialize(request)
+      @request = request
+    end
+
+    def value=(result)
+      @received = true
+      @value = result
+    end
+
+    def received?
+      @received
+    end
+
+    def value
+      if @value.is_a? Exception
+        @value.set_backtrace(@value.backtrace.to_a + @request.stacktrace) if @value.respond_to? :set_backtrace
+        raise @value
+      else
+        @value
+      end
+    end
+  end
+end

data/lib/pipe_rpc/client_request_result_response.rb

@@ -0,0 +1,14 @@
+class PipeRpc::ResultResponse; end
+
+module PipeRpc
+  class Client::Request::ResultResponse < ResultResponse
+    def initialize(request, body)
+      @request = request
+      super body
+    end
+
+    def to_result
+      result
+    end
+  end
+end

data/lib/pipe_rpc/error.rb

@@ -1,7 +1,14 @@
 module PipeRpc
   class Error < RuntimeError; end
-  class InternalError < Error; end
+  class ClosedError < Error; end
+  class UnknownError < Error; end
+
+  class MessageError < Error; end
+  class MessageParseError < MessageError; end
+  class InvalidMessageError < MessageError; end
+
+  class NoRequestForResponseError < Error; end
   class NoServerError < Error; end
+  class InternalError < Error; end
   class ReflectedError < Error; end
-  class CanceledError < Error; end
 end

data/lib/pipe_rpc/error_response.rb

@@ -5,7 +5,7 @@ module PipeRpc
       error = args.fetch(:error)
       @code = error.fetch(:code)
       @message = msg_for(@code) || error.fetch(:message, 'Unknown error')
-      @data = error.fetch(:data, nil)
+      @data = error.fetch(:data, {})
     end
 
     attr_reader :id, :code, :message, :data
@@ -14,15 +14,6 @@ module PipeRpc
       { id: id, error: { code: code, message: message, data: data } }
     end
 
-    def native_error(request = nil)
-      @request = request
-      error_for(@code)
-    end
-
-    def result_for(*args)
-      native_error(*args)
-    end
-
     private
 
     def msg_for(code)
@@ -37,41 +28,5 @@ module PipeRpc
       else nil
       end
     end
-
-    def error_for(code)
-      case code
-      when -32601 then no_method_error
-      when -32602 then argument_error
-      when -32604 then no_server_error
-      when -32605 then reflected_error
-      else internal_error
-      end
-    end
-
-    def no_method_error
-      method = @data.fetch(:method)
-      args = @data.fetch(:args)
-      NoMethodError.new("undefined method `#{method}' for <Client:#{@request.server}>", method, args)
-    end
-
-    def argument_error
-      ArgumentError.new(@data.fetch(:message))
-    end
-
-    def no_server_error
-      NoServerError.new("undefined server `#{@request.server}'")
-    end
-
-    def internal_error
-      InternalError.new(@data[:message]).tap do |error|
-        error.set_backtrace(@data[:backtrace]) if error.respond_to? :set_backtrace
-      end
-    end
-
-    def reflected_error
-      ReflectedError.new("#{@data[:message]}").tap do |error|
-        error.set_backtrace(@data[:backtrace]) if error.respond_to? :set_backtrace
-      end
-    end
   end
 end

data/lib/pipe_rpc/gateway.rb

@@ -0,0 +1,39 @@
+module PipeRpc
+  class Gateway
+    def initialize(args)
+      @hub = Hub.new(args)
+    end
+
+    def channel
+      @hub.channel
+    end
+
+    def servers
+      @hub.servers
+    end
+
+    def clients
+      @hub.clients
+    end
+
+    def loop_iteration=(iteration)
+      @hub.requests.wait_for_results_through(iteration)
+    end
+
+    def on_sent(&on_sent)
+      @hub.socket.on_sent(&on_sent)
+    end
+
+    def on_received(&on_received)
+      @hub.socket.on_received(&on_received)
+    end
+
+    def close
+      @hub.socket.close
+    end
+
+    def handle_message
+      @hub.handle_message
+    end
+  end
+end

data/lib/pipe_rpc/hub.rb

@@ -3,111 +3,15 @@ module PipeRpc
     def initialize(args)
       @channel = args[:input]
       @socket = Socket.new(self, args)
-      @requester = Requester.new(self)
-      @responder = Responder.new(self)
-      @clients = {}
-      self.loop_iteration = nil
+      @requests = Requests.new(self)
+      @servers = Servers.new
+      @clients = Clients.new(self)
     end
 
-    attr_reader :channel
-    attr_accessor :logger
-
-    def log(msg)
-      if logger == :reflect
-        notify(server: :reflect_logger, method: :log, arguments: [msg])
-      elsif logger.respond_to? :debug
-        logger.debug msg
-      elsif logger
-        logger.call msg
-      end
-    end
-
-    def add_server(servers)
-      @responder.add_server(servers)
-    end
-
-    def rmv_server(server_name)
-      @responder.rmv_server(server_name)
-    end
-
-    def on_incoming_request(&on_request)
-      @responder.on_request(&on_request)
-    end
-
-    def client_for(server_name)
-      @clients[server_name] ||= Client.new(self, server: server_name)
-    end
-
-    def loop_iteration=(proc)
-      @loop_iteration = proc
-    end
-
-    def on_sent(&on_sent)
-      @socket.on_write(&on_sent)
-    end
-
-    def on_received(&on_received)
-      @socket.on_read(&on_received)
-    end
-
-    def notify(signature)
-      @socket.write @requester.notification(signature)
-    end
-
-    def cancel
-      @socket.close
-      @canceled = true
-    end
-
-    def request(signature, &on_result)
-      raise CanceledError.new if @canceled
-
-      result = nil
-      result_ready = false
-
-      request = @requester.request(signature) do |*response|
-        result = on_result.call(*response)
-        result_ready = true
-      end
-      @socket.write request
-
-      loop do
-        raise CanceledError.new if @canceled
-        return result if result_ready
-        @loop_iteration ? @loop_iteration.call : handle_message
-      end
-    end
-
-    def send_response(response)
-      @socket.write response
-    end
+    attr_reader :channel, :servers, :clients, :requests, :socket
 
     def handle_message
-      message = next_message # blocks
-
-      return unless message
-
-      if message.notification?
-        @responder.handle_notification(message.handler)
-      elsif message.request?
-        @responder.handle_request(message.handler)
-      elsif message.response?
-        @requester.handle_response(message.handler)
-      elsif message.error?
-        raise message.handler.native_error
-      else
-        send_response ErrorResponse.new(id: nil, error: { code: -32600,
-              data: { message: 'no request, result or error' } })
-      end
-    end
-
-    private
-
-    def next_message
-      Message.new(self, @socket.read) # blocks
-    rescue => e
-      send_response ErrorResponse.new(id: nil, error: { code: -32700, data: { message: e.message } })
-      nil
+      Message.new(self, @socket.read).handle
     end
   end
 end

data/lib/pipe_rpc/hub_clients.rb

@@ -0,0 +1,12 @@
+module PipeRpc
+  class Hub::Clients
+    def initialize(hub)
+      @hub = hub
+      @clients = {}
+    end
+
+    def [](server)
+      @clients[server.to_sym] ||= Client.new(server.to_sym, @hub)
+    end
+  end
+end

data/lib/pipe_rpc/hub_message.rb

@@ -0,0 +1,48 @@
+module PipeRpc
+  class Hub
+    class Message
+      def initialize(hub, body)
+        @hub = hub
+        @body = body
+      end
+
+      def request?
+        @body.has_key? :method
+      end
+
+      def response?
+        (@body.has_key? :error or @body.has_key? :result) and !!@body[:id]
+      end
+
+      def error?
+        @body.has_key? :error and @body[:id].nil?
+      end
+
+      def handler_type
+        if request?
+          Hub::Request
+        elsif response?
+          Client::Request::Response
+        elsif error?
+          Message::ErrorResponse
+        else
+          raise 'no request, result or error'
+        end
+      end
+
+      def handler
+        handler_type.new(@hub, @body)
+      rescue => e
+        @hub.socket.write ErrorResponse.new(id: @body[:id], error: { code: -32600,
+              data: { message: e.message } })
+        nil
+      end
+
+      def handle
+        handler.tap do |handler|
+          handler.handle if handler
+        end
+      end
+    end
+  end
+end

data/lib/pipe_rpc/hub_message_error_response.rb

@@ -0,0 +1,22 @@
+class PipeRpc::ErrorResponse; end
+
+module PipeRpc
+  class Hub::Message::ErrorResponse < ErrorResponse
+    def initialize(hub, body)
+      @hub = hub
+      super body
+    end
+
+    def to_error
+      case @code
+      when -32700 then MessageParseError.new(@data.fetch(:message))
+      when -32600 then InvalidMessageError.new(@data.fetch(:message))
+      else UnknownError.new(@data[:message])
+      end
+    end
+
+    def handle
+      raise to_error
+    end
+  end
+end

data/lib/pipe_rpc/hub_request.rb

@@ -0,0 +1,34 @@
+class PipeRpc::Request; end
+
+module PipeRpc
+  class Hub::Request < Request
+    def initialize(hub, body)
+      @hub = hub
+      super body
+    end
+
+    CALL_FILE, CALL_LINENO = __FILE__, __LINE__+4
+    def handle
+      evaluate_result do
+        # the block is passed for asynchronous evaluation
+        @hub.servers[server].__send__(method, *arguments, &evaluate_result_proc)
+      end
+    end
+
+    def evaluate_result(result = nil, &block)
+      result = Result.new(self, block_given? ? yield : result)
+    rescue Exception => e
+      result = ErrorResult.new(self, e)
+    ensure
+      asynchronous = result.value == evaluate_result_proc
+      @hub.socket.write(result.to_response) unless asynchronous
+      return result.value
+    end
+
+    def evaluate_result_proc
+      @evaluate_result_proc ||= proc do |result = nil, &block|
+        evaluate_result(result, &block)
+      end
+    end
+  end
+end

data/lib/pipe_rpc/{hub/responder/request/error.rb → hub_request_error.rb}

@@ -1,5 +1,5 @@
 module PipeRpc
-  class Hub::Responder::Request
+  class Hub::Request
     class Error
       def initialize(error)
         @error = error
@@ -13,8 +13,7 @@ module PipeRpc
         when method_call_error? && NoMethodError then -32601
         when method_call_error? && ArgumentError then -32602
         when InternalError then -32605
-        when StandardError then -32603
-        else nil
+        else -32603
         end
       end
 

data/lib/pipe_rpc/{hub/responder/request/error_result.rb → hub_request_error_result.rb}

@@ -1,5 +1,5 @@
 module PipeRpc
-  class Hub::Responder::Request
+  class Hub::Request
     class ErrorResult
       def initialize(request, error)
         @request, @error = request, Error.new(error)
@@ -9,10 +9,6 @@ module PipeRpc
         @error.error
       end
 
-      def asynchronous?
-        false
-      end
-
       def to_response
         ErrorResponse.new(id: @request.id, error: { code: @error.code, data: { message: @error.message,
             backtrace: @error.backtrace, method: @request.method, args: @request.arguments } })

data/lib/pipe_rpc/{hub/responder/request/result.rb → hub_request_result.rb}

@@ -1,17 +1,13 @@
 module PipeRpc
-  class Hub::Responder::Request::Result
+  class Hub::Request::Result
     def initialize(request, result)
-      @request, @result = request, result
+      @request, @result, @async_responder = request, result
     end
 
     def value
       @result
     end
 
-    def asynchronous?
-      @result == @request.evaluate_result_proc
-    end
-
     def to_response
       ResultResponse.new(id: @request.id, result: @result)
     end

data/lib/pipe_rpc/hub_requests.rb

@@ -0,0 +1,35 @@
+module PipeRpc
+  class Hub::Requests
+    def initialize(hub)
+      @hub = hub
+      @requests ={}
+      @uid = 0
+      wait_for_results_through nil
+    end
+
+    attr_reader :requests
+
+    def evaluate(request)
+      @uid += 1
+      request.id = @uid
+      @requests[@uid] = request
+      @hub.socket.write request
+      @wait.call until request.result.received?
+      request.result.value
+    end
+
+    def [](id)
+      @requests[id]
+    end
+
+    def inject_result_for(id, result)
+      request = @requests.delete(id)
+      raise NoRequestForResponseError.new("no request with id '#{id.inspect}'") unless request
+      request.result.value = result
+    end
+
+    def wait_for_results_through(iteration)
+      @wait = iteration.respond_to?(:call) ? iteration : proc{ @hub.handle_message }
+    end
+  end
+end

data/lib/pipe_rpc/hub_servers.rb

@@ -0,0 +1,19 @@
+module PipeRpc
+  class Hub::Servers
+    def initialize
+      @servers = Hash.new{ |hash, key| raise NoServerError.new("no server #{key}") }
+    end
+
+    def add(servers)
+      servers.each{ |name, server| @servers[name.to_sym] = server }
+    end
+
+    def [](name)
+      @servers[name.to_sym]
+    end
+
+    def remove(name)
+      @servers.delete(name.to_sym)
+    end
+  end
+end

data/lib/pipe_rpc/hub_socket.rb

@@ -0,0 +1,40 @@
+module PipeRpc
+  class Hub::Socket
+    def initialize(hub, args = {})
+      @hub = hub
+      @input = args.fetch(:input)
+      @output = args.fetch(:output)
+      @on_sent = []
+      @on_received = []
+    end
+
+    def read
+      raise ClosedError if @input.closed?
+      incoming = Incoming.new(@input.gets) # blocks
+      incoming.trigger(@on_received)
+      incoming.to_h
+    rescue JSON::JSONError => e
+      write ErrorResponse.new(id: nil, error: { code: -32700, data: { message: e.message } })
+    end
+
+    def write(obj)
+      raise ClosedError if @output.closed?
+      outgoing = Outgoing.new(obj)
+      outgoing.trigger(@on_sent)
+      @output.puts outgoing.to_payload
+    end
+
+    def on_sent(&on_sent)
+      @on_sent << on_sent
+    end
+
+    def on_received(&on_received)
+      @on_received << on_received
+    end
+
+    def close
+      @input.close
+      @output.close
+    end
+  end
+end

data/lib/pipe_rpc/hub_socket_incoming.rb

@@ -0,0 +1,20 @@
+module PipeRpc
+  class Hub::Socket
+    class Incoming
+      def initialize(payload)
+        @payload = payload
+      end
+
+      def to_h
+        @hash ||= JSON.load(@payload).symbolize_keys.tap do |hash|
+          hash[:error] = hash[:error].symbolize_keys if hash[:error]
+          hash[:error][:data] = hash[:error][:data].symbolize_keys if hash[:error] and hash[:error][:data]
+        end
+      end
+
+      def trigger(callbacks)
+        callbacks.each{ |callback| callback.call(to_h) }
+      end
+    end
+  end
+end

data/lib/pipe_rpc/hub_socket_outgoing.rb

@@ -0,0 +1,21 @@
+module PipeRpc
+  class Hub::Socket
+    class Outgoing
+      def initialize(object)
+        @object = object
+      end
+
+      def to_h
+        @hash ||= @object.to_h
+      end
+
+      def to_payload
+        @payload ||= JSON.dump(to_h)
+      end
+
+      def trigger(callbacks)
+        callbacks.each{ |callback| callback.call(to_h) }
+      end
+    end
+  end
+end

data/lib/pipe_rpc/result_response.rb

@@ -7,10 +7,6 @@ module PipeRpc
 
     attr_reader :result, :id
 
-    def result_for(request)
-      result
-    end
-
     def to_h
       { id: id, result: result }
     end

data/lib/pipe_rpc/version.rb

@@ -1,3 +1,3 @@
 module PipeRpc
-  VERSION = "0.3.2"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pipe_rpc
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Christopher Aue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-04 00:00:00.000000000 Z
+date: 2016-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -99,19 +99,29 @@ files:
 - lib/hash.rb
 - lib/pipe_rpc.rb
 - lib/pipe_rpc/client.rb
+- lib/pipe_rpc/client_request.rb
+- lib/pipe_rpc/client_request_error_response.rb
+- lib/pipe_rpc/client_request_response.rb
+- lib/pipe_rpc/client_request_result.rb
+- lib/pipe_rpc/client_request_result_response.rb
 - lib/pipe_rpc/error.rb
 - lib/pipe_rpc/error_response.rb
+- lib/pipe_rpc/gateway.rb
 - lib/pipe_rpc/hub.rb
-- lib/pipe_rpc/hub/message.rb
-- lib/pipe_rpc/hub/requester.rb
-- lib/pipe_rpc/hub/responder.rb
-- lib/pipe_rpc/hub/responder/request.rb
-- lib/pipe_rpc/hub/responder/request/error.rb
-- lib/pipe_rpc/hub/responder/request/error_result.rb
-- lib/pipe_rpc/hub/responder/request/result.rb
+- lib/pipe_rpc/hub_clients.rb
+- lib/pipe_rpc/hub_message.rb
+- lib/pipe_rpc/hub_message_error_response.rb
+- lib/pipe_rpc/hub_request.rb
+- lib/pipe_rpc/hub_request_error.rb
+- lib/pipe_rpc/hub_request_error_result.rb
+- lib/pipe_rpc/hub_request_result.rb
+- lib/pipe_rpc/hub_requests.rb
+- lib/pipe_rpc/hub_servers.rb
+- lib/pipe_rpc/hub_socket.rb
+- lib/pipe_rpc/hub_socket_incoming.rb
+- lib/pipe_rpc/hub_socket_outgoing.rb
 - lib/pipe_rpc/request.rb
 - lib/pipe_rpc/result_response.rb
-- lib/pipe_rpc/socket.rb
 - lib/pipe_rpc/version.rb
 - pipe_rpc.gemspec
 homepage: https://github.com/christopheraue/ruby-pipe_rpc

data/lib/pipe_rpc/hub/message.rb

@@ -1,57 +0,0 @@
-module PipeRpc
-  class Hub
-    class Message
-      def initialize(hub, message)
-        @hub = hub
-        @message = message
-      end
-
-      def notification?
-        @message.has_key? :method and not id?
-      end
-
-      def request?
-        @message.has_key? :method and id?
-      end
-
-      def response?
-        (result? or error_message?) and id?
-      end
-
-      def error?
-        error_message? and not id?
-      end
-
-      def handler
-        @handler ||= type.new(@message)
-      rescue => e
-        @hub.send_response ErrorResponse.new(id: nil, error: { code: -32600, data: { message: e.message } })
-        nil
-      end
-
-      private
-
-      def result?
-        @message.has_key? :result
-      end
-
-      def error_message?
-        @message.has_key? :error
-      end
-
-      def type
-        if error_message?
-          ErrorResponse
-        elsif result?
-          ResultResponse
-        else
-          Request
-        end
-      end
-
-      def id?
-        not @message[:id].nil?
-      end
-    end
-  end
-end

data/lib/pipe_rpc/hub/requester.rb

@@ -1,31 +0,0 @@
-module PipeRpc
-  class Hub
-    class Requester
-      def initialize(hub)
-        @hub = hub
-        @requests = {}
-        @uid = 0
-      end
-
-      def next_uid
-        @uid += 1
-      end
-
-      def notification(signature)
-        Request.new(signature)
-      end
-
-      def request(signature, &on_response)
-        request = Request.new(signature.merge(id: next_uid))
-        @requests[request.id] = { request: request, on_response: on_response }
-        request
-      end
-
-      def handle_response(response)
-        request = @requests.delete(response.id)
-        raise InternalError.new("no request for response(id: #{response.id})") unless request
-        request[:on_response].call response.result_for(request[:request])
-      end
-    end
-  end
-end

data/lib/pipe_rpc/hub/responder/request.rb

@@ -1,35 +0,0 @@
-module PipeRpc
-  class Hub::Responder
-    class Request
-      def initialize(responder, request)
-        @responder, @request = responder, request
-      end
-
-      def id
-        @request.id
-      end
-
-      CALL_FILE, CALL_LINENO = __FILE__, __LINE__+3
-      def handle
-        evaluate_result do
-          @responder.servers[@request.server].__send__(@request.method, *@request.arguments, &evaluate_result_proc)
-        end
-      end
-
-      def evaluate_result(result = nil, &block)
-        result = Result.new(self, block_given? ? yield : result)
-      rescue Exception => e
-        result = ErrorResult.new(@request, e)
-      ensure
-        @responder.send_response(result.to_response) unless result.asynchronous?
-        return result.value
-      end
-
-      def evaluate_result_proc
-        @evaluate_result_proc ||= proc do |result = nil, &block|
-          evaluate_result(result, &block)
-        end
-      end
-    end
-  end
-end

data/lib/pipe_rpc/hub/responder.rb

@@ -1,39 +0,0 @@
-module PipeRpc
-  class Hub
-    class Responder
-      def initialize(hub)
-        @hub = hub
-        @servers = Hash.new{ |hash, key| ::Kernel.raise NoServerError.new("no server #{key}") }
-      end
-
-      def servers
-        @servers.dup
-      end
-
-      def add_server(servers)
-        servers.each{ |name, server| @servers[name.to_sym] = server }
-      end
-
-      def rmv_server(server_name)
-        @servers.delete(server_name.to_sym)
-      end
-
-      def on_request(&on_request)
-        @on_request = on_request
-      end
-
-      def handle_notification(notification)
-        handle_request(notification)
-      end
-
-      def handle_request(request)
-        @on_request.call(request.server, request.method, request.arguments) if @on_request
-        Request.new(self, request).handle
-      end
-
-      def send_response(response)
-        @hub.send_response response
-      end
-    end
-  end
-end

data/lib/pipe_rpc/socket.rb

@@ -1,50 +0,0 @@
-module PipeRpc
-  class Socket
-    def initialize(hub, args = {})
-      @hub = hub
-      @input = args.fetch(:input)
-      @output = args.fetch(:output)
-      on_write{}
-      on_read{}
-    end
-
-    def read
-      symbolize_message_keys(JSON.load(@input.gets)).tap do |message|
-        next if message[:server] == 'reflect_logger'
-        @hub.log "received: #{message.inspect}"
-        @on_read.call(message)
-      end
-    end
-
-    def write(obj)
-      raise InternalError.new('Output pipe broke') if @output.closed?
-      @output.puts(JSON.dump(obj.to_h.tap do |message|
-        next if @hub.logger == :reflect
-        @hub.log "sent: #{message.inspect}"
-        @on_write.call(message)
-      end))
-    end
-
-    def on_write(&on_write)
-      @on_write = on_write || proc{}
-    end
-
-    def on_read(&on_read)
-      @on_read = on_read || proc{}
-    end
-
-    def close
-      @input.close
-      @output.close
-    end
-
-    private
-
-    def symbolize_message_keys(message)
-      hash = message.symbolize_keys
-      hash[:error] = hash[:error].symbolize_keys if hash[:error]
-      hash[:error][:data] = hash[:error][:data].symbolize_keys if hash[:error] and hash[:error][:data]
-      hash
-    end
-  end
-end