protostar 0.1.0.beta1

data/lib/protostar/text/printer.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Text
+    # Prints a message the way protoc's TextFormat::Printer does: fields in
+    # number order, two-space indents, map entries sorted by key, strings
+    # escaped with CEscape, floats in their shortest round-trip form, then
+    # extensions and unknown fields.
+    # @api private
+    class Printer
+      F = Message::FieldInfo
+
+      # CEscape: named escapes, octal for every other byte outside printable ASCII
+      ESCAPES = Array.new(256) do |b|
+        case b
+        when 0x0A then "\\n"
+        when 0x0D then "\\r"
+        when 0x09 then "\\t"
+        when 0x22 then "\\\""
+        when 0x27 then "\\'"
+        when 0x5C then "\\\\"
+        when 0x20..0x7E then b.chr
+        else format("\\%03o", b)
+        end.freeze
+      end.freeze
+      ESCAPED = /[^\x20-\x7e]|["'\\]/n
+      UTF8_ESCAPED = /[\x00-\x1f\x7f"'\\]/
+      ANY = "google.protobuf.Any"
+      FLOAT_MIN_NORMAL = 1.1754943508222875e-38
+
+      # @return [Boolean] whether protoc prints the field by its message type's
+      #   name: a group whose field name is the type name in lower case
+      def self.group_like?(info)
+        return false unless info.kind == F::GROUP
+        type = info.descriptor.message_type
+        type.name.downcase == info.name && type.file.equal?(info.descriptor.file) &&
+          type.containing_message.equal?(info.descriptor.containing_message)
+      end
+
+      def initialize(single_line: false, expand_any: false, as_utf8: false, unknown_fields: true, registry: nil, pool: nil)
+        @single_line = single_line
+        @unknown_fields = unknown_fields
+        @expand_any = expand_any
+        @as_utf8 = as_utf8
+        @registry = registry
+        @extensions = Extensions.new(registry, pool)
+      end
+
+      # @param message [Message]
+      # @return [String]
+      def print(message)
+        out = +""
+        fields(message, out, 0)
+        @single_line ? out.rstrip : out
+      end
+
+      private
+
+      def fields(msg, out, depth)
+        return if @expand_any && any(msg, out, depth)
+        values = msg.__values
+        items = []
+        msg.class.__fields.each do |info|
+          v = values[info.index]
+          next if v.nil?
+          if info.map || info.repeated
+            next if v.empty?
+          elsif !info.presence && info.zero?(v)
+            next
+          end
+          items << [info, v]
+        end
+        unknown = msg.unknown_fields
+        unless unknown.empty?
+          extensions = @extensions.of(msg.class.descriptor)
+          unless extensions.empty?
+            unknown = extensions_as_items(unknown, extensions, items)
+          end
+        end
+        items.sort_by! { |info, _| info.number }
+        items.each { |info, v| field(info, v, out, depth) }
+        unknown_fields(unknown.map { |u| [u.number, u.wire_type, u] }, out, depth) if @unknown_fields
+      end
+
+      # Moves the unknown fields that hold extensions into items; returns the rest
+      def extensions_as_items(unknown, extensions, items)
+        by_number = unknown.group_by(&:number)
+        rest = unknown
+        by_number.each do |number, list|
+          field = extensions[number] or next
+          info = @extensions.info(field) or next
+          values = @extensions.read(info, list) or next
+          next if values.empty?
+          items << [info, info.repeated ? values : values.last]
+          rest -= list
+        end
+        rest
+      end
+
+      def field(info, v, out, depth)
+        extension = info.descriptor.extension?
+        name = if extension then "[#{info.descriptor.full_name}]"
+        elsif self.class.group_like?(info) then info.descriptor.message_type.name
+        else info.name
+        end
+        if info.map
+          v.keys.sort_by { |k| map_key_order(k) }.each do |k|
+            open_block(name, out, depth)
+            line("key: #{scalar(info.key, k)}", out, depth + 1)
+            value = v[k]
+            if info.value.message?
+              open_block("value", out, depth + 1)
+              fields(value, out, depth + 2)
+              close_block(out, depth + 1)
+            else
+              line("value: #{scalar(info.value, value)}", out, depth + 1)
+            end
+            close_block(out, depth)
+          end
+        else
+          (info.repeated ? v : [v]).each do |e|
+            if info.message?
+              open_block(name, out, depth)
+              fields(e, out, depth + 1)
+              close_block(out, depth)
+            else
+              line("#{name}: #{scalar(info, e)}", out, depth)
+            end
+          end
+        end
+      end
+
+      def map_key_order(k)
+        case k
+        when false then 0
+        when true then 1
+        else k
+        end
+      end
+
+      def line(text, out, depth)
+        if @single_line
+          out << text << " "
+        else
+          out << ("  " * depth) << text << "\n"
+        end
+      end
+
+      def open_block(name, out, depth)
+        line("#{name} {", out, depth)
+      end
+
+      def close_block(out, depth)
+        line("}", out, depth)
+      end
+
+      def scalar(info, v)
+        case info.kind
+        when F::DOUBLE then double(v)
+        when F::FLOAT then float(v)
+        when F::BOOL then v ? "true" : "false"
+        when F::STRING then quote(v, @as_utf8)
+        when F::BYTES then quote(v, false)
+        when F::ENUM then v.to_s
+        else v.to_s
+        end
+      end
+
+      def quote(s, utf8)
+        if utf8 && s.valid_encoding? && s.encoding == Encoding::UTF_8
+          "\"#{s.gsub(UTF8_ESCAPED) { |c| ESCAPES[c.ord] }}\""
+        else
+          "\"#{s.b.gsub(ESCAPED) { |c| ESCAPES[c.ord] }}\""
+        end
+      end
+
+      def double(v)
+        return nonfinite(v) unless v.finite?
+        s = format("%.15g", v)
+        back = Float(s)
+        (back == v) ? s : format("%.17g", v)
+      end
+
+      # protoc reads the short form back with strtof, which it does not trust
+      # for subnormal results, so those always get nine digits
+      def float(v)
+        return nonfinite(v) unless v.finite?
+        s = format("%.6g", v)
+        back = Message::Coercion.float32(Float(s))
+        (back == v && (back == 0 || back.abs >= FLOAT_MIN_NORMAL)) ? s : format("%.9g", v)
+      end
+
+      def nonfinite(v)
+        if v.nan? then "nan"
+        elsif v > 0 then "inf"
+        else "-inf"
+        end
+      end
+
+      def any(msg, out, depth)
+        return false unless msg.class.descriptor.full_name == ANY
+        values = msg.__values
+        by_name = msg.class.__by_name
+        url = values[by_name.fetch("type_url").index]
+        bytes = values[by_name.fetch("value").index]
+        return false if url.nil? || url.empty? || !msg.unknown_fields.empty?
+        slash = url.rindex("/")
+        return false if slash.nil?
+        klass = Types.find(url[(slash + 1)..], registry: @registry || Types.registry)
+        return false unless klass.is_a?(Class)
+        inner = begin
+          klass.decode(bytes || "")
+        rescue DecodeError
+          return false
+        end
+        open_block("[#{url}]", out, depth)
+        fields(inner, out, depth + 1)
+        close_block(out, depth)
+        true
+      end
+
+      # protoc's PrintUnknownFields: varints unsigned, fixed widths in hex,
+      # length-delimited as a nested block when the bytes read as fields
+      def unknown_fields(list, out, depth)
+        list.each do |number, wire_type, value|
+          case wire_type
+          when Wire::VARINT
+            line("#{number}: #{unknown_value(wire_type, value)}", out, depth)
+          when Wire::FIXED32, Wire::FIXED64
+            line("#{number}: #{unknown_value(wire_type, value)}", out, depth)
+          when Wire::LENGTH_DELIMITED
+            payload = value.is_a?(UnknownField) ? value.value : value
+            nested = payload.empty? ? nil : UnknownSet.parse(payload)
+            if nested
+              open_block(number, out, depth)
+              unknown_fields(nested, out, depth + 1)
+              close_block(out, depth)
+            else
+              line("#{number}: #{quote(payload, false)}", out, depth)
+            end
+          when Wire::START_GROUP
+            nested = value.is_a?(UnknownField) ? UnknownSet.parse(value.value) : value
+            open_block(number, out, depth)
+            unknown_fields(nested || [], out, depth + 1)
+            close_block(out, depth)
+          end
+        end
+      end
+
+      def unknown_value(wire_type, value)
+        value = value.value if value.is_a?(UnknownField)
+        case wire_type
+        when Wire::FIXED32 then format("0x%08x", value)
+        when Wire::FIXED64 then format("0x%016x", value)
+        else value.to_s
+        end
+      end
+
+      # Reads bytes as a sequence of fields with no schema, the way protoc's
+      # UnknownFieldSet does, to see whether a length-delimited field holds a message
+      # @api private
+      module UnknownSet
+        MAX_DEPTH = 100
+
+        module_function
+
+        # @return [Array<Array(Integer, Integer, Object)>, nil] number, wire type and
+        #   value (Integer, payload String, or the fields of a group); nil when the
+        #   bytes are not a well-formed sequence of fields
+        def parse(bytes)
+          r = Wire::Reader.new(bytes)
+          list = read(r, nil, MAX_DEPTH)
+          r.eof? ? list : nil
+        rescue DecodeError
+          nil
+        end
+
+        def read(r, group, depth)
+          return nil if depth <= 0
+          list = []
+          until r.eof?
+            tag = r.read_varint
+            number = tag >> 3
+            wire_type = tag & 7
+            return nil if number == 0 || number > Wire::MAX_FIELD_NUMBER
+            case wire_type
+            when Wire::VARINT then list << [number, wire_type, r.read_varint]
+            when Wire::FIXED64 then list << [number, wire_type, r.read_fixed64]
+            when Wire::FIXED32 then list << [number, wire_type, r.read_fixed32]
+            when Wire::LENGTH_DELIMITED then list << [number, wire_type, r.read_bytes]
+            when Wire::START_GROUP
+              nested = read(r, number, depth - 1) or return nil
+              list << [number, wire_type, nested]
+            when Wire::END_GROUP
+              return (number == group) ? list : nil
+            else return nil
+            end
+          end
+          group ? nil : list
+        end
+      end
+    end
+  end
+end

data/lib/protostar/text/tokenizer.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Protostar
+  module Text
+    # Splits text format into tokens the way protoc's io::Tokenizer does:
+    # identifiers, integers (decimal, hex, octal), floats (an `f` suffix
+    # allowed), quoted strings, and single-character symbols. `#` starts a
+    # comment that runs to the end of the line.
+    # @api private
+    class Tokenizer
+      # One token: `type` is :identifier, :integer, :float, :string, :symbol
+      # or :eof, `text` its source text, `pos` its byte offset
+      class Token
+        attr_reader :type, :text, :pos
+
+        def initialize(type, text, pos)
+          @type = type
+          @text = text
+          @pos = pos
+          freeze
+        end
+
+        def ==(other)
+          other.is_a?(Token) && other.type == @type && other.text == @text && other.pos == @pos
+        end
+      end
+
+      SKIP = /(?:\s+|#[^\n]*)+/
+      IDENTIFIER = /[A-Za-z_][A-Za-z0-9_]*/
+      HEX = /0[xX][0-9A-Fa-f]+/
+      FLOAT = /(?:\d+\.\d*|\.\d+)(?:[eE][-+]?\d+)?[fF]?|\d+[eE][-+]?\d+[fF]?|\d+[fF]/
+      INTEGER = /\d+/
+      STRING = /"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'/
+      NUMBER_TAIL = /[A-Za-z0-9_.]/
+      URL_CHARS = %r{[A-Za-z0-9_\-.~!$&()*+,;=%/]+}
+
+      def initialize(text)
+        @text = text
+        @scanner = StringScanner.new(text)
+        @peeked = nil
+      end
+
+      # @return [Token] the next token without consuming it
+      def peek
+        @peeked ||= scan
+      end
+
+      # @return [Token] the next token, consumed
+      def next
+        t = peek
+        @peeked = nil
+        t
+      end
+
+      # What protoc's tokenizer reads in URL mode between `[` and `]`: runs of
+      # URL characters, joined, with whitespace and comments between them
+      # dropped. Call it right after consuming the `[`.
+      # @return [Array(String, Integer)] the text and where it starts
+      def url_chars
+        raise ArgumentError, "a token was peeked past the [" if @peeked
+        @scanner.skip(SKIP)
+        pos = @scanner.pos
+        text = +""
+        while (run = @scanner.scan(URL_CHARS))
+          text << run
+          @scanner.skip(SKIP)
+        end
+        [text, pos]
+      end
+
+      # @return [Array(Integer, Integer)] 1-based line and column of a byte position
+      def line_col(pos)
+        before = @text.byteslice(0, pos)
+        line = before.count("\n") + 1
+        last = before.rindex("\n")
+        [line, before.length - (last ? last + 1 : 0) + 1]
+      end
+
+      # @raise [ParseError]
+      def fail!(message, pos)
+        raise ParseError.new(message, *line_col(pos))
+      end
+
+      private
+
+      def scan
+        s = @scanner
+        s.skip(SKIP)
+        pos = s.pos
+        return Token.new(:eof, "", pos) if s.eos?
+        if (t = s.scan(IDENTIFIER))
+          Token.new(:identifier, t, pos)
+        elsif (t = s.scan(HEX))
+          number(:integer, t, pos)
+        elsif (t = s.scan(FLOAT))
+          number(:float, t, pos)
+        elsif (t = s.scan(INTEGER))
+          number(:integer, t, pos)
+        elsif (t = s.scan(STRING))
+          Token.new(:string, t, pos)
+        elsif s.check(/["']/)
+          fail!("unterminated string", pos)
+        else
+          Token.new(:symbol, s.getch, pos)
+        end
+      end
+
+      def number(type, text, pos)
+        fail!("need space between number and identifier", @scanner.pos) if @scanner.check(NUMBER_TAIL)
+        Token.new(type, text, pos)
+      end
+    end
+  end
+end

data/lib/protostar/text.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Protostar
+  # protoc's text format: what `protoc --decode` prints and `--encode` reads.
+  #
+  #   text = Protostar::Text.print(person)      # also person.to_text
+  #   Protostar::Text.parse(Person, text) == person
+  #
+  # Extensions have no API of their own yet: they travel as unknown fields.
+  # The printer shows an unknown field as `[full.name]` when it is an
+  # extension of the message known to its file (or to `pool:`), and the
+  # parser turns `[full.name]` into the unknown field the binary codec would
+  # have kept.
+  module Text
+    # Raised by everything in {Text}
+    class Error < Protostar::Error; end
+
+    # Raised for text that does not describe a message of the class it is
+    # parsed into. The message starts with `line:column:`, both 1-based.
+    class ParseError < Error
+      # @return [Integer]
+      attr_reader :line, :column
+
+      def initialize(message, line, column)
+        @line = line
+        @column = column
+        super("#{line}:#{column}: #{message}")
+      end
+    end
+
+    class << self
+      # @param message [Message]
+      # @option options [Boolean] :single_line everything on one line, fields separated by spaces
+      # @option options [Boolean] :expand_any print an Any whose type is known as
+      #   `[type_url] { ... }`; off by default, as in `protoc --decode`
+      #   (protoc's DebugString expands)
+      # @option options [Boolean] :as_utf8 keep valid UTF-8 in strings readable instead of
+      #   escaping every byte above 0x7e in octal as protoc does
+      # @option options [Boolean] :unknown_fields false leaves unknown fields out, as
+      #   protoc's Printer#SetHideUnknownFields does; extensions still print
+      # @option options [Types::Registry] :registry where classes for Any and extensions are found
+      # @option options [Schema::Pool, nil] :pool where extensions are found; by default
+      #   the message's file and the files it imports
+      # @return [String]
+      def print(message, **options)
+        Printer.new(**options).print(message)
+      end
+
+      # @param klass [Class] a message class
+      # @param text [String]
+      # @option options [Boolean] :allow_unknown_fields skip fields and extensions that are not known
+      # @option options [Boolean] :allow_partial when false, raise if a required field is missing
+      # @option options [Types::Registry] :registry where classes for Any and extensions are found
+      # @option options [Schema::Pool, nil] :pool where extensions are found
+      # @return [Message]
+      # @raise [ParseError]
+      def parse(klass, text, **options)
+        Parser.new(text, **options).parse(klass)
+      end
+    end
+  end
+end
+
+require_relative "text/tokenizer"
+require_relative "text/extensions"
+require_relative "text/printer"
+require_relative "text/parser"

data/lib/protostar/types.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Protostar
+  # Defines message classes and enum modules from descriptors, and keeps a
+  # registry of them by full name.
+  #
+  #   types = Protostar::Types.define(schema_file)
+  #   Person = types.fetch("acme.Person")
+  #   Protostar::Types.find("acme.Person") # => Person
+  #
+  # The registry is a process-wide object guarded by a Mutex and is meant to be
+  # used from the main Ractor. The classes and modules it hands out can be used
+  # from any Ractor.
+  module Types
+    # A set of defined types, by full name, and the files they came from
+    class Registry
+      # @param open_enums [Boolean] treat every enum as open: numbers without a
+      #   name are kept in the field on decode and accepted on assignment, as
+      #   google-protobuf's Ruby gem does, instead of going to unknown fields
+      def initialize(open_enums: false)
+        @open_enums = open_enums
+        @mutex = Mutex.new
+        @types = {}
+        @files = {}
+      end
+
+      # @param full_name [String] without a leading dot
+      # @return [Class, Module, nil]
+      def find(full_name)
+        @mutex.synchronize { @types[full_name] }
+      end
+
+      # @param file_name [String]
+      # @return [Hash{String => Class, Module}, nil] what {#define} returned for the file
+      def file(file_name)
+        @mutex.synchronize { @files[file_name]&.last }
+      end
+
+      # Defines every message and enum of a file. The file's dependencies must
+      # have been defined first. Defining the same {Schema::File} again returns
+      # the types made the first time.
+      # @param file [Schema::File]
+      # @param name [Module, nil] a namespace: when given, top-level types
+      #   become its constants and nested types constants of their parent class
+      # @return [Hash{String => Class, Module}] frozen, full name to class or module
+      # @raise [Error] for an undefined dependency or a name already defined from another file
+      def define(file, name: nil)
+        @mutex.synchronize do
+          if (defined = @files[file.name])
+            return defined.last if defined.first.equal?(file)
+            raise Error, "file \"#{file.name}\" is already defined from another descriptor"
+          end
+          types = Definer.new(file, @types, open_enums: @open_enums).define
+          types.each_key do |full_name|
+            raise Error, "\"#{full_name}\" is already defined by \"#{@types[full_name].descriptor.file.name}\"" if @types.key?(full_name)
+          end
+          Types.assign_constants(file, types, name) if name
+          types.each_value { |t| t.freeze if t.is_a?(Module) && !t.is_a?(Class) }
+          @types.merge!(types)
+          @files[file.name] = [file, types]
+          types
+        end
+      end
+    end
+
+    @registry = Registry.new
+
+    class << self
+      # @return [Registry] the process-wide registry
+      attr_reader :registry
+
+      # @see Registry#define
+      def define(file, name: nil, registry: @registry)
+        registry.define(file, name: name)
+      end
+
+      # @see Registry#find
+      def find(full_name, registry: @registry)
+        registry.find(full_name)
+      end
+
+      # @api private
+      def assign_constants(file, types, namespace)
+        place = lambda do |descriptor, owner|
+          const = Enum.constant_name(descriptor.name)
+          type = types[descriptor.full_name]
+          return unless const && type
+          owner.const_set(const, type) unless owner.const_defined?(const, false)
+          return unless descriptor.is_a?(Schema::Message)
+          descriptor.nested_messages.each { |m| place.call(m, type) }
+          descriptor.nested_enums.each { |e| place.call(e, type) }
+        end
+        file.messages.each { |m| place.call(m, namespace) }
+        file.enums.each { |e| place.call(e, namespace) }
+      end
+    end
+
+    # Makes the classes and modules of one file
+    # @api private
+    class Definer
+      def initialize(file, known, open_enums: false)
+        @file = file
+        @known = known
+        @open_enums = open_enums
+        @types = {}
+        @reserved = Message::Accessors.reserved
+      end
+
+      def define
+        messages = @file.all_messages.reject(&:map_entry?)
+        @file.all_enums.each { |e| @types[e.full_name] = Enum.build(e) }
+        messages.each { |m| @types[m.full_name] = Class.new(Message) }
+        messages.each { |m| setup(@types[m.full_name], m) }
+        @types.freeze
+      end
+
+      private
+
+      # Names end up inside class_eval'd source, so anything a .proto could not spell is refused
+      IDENTIFIER = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+
+      def setup(klass, descriptor)
+        (descriptor.fields.map(&:name) + descriptor.real_oneofs.map(&:name)).each do |n|
+          raise Protostar::Error, "#{descriptor.full_name} has a name that is not an identifier: #{n.inspect}" unless IDENTIFIER.match?(n)
+        end
+        oneof_slots = descriptor.real_oneofs.to_h do |o|
+          [o, o.fields.map { |f| descriptor.fields.index(f) }]
+        end
+        classes = method(:resolve)
+        fields = descriptor.fields.each_with_index.map do |f, i|
+          slots = oneof_slots[f.real_oneof] if f.real_oneof
+          Message::FieldInfo.new(f, i, classes, siblings: slots && (slots - [i]), open_enums: @open_enums)
+        end
+        oneofs = oneof_slots.map { |o, slots| [o.name.to_sym, slots] }
+        klass.__define(descriptor: descriptor, fields: fields, oneofs: oneofs)
+        Message::Accessors.install(klass, fields, oneofs, @reserved)
+        Codec::DecodeGenerator.install(klass, fields)
+        Codec::EncodeGenerator.install(klass, fields)
+        View::Generator.install(klass, fields, oneofs)
+        return unless descriptor.full_name.start_with?("google.protobuf.")
+        well_known = WellKnown::MIXINS[descriptor.full_name]
+        klass.include(well_known) if well_known
+      end
+
+      def resolve(descriptor)
+        @types[descriptor.full_name] || @known[descriptor.full_name] ||
+          raise(Error, "#{descriptor.full_name} comes from \"#{descriptor.file.name}\", which must be " \
+            "defined before \"#{@file.name}\"")
+      end
+    end
+  end
+end

data/lib/protostar/unknown_field.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Protostar
+  # A field the decoder did not recognise, kept so that it is re-emitted on
+  # encode. {#bytes} are the raw bytes that followed the tag on the wire,
+  # verbatim: a varint as it was encoded, 4 or 8 fixed bytes, a length prefix
+  # and its payload, or a group's contents through its end tag.
+  class UnknownField
+    # @return [Integer]
+    attr_reader :number
+    # @return [Integer] one of the {Wire} wire type constants
+    attr_reader :wire_type
+    # @return [String] frozen, binary
+    attr_reader :bytes
+
+    # @param number [Integer]
+    # @param wire_type [Integer]
+    # @param bytes [String] the bytes after the tag; copied unless frozen and binary
+    def initialize(number, wire_type, bytes)
+      @number = number
+      @wire_type = wire_type
+      @bytes = (bytes.frozen? && bytes.encoding == Encoding::BINARY) ? bytes : bytes.b.freeze
+      freeze
+    end
+
+    # @return [Integer, String] the decoded value: an Integer for varint and
+    #   fixed wire types, the payload without its length prefix for
+    #   length-delimited, the contents without the end tag for a group
+    def value
+      r = Wire::Reader.new(@bytes)
+      case @wire_type
+      when Wire::VARINT then r.read_varint
+      when Wire::FIXED32 then r.read_fixed32
+      when Wire::FIXED64 then r.read_fixed64
+      when Wire::LENGTH_DELIMITED then r.read_bytes
+      else @bytes.byteslice(0, @bytes.bytesize - Wire.varint_size(Wire.tag(@number, Wire::END_GROUP)))
+      end
+    end
+
+    # @return [String] the field as it goes on the wire, tag included
+    def to_wire
+      Wire.tag_bytes(@number, @wire_type) + @bytes
+    end
+
+    def ==(other)
+      other.is_a?(UnknownField) && other.number == @number && other.wire_type == @wire_type && other.bytes == @bytes
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [UnknownField, @number, @wire_type, @bytes].hash
+    end
+
+    def inspect
+      "#<#{self.class.name} #{@number}:#{Wire::NAMES.fetch(@wire_type)} #{@bytes.inspect}>"
+    end
+  end
+end