protobug 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb1c2e1db6e805829a6f6fb22f5d2738669059a8b68a3125dbc9166c6d562dec
-  data.tar.gz: '09653af0a53f28125bdd2181e3c0f64130d26dfc54d5fd0ca5ae7965f884b730'
+  metadata.gz: 04bd54e56a0b5d9f3bdc255e2b134257f7d2c35710e718cd50555834e9df482d
+  data.tar.gz: e6fbdee91e29f5f6c498004ad8137c2e59fc6d743933f22d834d923245632c6b
 SHA512:
-  metadata.gz: 771857441842b42c38e44a8fccf8091eaa8ae0188ab031817c7cfeb91944f1123f9d9ceca5c494518f427213bbc22e3dc9a5475e037b29b24daa69dc2cc77df2
-  data.tar.gz: a319557c088eccbda2f822c56f1e7bc944140ce212d43a84dc7e4e5ea26715f531f036e825c1ee129162402021c9e26024c19ad56dfff1dad52de2970cdcf3a6
+  metadata.gz: a417bfdfca7b8f9429f252cc698313141c8e3b0c2de5a40f4358a91f6c0834e692376cd5e57bb205c2c978b818f5ea4cabe752c7c04e807073d2d96252525b57
+  data.tar.gz: 1b766a9b88e937e6615573ef0dc1842e2341b81d020c28ee47aec99aa29729fb9bae351c227d81797eae80ac41b4ac7d7145b066ff6f0237410d963569077589

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## [Unreleased]
 
+## [0.2.0] - 2026-06-18
+
+### Added
+
+- New compiled proto gems: `protobug_fulcio_protos`, `protobug_googleapis_annotations_protos`,
+  `protobug_in_toto_attestation_protos`, and `protobug_protoc_gen_openapiv2_protos`.
+- Bump sigstore protobuf-specs to v0.5.1, adding `SigningConfig` v0.2 along with the
+  `Service`, `ServiceSelector`, and `ServiceConfiguration` messages.
+- Significantly expanded test coverage.
+
+### Fixed
+
+- Decode a truncated varint as an error (`EOFError`) instead of silently returning `nil`,
+  and reject varints whose 10th byte overflows 64 bits.
+- Encode fixed-width integers (`fixed64`/`sfixed64`/`sfixed32`) in little-endian order,
+  correcting the binary wire format on big-endian hosts.
+- Re-encode unknown fields of wire types 1 and 5 as raw bytes rather than varints.
+- Raise a structured `InvalidValueError` on invalid boolean values.
+- Accept decimal and exponent notation when parsing floats from JSON.
+
+### Changed
+
+- Generate message field accessors via `class_eval` rather than `define_method` closures.
+- `Enum#==` returns `false` for unrecognized operand types instead of raising.
+
 ## [0.1.0] - 2024-02-21
 
 - Initial release

data/lib/protobug/binary_encoding.rb

@@ -10,19 +10,27 @@ module Protobug
       raise EncodeError, "expected integer, got #{value.inspect}" unless value.is_a? Integer
       raise RangeError, "expected 64-bit integer" if value > (2**64) - 1 || value < -2**63
 
-      negative = value.negative?
-      value = (2**64) + value if negative
-      out = []
+      value += 2**64 if value < 0
       loop do
         if value.bit_length > 7
-          out << (0b1000_0000 | (value & 0b0111_1111))
+          outbuf << (0b1000_0000 | (value & 0b0111_1111))
           value >>= 7
         else
-          out << (value & 0b0111_1111)
+          outbuf << (value & 0b0111_1111)
           break
         end
       end
-      out.pack("c*", buffer: outbuf)
+    end
+
+    if RUBY_ENGINE == "truffleruby"
+      # see https://github.com/oracle/truffleruby/issues/3559
+      def pack(ary, format, buffer:)
+        buffer.concat ary.pack(format)
+      end
+    else
+      def pack(ary, format, buffer:)
+        ary.pack(format, buffer: buffer)
+      end
     end
 
     def encode_zigzag(size, value, outbuf)
@@ -34,7 +42,7 @@ module Protobug
       end
 
       encoded = 2 * value.abs
-      encoded -= 1 if value.negative?
+      encoded -= 1 if value < 0
       encode_varint encoded, outbuf
     end
 
@@ -43,20 +51,80 @@ module Protobug
       outbuf << contents
     end
 
-    def decode_varint(binary)
-      byte = binary.getbyte
-      return unless byte
-
-      value = 0
-      bl = 0
-      loop do
-        raise DecodeError, "varint too large" if bl > 63
-        return value if byte.nil?
-        return value | (byte << bl) if (byte & 0b1000_0000).zero? # no continuation bit set
+    def varint_eof!
+      raise EOFError, "unexpected EOF in the middle of a varint"
+    end
 
-        value |= ((byte & 0b0111_1111) << bl)
-        bl += 7
-        byte = binary.getbyte || raise(EOFError, "unexpected EOF")
+    def decode_varint(binary)
+      # Only the first byte may legitimately be absent (clean EOF, signaled by
+      # returning nil). Once a continuation bit is set, any subsequent missing
+      # byte is a truncated varint and must be rejected.
+      if (byte0 = binary.getbyte || return) < 0x80
+        byte0
+      elsif (byte1 = binary.getbyte || varint_eof!) < 0x80
+        (byte1 << 7) | (byte0 & 0x7F)
+      elsif (byte2 = binary.getbyte || varint_eof!) < 0x80
+        (byte2 << 14) |
+          ((byte1 & 0x7F) << 7) |
+          (byte0 & 0x7F)
+      elsif (byte3 = binary.getbyte || varint_eof!) < 0x80
+        (byte3 << 21) |
+          ((byte2 & 0x7F) << 14) |
+          ((byte1 & 0x7F) << 7) |
+          (byte0 & 0x7F)
+      elsif (byte4 = binary.getbyte || varint_eof!) < 0x80
+        (byte4 << 28) |
+          ((byte3 & 0x7F) << 21) |
+          ((byte2 & 0x7F) << 14) |
+          ((byte1 & 0x7F) << 7) |
+          (byte0 & 0x7F)
+      elsif (byte5 = binary.getbyte || varint_eof!) < 0x80
+        (byte5 << 35) |
+          ((byte4 & 0x7F) << 28) |
+          ((byte3 & 0x7F) << 21) |
+          ((byte2 & 0x7F) << 14) |
+          ((byte1 & 0x7F) << 7) |
+          (byte0 & 0x7F)
+      elsif (byte6 = binary.getbyte || varint_eof!) < 0x80
+        (byte6 << 42) |
+          ((byte5 & 0x7F) << 35) |
+          ((byte4 & 0x7F) << 28) |
+          ((byte3 & 0x7F) << 21) |
+          ((byte2 & 0x7F) << 14) |
+          ((byte1 & 0x7F) << 7) |
+          (byte0 & 0x7F)
+      elsif (byte7 = binary.getbyte || varint_eof!) < 0x80
+        (byte7 << 49) |
+          ((byte6 & 0x7F) << 42) |
+          ((byte5 & 0x7F) << 35) |
+          ((byte4 & 0x7F) << 28) |
+          ((byte3 & 0x7F) << 21) |
+          ((byte2 & 0x7F) << 14) |
+          ((byte1 & 0x7F) << 7) |
+          (byte0 & 0x7F)
+      elsif (byte8 = binary.getbyte || varint_eof!) < 0x80
+        (byte8 << 56) |
+          ((byte7 & 0x7F) << 49) |
+          ((byte6 & 0x7F) << 42) |
+          ((byte5 & 0x7F) << 35) |
+          ((byte4 & 0x7F) << 28) |
+          ((byte3 & 0x7F) << 21) |
+          ((byte2 & 0x7F) << 14) |
+          ((byte1 & 0x7F) << 7) |
+          (byte0 & 0x7F)
+      elsif (byte9 = binary.getbyte || varint_eof!) < 0x80
+        raise DecodeError, "varint overflow: 10th byte #{byte9} exceeds 64 bits" if byte9 > 1
+
+        (byte9 << 63) |
+          ((byte8 & 0x7F) << 56) |
+          ((byte7 & 0x7F) << 49) |
+          ((byte6 & 0x7F) << 42) |
+          ((byte5 & 0x7F) << 35) |
+          ((byte4 & 0x7F) << 28) |
+          ((byte3 & 0x7F) << 21) |
+          ((byte2 & 0x7F) << 14) |
+          ((byte1 & 0x7F) << 7) |
+          (byte0 & 0x7F)
       end
     end
 

data/lib/protobug/enum.rb

@@ -123,10 +123,15 @@ module Protobug
           value == other.value
         when Integer
           value == other
-        when String, Symbol
-          name.to_s == other.to_s
+        when String
+          # name is already a frozen String (see #initialize), so no allocation here.
+          name == other
+        when Symbol
+          # Symbol#name returns the frozen interned string, avoiding the allocation
+          # that Symbol#to_s would incur.
+          name == other.name
         else
-          raise "expected #{self.class}, got #{other.inspect}"
+          false
         end
       end
 

data/lib/protobug/field.rb

@@ -4,6 +4,8 @@ require_relative "binary_encoding"
 
 module Protobug
   class Field
+    PACKABLE_WIRE_TYPES = [0, 1, 5].freeze
+
     attr_accessor :number, :name, :json_name, :cardinality, :oneof, :ivar, :setter,
                   :adder, :haser, :clearer
 
@@ -61,19 +63,55 @@ module Protobug
       @proto3_optional
     end
 
-    def define_adder(message)
-      field = self
-      message.define_method(adder) do |value|
-        field.validate!(value, self)
+    def method_definitions
+      str = +""
 
-        existing = instance_variable_get(field.ivar)
-        if UNSET == existing
-          existing = field.default
-          instance_variable_set(field.ivar, existing)
-        end
+      str << "def #{setter}(value)\n"
+      str << "  return #{ivar} = ::Protobug::UNSET if value.nil?\n" if optional? && proto3_optional?
+      str << "  field = self.class.fields_by_name.fetch(#{name.to_s.dump})\n"
+      str << "  field.validate!(value, self)\n"
+      str << "  #{ivar} = value\n"
+      str << "end\n"
 
-        existing << value
+      str << "def #{name}\n"
+      str << "  value = #{ivar}\n"
+      str << "  ::Protobug::UNSET == value ? self.class.fields_by_name.fetch(#{name.to_s.dump}).default : value\n"
+      str << "end\n"
+
+      str << "def #{haser}\n"
+      str << "  value = #{ivar}\n"
+      str << "  return false if ::Protobug::UNSET == value\n"
+      if (!optional? || !proto3_optional?) && !oneof
+        str << "  field = self.class.fields_by_name.fetch(#{name.to_s.dump})\n"
+        str << "  return false if field.default == value\n"
       end
+      str << if repeated?
+               "  !value.empty?\n"
+             else
+               "  true\n"
+             end
+      str << "end\n"
+
+      str << "def #{clearer}\n"
+      str << "  #{ivar} = ::Protobug::UNSET\n"
+      str << "end\n"
+
+      adder_method_definition(str) if repeated?
+
+      str
+    end
+
+    def adder_method_definition(str)
+      str << "def #{adder}(value)\n"
+      str << "  existing = #{ivar}\n"
+      str << "  field = self.class.fields_by_name.fetch(#{name.to_s.dump})\n"
+      str << "  if ::Protobug::UNSET == existing\n"
+      str << "    existing = field.default\n"
+      str << "    #{ivar} = existing\n"
+      str << "  end\n"
+      str << "  field.validate!(value, self)\n"
+      str << "  existing << value\n"
+      str << "end\n"
     end
 
     def to_text(value)
@@ -108,12 +146,13 @@ module Protobug
     end
 
     def binary_decode(binary, message, registry, wire_type)
-      if repeated? && wire_type == 2 && [0, 1, 5].include?(self.wire_type)
+      own_wire_type = self.wire_type
+      if repeated? && wire_type == 2 && PACKABLE_WIRE_TYPES.include?(own_wire_type)
         len = StringIO.new(BinaryEncoding.decode_length(binary))
         len.binmode
 
-        message.send(adder, binary_decode_one(len, message, registry, self.wire_type)) until len.eof?
-      elsif wire_type != self.wire_type
+        message.send(adder, binary_decode_one(len, message, registry, own_wire_type)) until len.eof?
+      elsif wire_type != own_wire_type
         raise DecodeError, "wrong wire type for #{self}: #{wire_type.inspect}"
       else
         message.send(adder || setter, binary_decode_one(binary, message, registry, wire_type))
@@ -226,7 +265,9 @@ module Protobug
         nil
       end
 
-      def wire_type = 2
+      def wire_type
+        2
+      end
     end
 
     class MapField < MessageField
@@ -250,9 +291,17 @@ module Protobug
         end
       end
 
-      def repeated = true
-      def default = {}
-      def repeated? = true
+      def repeated
+        true
+      end
+
+      def default
+        {}
+      end
+
+      def repeated?
+        true
+      end
 
       def binary_encode(value, outbuf)
         value.each_with_object(@map_class.new) do |(k, v), entry|
@@ -295,24 +344,26 @@ module Protobug
         end
       end
 
-      def type_lookup(_registry) = @map_class
-
-      def define_adder(message)
-        field = self
-        message.define_method(adder) do |msg|
-          existing = instance_variable_get(field.ivar)
-          if UNSET == existing
-            existing = field.default
-            instance_variable_set(field.ivar, existing)
-          end
+      def type_lookup(_registry)
+        @map_class
+      end
 
-          existing[msg.key] = msg.value
-        end
+      def adder_method_definition(str)
+        str << "def #{adder}(msg)\n"
+        str << "  existing = #{ivar}\n"
+        str << "  if ::Protobug::UNSET == existing\n"
+        str << "    existing = {}\n"
+        str << "    #{ivar} = existing\n"
+        str << "  end\n"
+        str << "  existing[msg.key] = msg.value\n"
+        str << "end\n"
       end
     end
 
     class BytesField < Field
-      def self.type = :bytes
+      def self.type
+        :bytes
+      end
 
       def initialize(number, name, cardinality:, json_name: name, oneof: nil,
                      proto3_optional: cardinality == :optional)
@@ -352,11 +403,15 @@ module Protobug
         "".b
       end
 
-      def wire_type = 2
+      def wire_type
+        2
+      end
     end
 
     class StringField < BytesField
-      def self.type = :string
+      def self.type
+        :string
+      end
 
       def initialize(number, name, cardinality:, json_name: name, oneof: nil,
                      proto3_optional: cardinality == :optional)
@@ -414,15 +469,12 @@ module Protobug
         when :varint
           length_mask = (2**bit_length) - 1
           negative = signed && value & (2**bit_length.pred) != 0
-          # warn negative
-          length_mask >> 1 if signed
           if negative
             value &= length_mask # remove sign bit
 
             # 2's complement
             value ^= length_mask
             value += 1
-            # value &= length_mask
             -value
           else
             value & length_mask
@@ -439,7 +491,7 @@ module Protobug
         when :varint
           BinaryEncoding.encode_varint value, outbuf
         when :fixed
-          [value].pack(binary_pack, buffer: outbuf)
+          BinaryEncoding.pack([value], binary_pack, buffer: outbuf)
         end
       end
 
@@ -452,8 +504,10 @@ module Protobug
         when /\A-?\d+\z/
           value = Integer(value)
         when Float
-          value, remainder = value.divmod(1)
-          raise DecodeError, "expected integer for #{inspect}, got #{value.inspect}" unless remainder.zero?
+          int, remainder = value.divmod(1)
+          raise DecodeError, "expected integer for #{inspect}, got #{value.inspect}" unless remainder == 0
+
+          value = int
         else
           raise DecodeError, "expected integer for #{inspect}, got #{value.inspect}"
         end
@@ -494,77 +548,199 @@ module Protobug
     # signed: true, false
     # EXCEPT: no unsigned zigzag
     class Int64Field < IntegerField
-      def encoding = :varint
-      def bit_length = 64
-      def signed = true
-      def wire_type = 0
+      def encoding
+        :varint
+      end
+
+      def bit_length
+        64
+      end
+
+      def signed
+        true
+      end
+
+      def wire_type
+        0
+      end
     end
 
     class UInt64Field < IntegerField
-      def encoding = :varint
-      def bit_length = 64
-      def signed = false
-      def wire_type = 0
+      def encoding
+        :varint
+      end
+
+      def bit_length
+        64
+      end
+
+      def signed
+        false
+      end
+
+      def wire_type
+        0
+      end
     end
 
     class SInt64Field < IntegerField
-      def encoding = :zigzag
-      def bit_length = 64
-      def signed = true
-      def wire_type = 0
+      def encoding
+        :zigzag
+      end
+
+      def bit_length
+        64
+      end
+
+      def signed
+        true
+      end
+
+      def wire_type
+        0
+      end
     end
 
     class Fixed64Field < IntegerField
-      def encoding = :fixed
-      def bit_length = 64
-      def signed = false
-      def wire_type = 1
-      def binary_pack = "Q"
+      def encoding
+        :fixed
+      end
+
+      def bit_length
+        64
+      end
+
+      def signed
+        false
+      end
+
+      def wire_type
+        1
+      end
+
+      def binary_pack
+        "Q<"
+      end
     end
 
     class SFixed64Field < IntegerField
-      def encoding = :fixed
-      def bit_length = 64
-      def signed = true
-      def wire_type = 1
-      def binary_pack = "q"
+      def encoding
+        :fixed
+      end
+
+      def bit_length
+        64
+      end
+
+      def signed
+        true
+      end
+
+      def wire_type
+        1
+      end
+
+      def binary_pack
+        "q<"
+      end
     end
 
     class Int32Field < IntegerField
-      def encoding = :varint
-      def bit_length = 32
-      def signed = true
-      def wire_type = 0
+      def encoding
+        :varint
+      end
+
+      def bit_length
+        32
+      end
+
+      def signed
+        true
+      end
+
+      def wire_type
+        0
+      end
     end
 
     class UInt32Field < IntegerField
-      def encoding = :varint
-      def bit_length = 32
-      def signed = false
-      def wire_type = 0
+      def encoding
+        :varint
+      end
+
+      def bit_length
+        32
+      end
+
+      def signed
+        false
+      end
+
+      def wire_type
+        0
+      end
     end
 
     class SInt32Field < IntegerField
-      def encoding = :zigzag
-      def bit_length = 32
-      def signed = true
-      def wire_type = 0
+      def encoding
+        :zigzag
+      end
+
+      def bit_length
+        32
+      end
+
+      def signed
+        true
+      end
+
+      def wire_type
+        0
+      end
     end
 
     class Fixed32Field < IntegerField
-      def encoding = :fixed
-      def bit_length = 32
-      def signed = false
-      def wire_type = 5
-      def binary_pack = "V"
+      def encoding
+        :fixed
+      end
+
+      def bit_length
+        32
+      end
+
+      def signed
+        false
+      end
+
+      def wire_type
+        5
+      end
+
+      def binary_pack
+        "V"
+      end
     end
 
     class SFixed32Field < IntegerField
-      def encoding = :fixed
-      def bit_length = 32
-      def signed = true
-      def wire_type = 5
-      def binary_pack = "l"
+      def encoding
+        :fixed
+      end
+
+      def bit_length
+        32
+      end
+
+      def signed
+        true
+      end
+
+      def wire_type
+        5
+      end
+
+      def binary_pack
+        "l<"
+      end
     end
 
     class BoolField < UInt64Field
@@ -592,7 +768,7 @@ module Protobug
       end
 
       def validate!(value, message)
-        raise "expected boolean, got #{value.inspect}" unless [true, false].include?(value)
+        raise InvalidValueError.new(message, self, value, "expected boolean") unless [true, false].include?(value)
 
         super(value ? 1 : 0, message)
       end
@@ -669,9 +845,17 @@ module Protobug
     end
 
     class DoubleField < Field
-      def type = :double
-      def binary_pack = "E"
-      def wire_type = 1
+      def type
+        :double
+      end
+
+      def binary_pack
+        "E"
+      end
+
+      def wire_type
+        1
+      end
 
       def initialize(number, name, cardinality:, json_name: name, oneof: nil, packed: false,
                      proto3_optional: cardinality == :optional)
@@ -680,7 +864,7 @@ module Protobug
       end
 
       def binary_encode_one(value, outbuf)
-        [value].pack(binary_pack, buffer: outbuf)
+        BinaryEncoding.pack([value], binary_pack, buffer: outbuf)
       end
 
       def binary_decode_one(io, _message, _registry, wire_type)
@@ -700,7 +884,7 @@ module Protobug
           -Float::INFINITY
         when "NaN"
           Float::NAN
-        when /\A-?\d+\z/
+        when /\A-?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][-+]?\d+)?\z/
           Float(value)
         when NilClass
           UNSET
@@ -731,9 +915,17 @@ module Protobug
     end
 
     class FloatField < DoubleField
-      def type = :float
-      def binary_pack = "e"
-      def wire_type = 5
+      def type
+        :float
+      end
+
+      def binary_pack
+        "e"
+      end
+
+      def wire_type
+        5
+      end
     end
 
     class GroupField < Field

data/lib/protobug/message.rb

@@ -11,6 +11,10 @@ module Protobug
     "<UNSET>"
   end
 
+  def UNSET.to_s
+    "<UNSET>"
+  end
+
   def UNSET.===(other)
     other.equal? UNSET
   end
@@ -120,14 +124,11 @@ module Protobug
 
     def decode(binary, registry:, object: new)
       binary.binmode
-      loop do
-        header = BinaryEncoding.decode_varint(binary)
-        break if header.nil?
-
+      while (header = BinaryEncoding.decode_varint(binary))
         wire_type = header & 0b111
-        number = (header ^ wire_type) >> 3
+        number = header >> 3
 
-        unless number.positive?
+        unless number > 0
           raise DecodeError,
                 "unexpected field number #{number} in #{full_name || fields_by_name.inspect}"
         end
@@ -156,8 +157,10 @@ module Protobug
       message.unknown_fields.each_with_object(buf) do |(number, wire_type, value), outbuf|
         BinaryEncoding.encode_varint((number << 3) | wire_type, outbuf)
         case wire_type
-        when 0, 5
+        when 0
           BinaryEncoding.encode_varint(value, outbuf)
+        when 1, 5
+          outbuf << value
         when 2
           BinaryEncoding.encode_length(value, outbuf)
         else
@@ -167,6 +170,17 @@ module Protobug
     end
 
     def field(number, name, type:, **kwargs)
+      raise ArgumentError unless number.is_a? Integer
+
+      case name
+      when String
+        # OK
+      when Symbol
+        name = name.name
+      else
+        raise ArgumentError
+      end
+
       field =
         case type
         when :message
@@ -222,54 +236,26 @@ module Protobug
       fields_by_json_name[name] = field
       fields_by_json_name[field.json_name] = field
 
-      define_method(field.setter) do |value|
-        return instance_variable_set(field.ivar, UNSET) if value.nil? && field.optional? && field.proto3_optional?
-
-        field.validate!(value, self)
-        instance_variable_set(field.ivar, value)
-      end
-
-      define_method(name) do
-        value = instance_variable_get(field.ivar)
-        UNSET == value ? field.default : value
-      end
-
-      define_method(field.haser) do
-        value = instance_variable_get(field.ivar)
-        return false if UNSET == value
-
-        return false if (!field.optional? || !field.proto3_optional?) && !field.oneof && field.default == value
-
-        if field.repeated?
-          !value.empty?
-        else
-          true
-        end
-      end
-
-      define_method(field.clearer) do
-        instance_variable_set(field.ivar, UNSET)
-      end
-
-      field.define_adder(self) if field.repeated?
+      class_eval(field.method_definitions, __FILE__, __LINE__)
 
       return unless field.oneof
 
-      unless oneofs[field.oneof]
-        oneofs[field.oneof] = ary = []
+      unless (oneof = oneofs[field.oneof])
+        oneofs[field.oneof] = oneof = []
         define_method(field.oneof) do
-          ary.find { |f| send(f.haser) }&.name
+          oneof.find { |f| send(f.haser) }&.name
         end
       end
-      oneofs[field.oneof] << field
+      oneof << field
     end
 
     module InstanceMethods
       def ==(other)
-        self.class.full_name == other.class.full_name &&
-          self.class.fields_by_name.all? do |name, _|
-            send(name) == other.send(name)
-          end
+        return false unless other.instance_of?(self.class)
+
+        self.class.fields_by_name.all? do |name, _|
+          send(name) == other.send(name)
+        end
       end
       alias eql? ==
 
@@ -291,7 +277,7 @@ module Protobug
           pp.breakable
           fields_with_values.each_with_index do |(name, field), idx|
             pp.nest 2 do
-              unless idx.zero?
+              unless idx == 0
                 pp.text ","
                 pp.breakable " "
               end
@@ -303,7 +289,11 @@ module Protobug
       end
 
       def hash
-        self.class.fields_by_name.map { |name, _| send(name) }.hash
+        # Build a single array (map result is mutated in place via unshift) rather
+        # than allocating both the mapped array and a second spread literal.
+        values = self.class.fields_by_name.map { |name, _| send(name) }
+        values.unshift(self.class)
+        values.hash
       end
 
       def to_text

data/lib/protobug/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Protobug
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/protobug.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "protobug/version"
-
 module Protobug
   class Error < StandardError; end
   # Your code goes here...
 end
 
+require_relative "protobug/version"
 require_relative "protobug/base_descriptor"
 require_relative "protobug/enum"
 require_relative "protobug/message"
 require_relative "protobug/registry"
-require "date"

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: protobug
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Samuel Giddins
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-25 00:00:00.000000000 Z
+date: 2026-06-19 00:00:00.000000000 Z
 dependencies: []
-description: 
+description:
 email:
 - segiddins@segiddins.me
 executables: []
@@ -38,7 +38,7 @@ metadata:
   homepage_uri: https://github.com/segiddins/protobug
   source_code_uri: https://github.com/segiddins/protobug
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -54,7 +54,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.5.9
-signing_key: 
+signing_key:
 specification_version: 4
 summary: An embeddable protobuf compiler & runtime for Ruby
 test_files: []