protobuf 3.6.10 → 3.6.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 35210ca10c85eb3a8f769e223c53420c51d778ba
-  data.tar.gz: 68cd7f756d8e2cacf66ba4bd28f4d51dd83419a9
+  metadata.gz: 6812ca2cb7f6dd5b3f0924e53439a512e13f0da7
+  data.tar.gz: 56d57350ce7fc439d08ae6a14fff625477a03e56
 SHA512:
-  metadata.gz: a3d36aa1c336979c36ef24a3131d59c6013cdd4c87598b913155ab973ef2c9b9b88273c1f3b16a90a5c45d29728df9bd613c89f67d4c624604139553300f879b
-  data.tar.gz: 81c975787fe88dc9eefd228931f02ed7cbedf8a90e75e9f97d5010570175c2d0500d1bfe7d1119f462fb5ffb8b2e5bd03c0d75b0a3d7038a3e0de49c4eaef786
+  metadata.gz: a928049ac386285aa71ac18393aca3e6cbfe781e6a5a3695218d129102e5a9ea6fc2f2e81e2705b5ede7dcb5aa0b75bcf37cb9c03007e2efc63406612e866b31
+  data.tar.gz: a909a515c52c992147e98df9e72bcb985ce1098ebc271471d8138772587d52f1bd843506976bd010007dce6c56bece6ef3cda03aeba92f53981a3361f2442cd0

data/lib/protobuf/rpc/connectors/common.rb

@@ -119,7 +119,7 @@ module Protobuf
         def setup_connection
           initialize_stats
           @request_data = request_bytes
-          @stats.request_size = request_bytes.size
+          @stats.request_size = @request_data.size
         end
 
         def succeed(response)

data/lib/protobuf/rpc/middleware/exception_handler.rb

@@ -11,6 +11,10 @@ module Protobuf
         end
 
         def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
           app.call(env)
         rescue => exception
           log_exception(exception)

data/lib/protobuf/rpc/middleware/logger.rb

@@ -8,6 +8,10 @@ module Protobuf
 
         # TODO: Figure out how to control when logs are flushed
         def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
           instrumenter.start
           instrumenter.flush(env) # Log request stats
 

data/lib/protobuf/rpc/middleware/request_decoder.rb

@@ -11,8 +11,13 @@ module Protobuf
         end
 
         def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
           @env = env
 
+          logger.debug { sign_message("Decoding request: #{env.encoded_request}") }
           env.service_name = service_name
           env.method_name = method_name
           env.request = request
@@ -33,22 +38,15 @@ module Protobuf
         private
 
         def method_name
-          @method_name ||= begin
-            method_name = request_wrapper.method_name.underscore.to_sym
-
-            unless service.rpc_method?(method_name)
-              fail MethodNotFound, "#{service.name}##{method_name} is not a defined RPC method."
-            end
+          return @method_name unless @method_name.nil?
 
-            method_name
-          end
+          @method_name = request_wrapper.method_name.underscore.to_sym
+          fail MethodNotFound, "#{service.name}##{@method_name} is not a defined RPC method." unless service.rpc_method?(@method_name)
+          @method_name
         end
 
         def request
-          @request ||= begin
-            data = request_wrapper.request_proto
-            rpc_method.request_type.decode(data)
-          end
+          @request ||= rpc_method.request_type.decode(request_wrapper.request_proto)
         rescue => exception
           raise BadRequestData, "Unable to decode request: #{exception.message}"
         end
@@ -56,10 +54,7 @@ module Protobuf
         # Decode the incoming request object into our expected request object
         #
         def request_wrapper
-          @request_wrapper ||= begin
-            logger.debug { sign_message("Decoding request: #{env.encoded_request}") }
-            Socketrpc::Request.decode(env.encoded_request)
-          end
+          @request_wrapper ||= Socketrpc::Request.decode(env.encoded_request)
         rescue => exception
           raise BadRequestData, "Unable to decode request: #{exception.message}"
         end

data/lib/protobuf/rpc/middleware/response_encoder.rb

@@ -11,6 +11,10 @@ module Protobuf
         end
 
         def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
           @env = app.call(env)
 
           env.response = response
@@ -41,32 +45,23 @@ module Protobuf
         # Prod the object to see if we can produce a proto object as a response
         # candidate. Validate the candidate protos.
         def response
-          @response ||= begin
-                          candidate = env.response
-                          case
-                          when candidate.is_a?(Message) then
-                            validate!(candidate)
-                          when candidate.respond_to?(:to_proto) then
-                            validate!(candidate.to_proto)
-                          when candidate.respond_to?(:to_hash) then
-                            env.response_type.new(candidate.to_hash)
-                          when candidate.is_a?(PbError) then
-                            candidate
-                          else
-                            validate!(candidate)
-                          end
-                        end
+          return @response unless @response.nil?
+
+          candidate = env.response
+          return @response = validate!(candidate) if candidate.is_a?(Message)
+          return @response = validate!(candidate.to_proto) if candidate.respond_to?(:to_proto)
+          return @response = env.response_type.new(candidate.to_hash) if candidate.respond_to?(:to_hash)
+          return @response = candidate if candidate.is_a?(PbError)
+
+          @response = validate!(candidate)
         end
 
         # Ensure that the response candidate we've been given is of the type
         # we expect so that deserialization on the client side works.
         #
         def validate!(candidate)
-          actual = candidate.class
-          expected = env.response_type
-
-          if expected != actual
-            fail BadResponseProto, "Expected response to be of type #{expected.name} but was #{actual.name}"
+          if candidate.class != env.response_type
+            fail BadResponseProto, "Expected response to be of type #{env.response_type.name} but was #{candidate.class.name}"
           end
 
           candidate

data/lib/protobuf/rpc/service.rb

@@ -119,16 +119,8 @@ module Protobuf
         rpcs.key?(name)
       end
 
-      ##
-      # Instance Methods
-      #
-      # Get a callable object that will be used by the dispatcher
-      # to invoke the specified rpc method. Facilitates callback dispatch.
-      # The returned lambda is expected to be called at a later time (which
-      # is why we wrap the method call).
-      #
-      def callable_rpc_method(method_name)
-        -> { run_filters(method_name) }
+      def call(method_name)
+        run_filters(method_name)
       end
 
       # Response object for this rpc cycle. Not assignable.

data/lib/protobuf/rpc/service_dispatcher.rb

@@ -12,6 +12,10 @@ module Protobuf
       end
 
       def call(env)
+        dup._call(env)
+      end
+
+      def _call(env)
         @env = env
 
         env.response = dispatch_rpc_request
@@ -26,12 +30,10 @@ module Protobuf
 
       # Call the given service method.
       def dispatch_rpc_request
-        unless rpc_service.respond_to?(method_name)
-          fail MethodNotFound, "#{service_name}##{method_name} is not a publicly defined method."
-        end
-
-        rpc_service.callable_rpc_method(method_name).call
+        rpc_service.call(method_name)
         rpc_service.response
+      rescue NoMethodError
+        raise MethodNotFound, "#{service_name}##{method_name} is not a defined RPC method."
       end
 
       def method_name

data/lib/protobuf/rpc/service_filters.rb

@@ -120,15 +120,9 @@ module Protobuf
         # or an object that responds to `call`.
         #
         def invoke_via_if?(_rpc_method, filter)
-          if_check = filter.fetch(:if) { ->(_service) { return true } }
-          do_invoke = case
-                      when if_check.nil?
-                        true
-                      else
-                        call_or_send(if_check)
-                      end
-
-          do_invoke
+          if_check = filter.fetch(:if, nil)
+          return true if if_check.nil?
+          call_or_send(if_check)
         end
 
         # If the target rpc endpoint method is listed in the :only option,
@@ -150,15 +144,9 @@ module Protobuf
         # or an object that responds to `call`.
         #
         def invoke_via_unless?(_rpc_method, filter)
-          unless_check = filter.fetch(:unless) { ->(_service) { return false } }
-          skip_invoke = case
-                        when unless_check.nil?
-                          false
-                        else
-                          call_or_send(unless_check)
-                        end
-
-          !skip_invoke
+          unless_check = filter.fetch(:unless, nil)
+          return true if unless_check.nil?
+          !call_or_send(unless_check)
         end
 
         def rescue_filters
@@ -253,20 +241,10 @@ module Protobuf
         # __send__ assuming that we respond_to it. Return the call's return value.
         #
         def call_or_send(callable, *args, &block)
-          return_value = case
-                         when callable.respond_to?(:call)
-                           callable.call(self, *args, &block)
-                         when respond_to?(callable, true)
-                           __send__(callable, *args, &block)
-                         else
-                           fail "Object #{callable} is not callable"
-                         end
-
-          return_value
+          return callable.call(self, *args, &block) if callable.respond_to?(:call)
+          __send__(callable, *args, &block)
         end
-
       end
-
     end
   end
 end

data/lib/protobuf/version.rb

@@ -1,3 +1,3 @@
 module Protobuf
-  VERSION = '3.6.10'
+  VERSION = '3.6.11'
 end

data/spec/lib/protobuf/rpc/service_dispatcher_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe Protobuf::Rpc::ServiceDispatcher do
     before { allow(rpc_service).to receive(:response).and_return(response) }
 
     it "dispatches the request" do
-      stack_env = subject.call(env)
+      stack_env = subject._call(env)
       expect(stack_env.response).to eq response
     end
 
@@ -42,10 +42,10 @@ RSpec.describe Protobuf::Rpc::ServiceDispatcher do
     end
 
     context "when the given RPC method is implemented and a NoMethodError is raised" do
-      before { allow(rpc_service).to receive(:callable_rpc_method).and_return(-> { rpc_service.__send__(:foo) }) }
+      before { allow(rpc_service).to receive(:call).and_raise(NoMethodError) }
 
       it "raises the exeception" do
-        expect { subject.call(env) }.to raise_exception(NoMethodError)
+        expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::MethodNotFound)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protobuf
 version: !ruby/object:Gem::Version
-  version: 3.6.10
+  version: 3.6.11
 platform: ruby
 authors:
 - BJ Neilsen
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-15 00:00:00.000000000 Z
+date: 2016-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport