proto_turf 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 748636abfd68b4fbf48cb1786c3d2617ae0b48400c23e14c9ff03786601a4dd8
-  data.tar.gz: 9b3e76306ecefa2cfe6ca7b097b366d8145ec4c3a2c1dbe59b05625b1d1b37e7
+  metadata.gz: 9af9eb4df4dd0323090363e65378d08d4b9a55050eb0a08ea6ddfe2cd7bd8b59
+  data.tar.gz: 32fb8b5f560d5e49978930f5e863d5851efc17b288f75c26e45ee7d1cf8e98dd
 SHA512:
-  metadata.gz: 58e153ed45709e81d7b1d6d2b35523282d866a20f925e549ace5930daf29d1f2afafadcdd48b383bc7f27e662e401aa72cabc7cbd9e4a3d5bc3abad3f121f0d2
-  data.tar.gz: 5715d4b57c35db06292f30ec6228a19d4e089e65558cf0e2c0c698ec930fc471541a1b92d9743344a173a6b7b67ba2c8593bbe198bca5eb58841112d8f5339ce
+  metadata.gz: 3286859be78192d3495c3dc58e15dad50273aed4d611ddf579b9b27a16b01bbf0652d17af367192ed6dd9154a693a1991342439d53bde14777a5e61e5402a036
+  data.tar.gz: e8d941d3a7b153345e407ed62fb4e6201b93a65e01810f06cacb4fa616bbbf3c93b1456be349f3f53fd8e41d5a7f4fc4fcd0fad9fc380f8c7ff4ea101678fc18

data/.rspec

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

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## UNRELEASED
+
+# 0.0.3 - 2025-8-15
+
+* Initial release.

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,106 @@
+PATH
+  remote: .
+  specs:
+    proto_turf (0.0.2)
+      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)
+    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
+
+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,11 +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
 
-* For now, this library only supports a single message per `.proto` file that is registered with the Schema Registry. You can reference as many other files and messages as you like from that message, but keeping it to one message per file simplifies the workflow significantly.
 * 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.
 
-## TODO
+### Regenerating test protos
+Run the following to regenerate:
 
-* Support multi-message proto files
+```sh
+protoc -I spec/schemas --ruby_out=spec/gen --ruby_opt=paths=source_relative spec/schemas/**/*.proto
+```

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/version.rb

@@ -1,3 +1,3 @@
 class ProtoTurf
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/lib/proto_turf.rb

@@ -1,6 +1,10 @@
-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"
 
 class ProtoTurf
   # Provides a way to encode and decode messages without having to embed schemas
@@ -15,14 +19,13 @@ 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.
+  # schema_paths         - 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,7 @@ class ProtoTurf
     registry: nil,
     registry_url: nil,
     schema_context: nil,
-    schemas_path: nil,
+    schema_paths: nil,
     registry_path_prefix: nil,
     logger: nil,
     proxy: nil,
@@ -57,7 +60,7 @@ class ProtoTurf
     retry_limit: nil
   )
     @logger = logger || Logger.new($stderr)
-    @path = schemas_path
+    @paths = Array(schema_paths)
     @registry = registry || ProtoTurf::CachedConfluentSchemaRegistry.new(
       ProtoTurf::ConfluentSchemaRegistry.new(
         registry_url,
@@ -90,7 +93,8 @@ class ProtoTurf
   def encode(message, subject: nil)
     load_schemas! if @all_schemas.empty?
 
-    id = register_schema(message.class.descriptor.file_descriptor, subject: subject)
+    file_descriptor = message.class.descriptor.file_descriptor
+    id = register_schema(file_descriptor, subject: subject)
 
     stream = StringIO.new
     # Always start with the magic byte.
@@ -99,9 +103,15 @@ class ProtoTurf
     # The schema id is encoded as a 4-byte big-endian integer.
     stream.write([id].pack("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
-    write_int(stream, 0)
+    _, indexes = find_index(message.class.descriptor.to_proto,
+      file_descriptor.to_proto.message_type)
+
+    if indexes == [0]
+      write_int(stream, 0)
+    else
+      write_int(stream, indexes.length)
+      indexes.each { |i| write_int(stream, i) }
+    end
 
     # Now we write the actual message.
     stream.write(message.to_proto)
@@ -131,21 +141,53 @@ 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
-    read_int(stream)
+    index_length = read_int(stream)
+    indexes = []
+    if index_length.zero?
+      indexes.push(0)
+    else
+      index_length.times do
+        indexes.push(read_int(stream))
+      end
+    end
 
     schema = @registry.fetch(schema_id)
     encoded = stream.read
-    decode_protobuf(schema, encoded)
+    decode_protobuf(schema, encoded, indexes)
   rescue Excon::Error::NotFound
     raise SchemaNotFoundError.new("Schema with id: #{schema_id} is not found on registry")
   end
 
   private
 
+  def find_index(descriptor, messages, indexes = [])
+    messages.each_with_index do |sub_descriptor, i|
+      if sub_descriptor == descriptor
+        indexes.push(i)
+        return [true, indexes]
+      else
+        found, found_indexes = find_index(descriptor, sub_descriptor.nested_type, indexes + [i])
+        return [true, found_indexes] if found
+      end
+    end
+    []
+  end
+
+  def find_descriptor(indexes, messages)
+    first_index = indexes.shift
+    message = messages[first_index]
+    path = [message.name]
+    while indexes.length.positive?
+      message = message.nested_type[indexes.shift]
+      path.push(message.name)
+    end
+    path
+  end
+
   # Write an int with zig-zag encoding. Copied from Avro.
   def write_int(stream, n)
     n = (n << 1) ^ (n >> 63)
@@ -169,7 +211,7 @@ class ProtoTurf
     (n >> 1) ^ -(n & 1)
   end
 
-  def decode_protobuf(schema, encoded)
+  def decode_protobuf(schema, encoded, indexes)
     # get the package
     package = schema.match(/package (\S+);/)[1]
     # get the first message in the protobuf text
@@ -181,7 +223,9 @@ class ProtoTurf
     unless descriptor
       raise "Could not find schema for #{full_name}. Make sure the corresponding .proto file has been compiled and loaded."
     end
-    descriptor.msgclass.decode(encoded)
+    path = find_descriptor(indexes, descriptor.file_descriptor.to_proto.message_type)
+    correct_message = Google::Protobuf::DescriptorPool.generated_pool.lookup("#{package}.#{path.join(".")}")
+    correct_message.msgclass.decode(encoded)
   end
 
   def register_schema(file_descriptor, subject: nil)
@@ -189,7 +233,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)
@@ -197,20 +241,22 @@ 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) : ""
+    @paths.each do |path|
+      filename = "#{path}/#{file_descriptor.name}"
+      return File.read(filename) if File.exist?(filename)
+    end
+    ""
   end
 
   def load_schemas!
@@ -220,10 +266,9 @@ class ProtoTurf
     all_messages.each do |m|
       file_desc = m.descriptor.file_descriptor
       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,37 @@
+RSpec.describe "encoding" do
+  let(:proto_turf) do
+    ProtoTurf.new(
+      registry_url: "http://localhost:8081",
+      schema_paths: ["spec/schemas"]
+    )
+  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,58 @@
+RSpec.describe "encoding" do
+  let(:proto_turf) do
+    ProtoTurf.new(
+      registry_url: "http://localhost:8081",
+      schema_paths: ["spec/schemas"]
+    )
+  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/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,17 @@
+# 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(\tb\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
+  end
+end

data/spec/schemas/referenced/referer.proto

@@ -0,0 +1,24 @@
+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,7 @@
+syntax = "proto3";
+
+package simple.v1;
+
+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,14 @@
 --- !ruby/object:Gem::Specification
 name: proto_turf
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Daniel Orner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-14 00:00:00.000000000 Z
+date: 2025-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -24,6 +24,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,6 +80,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+- !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'
 description:
 email:
 - daniel.orner@flipp.com
@@ -73,6 +115,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rspec"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
 - lib/proto_turf.rb
@@ -80,6 +126,13 @@ files:
 - lib/proto_turf/confluent_schema_registry.rb
 - lib/proto_turf/version.rb
 - proto_turf.gemspec
+- spec/decoding_spec.rb
+- spec/encoding_spec.rb
+- spec/gen/referenced/referer_pb.rb
+- spec/gen/simple/simple_pb.rb
+- spec/schemas/referenced/referer.proto
+- spec/schemas/simple/simple.proto
+- spec/spec_helper.rb
 homepage: https://github.com/flipp-oss/proto_turf
 licenses:
 - MIT