protobuf 3.10.9 → 3.10.10

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.9' # 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

@@ -18,15 +18,18 @@ 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 '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"

data/spec/encoding/packed_decoding_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+
+# The protobuf spec: "Protobuf parsers must be able to parse repeated fields
+# that were compiled as packed as if they were not packed, and vice versa."
+# https://protobuf.dev/programming-guides/encoding/#packed
+#
+# proto3 encoders (Go, Java, C++, google-protobuf) pack repeated scalars by
+# default, so these fields must decode packed input although they do not
+# declare `packed`.
+RSpec.describe 'Decoding packed and unpacked repeated scalar fields' do
+  module PackedDecodingSpec
+    class Color < ::Protobuf::Enum
+      define :RED, 0
+      define :GREEN, 1
+      define :BLUE, 2
+    end
+
+    class Unpacked < ::Protobuf::Message
+      optional :string, :name, 15
+      repeated :int32, :r_i32, 21
+      repeated :int64, :r_i64, 22
+      repeated :uint32, :r_u32, 23
+      repeated :uint64, :r_u64, 24
+      repeated :sint32, :r_s32, 25
+      repeated :sint64, :r_s64, 26
+      repeated :bool, :r_b, 27
+      repeated ::PackedDecodingSpec::Color, :r_color, 28
+      repeated :fixed32, :r_f32, 29
+      repeated :fixed64, :r_f64, 30
+      repeated :sfixed32, :r_sf32, 31
+      repeated :sfixed64, :r_sf64, 32
+      repeated :float, :r_flt, 33
+      repeated :double, :r_dbl, 34
+      repeated :string, :r_str, 35
+    end
+
+    class Packed < ::Protobuf::Message
+      repeated :int32, :r_i32, 21, :packed => true
+      repeated :bool, :r_b, 27, :packed => true
+      repeated :double, :r_dbl, 34, :packed => true
+    end
+
+    class Singular < ::Protobuf::Message
+      optional :int32, :i32, 1
+      optional :bool, :b, 7
+      optional :string, :str, 15
+      map :string, :int32, :counts, 16
+    end
+  end
+
+  def tag(field, wire_type)
+    ::Protobuf::Varint.encode((field << 3) | wire_type)
+  end
+
+  def varint(value)
+    ::Protobuf::Varint.encode(value)
+  end
+
+  def len(field, bytes)
+    tag(field, ::Protobuf::WireType::LENGTH_DELIMITED) + varint(bytes.bytesize) + bytes
+  end
+
+  def unpacked_varints(field, values)
+    values.map { |v| tag(field, ::Protobuf::WireType::VARINT) + varint(v) }.join.b
+  end
+
+  # Bytes made by google-protobuf 4.36.2 (proto3, so every repeated scalar is
+  # packed) for:
+  #   r_i32: [1, -1, 300], r_i64: [5, -9_000_000_000],
+  #   r_u32: [0, 4_294_967_295], r_u64: [18_446_744_073_709_551_615],
+  #   r_s32: [-1, 2, -300], r_s64: [-5_000_000_000], r_b: [true, false, true],
+  #   r_color: [GREEN, BLUE], r_f32: [7, 4_294_967_295], r_f64: [8],
+  #   r_sf32: [-7], r_sf64: [-8], r_flt: [1.5, -2.25], r_dbl: [3.5, -0.125]
+  let(:google_protobuf_packed) do
+    hex = 'aa010d01ffffffffffffffffff01ac02b2010b0580ccbbbcdeffffffff01ba010600ffffffff0f' \
+          'c2010affffffffffffffffff01ca01040104d704d20105ffc7afa025da0103010001e201020102' \
+          'ea010807000000fffffffff201080800000000000000fa0104f9ffffff820208f8ffffffffffffff' \
+          '8a02080000c03f000010c09202100000000000000c40000000000000c0bf'
+    [hex].pack('H*')
+  end
+
+  describe 'packed input for fields that do not declare packed' do
+    subject(:message) { PackedDecodingSpec::Unpacked.decode(google_protobuf_packed) }
+
+    {
+      :r_i32 => [1, -1, 300],
+      :r_i64 => [5, -9_000_000_000],
+      :r_u32 => [0, 4_294_967_295],
+      :r_u64 => [18_446_744_073_709_551_615],
+      :r_s32 => [-1, 2, -300],
+      :r_s64 => [-5_000_000_000],
+      :r_b => [true, false, true],
+      :r_f32 => [7, 4_294_967_295],
+      :r_f64 => [8],
+      :r_sf32 => [-7],
+      :r_sf64 => [-8],
+      :r_flt => [1.5, -2.25],
+      :r_dbl => [3.5, -0.125],
+    }.each do |field, expected|
+      it "decodes #{field}" do
+        expect(message.public_send(field).to_a).to eq(expected)
+      end
+    end
+
+    it 'decodes enums' do
+      expect(message.r_color.to_a).to eq([PackedDecodingSpec::Color::GREEN, PackedDecodingSpec::Color::BLUE])
+    end
+
+    it 'decodes the report case: packed bools are not all false' do
+      expect(PackedDecodingSpec::Unpacked.decode(len(27, "\x01".b)).r_b.to_a).to eq([true])
+      expect(PackedDecodingSpec::Unpacked.decode(len(27, "\x01\x01".b)).r_b.to_a).to eq([true, true])
+    end
+
+    it 'decodes the report case: packed int64 does not raise' do
+      expect(PackedDecodingSpec::Unpacked.decode(len(22, "\x05\x09".b)).r_i64.to_a).to eq([5, 9])
+    end
+  end
+
+  describe 'packed records' do
+    it 'concatenates a packed run that is split over two records' do
+      bytes = len(21, "\x01\x02".b) + len(15, 'x') + len(21, "\x03".b)
+      expect(PackedDecodingSpec::Unpacked.decode(bytes).r_i32.to_a).to eq([1, 2, 3])
+    end
+
+    it 'accepts packed and unpacked records for the same field' do
+      bytes = len(21, "\x01\x02".b) + unpacked_varints(21, [3])
+      expect(PackedDecodingSpec::Unpacked.decode(bytes).r_i32.to_a).to eq([1, 2, 3])
+    end
+
+    it 'adds no values for an empty packed record' do
+      expect(PackedDecodingSpec::Unpacked.decode(len(21, ''.b)).r_i32.to_a).to eq([])
+    end
+
+    it 'does not change other fields' do
+      bytes = len(15, 'name') + len(21, "\x01".b) + len(35, 'a') + len(35, 'b')
+      message = PackedDecodingSpec::Unpacked.decode(bytes)
+      expect([message.name, message.r_i32.to_a, message.r_str.to_a]).to eq(['name', [1], %w[a b]])
+    end
+  end
+
+  describe 'unpacked input for fields that declare packed' do
+    it 'decodes varints' do
+      bytes = unpacked_varints(21, [1, 2])
+      expect(PackedDecodingSpec::Packed.decode(bytes).r_i32.to_a).to eq([1, 2])
+    end
+
+    it 'decodes bools' do
+      bytes = unpacked_varints(27, [1, 0])
+      expect(PackedDecodingSpec::Packed.decode(bytes).r_b.to_a).to eq([true, false])
+    end
+
+    it 'decodes fixed64 values' do
+      bytes = [3.5, -0.125].map { |v| tag(34, ::Protobuf::WireType::FIXED64) + [v].pack('E') }.join.b
+      expect(PackedDecodingSpec::Packed.decode(bytes).r_dbl.to_a).to eq([3.5, -0.125])
+    end
+  end
+
+  describe 'unchanged behavior' do
+    it 'decodes unpacked input for fields that do not declare packed' do
+      bytes = unpacked_varints(21, [1, 2]) + unpacked_varints(27, [1])
+      message = PackedDecodingSpec::Unpacked.decode(bytes)
+      expect([message.r_i32.to_a, message.r_b.to_a]).to eq([[1, 2], [true]])
+    end
+
+    it 'decodes packed input for fields that declare packed' do
+      expect(PackedDecodingSpec::Packed.decode(len(21, "\x01\x02".b)).r_i32.to_a).to eq([1, 2])
+    end
+
+    it 'round-trips both declarations' do
+      unpacked = PackedDecodingSpec::Unpacked.new(:r_i32 => [1, -1], :r_b => [true, false], :r_dbl => [1.5])
+      packed = PackedDecodingSpec::Packed.new(:r_i32 => [1, -1], :r_b => [true, false], :r_dbl => [1.5])
+      expect(PackedDecodingSpec::Unpacked.decode(unpacked.encode)).to eq(unpacked)
+      expect(PackedDecodingSpec::Packed.decode(packed.encode)).to eq(packed)
+    end
+
+    it 'decodes across declarations: packed writer, unpacked reader and back' do
+      packed = PackedDecodingSpec::Packed.new(:r_i32 => [1, 300], :r_b => [true, false], :r_dbl => [1.5, 2.5])
+      unpacked = PackedDecodingSpec::Unpacked.decode(packed.encode)
+      expect([unpacked.r_i32.to_a, unpacked.r_b.to_a, unpacked.r_dbl.to_a]).to eq([[1, 300], [true, false], [1.5, 2.5]])
+
+      back = PackedDecodingSpec::Packed.decode(unpacked.encode)
+      expect(back).to eq(packed)
+    end
+
+    it 'does not change encoding' do
+      message = PackedDecodingSpec::Unpacked.new(:r_i32 => [1, 2])
+      expect(message.encode).to eq(unpacked_varints(21, [1, 2]))
+    end
+  end
+
+  describe 'a record with the wrong wire type for a known field' do
+    it 'is skipped for a singular scalar field' do
+      bytes = len(1, 'xx') + len(7, "\x01".b) + len(15, 'ok')
+      message = PackedDecodingSpec::Singular.decode(bytes)
+      expect([message.i32, message.field?(:i32), message.b, message.field?(:b), message.str]).to eq([0, false, false, false, 'ok'])
+    end
+
+    it 'is skipped for a repeated scalar field' do
+      bytes = tag(29, ::Protobuf::WireType::VARINT) + varint(5) + len(21, "\x01".b)
+      message = PackedDecodingSpec::Unpacked.decode(bytes)
+      expect([message.r_f32.to_a, message.r_i32.to_a]).to eq([[], [1]])
+    end
+
+    it 'is skipped for a repeated string field' do
+      bytes = tag(35, ::Protobuf::WireType::VARINT) + varint(5) + len(35, 'ok')
+      expect(PackedDecodingSpec::Unpacked.decode(bytes).r_str.to_a).to eq(['ok'])
+    end
+
+    it 'is skipped for a map field' do
+      entry = len(1, 'a') + tag(2, ::Protobuf::WireType::VARINT) + varint(3)
+      bytes = tag(16, ::Protobuf::WireType::VARINT) + varint(5) + len(16, entry)
+      expect(PackedDecodingSpec::Singular.decode(bytes).counts.to_h).to eq('a' => 3)
+    end
+  end
+
+  describe 'callers that do not know the wire type' do
+    it 'Decoder.decode_each_field still works with a two-argument block' do
+      seen = []
+      ::Protobuf::Decoder.decode_each_field(StringIO.new(unpacked_varints(21, [7]))) { |tag, bytes| seen << [tag, bytes] }
+      expect(seen).to eq([[21, 7]])
+    end
+
+    it 'BaseField#set without a wire type uses the field declaration' do
+      message = PackedDecodingSpec::Packed.new
+      PackedDecodingSpec::Packed.get_field(:r_i32).set(message, "\x01\x02".b)
+      expect(message.r_i32.to_a).to eq([1, 2])
+
+      unpacked = PackedDecodingSpec::Unpacked.new
+      PackedDecodingSpec::Unpacked.get_field(:r_i32).set(unpacked, 3)
+      expect(unpacked.r_i32.to_a).to eq([3])
+    end
+  end
+end

data/spec/encoding/wire_compat_decoding_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+# Input that other protobuf implementations decode, but that made this gem
+# raise for the whole message.
+RSpec.describe 'Decoding input from other protobuf implementations' do
+  module WireCompatDecodingSpec
+    class Message < ::Protobuf::Message
+      optional :int32, :i32, 1
+      optional :uint32, :u32, 2
+      optional :sint32, :s32, 3
+      repeated :int32, :r_i32, 4
+      optional :int64, :i64, 5
+      optional :string, :str, 15
+    end
+  end
+
+  def tag(field, wire_type)
+    ::Protobuf::Varint.encode((field << 3) | wire_type)
+  end
+
+  def varint(field, value)
+    tag(field, ::Protobuf::WireType::VARINT) + ::Protobuf::Varint.encode(value)
+  end
+
+  def len(field, bytes)
+    tag(field, ::Protobuf::WireType::LENGTH_DELIMITED) + ::Protobuf::Varint.encode(bytes.bytesize) + bytes
+  end
+
+  def decode(bytes)
+    WireCompatDecodingSpec::Message.decode(bytes.b)
+  end
+
+  # The language guide calls int32, uint32, int64, and uint64 compatible: a
+  # parser keeps the low 32 bits, as in a C++ cast.
+  describe 'a 32-bit field that gets a wider varint' do
+    it 'keeps the low 32 bits of an int32' do
+      expect(decode(varint(1, 0xffff_ffff)).i32).to eq(-1)
+      expect(decode(varint(1, 0x1_0000_0005)).i32).to eq(5)
+      expect(decode(varint(1, 0xffff_ffff_8000_0000)).i32).to eq(-2_147_483_648)
+    end
+
+    it 'keeps the low 32 bits of a uint32' do
+      expect(decode(varint(2, 0x1_0000_0001)).u32).to eq(1)
+    end
+
+    it 'keeps the low 32 bits of a sint32 before the zigzag decode' do
+      # zigzag(-2) is 3; the bits above 32 are dropped.
+      expect(decode(varint(3, 0x4_0000_0003)).s32).to eq(-2)
+    end
+
+    it 'keeps the low 32 bits in a packed run' do
+      run = ::Protobuf::Varint.encode(0x1_0000_0007) + ::Protobuf::Varint.encode(1)
+      expect(decode(len(4, run)).r_i32.to_a).to eq([7, 1])
+    end
+
+    it 'decodes the other fields of the message' do
+      message = decode(varint(1, 0x1_0000_0005) + len(15, 'ok'))
+      expect([message.i32, message.str]).to eq([5, 'ok'])
+    end
+
+    it 'does not change values in range' do
+      message = WireCompatDecodingSpec::Message.new(
+        :i32 => -2_147_483_648, :u32 => 4_294_967_295, :s32 => -7, :r_i32 => [-1, 2_147_483_647], :i64 => -2**40,
+      )
+      expect(WireCompatDecodingSpec::Message.decode(message.encode)).to eq(message)
+    end
+  end
+
+  # Groups (wire types 3 and 4) come from proto2 group fields and from
+  # editions DELIMITED encoding. This gem has no group fields, so it skips a
+  # group as an unknown field.
+  describe 'a group' do
+    let(:start_group) { tag(95, ::Protobuf::WireType::START_GROUP) }
+    let(:end_group) { tag(95, ::Protobuf::WireType::END_GROUP) }
+
+    it 'is skipped, with the fields inside it' do
+      bytes = start_group + varint(1, 9) + len(15, 'in') + end_group + varint(1, 5)
+      message = decode(bytes)
+      expect([message.i32, message.str]).to eq([5, ''])
+    end
+
+    it 'is skipped with every wire type inside it' do
+      inner = varint(1, 1) + tag(2, ::Protobuf::WireType::FIXED64) + ("\x00" * 8) +
+              tag(3, ::Protobuf::WireType::FIXED32) + ("\x00" * 4) + len(4, 'abc')
+      expect(decode(start_group + inner + end_group + len(15, 'ok')).str).to eq('ok')
+    end
+
+    it 'is skipped with groups inside it' do
+      inner_start = tag(7, ::Protobuf::WireType::START_GROUP)
+      inner_end = tag(7, ::Protobuf::WireType::END_GROUP)
+      bytes = start_group + inner_start + varint(1, 9) + inner_end + end_group + varint(1, 5)
+      expect(decode(bytes).i32).to eq(5)
+    end
+
+    it 'is skipped when its field number is a known field' do
+      bytes = tag(1, ::Protobuf::WireType::START_GROUP) + varint(1, 9) + tag(1, ::Protobuf::WireType::END_GROUP)
+      expect(decode(bytes).field?(:i32)).to be(false)
+    end
+
+    it 'raises when the group has no end' do
+      expect { decode(start_group + varint(1, 9)) }.to raise_error(::Protobuf::InvalidWireType)
+    end
+
+    it 'raises when the end does not match the start' do
+      bytes = start_group + tag(96, ::Protobuf::WireType::END_GROUP)
+      expect { decode(bytes) }.to raise_error(::Protobuf::InvalidWireType)
+    end
+
+    it 'raises for an end group without a start' do
+      expect { decode(end_group) }.to raise_error(::Protobuf::InvalidWireType)
+    end
+  end
+end

data/spec/functional/railtie_boot_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'open3'
+require 'rbconfig'
+require 'tmpdir'
+require 'fileutils'
+
+# Boots a real Rails app in a subprocess, with the load order that the
+# `rpc_server` CLI uses: protobuf loads first, then the app file loads Rails.
+RSpec.describe 'Protobuf::Railtie in a booted Rails app' do
+  let(:lib_dir) { ::File.expand_path('../../../lib', __FILE__) }
+
+  def write(root, relative_path, contents)
+    full = ::File.join(root, relative_path)
+    ::FileUtils.mkdir_p(::File.dirname(full))
+    ::File.write(full, contents)
+  end
+
+  def build_app(root, services_path)
+    config_line = services_path ? "config.protobuf.services_path = #{services_path.inspect}" : ''
+
+    write(root, 'config/environment.rb', <<-RUBY)
+      require 'rails'
+      class RailtieBootApp < Rails::Application
+        config.root = #{root.inspect}
+        config.eager_load = false
+        config.logger = Logger.new(nil)
+        config.secret_key_base = 'x' * 64
+        #{config_line}
+      end
+      Rails.application.initialize!
+    RUBY
+
+    # app/services is a Zeitwerk root, so app/services/rpc/ is the Rpc namespace.
+    write(root, 'app/services/rpc/echo_service.rb', <<-RUBY)
+      module Rpc
+        class EchoService < ::Protobuf::Rpc::ApplicationService
+          rpc :echo, ::Protobuf::Socketrpc::Request, ::Protobuf::Socketrpc::Response
+          def echo; end
+        end
+      end
+    RUBY
+
+    write(root, 'app/services/plain_object.rb', <<-RUBY)
+      class PlainObject
+        $stdout.puts 'PLAIN_OBJECT_LOADED'
+      end
+    RUBY
+  end
+
+  def boot(root)
+    script = <<-RUBY
+      require 'protobuf/socket'
+      require #{::File.join(root, 'config/environment').inspect}
+      puts "BEFORE_BIND=\#{::Protobuf::Rpc::Service.implemented_services.inspect}"
+      ::ActiveSupport::Notifications.instrument('before_server_bind')
+      puts "AFTER_BIND=\#{::Protobuf::Rpc::Service.implemented_services.inspect}"
+    RUBY
+
+    Open3.capture2e(::RbConfig.ruby, '-I', lib_dir, '-e', script, :chdir => root)
+  end
+
+  it 'loads the configured services directory when the server binds' do
+    ::Dir.mktmpdir do |root|
+      build_app(root, 'app/services/rpc')
+      output, status = boot(root)
+
+      expect(status).to be_success, output
+      expect(output).to include('BEFORE_BIND=[]')
+      expect(output).to include('AFTER_BIND=["Rpc::EchoService"]')
+      expect(output).not_to include('PLAIN_OBJECT_LOADED')
+    end
+  end
+
+  it 'loads nothing when services_path is not configured' do
+    ::Dir.mktmpdir do |root|
+      build_app(root, nil)
+      output, status = boot(root)
+
+      expect(status).to be_success, output
+      expect(output).to include('AFTER_BIND=[]')
+      expect(output).not_to include('PLAIN_OBJECT_LOADED')
+    end
+  end
+end

data/spec/lib/protobuf/field/bool_field_spec.rb

@@ -53,6 +53,27 @@ RSpec.describe Protobuf::Field::BoolField do
     end
   end
 
+  describe '#decode' do
+    subject { described_class.new(SomeBoolMessage, :optional, described_class, :b, 1, :b, {}) }
+
+    it 'decodes 0 as false' do
+      expect(subject.decode(0)).to be(false)
+    end
+
+    it 'decodes 1 as true' do
+      expect(subject.decode(1)).to be(true)
+    end
+
+    it 'decodes any other non-zero varint as true, like the reference parsers' do
+      expect(subject.decode(2)).to be(true)
+      expect(subject.decode(0xffff_ffff_ffff_ffff)).to be(true)
+    end
+  end
+
+  it 'decodes a non-canonical varint (2) on the wire as true' do
+    expect(SomeBoolMessage.decode("\x08\x02".b).some_bool).to be(true)
+  end
+
   it 'defines ? method' do
     instance.required_bool = false
     expect(instance.required_bool?).to be(false)

data/spec/lib/protobuf/generators/service_generator_spec.rb

@@ -95,5 +95,28 @@ EOF
         expect(subject.to_s).to eq(compiled)
       end
     end
+
+    context 'with PB_SERVICE_PARENT in the environment' do
+      let(:service_parent) { ' ::Protobuf::Rpc::ApplicationService ' }
+
+      before do
+        allow(ENV).to receive(:[]).and_call_original
+        allow(ENV).to receive(:[]).with('PB_SERVICE_PARENT').and_return(service_parent)
+      end
+
+      it 'uses the given parent class' do
+        subject.compile
+        expect(subject.to_s).to start_with("class TestService < ::Protobuf::Rpc::ApplicationService\n")
+      end
+
+      context 'when it is empty' do
+        let(:service_parent) { '' }
+
+        it 'uses ::Protobuf::Rpc::Service' do
+          subject.compile
+          expect(subject.to_s).to eq(compiled)
+        end
+      end
+    end
   end
 end