schema_registry_client 0.0.7 → 0.0.8

data/lib/schema_registry_client/schema/avro.rb

@@ -1,60 +1,64 @@
 # frozen_string_literal: true
 
-require "schema_registry_client/schema/base"
-require "schema_registry_client/avro_schema_store"
+require 'schema_registry_client/schema/base'
+require 'schema_registry_client/avro_schema_store'
 
 module SchemaRegistry
   module Schema
     class Avro < Base
-      DEFAULT_SCHEMAS_PATH = "./schemas"
+      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
-            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

@@ -5,39 +5,37 @@ module SchemaRegistry
     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

@@ -1,29 +1,27 @@
 # frozen_string_literal: true
 
-require "schema_registry_client/schema/base"
-require "schema_registry_client/output/json_schema"
+require 'schema_registry_client/schema/base'
+require 'schema_registry_client/output/json_schema'
 
 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

@@ -1,130 +1,130 @@
 # 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
-      class << self
-        def schema_type
-          "PROTOBUF"
-        end
+      def self.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)
+      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 encode(message, stream, schema_name: nil)
+        _, indexes = find_index(message.class.descriptor.to_proto,
+                                message.class.descriptor.file_descriptor.to_proto.message_type)
+
+        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)
+      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) }
+      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
-
-          # Now we write the actual message.
-          stream.write(message.to_proto)
         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
+        encoded = stream.read
+        decode_protobuf(schema_text, encoded, indexes)
+      end
 
-          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
 
-        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
+      end
 
-            @all_schemas[file_path] = file_desc
-          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 dependencies(message)
-          load_schemas! unless @all_schemas&.any?
-          file_descriptor = if message.is_a?(Google::Protobuf::FileDescriptor)
-            message
+      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
-            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]
+            found, found_indexes = find_index(descriptor, sub_descriptor.nested_type, indexes + [i])
+            return [true, found_indexes] if found
           end
         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
-          end
-          []
+      def find_descriptor(indexes, messages)
+        first_index = indexes.shift
+        message = messages[first_index]
+        path = [message.name]
+        while indexes.length.positive?
+          message = message.nested_type[indexes.shift]
+          path.push(message.name)
         end
+        path
+      end
 
-        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 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
 
-        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
+        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
 
 module SchemaRegistry
-  VERSION = "0.0.7"
+  VERSION = '0.0.8'
 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.
     #
@@ -66,7 +66,7 @@ module SchemaRegistry
       client_key_data: nil,
       connect_timeout: nil,
       resolv_resolver: nil,
-      schema_type: SchemaRegistry::Schema::Protobuf
+      schema_type: SchemaRegistry::Schema::Protobuf.new
     )
       @logger = logger || Logger.new($stderr)
       @registry = registry || SchemaRegistry::CachedConfluentSchemaRegistry.new(
@@ -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,17 +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.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