schema_registry_client 0.0.6 → 0.0.7

data/spec/decoding_spec.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-RSpec.describe 'decoding' do
+RSpec.describe "decoding" do
   let(:schema_registry_client) do
-    SchemaRegistry.new(
-      registry_url: 'http://localhost:8081'
+    SchemaRegistry::Client.new(
+      registry_url: "http://localhost:8081"
     )
   end
 
-  it 'should decode a simple message' do
+  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')
+    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(schema_registry_client.decode(encoded)).to eq(msg)
 
@@ -21,12 +21,12 @@ RSpec.describe 'decoding' do
     expect(stub).to have_been_requested.once
   end
 
-  it 'should decode a complex message' do
+  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 })
+    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')
+      simple: Simple::V1::SimpleMessage.new(name: "my name")
     )
     encoded = "\u0000\u0000\u0000\u0000\u0014\u0004\u0002\u0000#{msg.to_proto}"
     expect(schema_registry_client.decode(encoded)).to eq(msg)
@@ -36,20 +36,20 @@ RSpec.describe 'decoding' do
     expect(stub).to have_been_requested.once
   end
 
-  describe 'with JSON' do
+  describe "with JSON" do
     let(:schema_registry_client) do
-      SchemaRegistry.new(
-        registry_url: 'http://localhost:8081',
+      SchemaRegistry::Client.new(
+        registry_url: "http://localhost:8081",
         schema_type: SchemaRegistry::Schema::ProtoJsonSchema
       )
     end
 
-    it 'should decode a simple message' do
+    it "should decode a simple message" do
       schema = File.read("#{__dir__}/schemas/simple/simple.json")
-      stub = stub_request(:get, 'http://localhost:8081/schemas/ids/15')
-             .to_return_json(body: { schema: schema })
+      stub = stub_request(:get, "http://localhost:8081/schemas/ids/15")
+        .to_return_json(body: {schema: schema})
       encoded = "\u0000\u0000\u0000\u0000\u000F{\"name\":\"my name\"}"
-      msg = { 'name' => 'my name' }
+      msg = {"name" => "my name"}
       expect(schema_registry_client.decode(encoded)).to eq(msg)
 
       # if we do it again we should not see any more requests
@@ -59,11 +59,11 @@ RSpec.describe 'decoding' do
     end
   end
 
-  describe 'with Avro' do
+  describe "with Avro" do
     let(:schema_registry_client) do
       SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
-      SchemaRegistry.new(
-        registry_url: 'http://localhost:8081',
+      SchemaRegistry::Client.new(
+        registry_url: "http://localhost:8081",
         schema_type: SchemaRegistry::Schema::Avro
       )
     end
@@ -72,16 +72,16 @@ RSpec.describe 'decoding' do
       SchemaRegistry.avro_schema_path = nil
     end
 
-    it 'should decode a simple message' do
+    it "should decode a simple message" do
       schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
-      stub = stub_request(:get, 'http://localhost:8081/schemas/ids/15')
-             .to_return_json(body: { schema: schema })
+      stub = stub_request(:get, "http://localhost:8081/schemas/ids/15")
+        .to_return_json(body: {schema: schema})
 
       # Avro-encoded data: "my name" as string (length 0x0E + bytes)
       encoded = "\u0000\u0000\u0000\u0000\u000F\u000Emy name"
       decoded = schema_registry_client.decode(encoded)
 
-      expect(decoded).to eq({ 'name' => 'my name' })
+      expect(decoded).to eq({"name" => "my name"})
 
       # if we do it again we should not see any more requests
       expect(schema_registry_client.decode(encoded)).to eq(decoded)
@@ -89,40 +89,40 @@ RSpec.describe 'decoding' do
       expect(stub).to have_been_requested.once
     end
 
-    it 'should decode a complex message with nested record' do
+    it "should decode a complex message with nested record" do
       schema = File.read("#{__dir__}/schemas/referenced/v1/MessageBA.avsc")
-      stub = stub_request(:get, 'http://localhost:8081/schemas/ids/20')
-             .to_return_json(body: { schema: schema })
+      stub = stub_request(:get, "http://localhost:8081/schemas/ids/20")
+        .to_return_json(body: {schema: schema})
 
       # Avro-encoded nested record
       encoded = "\u0000\u0000\u0000\u0000\u0014\u000Emy name"
       decoded = schema_registry_client.decode(encoded)
 
       expect(decoded).to eq({
-                              'simple' => {
-                                'name' => 'my name'
-                              }
-                            })
+        "simple" => {
+          "name" => "my name"
+        }
+      })
 
       # if we do it again we should not see any more requests
       expect(schema_registry_client.decode(encoded)).to eq(decoded)
       expect(stub).to have_been_requested.once
     end
 
-    it 'should decode a message with multiple fields' do
+    it "should decode a message with multiple fields" do
       multi_schema = {
-        'type' => 'record',
-        'name' => 'MultiFieldMessage',
-        'namespace' => 'test.v1',
-        'fields' => [
-          { 'name' => 'name', 'type' => 'string' },
-          { 'name' => 'age', 'type' => 'int' }
+        "type" => "record",
+        "name" => "MultiFieldMessage",
+        "namespace" => "test.v1",
+        "fields" => [
+          {"name" => "name", "type" => "string"},
+          {"name" => "age", "type" => "int"}
         ]
       }
       schema_json = JSON.generate(multi_schema)
 
-      stub = stub_request(:get, 'http://localhost:8081/schemas/ids/25')
-             .to_return_json(body: { schema: schema_json })
+      stub = stub_request(:get, "http://localhost:8081/schemas/ids/25")
+        .to_return_json(body: {schema: schema_json})
 
       # Manually encode the message for testing
       # Alice = 0x0A (length 5*2) + "Alice" bytes
@@ -130,39 +130,39 @@ RSpec.describe 'decoding' do
       encoded = "\u0000\u0000\u0000\u0000\u0019\u000AAlice\u003C"
       decoded = schema_registry_client.decode(encoded)
 
-      expect(decoded).to eq({ 'name' => 'Alice', 'age' => 30 })
+      expect(decoded).to eq({"name" => "Alice", "age" => 30})
 
       expect(stub).to have_been_requested.once
     end
 
-    it 'should handle schema evolution with reader schema' do
+    it "should handle schema evolution with reader schema" do
       # Writer schema (what was used to encode) - has an additional field with default
       writer_schema = {
-        'type' => 'record',
-        'name' => 'SimpleMessage',
-        'namespace' => 'simple.v1',
-        'fields' => [
-          { 'name' => 'name', 'type' => 'string' },
-          { 'name' => 'age', 'type' => 'int', 'default' => 0 }
+        "type" => "record",
+        "name" => "SimpleMessage",
+        "namespace" => "simple.v1",
+        "fields" => [
+          {"name" => "name", "type" => "string"},
+          {"name" => "age", "type" => "int", "default" => 0}
         ]
       }
 
       # Reader schema (what we have locally) - doesn't have the age field
       # This simulates reading old data with a newer schema or vice versa
 
-      stub = stub_request(:get, 'http://localhost:8081/schemas/ids/15')
-             .to_return_json(body: { schema: JSON.generate(writer_schema) })
+      stub = stub_request(:get, "http://localhost:8081/schemas/ids/15")
+        .to_return_json(body: {schema: JSON.generate(writer_schema)})
 
       # Encoded with writer schema: "my name" (0x0E + bytes) + age 25 (zigzag encoded as 50 = 0x32)
       encoded = "\u0000\u0000\u0000\u0000\u000F\u000Emy name\u0032"
       decoded = schema_registry_client.decode(encoded)
 
       # Decoded value should only have 'name' from reader schema, age is ignored
-      expect(decoded).to eq({ 'name' => 'my name' })
+      expect(decoded).to eq({"name" => "my name"})
       expect(stub).to have_been_requested.once
     end
 
-    it 'should raise error for invalid magic byte' do
+    it "should raise error for invalid magic byte" do
       # Wrong magic byte (0x01 instead of 0x00)
       encoded = "\u0001\u0000\u0000\u0000\u000F\u000Emy name"
 
@@ -171,7 +171,7 @@ RSpec.describe 'decoding' do
       end.to raise_error(/Expected data to begin with a magic byte/)
     end
 
-    it 'should raise error for unknown schema id' do
+    it "should raise error for unknown schema id" do
       # Schema ID 999 is not stubbed, so decoding should fail
       encoded = "\u0000\u0000\u0000\u0003\u00E7\u000Emy name"
 

data/spec/encoding_spec.rb

@@ -1,111 +1,111 @@
 # frozen_string_literal: true
 
-RSpec.describe 'encoding' do
+RSpec.describe "encoding" do
   let(:schema_registry_client) do
-    SchemaRegistry.new(
-      registry_url: 'http://localhost:8081'
+    SchemaRegistry::Client.new(
+      registry_url: "http://localhost:8081"
     )
   end
 
-  it 'should encode a simple message' do
+  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 = schema_registry_client.encode(msg, subject: 'simple')
+    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 = schema_registry_client.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 = schema_registry_client.encode(msg, subject: 'simple')
+    encoded2 = schema_registry_client.encode(msg, subject: "simple")
     expect(encoded2).to eq(encoded)
 
     expect(stub).to have_been_requested.once
   end
 
-  it 'should encode a complex message' do
+  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 })
+    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')
+      simple: Simple::V1::SimpleMessage.new(name: "my name")
     )
-    encoded = schema_registry_client.encode(msg, subject: 'referenced')
+    encoded = schema_registry_client.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 = schema_registry_client.encode(msg, subject: 'referenced')
+    encoded2 = schema_registry_client.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
 
-  describe 'with JSON' do
+  describe "with JSON" do
     let(:schema_registry_client) do
-      SchemaRegistry.new(
-        registry_url: 'http://localhost:8081',
+      SchemaRegistry::Client.new(
+        registry_url: "http://localhost:8081",
         schema_type: SchemaRegistry::Schema::ProtoJsonSchema
       )
     end
 
-    it 'should encode a simple message' do
+    it "should encode a simple message" do
       schema = File.read("#{__dir__}/schemas/simple/simple.json").strip
-      stub = stub_request(:post, 'http://localhost:8081/subjects/simple/versions')
-             .with(body: { 'schemaType' => 'JSON',
-                           'references' => [],
-                           'schema' => schema }).to_return_json(body: { id: 15 })
-      msg = Simple::V1::SimpleMessage.new(name: 'my name')
-      encoded = schema_registry_client.encode(msg, subject: 'simple')
+      stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
+        .with(body: {"schemaType" => "JSON",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 15})
+      msg = Simple::V1::SimpleMessage.new(name: "my name")
+      encoded = schema_registry_client.encode(msg, subject: "simple")
       expect(encoded).to eq("\u0000\u0000\u0000\u0000\u000F{\"name\":\"my name\"}")
 
       # if we do it again we should not see any more requests
-      encoded2 = schema_registry_client.encode(msg, subject: 'simple')
+      encoded2 = schema_registry_client.encode(msg, subject: "simple")
       expect(encoded2).to eq(encoded)
 
       expect(stub).to have_been_requested.once
     end
 
-    it 'should encode a complex message' do
+    it "should encode a complex message" do
       schema = File.read("#{__dir__}/schemas/referenced/referenced.json").strip
-      stub = stub_request(:post, 'http://localhost:8081/subjects/referenced/versions')
-             .with(body: { 'schemaType' => 'JSON',
-                           'references' => [],
-                           'schema' => schema }).to_return_json(body: { id: 20 })
+      stub = stub_request(:post, "http://localhost:8081/subjects/referenced/versions")
+        .with(body: {"schemaType" => "JSON",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 20})
       msg = Referenced::V1::MessageB::MessageBA.new(
-        simple: Simple::V1::SimpleMessage.new(name: 'my name')
+        simple: Simple::V1::SimpleMessage.new(name: "my name")
       )
-      encoded = schema_registry_client.encode(msg, subject: 'referenced')
+      encoded = schema_registry_client.encode(msg, subject: "referenced")
       expect(encoded).to eq("\u0000\u0000\u0000\u0000\u0014{\"simple\":{\"name\":\"my name\"}}")
 
       # if we do it again we should not see any more requests
-      encoded2 = schema_registry_client.encode(msg, subject: 'referenced')
+      encoded2 = schema_registry_client.encode(msg, subject: "referenced")
       expect(encoded2).to eq(encoded)
       expect(stub).to have_been_requested.once
     end
   end
 
-  describe 'with Avro' do
+  describe "with Avro" do
     let(:schema_registry_client) do
       SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
-      SchemaRegistry.new(
-        registry_url: 'http://localhost:8081',
+      SchemaRegistry::Client.new(
+        registry_url: "http://localhost:8081",
         schema_type: SchemaRegistry::Schema::Avro
       )
     end
@@ -114,74 +114,74 @@ RSpec.describe 'encoding' do
       SchemaRegistry.avro_schema_path = nil
     end
 
-    it 'should encode a simple message' do
+    it "should encode a simple message" do
       schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
-      stub = stub_request(:post, 'http://localhost:8081/subjects/simple/versions')
-             .with(body: { 'schemaType' => 'AVRO',
-                           'references' => [],
-                           'schema' => schema }).to_return_json(body: { id: 15 })
-      msg = { 'name' => 'my name' }
-      encoded = schema_registry_client.encode(msg, subject: 'simple', schema_name: 'simple.v1.SimpleMessage')
+      stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
+        .with(body: {"schemaType" => "AVRO",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 15})
+      msg = {"name" => "my name"}
+      encoded = schema_registry_client.encode(msg, subject: "simple", schema_name: "simple.v1.SimpleMessage")
       # Avro encoding: magic byte (0x00) + schema id (4 bytes, big-endian) + Avro binary data
       # "my name" encoded as Avro string: length (0x0E = 14) + "my name" bytes
       expect(encoded).to eq("\u0000\u0000\u0000\u0000\u000F\u000Emy name")
 
       # if we do it again we should not see any more requests
-      encoded2 = schema_registry_client.encode(msg, subject: 'simple', schema_name: 'simple.v1.SimpleMessage')
+      encoded2 = schema_registry_client.encode(msg, subject: "simple", schema_name: "simple.v1.SimpleMessage")
       expect(encoded2).to eq(encoded)
 
       expect(stub).to have_been_requested.once
     end
 
-    it 'should encode a complex message with nested record' do
+    it "should encode a complex message with nested record" do
       schema = File.read("#{__dir__}/schemas/referenced/v1/MessageBA.avsc")
-      stub = stub_request(:post, 'http://localhost:8081/subjects/referenced/versions')
-             .with(body: { 'schemaType' => 'AVRO',
-                           'references' => [],
-                           'schema' => schema }).to_return_json(body: { id: 20 })
+      stub = stub_request(:post, "http://localhost:8081/subjects/referenced/versions")
+        .with(body: {"schemaType" => "AVRO",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 20})
       msg = {
-        'simple' => {
-          'name' => 'my name'
+        "simple" => {
+          "name" => "my name"
         }
       }
-      encoded = schema_registry_client.encode(msg, subject: 'referenced', schema_name: 'referenced.v1.MessageBA')
+      encoded = schema_registry_client.encode(msg, subject: "referenced", schema_name: "referenced.v1.MessageBA")
       # Avro encoding: magic byte + schema id + Avro binary for nested record
       expect(encoded).to eq("\u0000\u0000\u0000\u0000\u0014\u000Emy name")
 
       # if we do it again we should not see any more requests
-      encoded2 = schema_registry_client.encode(msg, subject: 'referenced', schema_name: 'referenced.v1.MessageBA')
+      encoded2 = schema_registry_client.encode(msg, subject: "referenced", schema_name: "referenced.v1.MessageBA")
       expect(encoded2).to eq(encoded)
       expect(stub).to have_been_requested.once
     end
 
-    it 'should handle multiple fields' do
+    it "should handle multiple fields" do
       # Create a temporary schema file for testing
       multi_schema_path = "#{__dir__}/schemas/test/v1"
       FileUtils.mkdir_p(multi_schema_path)
 
       multi_schema = {
-        'type' => 'record',
-        'name' => 'MultiFieldMessage',
-        'namespace' => 'test.v1',
-        'fields' => [
-          { 'name' => 'name', 'type' => 'string' },
-          { 'name' => 'age', 'type' => 'int' }
+        "type" => "record",
+        "name" => "MultiFieldMessage",
+        "namespace" => "test.v1",
+        "fields" => [
+          {"name" => "name", "type" => "string"},
+          {"name" => "age", "type" => "int"}
         ]
       }
       schema_json = JSON.pretty_generate(multi_schema)
       File.write("#{multi_schema_path}/MultiFieldMessage.avsc", schema_json)
 
-      stub = stub_request(:post, 'http://localhost:8081/subjects/multi/versions')
-             .with(body: { 'schemaType' => 'AVRO',
-                           'references' => [],
-                           'schema' => schema_json }).to_return_json(body: { id: 25 })
+      stub = stub_request(:post, "http://localhost:8081/subjects/multi/versions")
+        .with(body: {"schemaType" => "AVRO",
+                     "references" => [],
+                     "schema" => schema_json}).to_return_json(body: {id: 25})
 
-      msg = { 'name' => 'Alice', 'age' => 30 }
-      encoded = schema_registry_client.encode(msg, subject: 'multi', schema_name: 'test.v1.MultiFieldMessage')
+      msg = {"name" => "Alice", "age" => 30}
+      encoded = schema_registry_client.encode(msg, subject: "multi", schema_name: "test.v1.MultiFieldMessage")
 
       # Verify encoding starts with magic byte and schema id
       expect(encoded[0]).to eq("\u0000")
-      expect(encoded[1..4].unpack1('N')).to eq(25)
+      expect(encoded[1..4].unpack1("N")).to eq(25)
 
       expect(stub).to have_been_requested.once
 
@@ -189,18 +189,18 @@ RSpec.describe 'encoding' do
       FileUtils.rm_rf("#{__dir__}/schemas/test")
     end
 
-    it 'should validate schema before encoding' do
+    it "should validate schema before encoding" do
       schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
-      stub_request(:post, 'http://localhost:8081/subjects/simple/versions')
-        .with(body: { 'schemaType' => 'AVRO',
-                      'references' => [],
-                      'schema' => schema }).to_return_json(body: { id: 15 })
+      stub_request(:post, "http://localhost:8081/subjects/simple/versions")
+        .with(body: {"schemaType" => "AVRO",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 15})
 
       # Invalid message - missing required field
-      msg = { 'invalid_field' => 'value' }
+      msg = {"invalid_field" => "value"}
 
       expect do
-        schema_registry_client.encode(msg, subject: 'simple', schema_name: 'simple.v1.SimpleMessage')
+        schema_registry_client.encode(msg, subject: "simple", schema_name: "simple.v1.SimpleMessage")
       end.to raise_error(Avro::SchemaValidator::ValidationError)
     end
   end

data/spec/gen/everything/everything_pb.rb

@@ -3,10 +3,10 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: everything/everything.proto
 
-require 'google/protobuf'
+require "google/protobuf"
 
-require 'simple/simple_pb'
-require 'google/protobuf/descriptor_pb'
+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"
 
@@ -15,12 +15,12 @@ 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
+    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

@@ -3,9 +3,9 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: referenced/referer.proto
 
-require 'google/protobuf'
+require "google/protobuf"
 
-require 'simple/simple_pb'
+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"
 
@@ -14,11 +14,11 @@ 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
+    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

@@ -3,7 +3,7 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: simple/simple.proto
 
-require 'google/protobuf'
+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"
 
@@ -12,7 +12,7 @@ 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
+    SimpleMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("simple.v1.SimpleMessage").msgclass
+    SimpleEnum = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("simple.v1.SimpleEnum").enummodule
   end
 end