pipe_rpc 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2ad289824f7ad565af6f419ddf007c4bd1745e37
-  data.tar.gz: d6511143979b1c2a998eb3072042a596d264307e
+  metadata.gz: 3a46e3217d0a8f86c3f3c550958abff130034dfd
+  data.tar.gz: dc2d57fff58b882edec090d2351508f02bc55705
 SHA512:
-  metadata.gz: a13574ab492318a87acb1c82b5f74eb6a7a4e28e4022106725ce3c405de8a56528d08d54493386b0e5d4fb5e5a025d4d77577c3065aa0cea4081529076380542
-  data.tar.gz: eeeb48e3f988525d562d66a5cd64d3f88d7df8edef572f10d4df391b00a53616e7b08ed9935ccd05923b7321ff60fac816f091f15c0d0dfc1c59cd22335077a6
+  metadata.gz: ccd3933db763f066f5ea5db393030a7acc5c347e3b2382a636a3901415b4619bcc88184ea40e05e9c6c5a0008e78f60fd07896214aefc812c26bc49ad70731d9
+  data.tar.gz: 3a83c2c879e4a7704fae148372aaf732abc31a38ee658fb1fc9ca601f6c80f2760731be6c9f7c55a2805abd578c0f7e655a96660f2eef34d637baaa43ea6b7f6

data/lib/pipe_rpc/error_response.rb

@@ -63,7 +63,7 @@ module PipeRpc
     end
 
     def internal_error
-      InternalError.new("#{@data[:message]}").tap do |error|
+      InternalError.new(@data[:message]).tap do |error|
         error.set_backtrace(@data[:backtrace]) if error.respond_to? :set_backtrace
       end
     end

data/lib/pipe_rpc/hub/message.rb

@@ -25,7 +25,7 @@ module PipeRpc
       def handler
         @handler ||= type.new(@message)
       rescue => e
-        @hub.send_error(id: nil, code: -32600, data: { message: e.message })
+        @hub.send_response ErrorResponse.new(id: nil, error: { code: -32600, data: { message: e.message } })
         nil
       end
 

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

@@ -0,0 +1,44 @@
+module PipeRpc
+  class Hub::Responder::Request
+    class Error
+      def initialize(error)
+        @error = error
+      end
+
+      attr_reader :error
+
+      def code
+        case @error
+        when NoServerError then -32604
+        when method_call_error? && NoMethodError then -32601
+        when method_call_error? && ArgumentError then -32602
+        when InternalError then -32605
+        when StandardError then -32603
+        else nil
+        end
+      end
+
+      def message
+        @error.message
+      end
+
+      def backtrace
+        @error.backtrace.to_a.dup.tap do |backtrace|
+          # In ruby, backtraces of argument errors have the location of the
+          # method definition and not from where it is called as first location
+          # in the backtrace. To normalize argument and no method errors,
+          # remove the first location for argument errors.
+          backtrace.shift if @error.is_a?(ArgumentError) and not Object.const_defined?(:MRUBY_VERSION)
+        end
+      end
+
+      def method_call_error?
+        if Object.const_defined?(:MRUBY_VERSION)
+          backtrace.first.nil?
+        else
+          backtrace.first.split(':').first(2) == [CALL_FILE, CALL_LINENO.to_s]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module PipeRpc
+  class Hub::Responder::Request
+    class ErrorResult
+      def initialize(request, error)
+        @request, @error = request, Error.new(error)
+      end
+
+      def value
+        @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 } })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module PipeRpc
+  class Hub::Responder::Request::Result
+    def initialize(request, result)
+      @request, @result = 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
+  end
+end

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

@@ -0,0 +1,35 @@
+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

@@ -3,7 +3,11 @@ module PipeRpc
     class Responder
       def initialize(hub)
         @hub = hub
-        @servers = {}
+        @servers = Hash.new{ |hash, key| ::Kernel.raise NoServerError.new("no server #{key}") }
+      end
+
+      def servers
+        @servers.dup
       end
 
       def add_server(servers)
@@ -19,71 +23,16 @@ module PipeRpc
       end
 
       def handle_notification(notification)
-        handle_request(notification) {}
-      end
-
-      def handle_request(request, &on_result)
-        id, server, method, args = request.id, @servers[request.server], request.method, request.arguments
-
-        unless server
-          @hub.send_error(id: id, code: -32604)
-          return
-        end
-
-        async = proc do |result|
-          on_result.call ResultResponse.new(id: id, result: result)
-        end
-
-        @on_request.call(server, method, args) if @on_request
-
-        # methods returning the async block as result state that they are asynchronous!
-        method_lineno = __LINE__+1
-        result = server.__send__(method, *args, &async)
-
-        # directly return result for synchronous calls
-        async.call(result) unless result == async
-
-      rescue NoMethodError => e
-        backtrace = e.backtrace.to_a
-        code = itself_caused_no_method_error?(backtrace, method_lineno) ? -32601 : -32603
-        @hub.send_error(id: id, code: code, data: { message: e.message, method: e.name,
-              args: e.args, backtrace: backtrace })
-
-      rescue ArgumentError => e
-        backtrace = e.backtrace.to_a
-        code = itself_caused_argument_error?(backtrace, method_lineno) ? -32602 : -32603
-        @hub.send_error(id: id, code: code, data: { message: e.message, backtrace: backtrace })
-
-      rescue InternalError => e # raised on the other side
-        backtrace = e.backtrace.to_a
-        @hub.send_error(id: id, code: -32605, data: { message: e.message, backtrace: backtrace })
-
-      rescue => e
-        backtrace = e.backtrace.to_a
-        @hub.send_error(id: id, code: -32603, data: { message: e.message, backtrace: backtrace })
-      end
-
-      private
-
-      def itself_caused_no_method_error?(backtrace, ref_lineno)
-        if Object.const_defined?(:MRUBY_VERSION)
-          !backtrace[0]
-        else
-          itself_caused_error?(backtrace[0], ref_lineno)
-        end
+        handle_request(notification)
       end
 
-      def itself_caused_argument_error?(backtrace, ref_lineno)
-        if Object.const_defined?(:MRUBY_VERSION)
-          !backtrace[0]
-        else
-          itself_caused_error?(backtrace[1], ref_lineno)
-        end
+      def handle_request(request)
+        @on_request.call(request.server, request.method, request.arguments) if @on_request
+        Request.new(self, request).handle
       end
 
-      def itself_caused_error?(backtrace_loc, ref_lineno)
-        file, lineno, = backtrace_loc.split(':')
-        (file == __FILE__) and (lineno.to_i == ref_lineno)
+      def send_response(response)
+        @hub.send_response response
       end
     end
   end

data/lib/pipe_rpc/hub.rb

@@ -70,8 +70,8 @@ module PipeRpc
       end
     end
 
-    def send_error(error = {})
-      @socket.write ErrorResponse.new(id: error.delete(:id), error: error)
+    def send_response(response)
+      @socket.write response
     end
 
     def handle_message
@@ -82,13 +82,14 @@ module PipeRpc
       if message.notification?
         @responder.handle_notification(message.handler)
       elsif message.request?
-        @responder.handle_request(message.handler) { |response| @socket.write response }
+        @responder.handle_request(message.handler)
       elsif message.response?
         @requester.handle_response(message.handler)
       elsif message.error?
         raise message.handler.native_error
       else
-        send_error(id: nil, code: -32600, data: { message: 'no request, result or error' })
+        send_response ErrorResponse.new(id: nil, error: { code: -32600,
+              data: { message: 'no request, result or error' } })
       end
     end
 
@@ -97,7 +98,7 @@ module PipeRpc
     def next_message
       Message.new(self, @socket.read) # blocks
     rescue => e
-      send_error(id: nil, code: -32700, data: { message: e.message })
+      send_response ErrorResponse.new(id: nil, error: { code: -32700, data: { message: e.message } })
       nil
     end
   end

data/lib/pipe_rpc/version.rb

@@ -1,3 +1,3 @@
 module PipeRpc
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

data/lib/pipe_rpc.rb

@@ -3,14 +3,6 @@ end
 
 require 'json'
 require_relative 'hash'
-require_relative "pipe_rpc/version"
-require_relative "pipe_rpc/error"
-require_relative "pipe_rpc/request"
-require_relative "pipe_rpc/result_response"
-require_relative "pipe_rpc/error_response"
-require_relative "pipe_rpc/socket"
-require_relative "pipe_rpc/client"
-require_relative "pipe_rpc/hub"
-require_relative "pipe_rpc/hub/message"
-require_relative "pipe_rpc/hub/requester"
-require_relative "pipe_rpc/hub/responder"
+
+lib = File.dirname(__FILE__)
+Dir["#{lib}/pipe_rpc/**/*.rb"].sort.each { |f| require f }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pipe_rpc
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Christopher Aue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-25 00:00:00.000000000 Z
+date: 2016-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -105,6 +105,10 @@ files:
 - 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/request.rb
 - lib/pipe_rpc/result_response.rb
 - lib/pipe_rpc/socket.rb