schema_registry_client 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bd3f6c9d59bc29bfbcc32577761bd90b17282dc63b7423a1d74978235b316c8
-  data.tar.gz: fde47855e0974f734724d0c9fbe36b80644be5ed2f42215cbfa389e4951affdb
+  metadata.gz: 8c4fb0ad39418dd0eb14e803f4c0652e47e64950b8684f564221a95b024177c1
+  data.tar.gz: c04a0a44298ff123a0a63cf530fe2c2ae56b7230cc740e2d02577f712d045e41
 SHA512:
-  metadata.gz: dd97621d317f2f951c960b2f928832004c8d38b8c4f0ebdf291bbdb68ed7d873f83f4a789426479ead787f77f1dc00c2a5c1898407373a1fdc27b448c6ed1f97
-  data.tar.gz: fe7f21af487e6e8294977e5b50e77bd2a77648df7eb1b9bd4cb56a709fe09e0401ecba9e44ba35854b6383d35fcb2baf3530cf485963f7887a4e1fa8c0fc6dc4
+  metadata.gz: c68cf8a284acdaad830acbbc76ea49b2cb1431b69e3c2961218f5c8af399b89d64f8b5eb1e25536e415f5720080152853f885d9984b47790ffd02d01cad73709
+  data.tar.gz: 7fb3f61b7159bf9f461f3fc9b6f8d0f145592f18a35b1e02d284a6f2ed62c95d30a6d8ff1082b2607976f134e6a74e1416e00483e61f8db2ecf27f601112bd84

data/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## UNRELEASED
 
+# 0.0.8 - 2026-02-04
+
+* Support passing a `schema_store` into the `Avro` schema backend.
+* Move schema backend methods from class-level to instance-level and require instantiation.
+
+# 0.0.7 - 2026-01-05
+
+* Switch to using `SchemaRegistry::Client` instead of bare `SchemaRegistry`.
+* Throw correct error when Avro schema is not found.
+
 # 0.0.6 - 2026-01-02
 
 * Initial release.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    schema_registry_client (0.0.6)
+    schema_registry_client (0.0.8)
       avro
       excon
       google-protobuf
@@ -22,33 +22,12 @@ GEM
     docile (1.4.1)
     excon (1.3.2)
       logger
-    google-protobuf (4.33.2)
-      bigdecimal
-      rake (>= 13)
-    google-protobuf (4.33.2-aarch64-linux-gnu)
-      bigdecimal
-      rake (>= 13)
-    google-protobuf (4.33.2-aarch64-linux-musl)
-      bigdecimal
-      rake (>= 13)
     google-protobuf (4.33.2-arm64-darwin)
       bigdecimal
       rake (>= 13)
-    google-protobuf (4.33.2-x86-linux-gnu)
-      bigdecimal
-      rake (>= 13)
-    google-protobuf (4.33.2-x86-linux-musl)
-      bigdecimal
-      rake (>= 13)
-    google-protobuf (4.33.2-x86_64-darwin)
-      bigdecimal
-      rake (>= 13)
     google-protobuf (4.33.2-x86_64-linux-gnu)
       bigdecimal
       rake (>= 13)
-    google-protobuf (4.33.2-x86_64-linux-musl)
-      bigdecimal
-      rake (>= 13)
     hashdiff (1.2.1)
     json (2.18.0)
     language_server-protocol (3.17.0.5)
@@ -127,15 +106,8 @@ GEM
       hashdiff (>= 0.4.0, < 2.0.0)
 
 PLATFORMS
-  aarch64-linux-gnu
-  aarch64-linux-musl
   arm64-darwin
-  ruby
-  x86-linux-gnu
-  x86-linux-musl
-  x86_64-darwin
-  x86_64-linux-gnu
-  x86_64-linux-musl
+  x86_64-linux
 
 DEPENDENCIES
   bundler (~> 2.0)

data/LICENSE

@@ -1,3 +1,5 @@
+Copyright (c) 2015 Daniel Schierbeck
+
 MIT License
 
 Permission is hereby granted, free of charge, to any person obtaining

data/README.md

@@ -1,6 +1,6 @@
 # schema_registry_client
 
-`schema_registry_client` is a library to interact with the Confluent Schema Registry using Google Protobuf. It is inspired by and based off of [avro_turf](https://github.com/dasch/avro_turf).
+`schema_registry_client` is a library to interact with the Confluent Schema Registry. It is inspired by and based off of [avro_turf](https://github.com/dasch/avro_turf).
 
 ## Installation
 
@@ -24,21 +24,66 @@ SchemaRegistry interacts with the Confluent Schema Registry, and caches all resu
 
 Example usage:
 
+### Avro
+
+Note that unlike AvroTurf, you must concatenate the namespace and schema name together when encoding.
+
 ```ruby
 require 'schema_registry_client'
 
-schema_registry_client = SchemaRegistry.new(registry_url: 'http://localhost:8081', schema_paths: ['path/to/protos'])
-message = MyProto::MyMessage.new(field1: 'value1', field2: 42)
-encoded = schema_registry_client.encode(message, subject: 'my-subject')
+client = SchemaRegistry::Client.new(registry_url: 'http://localhost:8081', schema_type: SchemaRegistry::Schema::Avro.new)
+SchemaRegistry.avro_schema_path = 'path/to/schemas'
+message = {field1: 'value1', field2: 42 }
+encoded = client.encode(message, schema_name: 'com.my-namespace.MySchema', subject: 'my-subject')
+
+# Decoding
+
+decoded_avro_message = client.decode(encoded_string)
+```
+
+### Protobuf
+
+```ruby
+client = SchemaRegistry::Client.new(registry_url: 'http://localhost:8081', schema_type: SchemaRegistry::Schema::Protobuf.new)
+message = MyProtoMessage.new(field1: 'value1', field2: 42)
+encoded = client.encode(message, subject: 'my-proto-subject')
 
 # Decoding
+decoded_proto_message = client.decode(encoded_string)
+```
 
-decoded_proto_message = schema_registry_client.decode(encoded_string)
+### Protobuf JSON Schema
+
+Since Protobuf is [not recommended to use for Kafka keys](https://protobuf.dev/programming-guides/encoding/#implications), it's instead recommended that you use the `ProtoJsonSchema` format. This will transform the Protobuf message into a JSON schema and register that with the registry instead. The encoded message will be the JSON representation of the Protobuf message, with keys sorted alphabetically to ensure consistent encoding.
+
+Note that the algorithm to translate into JSON Schema is currently very naive (e.g. it does not handle nested messages) since keys should usually be very simple. If more complex logic is needed, pull requests are welcome.
+
+```ruby
+client = SchemaRegistry::Client.new(registry_url: 'http://localhost:8081', schema_type: SchemaRegistry::Schema::ProtoJsonSchema)
+message = MyProtoMessage.new(field1: 'value1', field2: 42)
+encoded = client.encode(message, subject: 'my-proto-subject') # will register a JSON Schema subject and encode into JSON
+
+```
+
+You can use JSON Schema with regular Ruby hashes as well by passing `schema_text` into the encode method:
+
+```ruby
+client = SchemaRegistry::Client.new(registry_url: 'http://localhost:8081', schema_type: SchemaRegistry::Schema::ProtoJsonSchema)
+message = { field1: 'value1', field2: 42 }
+schema_text = {
+    "type" => "object",
+    "properties" => {
+        "field1" => { "type" => "string" },
+        "field2" => { "type" => "integer" }
+    },
+    "required" => ["field1", "field2"]
+}.to_json
+encoded = client.encode(message, subject: 'my-proto-subject', schema_text: schema_text)
 ```
 
 ## 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.
+* When decoding, this library does *not* attempt to fully parse the Protobuf 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:

data/lib/schema_registry_client/avro_schema_store.rb

@@ -2,7 +2,7 @@
 
 require 'avro'
 
-class SchemaRegistry
+module SchemaRegistry
   class AvroSchemaStore
     def initialize(path: nil)
       @path = path or raise 'Please specify a schema path'
@@ -116,7 +116,7 @@ class SchemaRegistry
       end
       load_schema!(fullname, @schemas.dup)
     rescue Errno::ENOENT, Errno::ENAMETOOLONG
-      raise "could not find Avro schema at `#{schema_path}'"
+      raise SchemaRegistry::SchemaNotFoundError, "could not find Avro schema at `#{schema_path}'"
     end
 
     def build_schema_path(fullname)

data/lib/schema_registry_client/cached_confluent_schema_registry.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class SchemaRegistry
+module SchemaRegistry
   class CachedConfluentSchemaRegistry
     # @param upstream [SchemaRegistry::ConfluentSchemaRegistry]
     def initialize(upstream)

data/lib/schema_registry_client/confluent_schema_registry.rb

@@ -2,7 +2,7 @@
 
 require 'excon'
 
-class SchemaRegistry
+module SchemaRegistry
   class ConfluentSchemaRegistry
     CONTENT_TYPE = 'application/vnd.schemaregistry.v1+json'
 

data/lib/schema_registry_client/output/json_schema.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class SchemaRegistry
+module SchemaRegistry
   module Output
     module JsonSchema
       class << self
@@ -12,7 +12,7 @@ class SchemaRegistry
         def output(descriptor, path: nil)
           properties = {}
           result = {
-            '$schema': 'https://json-schema.org/draft/2020-12/schema',
+            "$schema": 'https://json-schema.org/draft/2020-12/schema',
             type: 'object',
             properties: properties
           }

data/lib/schema_registry_client/output/proto_text.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class SchemaRegistry
+module SchemaRegistry
   module Output
     module ProtoText
       ParseInfo = Struct.new(:writer, :package, :message) do

data/lib/schema_registry_client/schema/avro.rb

@@ -3,58 +3,62 @@
 require 'schema_registry_client/schema/base'
 require 'schema_registry_client/avro_schema_store'
 
-class SchemaRegistry
+module SchemaRegistry
   module Schema
     class Avro < Base
       DEFAULT_SCHEMAS_PATH = './schemas'
 
-      class << self
-        def schema_type
-          'AVRO'
-        end
+      def self.schema_type
+        'AVRO'
+      end
 
-        def schema_store
-          @schema_store ||= SchemaRegistry::AvroSchemaStore.new(
-            path: SchemaRegistry.avro_schema_path || DEFAULT_SCHEMAS_PATH
-          )
-          @schema_store.load_schemas!
-          @schema_store
-        end
+      # @param schema_store [SchemaRegistry::AvroSchemaStore, nil]
+      def initialize(schema_store: nil)
+        @schema_store = schema_store
+      end
 
-        def schema_text(_message, schema_name: nil)
-          schema_store.find_text(schema_name)
-        end
+      # @return [SchemaRegistry::AvroSchemaStore]
+      def schema_store
+        @schema_store ||= SchemaRegistry::AvroSchemaStore.new(
+          path: SchemaRegistry.avro_schema_path || DEFAULT_SCHEMAS_PATH
+        )
+        @schema_store.load_schemas!
+        @schema_store
+      end
 
-        def encode(message, stream, schema_name: nil)
-          validate_options = { recursive: true,
-                               encoded: false,
-                               fail_on_extra_fields: true }
-          schema = schema_store.find(schema_name)
+      def schema_text(_message, schema_name: nil)
+        schema_store.find_text(schema_name)
+      end
 
-          ::Avro::SchemaValidator.validate!(schema, message, **validate_options)
+      def encode(message, stream, schema_name: nil)
+        validate_options = { recursive: true,
+                             encoded: false,
+                             fail_on_extra_fields: true }
+        schema = schema_store.find(schema_name)
 
-          writer = ::Avro::IO::DatumWriter.new(schema)
-          encoder = ::Avro::IO::BinaryEncoder.new(stream)
-          writer.write(message, encoder)
-        end
+        ::Avro::SchemaValidator.validate!(schema, message, **validate_options)
 
-        def decode(stream, schema_text)
-          # Parse the schema text from the registry into an Avro schema object
-          JSON.parse(schema_text)
-          writers_schema = ::Avro::Schema.parse(schema_text)
+        writer = ::Avro::IO::DatumWriter.new(schema)
+        encoder = ::Avro::IO::BinaryEncoder.new(stream)
+        writer.write(message, encoder)
+      end
 
-          decoder = ::Avro::IO::BinaryDecoder.new(stream)
+      def decode(stream, schema_text)
+        # Parse the schema text from the registry into an Avro schema object
+        JSON.parse(schema_text)
+        writers_schema = ::Avro::Schema.parse(schema_text)
 
-          # Try to find the reader schema locally, fall back to writer schema
-          readers_schema = begin
-            schema_store.find(writers_schema.fullname)
-          rescue StandardError
-            writers_schema
-          end
+        decoder = ::Avro::IO::BinaryDecoder.new(stream)
 
-          reader = ::Avro::IO::DatumReader.new(writers_schema, readers_schema)
-          reader.read(decoder)
+        # Try to find the reader schema locally, fall back to writer schema
+        readers_schema = begin
+          schema_store.find(writers_schema.fullname)
+        rescue StandardError
+          writers_schema
         end
+
+        reader = ::Avro::IO::DatumReader.new(writers_schema, readers_schema)
+        reader.read(decoder)
       end
     end
   end

data/lib/schema_registry_client/schema/base.rb

@@ -1,43 +1,41 @@
 # frozen_string_literal: true
 
-class SchemaRegistry
+module SchemaRegistry
   module Schema
     class MissingImplementationError < StandardError; end
 
     class Base
-      class << self
-        # @param message [Object]
-        # @param schema_name [String]
-        # @return [String]
-        def schema_text(_message, schema_name: nil)
-          raise MissingImplementationError, 'Subclasses must implement schema_text'
-        end
+      # @param message [Object]
+      # @param schema_name [String]
+      # @return [String]
+      def schema_text(_message, schema_name: nil)
+        raise MissingImplementationError, 'Subclasses must implement schema_text'
+      end
 
-        # @return [String]
-        def schema_type
-          raise MissingImplementationError, 'Subclasses must implement schema_type'
-        end
+      # @return [String]
+      def self.schema_type
+        raise MissingImplementationError, 'Subclasses must implement schema_type'
+      end
 
-        # @param message [Object]
-        # @param stream [StringIO]
-        # @param schema_name [String]
-        def encode(_message, _stream, schema_name: nil)
-          raise MissingImplementationError, 'Subclasses must implement encode'
-        end
+      # @param message [Object]
+      # @param stream [StringIO]
+      # @param schema_name [String]
+      def encode(_message, _stream, schema_name: nil)
+        raise MissingImplementationError, 'Subclasses must implement encode'
+      end
 
-        # @param stream [StringIO]
-        # @param schema_text [String]
-        # @param registry [Object]
-        # @return [Object]
-        def decode(_stream, _schema_text)
-          raise MissingImplementationError, 'Subclasses must implement decode'
-        end
+      # @param stream [StringIO]
+      # @param schema_text [String]
+      # @param registry [Object]
+      # @return [Object]
+      def decode(_stream, _schema_text)
+        raise MissingImplementationError, 'Subclasses must implement decode'
+      end
 
-        # @param message [Object]
-        # @return [Hash<String, String>]
-        def dependencies(_message)
-          {}
-        end
+      # @param message [Object]
+      # @return [Hash<String, String>]
+      def dependencies(_message)
+        {}
       end
     end
   end

data/lib/schema_registry_client/schema/proto_json_schema.rb

@@ -3,27 +3,25 @@
 require 'schema_registry_client/schema/base'
 require 'schema_registry_client/output/json_schema'
 
-class SchemaRegistry
+module SchemaRegistry
   module Schema
     class ProtoJsonSchema < Base
-      class << self
-        def schema_type
-          'JSON'
-        end
+      def self.schema_type
+        'JSON'
+      end
 
-        def schema_text(message, schema_name: nil)
-          SchemaRegistry::Output::JsonSchema.output(message.class.descriptor.to_proto)
-        end
+      def schema_text(message, schema_name: nil)
+        SchemaRegistry::Output::JsonSchema.output(message.class.descriptor.to_proto)
+      end
 
-        def encode(message, stream, schema_name: nil)
-          json = message.to_h.sort.to_h.to_json
-          stream.write(json)
-        end
+      def encode(message, stream, schema_name: nil)
+        json = message.to_h.sort.to_h.to_json
+        stream.write(json)
+      end
 
-        def decode(stream, _schema_text)
-          json = stream.read
-          JSON.parse(json)
-        end
+      def decode(stream, _schema_text)
+        json = stream.read
+        JSON.parse(json)
       end
     end
   end

data/lib/schema_registry_client/schema/protobuf.rb

@@ -7,124 +7,124 @@ require 'schema_registry_client/output/proto_text'
 require 'schema_registry_client/schema/base'
 require 'schema_registry_client/wire'
 
-class SchemaRegistry
+module SchemaRegistry
   module Schema
     class Protobuf < Base
-      class << self
-        def schema_type
-          '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
-          SchemaRegistry::Output::ProtoText.output(file_descriptor.to_proto)
-        end
+      def self.schema_type
+        'PROTOBUF'
+      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)
+      def schema_text(message, schema_name: nil)
+        file_descriptor = if message.is_a?(Google::Protobuf::FileDescriptor)
+                            message
+                          else
+                            message.class.descriptor.file_descriptor
+                          end
+        SchemaRegistry::Output::ProtoText.output(file_descriptor.to_proto)
+      end
 
-          if indexes == [0]
-            SchemaRegistry::Wire.write_int(stream, 0)
-          else
-            SchemaRegistry::Wire.write_int(stream, indexes.length)
-            indexes.each { |i| SchemaRegistry::Wire.write_int(stream, i) }
-          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)
 
-          # Now we write the actual message.
-          stream.write(message.to_proto)
+        if indexes == [0]
+          SchemaRegistry::Wire.write_int(stream, 0)
+        else
+          SchemaRegistry::Wire.write_int(stream, indexes.length)
+          indexes.each { |i| SchemaRegistry::Wire.write_int(stream, i) }
         end
 
-        def decode(stream, schema_text)
-          # See https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/index.html#wire-format
-          index_length = SchemaRegistry::Wire.read_int(stream)
-          indexes = []
-          if index_length.zero?
-            indexes.push(0)
-          else
-            index_length.times do
-              indexes.push(SchemaRegistry::Wire.read_int(stream))
-            end
-          end
+        # Now we write the actual message.
+        stream.write(message.to_proto)
+      end
 
-          encoded = stream.read
-          decode_protobuf(schema_text, encoded, indexes)
+      def decode(stream, schema_text)
+        # See https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/index.html#wire-format
+        index_length = SchemaRegistry::Wire.read_int(stream)
+        indexes = []
+        if index_length.zero?
+          indexes.push(0)
+        else
+          index_length.times do
+            indexes.push(SchemaRegistry::Wire.read_int(stream))
+          end
         end
 
-        def load_schemas!
-          @all_schemas = {}
-          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
+        encoded = stream.read
+        decode_protobuf(schema_text, encoded, indexes)
+      end
+
+      def load_schemas!
+        @all_schemas = {}
+        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
 
-            @all_schemas[file_path] = file_desc
-          end
+          @all_schemas[file_path] = file_desc
         end
+      end
 
-        def dependencies(message)
-          load_schemas! unless @all_schemas&.any?
-          file_descriptor = if message.is_a?(Google::Protobuf::FileDescriptor)
-                              message
-                            else
-                              message.class.descriptor.file_descriptor
-                            end
-
-          deps = file_descriptor.to_proto.dependency.to_a
-                                .reject { |d| d.start_with?('google/protobuf/') }
-          deps.to_h do |dep|
-            dependency_schema = @all_schemas[dep]
-            [dependency_schema.name, dependency_schema]
-          end
+      def dependencies(message)
+        return [] if message.nil?
+
+        load_schemas! unless @all_schemas&.any?
+        file_descriptor = if message.is_a?(Google::Protobuf::FileDescriptor)
+                            message
+                          else
+                            message.class.descriptor.file_descriptor
+                          end
+
+        deps = file_descriptor.to_proto.dependency.to_a
+                              .reject { |d| d.start_with?('google/protobuf/') }
+        deps.to_h do |dep|
+          dependency_schema = @all_schemas[dep]
+          [dependency_schema.name, dependency_schema]
         end
+      end
 
-        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
+      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
+      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
 
-        def decode_protobuf(schema, encoded, indexes)
-          # get the package
-          package = schema.match(/package (\S+);/)[1]
-          # get the first message in the protobuf text
-          # TODO - get the correct message based on schema index
-          message_name = schema.match(/message (\w+) {/)[1]
-          # look up the descriptor
-          full_name = "#{package}.#{message_name}"
-          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.'
-            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.msgclass.decode(encoded)
+      def decode_protobuf(schema, encoded, indexes)
+        # get the package
+        package = schema.match(/package (\S+);/)[1]
+        # get the first message in the protobuf text
+        # TODO - get the correct message based on schema index
+        message_name = schema.match(/message (\w+) {/)[1]
+        # look up the descriptor
+        full_name = "#{package}.#{message_name}"
+        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.'
+          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.msgclass.decode(encoded)
       end
     end
   end

data/lib/schema_registry_client/version.rb

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

data/lib/schema_registry_client/wire.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class SchemaRegistry
+module SchemaRegistry
   module Wire
     class << self
       # Write an int with zig-zag encoding. Copied from Avro.

data/lib/schema_registry_client.rb

@@ -8,149 +8,151 @@ require 'schema_registry_client/schema/protobuf'
 require 'schema_registry_client/schema/proto_json_schema'
 require 'schema_registry_client/schema/avro'
 
-class SchemaRegistry
+module SchemaRegistry
   class SchemaNotFoundError < StandardError; end
   class SchemaError < StandardError; end
 
-  # Provides a way to encode and decode messages without having to embed schemas
-  # in the encoded data. Confluent's Schema Registry[1] is used to register
-  # a schema when encoding a message -- the registry will issue a schema id that
-  # will be included in the encoded data alongside the actual message. When
-  # decoding the data, the schema id will be used to look up the writer's schema
-  # from the registry.
-  #
-  # 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
-
-  # Instantiate a new SchemaRegistry instance with the given configuration.
-  #
-  # registry             - A schema registry object that responds to all methods in the
-  #                        SchemaRegistry::ConfluentSchemaRegistry interface.
-  # registry_url         - The String URL of the schema registry that should be used.
-  # schema_context       - Schema registry context name (optional)
-  # 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).
-  # user                 - User for basic auth (optional).
-  # password             - Password for basic auth (optional).
-  # ssl_ca_file          - Name of file containing CA certificate (optional).
-  # client_cert          - Name of file containing client certificate (optional).
-  # client_key           - Name of file containing client private key to go with client_cert (optional).
-  # client_key_pass      - Password to go with client_key (optional).
-  # client_cert_data     - In-memory client certificate (optional).
-  # client_key_data      - In-memory client private key to go with client_cert_data (optional).
-  # connect_timeout      - Timeout to use in the connection with the schema registry (optional).
-  # resolv_resolver      - Custom domain name resolver (optional).
-  # schema_type          - A SchemaRegistry::Schema::Base subclass.
-  def initialize( # rubocop:disable Metrics/ParameterLists
-    registry: nil,
-    registry_url: nil,
-    schema_context: nil,
-    registry_path_prefix: nil,
-    logger: nil,
-    proxy: nil,
-    user: nil,
-    password: nil,
-    ssl_ca_file: nil,
-    client_cert: nil,
-    client_key: nil,
-    client_key_pass: nil,
-    client_cert_data: nil,
-    client_key_data: nil,
-    connect_timeout: nil,
-    resolv_resolver: nil,
-    schema_type: SchemaRegistry::Schema::Protobuf
-  )
-    @logger = logger || Logger.new($stderr)
-    @registry = registry || SchemaRegistry::CachedConfluentSchemaRegistry.new(
-      SchemaRegistry::ConfluentSchemaRegistry.new(
-        registry_url,
-        schema_context: schema_context,
-        logger: @logger,
-        proxy: proxy,
-        user: user,
-        password: password,
-        ssl_ca_file: ssl_ca_file,
-        client_cert: client_cert,
-        client_key: client_key,
-        client_key_pass: client_key_pass,
-        client_cert_data: client_cert_data,
-        client_key_data: client_key_data,
-        path_prefix: registry_path_prefix,
-        connect_timeout: connect_timeout,
-        resolv_resolver: resolv_resolver
-      )
-    )
-    @schema = schema_type
-  end
-
   class << self
     attr_accessor :avro_schema_path
   end
 
-  # Encodes a message using the specified schema.
-  # @param message [Object] The message that should be encoded. Must be compatible with the schema.
-  # @param subject [String] The subject name the schema should be registered under in the schema registry (optional).
-  # @param schema_name [String] the name of the schema to use for encoding (optional).
-  # @return [String] the encoded data.
-  def encode(message, subject: nil, schema_text: nil, schema_name: nil)
-    id = register_schema(message, subject, schema_text: schema_text, schema_name: schema_name)
-
-    stream = StringIO.new
-    # Always start with the magic byte.
-    stream.write(MAGIC_BYTE)
-
-    # The schema id is encoded as a 4-byte big-endian integer.
-    stream.write([id].pack('N'))
+  class Client
+    # Provides a way to encode and decode messages without having to embed schemas
+    # in the encoded data. Confluent's Schema Registry[1] is used to register
+    # a schema when encoding a message -- the registry will issue a schema id that
+    # will be included in the encoded data alongside the actual message. When
+    # decoding the data, the schema id will be used to look up the writer's schema
+    # from the registry.
+    #
+    # 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
+
+    # Instantiate a new SchemaRegistry instance with the given configuration.
+    #
+    # registry             - A schema registry object that responds to all methods in the
+    #                        SchemaRegistry::ConfluentSchemaRegistry interface.
+    # registry_url         - The String URL of the schema registry that should be used.
+    # schema_context       - Schema registry context name (optional)
+    # 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).
+    # user                 - User for basic auth (optional).
+    # password             - Password for basic auth (optional).
+    # ssl_ca_file          - Name of file containing CA certificate (optional).
+    # client_cert          - Name of file containing client certificate (optional).
+    # client_key           - Name of file containing client private key to go with client_cert (optional).
+    # client_key_pass      - Password to go with client_key (optional).
+    # client_cert_data     - In-memory client certificate (optional).
+    # client_key_data      - In-memory client private key to go with client_cert_data (optional).
+    # connect_timeout      - Timeout to use in the connection with the schema registry (optional).
+    # resolv_resolver      - Custom domain name resolver (optional).
+    # schema_type          - A SchemaRegistry::Schema::Base subclass.
+    def initialize( # rubocop:disable Metrics/ParameterLists
+      registry: nil,
+      registry_url: nil,
+      schema_context: nil,
+      registry_path_prefix: nil,
+      logger: nil,
+      proxy: nil,
+      user: nil,
+      password: nil,
+      ssl_ca_file: nil,
+      client_cert: nil,
+      client_key: nil,
+      client_key_pass: nil,
+      client_cert_data: nil,
+      client_key_data: nil,
+      connect_timeout: nil,
+      resolv_resolver: nil,
+      schema_type: SchemaRegistry::Schema::Protobuf.new
+    )
+      @logger = logger || Logger.new($stderr)
+      @registry = registry || SchemaRegistry::CachedConfluentSchemaRegistry.new(
+        SchemaRegistry::ConfluentSchemaRegistry.new(
+          registry_url,
+          schema_context: schema_context,
+          logger: @logger,
+          proxy: proxy,
+          user: user,
+          password: password,
+          ssl_ca_file: ssl_ca_file,
+          client_cert: client_cert,
+          client_key: client_key,
+          client_key_pass: client_key_pass,
+          client_cert_data: client_cert_data,
+          client_key_data: client_key_data,
+          path_prefix: registry_path_prefix,
+          connect_timeout: connect_timeout,
+          resolv_resolver: resolv_resolver
+        )
+      )
+      @schema = schema_type
+    end
 
-    @schema.encode(message, stream, schema_name: schema_name)
-    stream.string
-  end
+    # Encodes a message using the specified schema.
+    # @param message [Object] The message that should be encoded. Must be compatible with the schema.
+    # @param subject [String] The subject name the schema should be registered under in the schema registry (optional).
+    # @param schema_name [String] the name of the schema to use for encoding (optional).
+    # @return [String] the encoded data.
+    def encode(message, subject: nil, schema_text: nil, schema_name: nil)
+      id = register_schema(message, subject, schema_text: schema_text, schema_name: schema_name)
 
-  # Decodes data into the original message.
-  #
-  # @param data [String] a string containing encoded data.
-  # @return [Object] the decoded data.
-  def decode(data)
-    stream = StringIO.new(data)
+      stream = StringIO.new
+      # Always start with the magic byte.
+      stream.write(MAGIC_BYTE)
 
-    # The first byte is MAGIC!!!
-    magic_byte = stream.read(1)
+      # The schema id is encoded as a 4-byte big-endian integer.
+      stream.write([id].pack('N'))
 
-    raise "Expected data to begin with a magic byte, got `#{magic_byte.inspect}`" if magic_byte != MAGIC_BYTE
+      @schema.encode(message, stream, schema_name: schema_name)
+      stream.string
+    end
 
-    # The schema id is a 4-byte big-endian integer.
-    schema_id = stream.read(4).unpack1('N')
-    schema = @registry.fetch(schema_id)
-    @schema.decode(stream, schema)
-  rescue Excon::Error::NotFound
-    raise SchemaNotFoundError, "Schema with id: #{schema_id} is not found on registry"
-  end
+    # Decodes data into the original message.
+    #
+    # @param data [String] a string containing encoded data.
+    # @return [Object] the decoded data.
+    def decode(data)
+      stream = StringIO.new(data)
 
-  private
+      # The first byte is MAGIC!!!
+      magic_byte = stream.read(1)
 
-  def register_schema(message, subject, schema_text: nil, schema_name: nil)
-    schema_text ||= @schema.schema_text(message, schema_name: schema_name)
-    return if @registry.registered?(schema_text, subject)
+      raise "Expected data to begin with a magic byte, got `#{magic_byte.inspect}`" if magic_byte != MAGIC_BYTE
 
-    # register dependencies first
-    dependencies = @schema.dependencies(message)
-    versions = dependencies.map do |name, dependency|
-      result = register_schema(dependency, name)
-      @registry.fetch_version(result, name)
+      # The schema id is a 4-byte big-endian integer.
+      schema_id = stream.read(4).unpack1('N')
+      schema = @registry.fetch(schema_id)
+      @schema.decode(stream, schema)
+    rescue Excon::Error::NotFound
+      raise SchemaNotFoundError, "Schema with id: #{schema_id} is not found on registry"
     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.schema_type)
+    private
+
+    def register_schema(message, subject, schema_text: nil, schema_name: nil)
+      schema_text ||= @schema.schema_text(message, schema_name: schema_name)
+      return if @registry.registered?(schema_text, subject)
+
+      # register dependencies first
+      dependencies = @schema.dependencies(message)
+      versions = dependencies.map do |name, dependency|
+        result = register_schema(dependency, name)
+        @registry.fetch_version(result, name)
+      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)
+    end
   end
 end

data/spec/decoding_spec.rb

@@ -2,7 +2,7 @@
 
 RSpec.describe 'decoding' do
   let(:schema_registry_client) do
-    SchemaRegistry.new(
+    SchemaRegistry::Client.new(
       registry_url: 'http://localhost:8081'
     )
   end
@@ -38,9 +38,9 @@ RSpec.describe 'decoding' do
 
   describe 'with JSON' do
     let(:schema_registry_client) do
-      SchemaRegistry.new(
+      SchemaRegistry::Client.new(
         registry_url: 'http://localhost:8081',
-        schema_type: SchemaRegistry::Schema::ProtoJsonSchema
+        schema_type: SchemaRegistry::Schema::ProtoJsonSchema.new
       )
     end
 
@@ -62,9 +62,9 @@ RSpec.describe 'decoding' do
   describe 'with Avro' do
     let(:schema_registry_client) do
       SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
-      SchemaRegistry.new(
+      SchemaRegistry::Client.new(
         registry_url: 'http://localhost:8081',
-        schema_type: SchemaRegistry::Schema::Avro
+        schema_type: SchemaRegistry::Schema::Avro.new
       )
     end
 

data/spec/encoding_spec.rb

@@ -2,7 +2,7 @@
 
 RSpec.describe 'encoding' do
   let(:schema_registry_client) do
-    SchemaRegistry.new(
+    SchemaRegistry::Client.new(
       registry_url: 'http://localhost:8081'
     )
   end
@@ -59,9 +59,9 @@ RSpec.describe 'encoding' do
 
   describe 'with JSON' do
     let(:schema_registry_client) do
-      SchemaRegistry.new(
+      SchemaRegistry::Client.new(
         registry_url: 'http://localhost:8081',
-        schema_type: SchemaRegistry::Schema::ProtoJsonSchema
+        schema_type: SchemaRegistry::Schema::ProtoJsonSchema.new
       )
     end
 
@@ -104,9 +104,9 @@ RSpec.describe 'encoding' do
   describe 'with Avro' do
     let(:schema_registry_client) do
       SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
-      SchemaRegistry.new(
+      SchemaRegistry::Client.new(
         registry_url: 'http://localhost:8081',
-        schema_type: SchemaRegistry::Schema::Avro
+        schema_type: SchemaRegistry::Schema::Avro.new
       )
     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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema_registry_client
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Daniel Orner