proto_turf 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a059f77cfc5a504cf09140a84a578a3609ef40c83074897f8dda0eb42bcc011e
-  data.tar.gz: 1f0156bec33ddd18a48d90a3500b20066bf3a99a57627ef5a811e4efe439a60f
+  metadata.gz: d406d02e3db35efe7976a07238831d78ffeefc9692b6082c240aaf61983ec8be
+  data.tar.gz: 6ed547fb924c5d14526e22523417397b0b8b64682d4a79ca5aa78284ae940703
 SHA512:
-  metadata.gz: 6d7d01d659d17256f3cb3bcba5abb9a1b5634c0e423cb7a0b603855ddbd3c26abb882ca8ae23e651fa5b1e7d39286ff024933fb31c058b57a6077d5b6a4f37ae
-  data.tar.gz: eab1c0e1e9b220a1eb1a9adf2b969adde64298d248816faffa9ed96f15d0ca565997d9d7e201f8d4fef5fe7cf3d128d971720b3393532fb083704bf1ca640774
+  metadata.gz: 8bd87219da56f1a9c555265dde48c7b11e86986b3e14ce4f849747054e7e5dc1c51ac64b43b584894f2215320580a72a9a159f0e94c56b868d99fc4c6ed0cc05
+  data.tar.gz: 43d9f128249dfc33e6f8db72a44541cc69a665e168075de1af6f40564e24c0bbdcc12587f1bdb4744ffe2606c3ff66cdc495ca08f06a6a7223c6882626d0b9be

data/.github/workflows/lint.yml

@@ -0,0 +1,18 @@
+name: Lint
+
+on: [push, pull_request]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby ${{ matrix.ruby }}
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.4
+        bundler-cache: true
+    - name: Run standardrb
+      run: bundle exec standardrb

data/.github/workflows/release.yml

@@ -0,0 +1,31 @@
+name: Release Gem
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - 'v*.*.*' # Matches semantic versioning tags like v1.0.0
+  workflow_dispatch: # Allows manual triggering of the workflow
+
+jobs:
+  push:
+    name: Push gem to RubyGems.org
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write # IMPORTANT: this permission is mandatory for trusted publishing
+      contents: write # IMPORTANT: this permission is required for `rake release` to push the release tag
+
+    steps:
+      # Set up
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+          ruby-version: ruby
+
+      # Release
+      - uses: rubygems/release-gem@v1

data/.github/workflows/test.yml

@@ -0,0 +1,22 @@
+name: Test
+
+on: [push, pull_request]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [3.1, 3.2, 3.3, 3.4]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby ${{ matrix.ruby }}
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - name: Build and test with RSpec
+      run: bundle exec rspec

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## UNRELEASED
 
-# 0.0.2 - 2025-8-14
+# 0.0.4 - 2025-08-19
+
+* Changed emitting of protobuf schemas from file-based to generated from descriptors.
+
+# 0.0.3 - 2025-08-15
 
 * Initial release.

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,110 @@
+PATH
+  remote: .
+  specs:
+    proto_turf (0.0.4)
+      excon
+      google-protobuf
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
+    ast (2.4.3)
+    bigdecimal (3.2.2)
+    crack (1.0.0)
+      bigdecimal
+      rexml
+    diff-lcs (1.6.1)
+    excon (1.2.9)
+      logger
+    google-protobuf (4.30.2-arm64-darwin)
+      bigdecimal
+      rake (>= 13)
+    google-protobuf (4.30.2-x86_64-linux)
+      bigdecimal
+      rake (>= 13)
+    hashdiff (1.2.0)
+    json (2.13.2)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    parallel (1.27.0)
+    parser (3.3.9.0)
+      ast (~> 2.4.1)
+      racc
+    prism (1.4.0)
+    public_suffix (6.0.2)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.3.0)
+    regexp_parser (2.11.2)
+    rexml (3.4.1)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.3)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.3)
+    rubocop (1.75.8)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.44.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.46.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.4)
+    rubocop-performance (1.25.0)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.75.0, < 2.0)
+      rubocop-ast (>= 1.38.0, < 2.0)
+    ruby-progressbar (1.13.0)
+    standard (1.50.0)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.75.5)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.8)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.8.0)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.25.0)
+    standardrb (1.0.1)
+      standard
+    unicode-display_width (3.1.5)
+      unicode-emoji (~> 4.0, >= 4.0.4)
+    unicode-emoji (4.0.4)
+    webmock (3.25.1)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  arm64-darwin
+  x86_64-linux
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  proto_turf!
+  rake (~> 13.0)
+  rspec (~> 3.2)
+  standardrb
+  webmock
+
+BUNDLED WITH
+   2.6.7

data/README.md

@@ -27,7 +27,7 @@ Example usage:
 ```ruby
 require 'proto_turf'
 
-proto_turf = ProtoTurf.new(registry_url: 'http://localhost:8081')
+proto_turf = ProtoTurf.new(registry_url: 'http://localhost:8081', schema_paths: ['path/to/protos'])
 message = MyProto::MyMessage.new(field1: 'value1', field2: 42)
 encoded = proto_turf.encode(message, subject: 'my-subject')
 
@@ -38,7 +38,15 @@ decoded_proto_message = proto_turf.decode(encoded_string)
 
 If you're using [buf](https://buf.build/) to manage your Protobuf definitions, you should run `buf export` before using `proto_turf` to ensure that all the dependencies are available as `.proto` files in your project. The actual proto text is needed when registering the schema with the Schema Registry.
 
+Because `buf export` overwrites/deletes existing files, you should run it into a different directory and provide both as `schema_paths` to the `ProtoTurf` constructor.
+
 ## Notes about usage
 
 * When decoding, this library does *not* attempt to fully parse the Proto definition stored on the schema registry and generate dynamic classes. Instead, it simply parses out the package and message and assumes that the reader has the message available in the descriptor pool. Any compatibility issues should be detected through normal means, i.e. just by instantiating the message and seeing if any errors are raised.
 
+### Regenerating test protos
+Run the following to regenerate:
+
+```sh
+protoc -I spec/schemas --ruby_out=spec/gen --ruby_opt=paths=source_relative spec/schemas/**/*.proto
+```

data/Rakefile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'

data/lib/proto_turf/cached_confluent_schema_registry.rb

@@ -1,5 +1,4 @@
 class ProtoTurf::CachedConfluentSchemaRegistry
-
   # @param upstream [ProtoTurf::ConfluentSchemaRegistry]
   def initialize(upstream)
     @upstream = upstream
@@ -9,7 +8,7 @@ class ProtoTurf::CachedConfluentSchemaRegistry
   end
 
   # Delegate the following methods to the upstream
-  %i(subject_versions schema_subject_versions).each do |name|
+  %i[subject_versions schema_subject_versions].each do |name|
     define_method(name) do |*args|
       instance_variable_get(:@upstream).send(name, *args)
     end
@@ -29,14 +28,14 @@ class ProtoTurf::CachedConfluentSchemaRegistry
     return @versions_by_subject_and_id[key] if @versions_by_subject_and_id[key]
 
     results = @upstream.schema_subject_versions(id)
-    @versions_by_subject_and_id[key] = results&.find { |r| r['subject'] == subject }&.dig('version')
+    @versions_by_subject_and_id[key] = results&.find { |r| r["subject"] == subject }&.dig("version")
   end
 
   # @param subject [String] the subject to check
   # @param schema [String] the schema text to check
   # @return [Boolean] true if we know the schema has been registered for that subject.
   def registered?(subject, schema)
-    @ids_by_schema[[subject, schema]].present?
+    @ids_by_schema[[subject, schema]] && !@ids_by_schema[[subject, schema]].empty?
   end
 
   # @param subject [String] the subject to register the schema under
@@ -47,5 +46,4 @@ class ProtoTurf::CachedConfluentSchemaRegistry
 
     @ids_by_schema[key] ||= @upstream.register(subject, schema, references: references)
   end
-
 end

data/lib/proto_turf/confluent_schema_registry.rb

@@ -1,8 +1,7 @@
-require 'excon'
+require "excon"
 
 class ProtoTurf
   class ConfluentSchemaRegistry
-
     CONTENT_TYPE = "application/vnd.schemaregistry.v1+json".freeze
 
     def initialize(
@@ -24,7 +23,7 @@ class ProtoTurf
       retry_limit: nil
     )
       @path_prefix = path_prefix
-      @schema_context_prefix = schema_context.nil? ? '' : ":.#{schema_context}:"
+      @schema_context_prefix = schema_context.nil? ? "" : ":.#{schema_context}:"
       @schema_context_options = schema_context.nil? ? {} : {query: {subject: @schema_context_prefix}}
       @logger = logger
       headers = Excon.defaults[:headers].merge(
@@ -57,7 +56,7 @@ class ProtoTurf
     # @return [String] the schema string stored in the registry for the given id
     def fetch(id)
       @logger.info "Fetching schema with id #{id}"
-      data = get("/schemas/ids/#{id}", idempotent: true, **@schema_context_options, )
+      data = get("/schemas/ids/#{id}", idempotent: true, **@schema_context_options)
       data.fetch("schema")
     end
 
@@ -73,9 +72,9 @@ class ProtoTurf
     # @return [Integer] the ID of the registered schema
     def register(subject, schema, references: [])
       data = post("/subjects/#{@schema_context_prefix}#{CGI.escapeURIComponent(subject)}/versions",
-                  body: { schemaType: 'PROTOBUF',
-                          references: references,
-                          schema: schema.to_s }.to_json)
+        body: {schemaType: "PROTOBUF",
+               references: references,
+               schema: schema.to_s}.to_json)
 
       id = data.fetch("id")
 
@@ -105,7 +104,7 @@ class ProtoTurf
     end
 
     def request(path, **options)
-      options = { expects: 200 }.merge!(options)
+      options = {expects: 200}.merge!(options)
       path = File.join(@path_prefix, path) unless @path_prefix.nil?
       response = @connection.request(path: path, **options)
       JSON.parse(response.body)
@@ -113,6 +112,5 @@ class ProtoTurf
       @logger.error("Error while requesting #{path}: #{e.response.body}")
       raise
     end
-
   end
 end

data/lib/proto_turf/proto_text.rb

@@ -0,0 +1,315 @@
+class ProtoTurf
+  module ProtoText
+    ParseInfo = Struct.new(:writer, :package, :message) do
+      %i[write write_indent write_line writenl indent dedent].each do |method|
+        define_method(method) do |*args|
+          writer.send(method, *args)
+        end
+      end
+    end
+
+    class Writer < StringIO
+      def initialize(...)
+        super
+        @indent = 0
+      end
+
+      def write_indent(str)
+        @indent.times { write(" ") }
+        write(str)
+      end
+
+      def write_line(line, nl = 1)
+        write_indent(line)
+        nl.times { writenl }
+      end
+
+      def writenl
+        write("\n")
+      end
+
+      def indent
+        @indent += 2
+      end
+
+      def dedent
+        @indent -= 2
+      end
+    end
+
+    class << self
+      def fetch(message_name)
+        name = message_name.start_with?(".") ? message_name[1..] : message_name
+        Google::Protobuf::DescriptorPool.generated_pool.lookup(name)
+      end
+
+      def output(file_descriptor)
+        writer = Writer.new
+        info = ParseInfo.new(writer, file_descriptor.package)
+        writer.write_line("syntax = \"#{file_descriptor.syntax}\";", 2)
+        writer.write_line("package #{file_descriptor.package};")
+        writer.writenl
+        found = false
+        file_descriptor.options.to_h.each do |name, value|
+          found = true
+          writer.write_line("option #{name} = #{value.to_json};")
+        end
+        writer.writenl if found
+
+        found = false
+        file_descriptor.dependency.each do |dependency|
+          found = true
+          writer.write_line("import \"#{dependency}\";")
+        end
+        writer.writenl if found
+
+        writer.writenl if write_options(info, file_descriptor)
+        writer.writenl if write_extensions(info, file_descriptor)
+
+        file_descriptor.enum_type.each do |enum_type|
+          write_enum(info, enum_type)
+        end
+        file_descriptor.message_type.each do |message_type|
+          write_message(info, message_type)
+        end
+        file_descriptor.service.each do |service|
+          write_service(info, service)
+        end
+        writer.string
+      end
+
+      def write_extensions(info, descriptor)
+        descriptor.extension.each do |extension|
+          info.write_line("extend #{extension.extendee[1..]} {")
+          info.indent
+          write_field(info, extension)
+          info.dedent
+          info.write_line("}")
+        end
+        descriptor.extension.any?
+      end
+
+      def write_reserved(writer, descriptor)
+        reserved = descriptor.reserved_range.map do |range|
+          (range.start == range.end - 1) ? range.start.to_s : "#{range.start} to #{range.end - 1}"
+        end
+        found = false
+        if reserved.any?
+          found = true
+          writer.write_line("reserved #{reserved.join(", ")};")
+        end
+        if descriptor.reserved_name.any?
+          found = true
+          writer.write_line("reserved #{descriptor.reserved_name.map(&:to_json).join(", ")};")
+        end
+        writer.writenl if found
+      end
+
+      def write_imports(writer, file_descriptor)
+        writer.writenl
+        file_descriptor.dependency.each do |dependency|
+          writer.write_line("import \"#{dependency}\";")
+        end
+        file_descriptor.public_dependency.each do |public_dependency|
+          writer.write_line("import public \"#{public_dependency}\";")
+        end
+        file_descriptor.option_dependency.each do |option_dependency|
+          writer.write_line("import weak \"#{option_dependency}\";")
+        end
+        writer.writenl
+      end
+
+      def write_message(info, message_type)
+        info.message = message_type
+        info.write_indent("message ")
+        info.write("#{message_type.name} {")
+        info.writenl
+        info.indent
+
+        write_options(info, message_type)
+        write_reserved(info, message_type)
+
+        message_type.enum_type.each do |enum|
+          info.writenl
+          write_enum(info, enum)
+        end
+        message_type.field.each do |field|
+          write_field(info, field)
+        end
+        message_type.extension.each do |extension|
+          write_field(info, extension)
+        end
+        write_oneofs(info, message_type)
+        message_type.nested_type.each do |subtype|
+          info.writenl
+          write_message(info, subtype)
+        end
+        info.dedent
+        info.write_line("}")
+      end
+
+      def field_type(info, field_type)
+        case field_type.type
+        when :TYPE_INT32
+          "int32"
+        when :TYPE_INT64
+          "int64"
+        when :TYPE_UINT32
+          "uint32"
+        when :TYPE_UINT64
+          "uint64"
+        when :TYPE_SINT32
+          "sint32"
+        when :TYPE_SINT64
+          "sint64"
+        when :TYPE_FIXED32
+          "fixed32"
+        when :TYPE_FIXED64
+          "fixed64"
+        when :TYPE_SFIXED32
+          "sfixed32"
+        when :TYPE_SFIXED64
+          "sfixed64"
+        when :TYPE_FLOAT
+          "float"
+        when :TYPE_DOUBLE
+          "double"
+        when :TYPE_BOOL
+          "bool"
+        when :TYPE_STRING
+          "string"
+        when :TYPE_BYTES
+          "bytes"
+        when :TYPE_ENUM, :TYPE_MESSAGE
+          # remove leading .
+          type = fetch(field_type.type_name[1..])
+          name = type.name.sub("#{info.package}.#{info.message.name}.", "")
+          name.sub("#{info.package}.", "")
+        end
+      end
+
+      def write_field(info, field, oneof: false)
+        info.write_indent("")
+        return if !oneof && field.has_oneof_index?
+
+        klass = nil
+        if field.type_name && field.type_name != ""
+          klass = fetch(field.type_name).to_proto
+        end
+
+        if field.proto3_optional
+          info.write("optional ")
+        elsif field.label == :LABEL_REPEATED && !klass&.options&.map_entry
+          info.write("repeated ")
+        end
+
+        if klass&.options&.map_entry
+          info.write("map<#{field_type(info, klass.field[0])}, #{field_type(info, klass.field[1])}>")
+        else
+          info.write(field_type(info, field).to_s)
+        end
+        info.write(" #{field.name} = #{field.number}")
+
+        write_field_options(info, field)
+        info.write(";")
+        info.writenl
+      end
+
+      def write_field_options(info, field)
+        return unless field.options
+
+        info.write(" [")
+        info.write(field.options.to_h.map { |name, value| "#{name} = #{value}" }.join(", "))
+        write_options(info, field, include_option_label: false)
+        info.write("]")
+      end
+
+      def write_oneofs(info, message)
+        message.oneof_decl.each_with_index do |oneof, i|
+          next if oneof.name.start_with?("_") &&
+            message.field.any? { |f| f.proto3_optional && f.name == oneof.name[1..] }
+          info.write_line("oneof #{oneof.name} {")
+          info.indent
+          message.field.select { |f| f.has_oneof_index? && f.oneof_index == i }.each do |field|
+            write_field(info, field, oneof: true)
+          end
+          info.dedent
+          info.write_line("}")
+        end
+      end
+
+      def write_enum(info, enum_type)
+        info.write("enum ")
+        info.write("#{enum_type.name} {")
+        info.writenl
+        info.indent
+        write_reserved(info, enum_type)
+        enum_type.value.each do |value|
+          info.write_line("#{value.name} = #{value.number};")
+        end
+        info.dedent
+        info.write_line("}")
+        info.writenl
+      end
+
+      def method_type(package, name)
+        output = name.sub("#{package}.", "")
+        output = output[1..] if output.start_with?(".")
+        output
+      end
+
+      def write_service(info, service)
+        info.write_line("service #{service.name} {")
+        info.indent
+        service["method"].each do |method|
+          info.write_indent("rpc #{method.name}(#{method_type(info.package, method.input_type)}) ")
+          info.write("returns (#{method_type(info.package, method.output_type)}) {")
+          info.writenl
+          info.indent
+          if method.options
+            write_options(info, method)
+          end
+          info.dedent
+          info.write_line("};")
+        end
+        info.dedent
+        info.write_line("}")
+      end
+
+      # @return [Boolean] true if any options were written
+      def write_options(info, descriptor, include_option_label: true)
+        # unfortunately there doesn't seem to be a way to get the full list of options without
+        # resorting to to_json.
+        json = JSON.parse(descriptor.options.to_json)
+        return if !json || json.empty?
+
+        found = false
+        json.keys.each do |name|
+          option_name = name.tr("[]", "")
+          ext = fetch(option_name)
+          next if ext.nil?
+
+          found = true
+          options = ext.get(descriptor.options)
+          if include_option_label
+            info.write_indent("option (#{option_name}) =")
+          else
+            info.write("(#{option_name}) = ")
+          end
+          if options.respond_to?(:to_h)
+            lines = JSON.pretty_generate(options.to_h).lines(chomp: true)
+            lines.each_with_index do |line, i|
+              info.write_indent(line)
+              info.writenl if i < lines.length - 1
+            end
+            info.write(";")
+          else
+            info.write(options.to_json)
+          end
+          info.writenl
+        end
+        found
+      end
+    end
+  end
+end

data/lib/proto_turf/version.rb

@@ -1,3 +1,3 @@
 class ProtoTurf
-  VERSION = "0.0.2"
+  VERSION = "0.0.4"
 end

data/lib/proto_turf.rb

@@ -1,6 +1,11 @@
-require 'logger'
-require 'proto_turf/confluent_schema_registry'
-require 'proto_turf/cached_confluent_schema_registry'
+require "logger"
+require "google/protobuf"
+require "google/protobuf/well_known_types"
+require "google/protobuf/descriptor_pb"
+require "json"
+require "proto_turf/confluent_schema_registry"
+require "proto_turf/cached_confluent_schema_registry"
+require "proto_turf/proto_text"
 
 class ProtoTurf
   # Provides a way to encode and decode messages without having to embed schemas
@@ -15,14 +20,12 @@ class ProtoTurf
   # https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/index.html#wire-format
   MAGIC_BYTE = [0].pack("C").freeze
 
-
   # Instantiate a new ProtoTurf instance with the given configuration.
   #
   # registry             - A schema registry object that responds to all methods in the
   #                        ProtoTurf::ConfluentSchemaRegistry interface.
   # registry_url         - The String URL of the schema registry that should be used.
   # schema_context       - Schema registry context name (optional)
-  # schemas_path         - The String file system path where local schemas are stored.
   # registry_path_prefix - The String URL path prefix used to namespace schema registry requests (optional).
   # logger               - The Logger that should be used to log information (optional).
   # proxy                - Forward the request via  proxy (optional).
@@ -40,7 +43,6 @@ class ProtoTurf
     registry: nil,
     registry_url: nil,
     schema_context: nil,
-    schemas_path: nil,
     registry_path_prefix: nil,
     logger: nil,
     proxy: nil,
@@ -57,7 +59,6 @@ class ProtoTurf
     retry_limit: nil
   )
     @logger = logger || Logger.new($stderr)
-    @path = schemas_path
     @registry = registry || ProtoTurf::CachedConfluentSchemaRegistry.new(
       ProtoTurf::ConfluentSchemaRegistry.new(
         registry_url,
@@ -101,7 +102,7 @@ class ProtoTurf
     stream.write([id].pack("N"))
 
     _, indexes = find_index(message.class.descriptor.to_proto,
-                            file_descriptor.to_proto.message_type)
+      file_descriptor.to_proto.message_type)
 
     if indexes == [0]
       write_int(stream, 0)
@@ -138,7 +139,7 @@ class ProtoTurf
     end
 
     # The schema id is a 4-byte big-endian integer.
-    schema_id = stream.read(4).unpack("N").first
+    schema_id = stream.read(4).unpack1("N")
 
     # For now, we're only going to support a single message per schema. See
     # https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/index.html#wire-format
@@ -161,7 +162,7 @@ class ProtoTurf
 
   private
 
-  def find_index(descriptor, messages, indexes=[])
+  def find_index(descriptor, messages, indexes = [])
     messages.each_with_index do |sub_descriptor, i|
       if sub_descriptor == descriptor
         indexes.push(i)
@@ -221,7 +222,7 @@ class ProtoTurf
       raise "Could not find schema for #{full_name}. Make sure the corresponding .proto file has been compiled and loaded."
     end
     path = find_descriptor(indexes, descriptor.file_descriptor.to_proto.message_type)
-    correct_message = Google::Protobuf::DescriptorPool.generated_pool.lookup("#{package}.#{path.join('.')}")
+    correct_message = Google::Protobuf::DescriptorPool.generated_pool.lookup("#{package}.#{path.join(".")}")
     correct_message.msgclass.decode(encoded)
   end
 
@@ -230,7 +231,7 @@ class ProtoTurf
     return if @registry.registered?(file_descriptor.name, subject)
 
     # register dependencies first
-    dependencies = file_descriptor.to_proto.dependency.to_a.reject { |d| d.start_with?('google/protobuf/') }
+    dependencies = file_descriptor.to_proto.dependency.to_a.reject { |d| d.start_with?("google/protobuf/") }
     versions = dependencies.map do |dependency|
       dependency_descriptor = @all_schemas[dependency]
       result = register_schema(dependency_descriptor, subject: dependency_descriptor.name)
@@ -238,33 +239,27 @@ class ProtoTurf
     end
 
     @registry.register(subject,
-                       schema_text(file_descriptor),
-                       references: dependencies.map.with_index do |dependency, i|
-                         {
-                           name: dependency,
-                           subject: dependency,
-                           version: versions[i]
-                         }
-                       end
-    )
+      schema_text(file_descriptor),
+      references: dependencies.map.with_index do |dependency, i|
+        {
+          name: dependency,
+          subject: dependency,
+          version: versions[i]
+        }
+      end)
   end
 
   def schema_text(file_descriptor)
-    filename = "#{@path}/#{file_descriptor.name}"
-    File.exist?(filename) ? File.read(filename) : ""
+    ProtoTurf::ProtoText.output(file_descriptor.to_proto)
   end
 
   def load_schemas!
-    all_messages = ObjectSpace.each_object(Class).select do |o|
-      o < Google::Protobuf.const_get(:AbstractMessage)
-    end.to_a
-    all_messages.each do |m|
-      file_desc = m.descriptor.file_descriptor
+    all_files = ObjectSpace.each_object(Google::Protobuf::FileDescriptor).to_a
+    all_files.each do |file_desc|
       file_path = file_desc.name
-      next if file_path.start_with?('google/protobuf/') # skip built-in protos
+      next if file_path.start_with?("google/protobuf/") # skip built-in protos
 
       @all_schemas[file_path] = file_desc
     end
   end
-
 end

data/proto_turf.gemspec

@@ -1,27 +1,28 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'proto_turf/version'
+require "proto_turf/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "proto_turf"
-  spec.version       = ProtoTurf::VERSION
-  spec.authors       = ["Daniel Orner"]
-  spec.email         = ["daniel.orner@flipp.com"]
-  spec.summary       = "Support for Protobuf files in Confluent Schema Registry"
-  spec.homepage      = "https://github.com/flipp-oss/proto_turf"
-  spec.license       = "MIT"
+  spec.name = "proto_turf"
+  spec.version = ProtoTurf::VERSION
+  spec.authors = ["Daniel Orner"]
+  spec.email = ["daniel.orner@flipp.com"]
+  spec.summary = "Support for Protobuf files in Confluent Schema Registry"
+  spec.homepage = "https://github.com/flipp-oss/proto_turf"
+  spec.license = "MIT"
 
   spec.metadata["rubygems_mfa_required"] = "true"
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_dependency "google-protobuf"
+  spec.add_dependency "excon"
 
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "standardrb"
 end

data/spec/decoding_spec.rb

@@ -0,0 +1,36 @@
+RSpec.describe "encoding" do
+  let(:proto_turf) do
+    ProtoTurf.new(
+      registry_url: "http://localhost:8081"
+    )
+  end
+
+  it "should decode a simple message" do
+    schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+    stub = stub_request(:get, "http://localhost:8081/schemas/ids/15")
+      .to_return_json(body: {schema: schema})
+    msg = Simple::V1::SimpleMessage.new(name: "my name")
+    encoded = "\u0000\u0000\u0000\u0000\u000F\u0000" + msg.to_proto
+    expect(proto_turf.decode(encoded)).to eq(msg)
+
+    # if we do it again we should not see any more requests
+    expect(proto_turf.decode(encoded)).to eq(msg)
+
+    expect(stub).to have_been_requested.once
+  end
+
+  it "should decode a complex message" do
+    schema = File.read("#{__dir__}/schemas/referenced/referer.proto")
+    stub = stub_request(:get, "http://localhost:8081/schemas/ids/20")
+      .to_return_json(body: {schema: schema})
+    msg = Referenced::V1::MessageB::MessageBA.new(
+      simple: Simple::V1::SimpleMessage.new(name: "my name")
+    )
+    encoded = "\u0000\u0000\u0000\u0000\u0014\u0004\u0002\u0000" + msg.to_proto
+    expect(proto_turf.decode(encoded)).to eq(msg)
+
+    # if we do it again we should not see any more requests
+    expect(proto_turf.decode(encoded)).to eq(msg)
+    expect(stub).to have_been_requested.once
+  end
+end

data/spec/encoding_spec.rb

@@ -0,0 +1,57 @@
+RSpec.describe "encoding" do
+  let(:proto_turf) do
+    ProtoTurf.new(
+      registry_url: "http://localhost:8081"
+    )
+  end
+
+  it "should encode a simple message" do
+    schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+    stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
+      .with(body: {"schemaType" => "PROTOBUF",
+                   "references" => [],
+                   "schema" => schema}).to_return_json(body: {id: 15})
+    msg = Simple::V1::SimpleMessage.new(name: "my name")
+    encoded = proto_turf.encode(msg, subject: "simple")
+    expect(encoded).to eq("\u0000\u0000\u0000\u0000\u000F\u0000" + msg.to_proto)
+
+    # if we do it again we should not see any more requests
+    encoded2 = proto_turf.encode(msg, subject: "simple")
+    expect(encoded2).to eq(encoded)
+
+    expect(stub).to have_been_requested.once
+  end
+
+  it "should encode a complex message" do
+    schema = File.read("#{__dir__}/schemas/referenced/referer.proto")
+    dep_schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+    dep_stub = stub_request(:post, "http://localhost:8081/subjects/simple%2Fsimple.proto/versions")
+      .with(body: {"schemaType" => "PROTOBUF",
+                   "references" => [],
+                   "schema" => dep_schema}).to_return_json(body: {id: 15})
+    version_stub = stub_request(:get, "http://localhost:8081/schemas/ids/15/versions")
+      .to_return_json(body: [{version: 1, subject: "simple/simple.proto"}])
+    stub = stub_request(:post, "http://localhost:8081/subjects/referenced/versions")
+      .with(body: {"schemaType" => "PROTOBUF",
+                   "references" => [
+                     {
+                       name: "simple/simple.proto",
+                       subject: "simple/simple.proto",
+                       version: 1
+                     }
+                   ],
+                   "schema" => schema}).to_return_json(body: {id: 20})
+    msg = Referenced::V1::MessageB::MessageBA.new(
+      simple: Simple::V1::SimpleMessage.new(name: "my name")
+    )
+    encoded = proto_turf.encode(msg, subject: "referenced")
+    expect(encoded).to eq("\u0000\u0000\u0000\u0000\u0014\u0004\u0002\u0000" + msg.to_proto)
+
+    # if we do it again we should not see any more requests
+    encoded2 = proto_turf.encode(msg, subject: "referenced")
+    expect(encoded2).to eq(encoded)
+    expect(stub).to have_been_requested.once
+    expect(dep_stub).to have_been_requested.once
+    expect(version_stub).to have_been_requested.once
+  end
+end

data/spec/gen/everything/everything_pb.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: everything/everything.proto
+
+require "google/protobuf"
+
+require "simple/simple_pb"
+require "google/protobuf/descriptor_pb"
+
+descriptor_data = "\n\x1b\x65verything/everything.proto\x12\reverything.v1\x1a\x13simple/simple.proto\x1a google/protobuf/descriptor.proto\"*\n\x0e\x46oreignMessage\x12\n\n\x02id\x18\x01 \x01(\x05\x12\x0c\n\x04name\x18\x02 \x01(\t\"\xc0\x12\n\x0cTestAllTypes\x12\x16\n\x0eoptional_int32\x18\x01 \x01(\x05\x12\x16\n\x0eoptional_int64\x18\x02 \x01(\x03\x12\x17\n\x0foptional_uint32\x18\x03 \x01(\r\x12\x17\n\x0foptional_uint64\x18\x04 \x01(\x04\x12\x17\n\x0foptional_sint32\x18\x05 \x01(\x11\x12\x17\n\x0foptional_sint64\x18\x06 \x01(\x12\x12\x18\n\x10optional_fixed32\x18\x07 \x01(\x07\x12\x18\n\x10optional_fixed64\x18\x08 \x01(\x06\x12\x19\n\x11optional_sfixed32\x18\t \x01(\x0f\x12\x19\n\x11optional_sfixed64\x18\n \x01(\x10\x12\x16\n\x0eoptional_float\x18\x0b \x01(\x02\x12\x17\n\x0foptional_double\x18\x0c \x01(\x01\x12\x15\n\roptional_bool\x18\r \x01(\x08\x12\x17\n\x0foptional_string\x18\x0e \x01(\t\x12\x16\n\x0eoptional_bytes\x18\x0f \x01(\x0c\x12J\n\x17optional_nested_message\x18\x12 \x01(\x0b\x32).everything.v1.TestAllTypes.NestedMessage\x12?\n\x18optional_foreign_message\x18\x13 \x01(\x0b\x32\x1d.everything.v1.ForeignMessage\x12\x39\n\x17optional_import_message\x18\x14 \x01(\x0b\x32\x18.simple.v1.SimpleMessage\x12\x44\n\x14optional_nested_enum\x18\x15 \x01(\x0e\x32&.everything.v1.TestAllTypes.NestedEnum\x12\x39\n\x15optional_foreign_enum\x18\x16 \x01(\x0e\x32\x1a.everything.v1.ForeignEnum\x12\x33\n\x14optional_import_enum\x18\x17 \x01(\x0e\x32\x15.simple.v1.SimpleEnum\x12!\n\x15optional_string_piece\x18\x18 \x01(\tB\x02\x08\x02\x12\x19\n\roptional_cord\x18\x19 \x01(\tB\x02\x08\x01\x12\x1f\n\x13optional_bytes_cord\x18V \x01(\x0c\x42\x02\x08\x01\x12L\n\x15optional_lazy_message\x18\x1b \x01(\x0b\x32).everything.v1.TestAllTypes.NestedMessageB\x02(\x01\x12W\n optional_unverified_lazy_message\x18\x1c \x01(\x0b\x32).everything.v1.TestAllTypes.NestedMessageB\x02x\x01\x12\x16\n\x0erepeated_int32\x18\x1f \x03(\x05\x12\x16\n\x0erepeated_int64\x18  \x03(\x03\x12\x17\n\x0frepeated_uint32\x18! \x03(\r\x12\x17\n\x0frepeated_uint64\x18\" \x03(\x04\x12\x17\n\x0frepeated_sint32\x18# \x03(\x11\x12\x17\n\x0frepeated_sint64\x18$ \x03(\x12\x12\x18\n\x10repeated_fixed32\x18% \x03(\x07\x12\x18\n\x10repeated_fixed64\x18& \x03(\x06\x12\x19\n\x11repeated_sfixed32\x18' \x03(\x0f\x12\x19\n\x11repeated_sfixed64\x18( \x03(\x10\x12\x16\n\x0erepeated_float\x18) \x03(\x02\x12\x17\n\x0frepeated_double\x18* \x03(\x01\x12\x15\n\rrepeated_bool\x18+ \x03(\x08\x12\x17\n\x0frepeated_string\x18, \x03(\t\x12\x16\n\x0erepeated_bytes\x18- \x03(\x0c\x12J\n\x17repeated_nested_message\x18\x30 \x03(\x0b\x32).everything.v1.TestAllTypes.NestedMessage\x12?\n\x18repeated_foreign_message\x18\x31 \x03(\x0b\x32\x1d.everything.v1.ForeignMessage\x12\x39\n\x17repeated_import_message\x18\x32 \x03(\x0b\x32\x18.simple.v1.SimpleMessage\x12\x44\n\x14repeated_nested_enum\x18\x33 \x03(\x0e\x32&.everything.v1.TestAllTypes.NestedEnum\x12\x39\n\x15repeated_foreign_enum\x18\x34 \x03(\x0e\x32\x1a.everything.v1.ForeignEnum\x12\x33\n\x14repeated_import_enum\x18\x35 \x03(\x0e\x32\x15.simple.v1.SimpleEnum\x12!\n\x15repeated_string_piece\x18\x36 \x03(\tB\x02\x08\x02\x12\x19\n\rrepeated_cord\x18\x37 \x03(\tB\x02\x08\x01\x12L\n\x15repeated_lazy_message\x18\x39 \x03(\x0b\x32).everything.v1.TestAllTypes.NestedMessageB\x02(\x01\x12\x16\n\x0coneof_uint32\x18o \x01(\rH\x00\x12I\n\x14oneof_nested_message\x18p \x01(\x0b\x32).everything.v1.TestAllTypes.NestedMessageH\x00\x12\x16\n\x0coneof_string\x18q \x01(\tH\x00\x12\x15\n\x0boneof_bytes\x18r \x01(\x0cH\x00\x12\x18\n\noneof_cord\x18s \x01(\tB\x02\x08\x01H\x00\x12 \n\x12oneof_string_piece\x18t \x01(\tB\x02\x08\x02H\x00\x12R\n\x19oneof_lazy_nested_message\x18u \x01(\x0b\x32).everything.v1.TestAllTypes.NestedMessageB\x02(\x01H\x00\x1a\"\n\rNestedMessage\x12\x11\n\x02\x62\x62\x18\x01 \x01(\x05\x42\x05\x90\x82\x19\xd2\t\x1a\x1a\n\rOptionalGroup\x12\t\n\x01\x61\x18\x11 \x01(\x05\x1a\x1a\n\rRepeatedGroup\x12\t\n\x01\x61\x18/ \x01(\x05\"'\n\nNestedEnum\x12\x07\n\x03\x46OO\x10\x00\x12\x07\n\x03\x42\x41R\x10\x02\x12\x07\n\x03\x42\x41Z\x10\x03\x42\r\n\x0boneof_field*/\n\x0b\x46oreignEnum\x12\x0f\n\x0b\x46OREIGN_FOO\x10\x00\x12\x0f\n\x0b\x46OREIGN_BAR\x10\x01\x32Y\n\x0bTestService\x12J\n\nTestMethod\x12\x1b.everything.v1.TestAllTypes\x1a\x1d.everything.v1.ForeignMessage\"\x00:4\n\x0bsome_option\x12\x1d.google.protobuf.FieldOptions\x18\xa2\x90\x03 \x01(\x05\x62\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Everything
+  module V1
+    ForeignMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("everything.v1.ForeignMessage").msgclass
+    TestAllTypes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("everything.v1.TestAllTypes").msgclass
+    TestAllTypes::NestedMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("everything.v1.TestAllTypes.NestedMessage").msgclass
+    TestAllTypes::OptionalGroup = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("everything.v1.TestAllTypes.OptionalGroup").msgclass
+    TestAllTypes::RepeatedGroup = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("everything.v1.TestAllTypes.RepeatedGroup").msgclass
+    TestAllTypes::NestedEnum = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("everything.v1.TestAllTypes.NestedEnum").enummodule
+    ForeignEnum = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("everything.v1.ForeignEnum").enummodule
+  end
+end

data/spec/gen/referenced/referer_pb.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: referenced/referer.proto
+
+require "google/protobuf"
+
+require "simple/simple_pb"
+
+descriptor_data = "\n\x18referenced/referer.proto\x12\rreferenced.v1\x1a\x13simple/simple.proto\"j\n\x08MessageA\x1a\x43\n\tMessageAA\x12\x0c\n\x04name\x18\x01 \x01(\t\x12(\n\x06simple\x18\x02 \x01(\x0b\x32\x18.simple.v1.SimpleMessage\x1a\x19\n\tMessageAB\x12\x0c\n\x04name\x18\x01 \x01(\t\"j\n\x08MessageB\x1a\x43\n\tMessageBA\x12\x0c\n\x04name\x18\x01 \x01(\t\x12(\n\x06simple\x18\x02 \x01(\x0b\x32\x18.simple.v1.SimpleMessage\x1a\x19\n\tMessageBB\x12\x0c\n\x04name\x18\x01 \x01(\tb\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Referenced
+  module V1
+    MessageA = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("referenced.v1.MessageA").msgclass
+    MessageA::MessageAA = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("referenced.v1.MessageA.MessageAA").msgclass
+    MessageA::MessageAB = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("referenced.v1.MessageA.MessageAB").msgclass
+    MessageB = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("referenced.v1.MessageB").msgclass
+    MessageB::MessageBA = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("referenced.v1.MessageB.MessageBA").msgclass
+    MessageB::MessageBB = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("referenced.v1.MessageB.MessageBB").msgclass
+  end
+end

data/spec/gen/simple/simple_pb.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: simple/simple.proto
+
+require "google/protobuf"
+
+descriptor_data = "\n\x13simple/simple.proto\x12\tsimple.v1\"\x1d\n\rSimpleMessage\x12\x0c\n\x04name\x18\x01 \x01(\t*,\n\nSimpleEnum\x12\x0e\n\nSIMPLE_FOO\x10\x00\x12\x0e\n\nSIMPLE_BAR\x10\x01\x62\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Simple
+  module V1
+    SimpleMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("simple.v1.SimpleMessage").msgclass
+    SimpleEnum = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("simple.v1.SimpleEnum").enummodule
+  end
+end

data/spec/proto_text_spec.rb

@@ -0,0 +1,8 @@
+RSpec.describe ProtoTurf::ProtoText do
+  it "should output as expected" do
+    output = described_class.output(Everything::V1::TestAllTypes.descriptor.file_descriptor.to_proto)
+
+    expected = File.read("#{__dir__}/schemas/everything/everything.proto")
+    expect(output).to eq(expected)
+  end
+end

data/spec/schemas/everything/everything.proto

@@ -0,0 +1,105 @@
+syntax = "proto3";
+
+package everything.v1;
+
+import "simple/simple.proto";
+import "google/protobuf/descriptor.proto";
+
+extend google.protobuf.FieldOptions {
+  int32 some_option = 51234;
+}
+
+enum ForeignEnum {
+  FOREIGN_FOO = 0;
+  FOREIGN_BAR = 1;
+}
+
+message ForeignMessage {
+  int32 id = 1;
+  string name = 2;
+}
+message TestAllTypes {
+
+enum NestedEnum {
+    FOO = 0;
+    BAR = 2;
+    BAZ = 3;
+  }
+
+  int32 optional_int32 = 1;
+  int64 optional_int64 = 2;
+  uint32 optional_uint32 = 3;
+  uint64 optional_uint64 = 4;
+  sint32 optional_sint32 = 5;
+  sint64 optional_sint64 = 6;
+  fixed32 optional_fixed32 = 7;
+  fixed64 optional_fixed64 = 8;
+  sfixed32 optional_sfixed32 = 9;
+  sfixed64 optional_sfixed64 = 10;
+  float optional_float = 11;
+  double optional_double = 12;
+  bool optional_bool = 13;
+  string optional_string = 14;
+  bytes optional_bytes = 15;
+  NestedMessage optional_nested_message = 18;
+  ForeignMessage optional_foreign_message = 19;
+  simple.v1.SimpleMessage optional_import_message = 20;
+  NestedEnum optional_nested_enum = 21;
+  ForeignEnum optional_foreign_enum = 22;
+  simple.v1.SimpleEnum optional_import_enum = 23;
+  string optional_string_piece = 24 [ctype = STRING_PIECE];
+  string optional_cord = 25 [ctype = CORD];
+  bytes optional_bytes_cord = 86 [ctype = CORD];
+  NestedMessage optional_lazy_message = 27 [lazy = true];
+  NestedMessage optional_unverified_lazy_message = 28 [unverified_lazy = true];
+  repeated int32 repeated_int32 = 31;
+  repeated int64 repeated_int64 = 32;
+  repeated uint32 repeated_uint32 = 33;
+  repeated uint64 repeated_uint64 = 34;
+  repeated sint32 repeated_sint32 = 35;
+  repeated sint64 repeated_sint64 = 36;
+  repeated fixed32 repeated_fixed32 = 37;
+  repeated fixed64 repeated_fixed64 = 38;
+  repeated sfixed32 repeated_sfixed32 = 39;
+  repeated sfixed64 repeated_sfixed64 = 40;
+  repeated float repeated_float = 41;
+  repeated double repeated_double = 42;
+  repeated bool repeated_bool = 43;
+  repeated string repeated_string = 44;
+  repeated bytes repeated_bytes = 45;
+  repeated NestedMessage repeated_nested_message = 48;
+  repeated ForeignMessage repeated_foreign_message = 49;
+  repeated simple.v1.SimpleMessage repeated_import_message = 50;
+  repeated NestedEnum repeated_nested_enum = 51;
+  repeated ForeignEnum repeated_foreign_enum = 52;
+  repeated simple.v1.SimpleEnum repeated_import_enum = 53;
+  repeated string repeated_string_piece = 54 [ctype = STRING_PIECE];
+  repeated string repeated_cord = 55 [ctype = CORD];
+  repeated NestedMessage repeated_lazy_message = 57 [lazy = true];
+                oneof oneof_field {
+    uint32 oneof_uint32 = 111;
+    NestedMessage oneof_nested_message = 112;
+    string oneof_string = 113;
+    bytes oneof_bytes = 114;
+    string oneof_cord = 115 [ctype = CORD];
+    string oneof_string_piece = 116 [ctype = STRING_PIECE];
+    NestedMessage oneof_lazy_nested_message = 117 [lazy = true];
+  }
+
+  message NestedMessage {
+    int32 bb = 1 [(everything.v1.some_option) = 1234
+];
+  }
+
+  message OptionalGroup {
+    int32 a = 17;
+  }
+
+  message RepeatedGroup {
+    int32 a = 47;
+  }
+}
+service TestService {
+  rpc TestMethod(TestAllTypes) returns (ForeignMessage) {
+  };
+}

data/spec/schemas/referenced/referer.proto

@@ -0,0 +1,28 @@
+syntax = "proto3";
+
+package referenced.v1;
+
+import "simple/simple.proto";
+
+message MessageA {
+
+  message MessageAA {
+    string name = 1;
+    simple.v1.SimpleMessage simple = 2;
+  }
+
+  message MessageAB {
+    string name = 1;
+  }
+}
+message MessageB {
+
+  message MessageBA {
+    string name = 1;
+    simple.v1.SimpleMessage simple = 2;
+  }
+
+  message MessageBB {
+    string name = 1;
+  }
+}

data/spec/schemas/simple/simple.proto

@@ -0,0 +1,12 @@
+syntax = "proto3";
+
+package simple.v1;
+
+enum SimpleEnum {
+  SIMPLE_FOO = 0;
+  SIMPLE_BAR = 1;
+}
+
+message SimpleMessage {
+  string name = 1;
+}

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("gen", __dir__))
+Dir["#{__dir__}/gen/**/*.rb"].each { |file| require file }
+require "proto_turf"
+require "webmock/rspec"
+
+RSpec.configure do |config|
+  config.full_backtrace = true
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: proto_turf
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Daniel Orner
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -24,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -66,27 +79,71 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
-description:
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: standardrb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 email:
 - daniel.orner@flipp.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/lint.yml"
+- ".github/workflows/release.yml"
+- ".github/workflows/test.yml"
+- ".rspec"
 - CHANGELOG.md
+- Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
+- Rakefile
 - lib/proto_turf.rb
 - lib/proto_turf/cached_confluent_schema_registry.rb
 - lib/proto_turf/confluent_schema_registry.rb
+- lib/proto_turf/proto_text.rb
 - lib/proto_turf/version.rb
 - proto_turf.gemspec
+- spec/decoding_spec.rb
+- spec/encoding_spec.rb
+- spec/gen/everything/everything_pb.rb
+- spec/gen/referenced/referer_pb.rb
+- spec/gen/simple/simple_pb.rb
+- spec/proto_text_spec.rb
+- spec/schemas/everything/everything.proto
+- spec/schemas/referenced/referer.proto
+- spec/schemas/simple/simple.proto
+- spec/spec_helper.rb
 homepage: https://github.com/flipp-oss/proto_turf
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -101,8 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Support for Protobuf files in Confluent Schema Registry
 test_files: []