protobuf 3.6.12 → 3.7.0.pre0

data/lib/protobuf/field/enum_field.rb

@@ -1,8 +1,8 @@
-require 'protobuf/field/varint_field'
+require 'protobuf/field/integer_field'
 
 module Protobuf
   module Field
-    class EnumField < VarintField
+    class EnumField < IntegerField
 
       ##
       # Class Methods
@@ -25,36 +25,26 @@ module Protobuf
       end
 
       def decode(value)
-        value if acceptable?(value)
+        decoded = super(value)
+        decoded if acceptable?(decoded)
       end
 
       def enum?
         true
       end
 
+      def coerce!(value)
+        enum_value = type_class.fetch(value)
+        fail TypeError, "Invalid Enum value: #{value.inspect} for #{name}" unless enum_value
+        enum_value
+      end
+
       private
 
       ##
       # Private Instance Methods
       #
 
-      def define_setter
-        field = self
-        message_class.class_eval do
-          define_method("#{field.name}=") do |value|
-            orig_value = value
-            if value.nil?
-              @values.delete(field.name)
-            else
-              value = field.type_class.fetch(value)
-              fail TypeError, "Invalid Enum value: #{orig_value.inspect} for #{field.name}" unless value
-
-              @values[field.name] = value
-            end
-          end
-        end
-      end
-
       def typed_default_value
         if default.is_a?(Symbol)
           type_class.const_get(default)

data/lib/protobuf/field/message_field.rb

@@ -9,7 +9,7 @@ module Protobuf
       #
 
       def acceptable?(val)
-        val.is_a?(type_class) || val.respond_to?(:to_hash)
+        val.is_a?(type_class) || val.respond_to?(:to_hash) || val.respond_to?(:to_proto)
       end
 
       def decode(bytes)
@@ -30,30 +30,20 @@ module Protobuf
         ::Protobuf::WireType::LENGTH_DELIMITED
       end
 
-      private
+      def coerce!(value)
+        return nil if value.nil?
 
-      ##
-      # Private Instance Methods
-      #
+        coerced_value = if value.respond_to?(:to_proto)
+                          value.to_proto
+                        elsif value.respond_to?(:to_hash)
+                          type_class.new(value.to_hash)
+                        else
+                          value
+                        end
+
+        return coerced_value if coerced_value.is_a?(type_class)
 
-      def define_setter
-        field = self
-        message_class.class_eval do
-          define_method("#{field.name}=") do |val|
-            case
-            when val.nil?
-              @values.delete(field.name)
-            when val.is_a?(field.type_class)
-              @values[field.name] = val
-            when val.respond_to?(:to_proto)
-              @values[field.name] = val.to_proto
-            when val.respond_to?(:to_hash)
-              @values[field.name] = field.type_class.new(val.to_hash)
-            else
-              fail TypeError, "Expected value of type '#{field.type_class}' for field #{field.name}, but got '#{val.class}'"
-            end
-          end
-        end
+        fail TypeError, "Expected value of type '#{type_class}' for field #{name}, but got '#{value.class}'"
       end
 
     end

data/lib/protobuf/generators/enum_generator.rb

@@ -32,6 +32,7 @@ module Protobuf
 
       def build_value(enum_value_descriptor)
         name = enum_value_descriptor.name
+        name.upcase! if ENV.key?('PB_UPCASE_ENUMS')
         number = enum_value_descriptor.number
         "define :#{name}, #{number}"
       end

data/lib/protobuf/generators/field_generator.rb

@@ -20,7 +20,13 @@ module Protobuf
       attr_reader :field_options
 
       def applicable_options
-        @applicable_options ||= field_options.map { |k, v| ":#{k} => #{v}" }
+        # Note on the strange use of `#inspect`:
+        #   :boom.inspect #=> ":boom"
+        #   :".boom.foo".inspect #=> ":\".boom.foo\""
+        # An alternative to `#inspect` would be always adding double quotes,
+        # but the generatated code looks un-idiomatic:
+        #   ":\"#{:boom}\"" #=> ":\"boom\"" <-- Note the unnecessary double quotes
+        @applicable_options ||= field_options.map { |k, v| "#{k.inspect} => #{v}" }
       end
 
       def default_value
@@ -64,7 +70,7 @@ module Protobuf
       end
 
       def name
-        @name ||= ":#{descriptor.name}"
+        @name ||= descriptor.name.to_sym.inspect
       end
 
       def number

data/lib/protobuf/generators/file_generator.rb

@@ -64,6 +64,11 @@ module Protobuf
       # the value is an array of field descriptors.
       #
       def map_extensions(descriptor, namespaces)
+        if fully_qualified_token?(descriptor.name)
+          fully_qualified_namespace = descriptor.name
+        elsif !(namespace = namespaces.reject(&:empty?).join(".")).empty?
+          fully_qualified_namespace = ".#{namespace}"
+        end
         # Record all the message descriptor name's we encounter (should be the whole tree).
         if descriptor.is_a?(::Google::Protobuf::DescriptorProto)
           if fully_qualified_token?(descriptor.name)
@@ -75,6 +80,9 @@ module Protobuf
         end
 
         descriptor.extension.each do |field_descriptor|
+          unless fully_qualified_token?(field_descriptor.name) && fully_qualified_namespace
+            field_descriptor.name = "#{fully_qualified_namespace}.#{field_descriptor.name}"
+          end
           @extension_fields[field_descriptor.extendee] << field_descriptor
         end
 

data/lib/protobuf/generators/service_generator.rb

@@ -15,10 +15,10 @@ module Protobuf
       end
 
       def build_method(method_descriptor)
-        name = method_descriptor.name
         request_klass = modulize(method_descriptor.input_type)
         response_klass = modulize(method_descriptor.output_type)
-        "rpc :#{name.underscore}, #{request_klass}, #{response_klass}"
+        name = ENV.key?('PB_USE_RAW_RPC_NAMES') ? method_descriptor.name : method_descriptor.name.underscore
+        "rpc :#{name}, #{request_klass}, #{response_klass}"
       end
 
     end

data/lib/protobuf/message.rb

@@ -77,14 +77,14 @@ module Protobuf
       return to_enum(:each_field) unless block_given?
 
       self.class.all_fields.each do |field|
-        value = __send__(field.getter)
+        value = self[field.name]
         yield(field, value)
       end
     end
 
     def each_field_for_serialization
       self.class.all_fields.each do |field|
-        value = @values[field.getter]
+        value = @values[field.fully_qualified_name]
         if value.nil?
           fail ::Protobuf::SerializationError, "Required field #{self.class.name}##{field.name} does not have a value." if field.required?
           next
@@ -95,13 +95,15 @@ module Protobuf
     end
 
     def field?(name)
-      @values.key?(name)
+      field = self.class.get_field(name, true)
+      return false if field.nil?
+      @values.key?(field.fully_qualified_name)
     end
     ::Protobuf.deprecator.define_deprecated_methods(self, :has_field? => :field?)
 
     def inspect
       attrs = self.class.fields.map do |field|
-        [field.name, send(field.name).inspect].join('=')
+        [field.name, self[field.name].inspect].join('=')
       end.join(' ')
 
       "#<#{self.class} #{attrs}>"
@@ -113,7 +115,7 @@ module Protobuf
 
     def respond_to_has_and_present?(key)
       respond_to_has?(key) &&
-        (__send__(key).present? || [true, false].include?(__send__(key)))
+        (self[key].present? || [true, false].include?(self[key]))
     end
 
     # Return a hash-representation of the given fields for this message type.
@@ -121,9 +123,10 @@ module Protobuf
       result = {}
 
       @values.each_key do |field_name|
-        value = __send__(field_name)
+        value = self[field_name]
+        field = self.class.get_field(field_name, true)
         hashed_value = value.respond_to?(:to_hash_value) ? value.to_hash_value : value
-        result[field_name] = hashed_value
+        result[field.name] = hashed_value
       end
 
       result
@@ -140,20 +143,52 @@ module Protobuf
     def ==(other)
       return false unless other.is_a?(self.class)
       each_field do |field, value|
-        return false unless value == other.__send__(field.name)
+        return false unless value == other[field.name]
       end
       true
     end
 
     def [](name)
       if (field = self.class.get_field(name, true))
-        __send__(field.getter)
+        if field.repeated?
+          @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(field)
+        elsif @values.key?(field.fully_qualified_name)
+          @values[field.fully_qualified_name]
+        else
+          field.default_value
+        end
+      else
+        fail ArgumentError, "invalid field name=#{name.inspect}"
       end
     end
 
     def []=(name, value)
       if (field = self.class.get_field(name, true))
-        __send__(field.setter, value) unless value.nil?
+        if field.repeated?
+          if value.is_a?(Array)
+            value = value.compact
+          else
+            fail TypeError, <<-TYPE_ERROR
+                Expected repeated value of type '#{field.type_class}'
+                Got '#{value.class}' for repeated protobuf field #{field.name}
+            TYPE_ERROR
+          end
+
+          if value.empty?
+            @values.delete(field.fully_qualified_name)
+          else
+            @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(field)
+            @values[field.fully_qualified_name].replace(value)
+          end
+        else
+          if value.nil?
+            @values.delete(field.fully_qualified_name)
+          elsif field.acceptable?(value)
+            @values[field.fully_qualified_name] = field.coerce!(value)
+          else
+            fail TypeError, "Unacceptable value #{value} for field #{field.name} of type #{field.type_class}"
+          end
+        end
       else
         unless ::Protobuf.ignore_unknown_fields?
           fail ::Protobuf::FieldNotDefinedError, name
@@ -193,9 +228,9 @@ module Protobuf
       object.__send__(:initialize)
       @values.each do |name, value|
         if value.is_a?(::Protobuf::Field::FieldArray)
-          object.__send__(name).replace(value.map { |v| duplicate.call(v) })
+          object[name].replace(value.map { |v| duplicate.call(v) })
         else
-          object.__send__("#{name}=", duplicate.call(value))
+          object[name] = duplicate.call(value)
         end
       end
       object

data/lib/protobuf/message/fields.rb

@@ -1,7 +1,11 @@
+require "set"
+
 module Protobuf
   class Message
     module Fields
 
+      ACCESSOR_SUFFIXES = ["", "=", "!", "?"].freeze
+
       def self.extended(other)
         other.extend(ClassMethods)
         ::Protobuf.deprecator.define_deprecated_methods(
@@ -92,20 +96,88 @@ module Protobuf
           end
         end
 
-        def define_field(rule, type_class, field_name, tag, options)
-          raise_if_tag_collision(tag, field_name)
-          raise_if_name_collision(field_name)
+        def define_field(rule, type_class, fully_qualified_field_name, tag, options)
+          raise_if_tag_collision(tag, fully_qualified_field_name)
+          raise_if_name_collision(fully_qualified_field_name)
+
+          # Determine appropirate accessor for fields depending on name collisions via extensions:
+
+          # Case 1: Base field = "string_field" and no extensions of the same name
+          # Result:
+          #   message.string_field #=> @values["string_field"]
+          #   message[:string_field] #=> @values["string_field"]
+          #   message['string_field'] #=> @values["string_field"]
+
+          # Case 2: Base field = "string_field" and extension 1 = ".my_package.string_field", extension N = ".package_N.string_field"...
+          # Result:
+          #   message.string_field #=> @values["string_field"]
+          #   message[:string_field] #=> @values["string_field"]
+          #   message['string_field'] #=> @values["string_field"]
+          #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
+          #   message['.my_package.string_field']  #=> @values[".my_package.string_field"]
+
+          # Case 3: No base field, extension 1 = ".my_package.string_field", extension 2 = ".other_package.string_field", extension N...
+          # Result:
+          #   message.string_field #=> raise NoMethodError (no simple accessor allowed)
+          #   message[:string_field] #=> raise NoMethodError (no simple accessor allowed)
+          #   message['string_field'] #=> raise NoMethodError (no simple accessor allowed)
+          #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
+          #   message['.my_package.string_field']  #=> @values[".my_package.string_field"]
+          #   message[:'.other_package.string_field'] #=> @values[".other_package.string_field"]
+          #   message['.other_package.string_field']  #=> @values[".other_package.string_field"]
+
+          # Case 4: No base field, extension = ".my_package.string_field", no other extensions
+          # Result:
+          #   message.string_field #=> @values[".my_package.string_field"]
+          #   message[:string_field] #=> @values[".my_package.string_field"]
+          #   message['string_field'] #=> @values[".my_package.string_field"]
+          #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
+          #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
+
+          if options[:extension]
+            base_name = fully_qualified_field_name.to_s.split('.').last.to_sym
+            if field_store[base_name]
+              # Case 3
+              if field_store[base_name].extension?
+                remove_existing_accessors(base_name)
+                simple_name = nil
+              # Case 2
+              else
+                simple_name = nil
+              end
+            # Case 4
+            else
+              simple_name = base_name
+            end
+          else
+            # Case 1
+            simple_name = fully_qualified_field_name
+          end
 
-          field = ::Protobuf::Field.build(self, rule, type_class, field_name, tag, options)
+          field = ::Protobuf::Field.build(self, rule, type_class, fully_qualified_field_name,
+                                          tag, simple_name, options)
           field_store[tag] = field
-          field_store[field_name] = field
-          field_store[field_name.to_s] = field
+          field_store[fully_qualified_field_name.to_sym] = field
+          field_store[fully_qualified_field_name.to_s] = field
+          if simple_name && simple_name != fully_qualified_field_name
+            field_store[simple_name.to_sym] = field
+            field_store[simple_name.to_s] = field
+          end
           # defining a new field for the message will cause cached @all_fields, @extension_fields,
           # and @fields to be incorrect; reset them
           @all_fields = @extension_fields = @fields = nil
+        end
 
-          define_method("#{field_name}!") do
-            @values[field_name]
+        def remove_existing_accessors(accessor)
+          field_store.delete(accessor.to_sym).try(:fully_qualified_name_only!)
+          field_store.delete(accessor.to_s)
+          ACCESSOR_SUFFIXES.each do |modifier|
+            begin
+              remove_method("#{accessor}#{modifier}")
+            # rubocop: disable Lint/HandleExceptions
+            rescue NameError
+              # Do not remove the method
+            end
           end
         end
 

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_data.size
+          @stats.request_size = request_bytes.size
         end
 
         def succeed(response)

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

@@ -29,9 +29,9 @@ module Protobuf
         def timeout
           @timeout ||= begin
             if ::ENV.key?("PB_RPC_PING_PORT_TIMEOUT")
-              ::ENV["PB_RPC_PING_PORT_TIMEOUT"].to_f / 1000
+              ::ENV["PB_RPC_PING_PORT_TIMEOUT"].to_i
             else
-              0.2 # 200 ms
+              5 # 5 seconds
             end
           end
         end

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

@@ -226,7 +226,7 @@ module Protobuf
 
         # Alias for ::Protobuf::Rpc::ServiceDirectory.instance
         def service_directory
-          ::Protobuf::Rpc.service_directory
+          ::Protobuf::Rpc::ServiceDirectory.instance
         end
 
         def snd_timeout

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

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