schema_registry_client 0.0.8 → 0.0.10

data/lib/schema_registry_client/schema/protobuf.rb

@@ -1,31 +1,31 @@
 # frozen_string_literal: true
 
-require 'google/protobuf'
-require 'google/protobuf/well_known_types'
-require 'google/protobuf/descriptor_pb'
-require 'schema_registry_client/output/proto_text'
-require 'schema_registry_client/schema/base'
-require 'schema_registry_client/wire'
+require "google/protobuf"
+require "google/protobuf/well_known_types"
+require "google/protobuf/descriptor_pb"
+require "schema_registry_client/output/proto_text"
+require "schema_registry_client/schema/base"
+require "schema_registry_client/wire"
 
 module SchemaRegistry
   module Schema
     class Protobuf < Base
       def self.schema_type
-        'PROTOBUF'
+        "PROTOBUF"
       end
 
       def schema_text(message, schema_name: nil)
         file_descriptor = if message.is_a?(Google::Protobuf::FileDescriptor)
-                            message
-                          else
-                            message.class.descriptor.file_descriptor
-                          end
+          message
+        else
+          message.class.descriptor.file_descriptor
+        end
         SchemaRegistry::Output::ProtoText.output(file_descriptor.to_proto)
       end
 
       def encode(message, stream, schema_name: nil)
         _, indexes = find_index(message.class.descriptor.to_proto,
-                                message.class.descriptor.file_descriptor.to_proto.message_type)
+          message.class.descriptor.file_descriptor.to_proto.message_type)
 
         if indexes == [0]
           SchemaRegistry::Wire.write_int(stream, 0)
@@ -59,7 +59,7 @@ module SchemaRegistry
         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
@@ -70,13 +70,13 @@ module SchemaRegistry
 
         load_schemas! unless @all_schemas&.any?
         file_descriptor = if message.is_a?(Google::Protobuf::FileDescriptor)
-                            message
-                          else
-                            message.class.descriptor.file_descriptor
-                          end
+          message
+        else
+          message.class.descriptor.file_descriptor
+        end
 
         deps = file_descriptor.to_proto.dependency.to_a
-                              .reject { |d| d.start_with?('google/protobuf/') }
+          .reject { |d| d.start_with?("google/protobuf/") }
         deps.to_h do |dep|
           dependency_schema = @all_schemas[dep]
           [dependency_schema.name, dependency_schema]
@@ -118,12 +118,12 @@ module SchemaRegistry
         descriptor = Google::Protobuf::DescriptorPool.generated_pool.lookup(full_name)
         unless descriptor
           msg = "Could not find schema for #{full_name}. " \
-                'Make sure the corresponding .proto file has been compiled and loaded.'
+                "Make sure the corresponding .proto file has been compiled and loaded."
           raise msg
         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
     end

data/lib/schema_registry_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SchemaRegistry
-  VERSION = '0.0.8'
+  VERSION = "0.0.10"
 end

data/lib/schema_registry_client.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'logger'
-require 'json'
-require 'schema_registry_client/confluent_schema_registry'
-require 'schema_registry_client/cached_confluent_schema_registry'
-require 'schema_registry_client/schema/protobuf'
-require 'schema_registry_client/schema/proto_json_schema'
-require 'schema_registry_client/schema/avro'
+require "logger"
+require "json"
+require "schema_registry_client/confluent_schema_registry"
+require "schema_registry_client/cached_confluent_schema_registry"
+require "schema_registry_client/schema/protobuf"
+require "schema_registry_client/schema/proto_json_schema"
+require "schema_registry_client/schema/avro"
 
 module SchemaRegistry
   class SchemaNotFoundError < StandardError; end
@@ -27,7 +27,7 @@ module SchemaRegistry
     # 1: https://github.com/confluentinc/schema-registry
     # https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/serdes-protobuf.html
     # https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/index.html#wire-format
-    MAGIC_BYTE = [0].pack('C').freeze
+    MAGIC_BYTE = [0].pack("C").freeze
 
     # Instantiate a new SchemaRegistry instance with the given configuration.
     #
@@ -104,7 +104,7 @@ module SchemaRegistry
       stream.write(MAGIC_BYTE)
 
       # The schema id is encoded as a 4-byte big-endian integer.
-      stream.write([id].pack('N'))
+      stream.write([id].pack("N"))
 
       @schema.encode(message, stream, schema_name: schema_name)
       stream.string
@@ -123,7 +123,7 @@ module SchemaRegistry
       raise "Expected data to begin with a magic byte, got `#{magic_byte.inspect}`" if magic_byte != MAGIC_BYTE
 
       # The schema id is a 4-byte big-endian integer.
-      schema_id = stream.read(4).unpack1('N')
+      schema_id = stream.read(4).unpack1("N")
       schema = @registry.fetch(schema_id)
       @schema.decode(stream, schema)
     rescue Excon::Error::NotFound
@@ -144,15 +144,15 @@ module SchemaRegistry
       end
 
       @registry.register(subject,
-                         schema_text,
-                         references: dependencies.keys.map.with_index do |dependency, i|
-                           {
-                             name: dependency,
-                             subject: dependency,
-                             version: versions[i]
-                           }
-                         end,
-                         schema_type: @schema.class.schema_type)
+        schema_text,
+        references: dependencies.keys.map.with_index do |dependency, i|
+          {
+            name: dependency,
+            subject: dependency,
+            version: versions[i]
+          }
+        end,
+        schema_type: @schema.class.schema_type)
     end
   end
 end

data/schema_registry_client.gemspec

@@ -1,33 +1,33 @@
 # frozen_string_literal: true
 
-lib = File.expand_path('lib', __dir__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'schema_registry_client/version'
+require "schema_registry_client/version"
 
 Gem::Specification.new do |spec|
-  spec.name = 'schema_registry_client'
+  spec.name = "schema_registry_client"
   spec.version = SchemaRegistry::VERSION
-  spec.authors = ['Daniel Orner']
-  spec.email = ['daniel.orner@flipp.com']
-  spec.summary = 'Confluent Schema Registry client with support for Avro and Protobuf'
-  spec.homepage = 'https://github.com/flipp-oss/schema_registry_client'
-  spec.license = 'MIT'
-  spec.required_ruby_version = '>= 3.0'
+  spec.authors = ["Daniel Orner"]
+  spec.email = ["daniel.orner@flipp.com"]
+  spec.summary = "Confluent Schema Registry client with support for Avro and Protobuf"
+  spec.homepage = "https://github.com/flipp-oss/schema_registry_client"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0"
 
-  spec.metadata['rubygems_mfa_required'] = 'true'
+  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.require_paths = ['lib']
+  spec.require_paths = ["lib"]
 
-  spec.add_dependency 'avro'
-  spec.add_dependency 'excon'
-  spec.add_dependency 'google-protobuf'
+  spec.add_dependency "avro"
+  spec.add_dependency "excon"
+  spec.add_dependency "google-protobuf"
 
-  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 'simplecov'
-  spec.add_development_dependency 'standardrb'
-  spec.add_development_dependency 'webmock'
+  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 "simplecov"
+  spec.add_development_dependency "standardrb"
+  spec.add_development_dependency "webmock"
 end

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::Client.new(
-      registry_url: 'http://localhost:8081'
+      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::Client.new(
-        registry_url: 'http://localhost:8081',
+        registry_url: "http://localhost:8081",
         schema_type: SchemaRegistry::Schema::ProtoJsonSchema.new
       )
     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::Client.new(
-        registry_url: 'http://localhost:8081',
+        registry_url: "http://localhost:8081",
         schema_type: SchemaRegistry::Schema::Avro.new
       )
     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"