protobuf 3.10.8 → 3.10.10

data/lib/protobuf/code_generator.rb

@@ -63,7 +63,14 @@ module Protobuf
       def define_set_method!
       end
 
-      def set_without_options(message_instance, bytes)
+      # Same rules as the set methods in BaseFieldObjectDefinitions: a packable
+      # repeated field decodes by the record's wire type, not its declaration.
+      def set_without_options(message_instance, bytes, record_wire_type = nil)
+        if repeated? && packable?
+          return set_packable_without_options(message_instance[name], bytes, record_wire_type)
+        end
+
+        return if record_wire_type && record_wire_type != wire_type
         return message_instance[name] = decode(bytes) unless repeated?
 
         if map?
@@ -75,9 +82,14 @@ module Protobuf
           return hash[entry.key]
         end
 
-        return message_instance[name] << decode(bytes) unless packed?
+        message_instance[name] << decode(bytes)
+      end
+
+      def set_packable_without_options(array, bytes, record_wire_type)
+        record_wire_type ||= packed? ? ::Protobuf::WireType::LENGTH_DELIMITED : wire_type
+        return array << decode(bytes) if record_wire_type == wire_type
+        return unless record_wire_type == ::Protobuf::WireType::LENGTH_DELIMITED
 
-        array = message_instance[name]
         stream = StringIO.new(bytes)
 
         if wire_type == ::Protobuf::WireType::VARINT
@@ -92,7 +104,7 @@ module Protobuf
       # Sets a MessageField that is known to be an option.
       # We must allow fields to be set one at a time, as option syntax allows us to
       # set each field within the option using a separate "option" line.
-      def set_with_options(message_instance, bytes)
+      def set_with_options(message_instance, bytes, record_wire_type = nil)
         if message_instance[name].is_a?(::Protobuf::Message)
           gp = Google::Protobuf
           if message_instance.is_a?(gp::EnumOptions) || message_instance.is_a?(gp::EnumValueOptions) ||
@@ -109,7 +121,7 @@ module Protobuf
           end
         end
 
-        set_without_options(message_instance, bytes)
+        set_without_options(message_instance, bytes, record_wire_type)
       end
       alias_method :set, :set_with_options
 

data/lib/protobuf/decoder.rb

@@ -1,7 +1,8 @@
 module Protobuf
   class Decoder
 
-    # Read bytes from +stream+ and pass to +message+ object.
+    # Read bytes from +stream+ and yield (tag, bytes, wire_type) for each field.
+    # A block that takes only (tag, bytes) still works: blocks drop extra arguments.
     def self.decode_each_field(stream)
       until stream.eof?
         bits = Varint.decode(stream)
@@ -17,12 +18,42 @@ module Protobuf
                   stream.read(8)
                 elsif wire_type == ::Protobuf::WireType::FIXED32
                   stream.read(4)
+                elsif wire_type == ::Protobuf::WireType::START_GROUP
+                  skip_group(stream, tag)
+                  next
                 else
                   fail InvalidWireType, wire_type
                 end
 
-        yield(tag, bytes)
+        yield(tag, bytes, wire_type)
       end
     end
+
+    # Skip a group (wire types 3 and 4), with any groups inside it. This gem
+    # has no group fields, so the rule for an unknown field applies, as in the
+    # reference parsers: skip it. A group without its end raises InvalidWireType.
+    def self.skip_group(stream, group_tag)
+      open_tags = [group_tag]
+      until open_tags.empty?
+        fail InvalidWireType, ::Protobuf::WireType::START_GROUP if stream.eof?
+
+        bits = Varint.decode(stream)
+        wire_type = bits & 0x07
+        tag = bits >> 3
+
+        case wire_type
+        when ::Protobuf::WireType::VARINT then Varint.decode(stream)
+        when ::Protobuf::WireType::LENGTH_DELIMITED then stream.read(Varint.decode(stream))
+        when ::Protobuf::WireType::FIXED64 then stream.read(8)
+        when ::Protobuf::WireType::FIXED32 then stream.read(4)
+        when ::Protobuf::WireType::START_GROUP then open_tags.push(tag)
+        when ::Protobuf::WireType::END_GROUP
+          fail InvalidWireType, wire_type unless open_tags.pop == tag
+        else
+          fail InvalidWireType, wire_type
+        end
+      end
+    end
+    private_class_method :skip_group
   end
 end

data/lib/protobuf/field/base_field.rb

@@ -287,8 +287,8 @@ module Protobuf
       def define_set_method!
         @set_method = if map?
                         OBJECT_MODULE::MapSetMethod.new(self)
-                      elsif repeated? && packed?
-                        OBJECT_MODULE::RepeatedPackedSetMethod.new(self)
+                      elsif repeated? && packable?
+                        OBJECT_MODULE::RepeatedPackableSetMethod.new(self)
                       elsif repeated?
                         OBJECT_MODULE::RepeatedNotPackedSetMethod.new(self)
                       else
@@ -296,8 +296,16 @@ module Protobuf
                       end
       end
 
-      def set(message_instance, bytes)
-        @set_method.call(message_instance, bytes)
+      # Whether the field's type can use the packed encoding (scalar numeric
+      # types). This is about the type, not about the `packed` option.
+      def packable?
+        ::Protobuf::Field::BaseField::PACKED_TYPES.include?(wire_type)
+      end
+
+      # +wire_type+ is the wire type of the record that +bytes+ came from. It is
+      # nil for callers that do not know it; then the field declaration decides.
+      def set(message_instance, bytes, wire_type = nil)
+        @set_method.call(message_instance, bytes, wire_type)
       end
 
       def tag_encoded
@@ -372,7 +380,7 @@ module Protobuf
       end
 
       def validate_packed_field
-        if packed? && ! ::Protobuf::Field::BaseField::PACKED_TYPES.include?(wire_type)
+        if packed? && !packable?
           fail "Can't use packed encoding for '#{type_class}' type"
         end
       end

data/lib/protobuf/field/base_field_object_definitions.rb

@@ -116,9 +116,13 @@ module Protobuf
         def initialize(selph)
           @selph = selph
           @name = selph.name
+          @wire_type = selph.wire_type
         end
 
-        def call(message_instance, bytes)
+        # A record whose wire type differs from the field's is skipped, as the
+        # protobuf spec and the reference parsers do.
+        def call(message_instance, bytes, wire_type = nil)
+          return if wire_type && wire_type != @wire_type
           message_instance.set_field(@name, @selph.decode(bytes), true, @selph)
         end
       end
@@ -127,9 +131,11 @@ module Protobuf
         def initialize(selph)
           @selph = selph
           @name = selph.name
+          @wire_type = selph.wire_type
         end
 
-        def call(message_instance, bytes)
+        def call(message_instance, bytes, wire_type = nil)
+          return if wire_type && wire_type != @wire_type
           hash = message_instance[@name]
           entry = @selph.decode(bytes)
           # decoded value could be nil for an
@@ -139,26 +145,54 @@ module Protobuf
         end
       end
 
+      # Repeated string, bytes, and message fields. These are never packed.
       class RepeatedNotPackedSetMethod
         def initialize(selph)
           @selph = selph
           @name = selph.name
+          @wire_type = selph.wire_type
         end
 
-        def call(message_instance, bytes)
+        def call(message_instance, bytes, wire_type = nil)
+          return if wire_type && wire_type != @wire_type
           message_instance[@name] << @selph.decode(bytes)
         end
       end
 
-      class RepeatedPackedSetMethod
+      # Repeated scalar numeric fields (varint, fixed32, fixed64). The protobuf
+      # spec requires a parser to accept both the packed and the unpacked
+      # encoding, whatever the field declares. The wire type of each record
+      # selects the decoding: LENGTH_DELIMITED is a packed run, and the field's
+      # own wire type is one value. A record without a wire type (an old
+      # caller of BaseField#set) falls back to the declaration.
+      class RepeatedPackableSetMethod
+        LENGTH_DELIMITED = ::Protobuf::WireType::LENGTH_DELIMITED
+
         def initialize(selph)
           @selph = selph
           @name = selph.name
           @wire_type = selph.wire_type
+          @packed = selph.packed?
+        end
+
+        def call(message_instance, bytes, wire_type = nil)
+          # Most common first: one unpacked value, as this gem encodes by default.
+          if wire_type == @wire_type
+            message_instance[@name] << @selph.decode(bytes)
+          elsif wire_type == LENGTH_DELIMITED
+            decode_packed(message_instance[@name], bytes)
+          elsif wire_type.nil?
+            if @packed
+              decode_packed(message_instance[@name], bytes)
+            else
+              message_instance[@name] << @selph.decode(bytes)
+            end
+          end
         end
 
-        def call(message_instance, bytes)
-          array = message_instance[@name]
+        private
+
+        def decode_packed(array, bytes)
           stream = ::StringIO.new(bytes)
 
           if @wire_type == ::Protobuf::WireType::VARINT

data/lib/protobuf/field/bool_field.rb

@@ -38,8 +38,9 @@ module Protobuf
         end
       end
 
+      # Any non-zero varint is true, as in the reference parsers.
       def decode(value)
-        value == ONE
+        value != 0
       end
 
       def encode(value)

data/lib/protobuf/field/int32_field.rb

@@ -16,6 +16,18 @@ module Protobuf
         INT32_MIN
       end
 
+      ##
+      # Public Instance Methods
+      #
+
+      # Keep the low 32 bits, as the reference parsers do. A peer that sends
+      # an int64 or uint64 value for this field (a compatible schema change)
+      # then decodes instead of raising.
+      def decode(value)
+        value &= 0xffff_ffff
+        value >= 0x8000_0000 ? value - 0x1_0000_0000 : value
+      end
+
     end
   end
 end

data/lib/protobuf/field/sint32_field.rb

@@ -16,6 +16,16 @@ module Protobuf
         INT32_MIN
       end
 
+      ##
+      # Public Instance Methods
+      #
+
+      # Keep the low 32 bits before the zigzag decode, as the reference
+      # parsers do. A peer that sends a sint64 value then decodes.
+      def decode(value)
+        super(value & 0xffff_ffff)
+      end
+
     end
   end
 end

data/lib/protobuf/field/uint32_field.rb

@@ -16,6 +16,15 @@ module Protobuf
         0
       end
 
+      ##
+      # Public Instance Methods
+      #
+
+      # Keep the low 32 bits, as the reference parsers do.
+      def decode(value)
+        value & 0xffff_ffff
+      end
+
     end
   end
 end

data/lib/protobuf/generators/printable.rb

@@ -82,12 +82,21 @@ module Protobuf
         when :enum then
           PARENT_CLASS_ENUM
         when :service then
-          PARENT_CLASS_SERVICE
+          service_parent_class
         else
           fail "Unknown parent class type #{type}: #{caller[0..5].join("\n")}"
         end
       end
 
+      # PB_SERVICE_PARENT sets the parent class of generated services, for
+      # example `ApplicationService` or `::Protobuf::Rpc::ApplicationService`.
+      # The parent class must be loaded before the generated file.
+      #
+      def service_parent_class
+        parent = ENV['PB_SERVICE_PARENT'].to_s.strip
+        parent.empty? ? PARENT_CLASS_SERVICE : parent
+      end
+
       # Print a class or module block, indicated by type.
       # If a class, can be given a parent class to inherit from.
       # If a block is given, call the block from within an indent block.

data/lib/protobuf/message/serialization.rb

@@ -38,8 +38,8 @@ module Protobuf
       # Decode the given stream into this message.
       #
       def decode_from(stream)
-        ::Protobuf::Decoder.decode_each_field(stream) do |tag, bytes|
-          set_field_bytes(tag, bytes)
+        ::Protobuf::Decoder.decode_each_field(stream) do |tag, bytes, wire_type|
+          set_field_bytes(tag, bytes, wire_type)
         end
 
         self
@@ -75,9 +75,9 @@ module Protobuf
 
       private
 
-      def set_field_bytes(tag, bytes)
+      def set_field_bytes(tag, bytes, wire_type = nil)
         field = _protobuf_message_field[tag]
-        field.set(self, bytes) if field
+        field.set(self, bytes, wire_type) if field
       end
 
     end

data/lib/protobuf/railtie.rb

@@ -0,0 +1,48 @@
+require 'rails/railtie'
+require 'protobuf/service_loader'
+
+module Protobuf
+  # RPC discovery (`Service.implemented_services`) walks `descendants`, which
+  # only sees loaded classes, and Zeitwerk loads lazily. This railtie loads the
+  # configured services directory one time, when the RPC server is about to
+  # bind. Web, console, and test processes never pay that cost.
+  #
+  # Opt in from config/application.rb:
+  #
+  #   config.protobuf.services_path = 'app/services/rpc'
+  #
+  # A relative path resolves against Rails.root.
+  class Railtie < ::Rails::Railtie
+    config.protobuf = ::ActiveSupport::OrderedOptions.new
+    config.protobuf.services_path = nil
+
+    initializer 'protobuf.load_services' do |app|
+      ::ActiveSupport::Notifications.subscribe('before_server_bind') do
+        ::Protobuf::Railtie.load_services(app)
+      end
+    end
+
+    def self.services_path(app)
+      configured = app.config.protobuf.services_path.to_s
+      return if configured.empty?
+
+      ::File.expand_path(configured, app.root.to_s)
+    end
+
+    def self.load_services(app)
+      path = services_path(app)
+      return unless path && ::File.directory?(path)
+
+      loader = ::Rails.autoloaders.main # nil with the classic autoloader
+      if loader.respond_to?(:eager_load_dir) # Zeitwerk 2.6.2+
+        begin
+          return loader.eager_load_dir(path)
+        rescue ::Zeitwerk::Error
+          # The main autoloader does not manage this path. Fall through.
+        end
+      end
+
+      ::Protobuf::ServiceLoader.load_services(path)
+    end
+  end
+end

data/lib/protobuf/rpc/application_service.rb

@@ -0,0 +1,12 @@
+require 'protobuf/rpc/service'
+
+module Protobuf
+  module Rpc
+    # Base class for application services, like `ApplicationController`.
+    # Filters and `rescue_from` handlers defined here pass to every subclass.
+    # Generate services with `PB_SERVICE_PARENT=::Protobuf::Rpc::ApplicationService`
+    # to inherit from it.
+    class ApplicationService < Service
+    end
+  end
+end

data/lib/protobuf/rpc/buffer.rb

@@ -44,7 +44,7 @@ module Protobuf
         end
       end
 
-      def set_data(data) # rubocop:disable Style/AccessorMethodName
+      def set_data(data) # rubocop:disable Naming/AccessorMethodName
         @data = data.to_s
         @size = @data.size
       end
@@ -61,7 +61,7 @@ module Protobuf
         @flush
       end
 
-      def get_data_size # rubocop:disable Style/AccessorMethodName
+      def get_data_size # rubocop:disable Naming/AccessorMethodName
         if @size == 0 || @data.match(SIZE_REGEX)
           sliced_size = @data.slice!(SIZE_REGEX)
           @size = sliced_size.delete('-').to_i unless sliced_size.nil?

data/lib/protobuf/rpc/service.rb

@@ -1,3 +1,4 @@
+require 'active_support/core_ext/class/subclasses'
 require 'protobuf/logging'
 require 'protobuf/message'
 require 'protobuf/rpc/client'
@@ -65,15 +66,18 @@ module Protobuf
       end
 
       # An array of defined service classes that contain implementation
-      # code
+      # code. Walks the full descendant tree so intermediate parents
+      # (e.g. ApplicationService) don't hide the real services from
+      # discovery.
       def self.implemented_services
-        classes = (subclasses || []).select do |subclass|
+        classes = descendants.select do |subclass|
           subclass.rpcs.any? do |(name, _)|
             subclass.method_defined? name
           end
         end
 
-        classes.map(&:name)
+        # Dev reloads can leave nameless/duplicate classes in `descendants`.
+        classes.map(&:name).compact.uniq
       end
 
       # Shorthand call to configure, passing a string formatted as hostname:port

data/lib/protobuf/rpc/service_filters.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/class/subclasses'
+
 module Protobuf
   module Rpc
     module ServiceFilters
@@ -34,23 +36,51 @@ module Protobuf
           @rescue_filters ||= {}
         end
 
+        # A subclass gets the filters of its parent, so a base class such as
+        # ApplicationService can hold shared filters. A filter that the parent
+        # adds later also goes to existing subclasses (after their own filters).
+        def inherited(subclass)
+          super
+          subclass.inherit_filters_from(self)
+        end
+
         def rescue_from(*ex_klasses, &block)
           options = ex_klasses.last.is_a?(Hash) ? ex_klasses.pop : {}
           callable = options.delete(:with) { block }
           fail ArgumentError, 'Option :with missing from rescue_from options' if callable.nil?
-          ex_klasses.each { |ex_klass| rescue_filters[ex_klass] = callable }
+          ex_klasses.each do |ex_klass|
+            inherited_callable = rescue_filters[ex_klass]
+            rescue_filters[ex_klass] = callable
+            descendants.each do |klass|
+              # A subclass keeps a handler that it defined itself.
+              current = klass.rescue_filters[ex_klass]
+              klass.rescue_filters[ex_klass] = callable if current.nil? || current.equal?(inherited_callable)
+            end
+          end
         end
 
-        private
+        protected
 
-        def define_filter(type, filter, options = {})
+        def inherit_filters_from(parent)
+          parent.filters.each { |type, list| filters[type] = list.dup }
+          parent.defined_filters.each { |type, set| defined_filters[type] = set.dup }
+          rescue_filters.merge!(parent.rescue_filters)
+        end
+
+        def defined_filters
+          @defined_filters ||= Hash.new { |h, k| h[k] = Set.new }
+        end
+
+        def add_filter(type, filter, options)
           return if filter_defined?(type, filter)
           filters[type] << options.merge(:callable => filter)
           remember_filter(type, filter)
         end
 
-        def defined_filters
-          @defined_filters ||= Hash.new { |h, k| h[k] = Set.new }
+        private
+
+        def define_filter(type, filter, options = {})
+          ([self] + descendants).each { |klass| klass.add_filter(type, filter, options) }
         end
 
         # Check to see if the filter has been defined.

data/lib/protobuf/service_loader.rb

@@ -0,0 +1,21 @@
+module Protobuf
+  # Requires every Ruby file below a directory, in sorted order. Protobuf::Railtie
+  # uses it when the main autoloader cannot eager-load the services directory
+  # (classic autoloader, Zeitwerk < 2.6.2, or a path outside the main loader).
+  #
+  # It uses `require`, not `load`. Zeitwerk tracks `require` of the files it
+  # manages, and a file never executes two times.
+  module ServiceLoader
+    DEFAULT_GLOB = '**/*.rb'.freeze
+
+    def self.load_services(path, glob = DEFAULT_GLOB)
+      return [] if path.nil?
+      dir = ::File.expand_path(path.to_s)
+      return [] unless ::File.directory?(dir)
+
+      ::Dir.glob(::File.join(dir, glob)).sort.each do |file|
+        require file
+      end
+    end
+  end
+end

data/lib/protobuf/version.rb

@@ -1,3 +1,3 @@
 module Protobuf
-  VERSION = '3.10.8' # rubocop:disable Style/MutableConstant
+  VERSION = '3.10.10' # rubocop:disable Style/MutableConstant
 end

data/lib/protobuf.rb

@@ -44,6 +44,10 @@ require 'protobuf/enum'
 require 'protobuf/message'
 require 'protobuf/descriptors'
 
+# Rails runs this hook when the application class is defined. That works even
+# when protobuf loads before Rails, as `rpc_server` does.
+::ActiveSupport.on_load(:before_configuration) { require 'protobuf/railtie' }
+
 module Protobuf
 
   class << self
@@ -114,6 +118,7 @@ end
 unless ENV.key?('PB_NO_NETWORKING')
   require 'protobuf/rpc/client'
   require 'protobuf/rpc/service'
+  require 'protobuf/rpc/application_service'
 
   env_connector_type = ENV.fetch('PB_CLIENT_TYPE') do
     :socket

data/protobuf.gemspec

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 $LOAD_PATH.push ::File.expand_path("../lib", __FILE__)
 require "protobuf/version"
 
@@ -19,39 +18,22 @@ require "protobuf/version"
   s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # Hack, as Rails 5 requires Ruby version >= 2.2.2.
-  active_support_max_version = "< 5" if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.2.2")
-  s.add_dependency "activesupport", '>= 3.2', active_support_max_version
+  s.required_ruby_version = '>= 3.1'
+
+  s.add_dependency "activesupport", '>= 6.0'
   s.add_dependency 'middleware'
   s.add_dependency 'thor'
   s.add_dependency 'thread_safe'
 
+  # Ruby 4.0 no longer loads benchmark from the standard library.
+  s.add_development_dependency 'benchmark'
   s.add_development_dependency 'benchmark-ips'
   s.add_development_dependency 'ffi-rzmq'
-  s.add_development_dependency 'rake', '< 11.0' # Rake 11.0.1 removes the last_comment method which rspec-core (< 3.4.4) uses
-  s.add_development_dependency 'rspec', '>= 3.0'
-  s.add_development_dependency "rubocop", "~> 0.38.0"
-  s.add_development_dependency "parser", "2.3.0.6" # Locked this down since 2.3.0.7 causes issues. https://github.com/bbatsov/rubocop/pull/2984
+  s.add_development_dependency 'railties', '>= 6.0'
+  s.add_development_dependency 'rake', '~> 13.0'
+  s.add_development_dependency 'rspec', '~> 3.5'
+  s.add_development_dependency "rubocop", "~> 0.81.0"
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'timecop'
   s.add_development_dependency 'yard'
-
-  # debuggers only work in MRI
-  if RUBY_ENGINE.to_sym == :ruby
-    # we don't support MRI < 1.9.3
-    pry_debugger = if RUBY_VERSION < '2.0.0'
-                     'pry-debugger'
-                   else
-                     'pry-byebug'
-                   end
-
-    s.add_development_dependency pry_debugger
-    s.add_development_dependency 'pry-stack_explorer'
-
-    s.add_development_dependency 'varint'
-    s.add_development_dependency 'ruby-prof'
-  elsif RUBY_PLATFORM =~ /java/i
-    s.add_development_dependency 'fast_blank_java'
-    s.add_development_dependency 'pry'
-  end
 end