avro_turf 1.19.0 → 1.20.1

data/lib/avro_turf/schema_registry.rb

@@ -1,4 +1,6 @@
-require 'avro_turf/confluent_schema_registry'
+# frozen_string_literal: true
+
+require "avro_turf/confluent_schema_registry"
 
 # AvroTurf::SchemaRegistry is deprecated and will be removed in a future release.
 # Use AvroTurf::ConfluentSchemaRegistry instead.

data/lib/avro_turf/schema_store.rb

@@ -1,8 +1,9 @@
-class AvroTurf::SchemaStore
+# frozen_string_literal: true
 
+class AvroTurf::SchemaStore
   def initialize(path: nil)
     @path = path or raise "Please specify a schema path"
-    @schemas = Hash.new
+    @schemas = {}
     @mutex = Mutex.new
   end
 

data/lib/avro_turf/schema_to_avro_patch.rb

@@ -1,36 +1,38 @@
+# frozen_string_literal: true
+
 class AvroTurf
   module AvroGemPatch
     module RecordSchema
       module ClassMethods
-        def make_field_objects(field_data, names, namespace=nil)
+        def make_field_objects(field_data, names, namespace = nil)
           new_field_data = []
           field_data.each do |field|
-            if field.respond_to?(:[]) && !field.key?('default')
+            if field.respond_to?(:[]) && !field.key?("default")
               field = field.clone
-              field['default'] = :no_default
+              field["default"] = :no_default
             end
             new_field_data << field
           end
           super(new_field_data, names, namespace)
         end
       end
-      
+
       def self.prepended(base)
         class << base
           prepend ClassMethods
         end
       end
     end
-    
+
     module Field
-      def initialize(type, name, default=:no_default, order=nil, names=nil, namespace=nil)
-        super(type, name, default, order, names, namespace)
+      def initialize(type, name, default = :no_default, order = nil, names = nil, namespace = nil)
+        super
       end
-      
-      def to_avro(names=Set.new)
-        {'name' => name, 'type' => type.to_avro(names)}.tap do |avro|
-          avro['default'] = default unless default == :no_default
-          avro['order'] = order if order
+
+      def to_avro(names = Set.new)
+        {"name" => name, "type" => type.to_avro(names)}.tap do |avro|
+          avro["default"] = default unless default == :no_default
+          avro["order"] = order if order
         end
       end
     end

data/lib/avro_turf/test/fake_confluent_schema_registry_server.rb

@@ -1,18 +1,22 @@
-require 'sinatra/base'
+# frozen_string_literal: true
+
+require_relative "fake_server"
+
+class FakeConfluentSchemaRegistryServer
+  include AvroTurf::Test::FakeServer
 
-class FakeConfluentSchemaRegistryServer < Sinatra::Base
   QUALIFIED_SUBJECT = /
       :(?<context>\.[^:]*)
       :(?<subject>.*)
     /x
-  DEFAULT_CONTEXT = '.'
-  SUBJECTS = Hash.new { |hash, key| hash[key] = Hash.new { Array.new } }
-  SCHEMAS = Hash.new { |hash, key| hash[key] = Array.new }
-  CONFIGS = Hash.new
-  SUBJECT_NOT_FOUND = { error_code: 40401, message: 'Subject not found' }.to_json.freeze
-  VERSION_NOT_FOUND = { error_code: 40402, message: 'Version not found' }.to_json.freeze
-  SCHEMA_NOT_FOUND = { error_code: 40403, message: 'Schema not found' }.to_json.freeze
-  DEFAULT_GLOBAL_CONFIG = { 'compatibility' => 'BACKWARD'.freeze }.freeze
+  DEFAULT_CONTEXT = "."
+  SUBJECTS = Hash.new { |hash, key| hash[key] = Hash.new { [] } }
+  SCHEMAS = Hash.new { |hash, key| hash[key] = [] }
+  CONFIGS = {}
+  SUBJECT_NOT_FOUND = {error_code: 40401, message: "Subject not found"}.to_json.freeze
+  VERSION_NOT_FOUND = {error_code: 40402, message: "Version not found"}.to_json.freeze
+  SCHEMA_NOT_FOUND = {error_code: 40403, message: "Schema not found"}.to_json.freeze
+  DEFAULT_GLOBAL_CONFIG = {"compatibility" => "BACKWARD"}.freeze
 
   @global_config = DEFAULT_GLOBAL_CONFIG.dup
 
@@ -20,22 +24,21 @@ class FakeConfluentSchemaRegistryServer < Sinatra::Base
     attr_reader :global_config
   end
 
-  helpers do
-    def parse_schema
-      request.body.rewind
-      JSON.parse(request.body.read).fetch("schema").tap do |schema|
-        Avro::Schema.parse(schema)
-      end
+  # Helper methods (previously in Sinatra helpers block)
+  def parse_schema
+    request.body.rewind
+    JSON.parse(request.body.read).fetch("schema").tap do |schema|
+      Avro::Schema.parse(schema)
     end
+  end
 
-    def parse_config
-      request.body.rewind
-      JSON.parse(request.body.read)
-    end
+  def parse_config
+    request.body.rewind
+    JSON.parse(request.body.read)
+  end
 
-    def global_config
-      self.class.global_config
-    end
+  def global_config
+    self.class.global_config
   end
 
   post "/subjects/:qualified_subject/versions" do
@@ -51,7 +54,7 @@ class FakeConfluentSchemaRegistryServer < Sinatra::Base
       SUBJECTS[context][subject] = SUBJECTS[context][subject] << schema_id
     end
 
-    { id: schema_id }.to_json
+    {id: schema_id}.to_json
   end
 
   get "/schemas/ids/:schema_id/versions" do
@@ -60,7 +63,7 @@ class FakeConfluentSchemaRegistryServer < Sinatra::Base
     schema = SCHEMAS[context].at(schema_id)
     halt(404, SCHEMA_NOT_FOUND) unless schema
 
-    related_subjects = SUBJECTS[context].select {|_, vs| vs.include? schema_id }
+    related_subjects = SUBJECTS[context].select { |_, vs| vs.include? schema_id }
 
     related_subjects.map do |subject, versions|
       {
@@ -74,14 +77,13 @@ class FakeConfluentSchemaRegistryServer < Sinatra::Base
     context, _subject = parse_qualified_subject(params[:subject])
     schema = SCHEMAS[context].at(params[:schema_id].to_i)
     halt(404, SCHEMA_NOT_FOUND) unless schema
-    { schema: schema }.to_json
+    {schema: schema}.to_json
   end
 
   get "/subjects" do
-    subject_names = SUBJECTS.reduce([]) do |acc, args|
+    subject_names = SUBJECTS.each_with_object([]) do |args, acc|
       context, subjects = args
-      subjects.keys.each { |subject| acc << (context == '.' ? subject : ":#{context}:#{subject}") }
-      acc
+      subjects.keys.each { |subject| acc << ((context == ".") ? subject : ":#{context}:#{subject}") }
     end
     subject_names.to_json
   end
@@ -98,11 +100,11 @@ class FakeConfluentSchemaRegistryServer < Sinatra::Base
     schema_ids = SUBJECTS[context][subject]
     halt(404, SUBJECT_NOT_FOUND) if schema_ids.empty?
 
-    schema_id = if params[:version] == 'latest'
-                  schema_ids.last
-                else
-                  schema_ids.at(Integer(params[:version]) - 1)
-                end
+    schema_id = if params[:version] == "latest"
+      schema_ids.last
+    else
+      schema_ids.at(Integer(params[:version]) - 1)
+    end
     halt(404, VERSION_NOT_FOUND) unless schema_id
 
     schema = SCHEMAS[context].at(schema_id)
@@ -171,13 +173,13 @@ class FakeConfluentSchemaRegistryServer < Sinatra::Base
   def parse_qualified_subject(qualified_subject)
     match = QUALIFIED_SUBJECT.match(qualified_subject)
     if !match.nil?
-      match.named_captures.values_at('context', 'subject')
+      match.named_captures.values_at("context", "subject")
     else
-      [ DEFAULT_CONTEXT, qualified_subject]
+      [DEFAULT_CONTEXT, qualified_subject]
     end
   end
 
   def qualify_subject(context, subject)
-    context == "." ? subject : ":#{context}:#{subject}"
+    (context == ".") ? subject : ":#{context}:#{subject}"
   end
 end

data/lib/avro_turf/test/fake_prefixed_confluent_schema_registry_server.rb

@@ -1,7 +1,9 @@
-require 'sinatra/base'
+# frozen_string_literal: true
+
+require_relative "fake_confluent_schema_registry_server"
 
 class FakePrefixedConfluentSchemaRegistryServer < FakeConfluentSchemaRegistryServer
-  DEFAULT_CONTEXT='.'
+  DEFAULT_CONTEXT = "."
 
   post "/prefix/subjects/:subject/versions" do
     schema = parse_schema
@@ -9,7 +11,7 @@ class FakePrefixedConfluentSchemaRegistryServer < FakeConfluentSchemaRegistrySer
 
     schemas_for_subject =
       SCHEMAS[DEFAULT_CONTEXT].select
-             .with_index { |_, i| ids_for_subject.include?(i) }
+        .with_index { |_, i| ids_for_subject.include?(i) }
 
     if schemas_for_subject.include?(schema)
       schema_id = SCHEMAS[DEFAULT_CONTEXT].index(schema)
@@ -19,13 +21,13 @@ class FakePrefixedConfluentSchemaRegistryServer < FakeConfluentSchemaRegistrySer
       SUBJECTS[DEFAULT_CONTEXT][params[:subject]] = SUBJECTS[DEFAULT_CONTEXT][params[:subject]] << schema_id
     end
 
-    { id: schema_id }.to_json
+    {id: schema_id}.to_json
   end
 
   get "/prefix/schemas/ids/:schema_id" do
     schema = SCHEMAS[DEFAULT_CONTEXT].at(params[:schema_id].to_i)
     halt(404, SCHEMA_NOT_FOUND) unless schema
-    { schema: schema }.to_json
+    {schema: schema}.to_json
   end
 
   get "/prefix/subjects" do
@@ -42,11 +44,11 @@ class FakePrefixedConfluentSchemaRegistryServer < FakeConfluentSchemaRegistrySer
     schema_ids = SUBJECTS[DEFAULT_CONTEXT][params[:subject]]
     halt(404, SUBJECT_NOT_FOUND) if schema_ids.empty?
 
-    schema_id = if params[:version] == 'latest'
-                  schema_ids.last
-                else
-                  schema_ids.at(Integer(params[:version]) - 1)
-                end
+    schema_id = if params[:version] == "latest"
+      schema_ids.last
+    else
+      schema_ids.at(Integer(params[:version]) - 1)
+    end
     halt(404, VERSION_NOT_FOUND) unless schema_id
 
     schema = SCHEMAS[DEFAULT_CONTEXT].at(schema_id)

data/lib/avro_turf/test/fake_schema_registry_server.rb

@@ -1,4 +1,6 @@
-require 'avro_turf/test/fake_confluent_schema_registry_server'
+# frozen_string_literal: true
+
+require "avro_turf/test/fake_confluent_schema_registry_server"
 
 # FakeSchemaRegistryServer is deprecated and will be removed in a future release.
 # Use FakeConfluentSchemaRegistryServer instead.

data/lib/avro_turf/test/fake_server.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "json"
+require "rack"
+
+# Ensure AvroTurf class exists so we can add modules to it
+# This is defined as a class (not module) in lib/avro_turf/version.rb
+class AvroTurf
+  module Test
+  end
+end
+
+# A lightweight Rack-based router module that provides Sinatra-like DSL.
+# This module is designed to replace Sinatra::Base for the fake schema registry servers
+# used in testing, eliminating the sinatra dependency.
+#
+# Usage:
+#   class MyServer
+#     include AvroTurf::Test::FakeServer
+#
+#     get "/path/:param" do
+#       { result: params[:param] }.to_json
+#     end
+#
+#     post "/other" do
+#       halt(404, '{"error": "not found"}') if some_condition
+#       '{"ok": true}'
+#     end
+#   end
+#
+module AvroTurf::Test::FakeServer
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.include(InstanceMethods)
+  end
+
+  module ClassMethods
+    # Storage for routes defined in this class
+    def routes
+      @routes ||= {"GET" => [], "POST" => [], "PUT" => [], "DELETE" => []}
+    end
+
+    # When a class inherits from another that includes FakeServer,
+    # ensure it gets its own routes hash
+    def inherited(subclass)
+      super
+      subclass.instance_variable_set(:@routes, nil)
+    end
+
+    # Define a GET route
+    def get(pattern, &block)
+      add_route("GET", pattern, block)
+    end
+
+    # Define a POST route
+    def post(pattern, &block)
+      add_route("POST", pattern, block)
+    end
+
+    # Define a PUT route
+    def put(pattern, &block)
+      add_route("PUT", pattern, block)
+    end
+
+    # Define a DELETE route
+    def delete(pattern, &block)
+      add_route("DELETE", pattern, block)
+    end
+
+    # Sinatra-compatible `set` method for configuration
+    def set(key, value)
+      case key
+      when :host_authorization
+        @host_authorization = value
+      else
+        instance_variable_set(:"@#{key}", value)
+      end
+    end
+
+    # Access host authorization settings
+    def host_authorization
+      @host_authorization
+    end
+
+    # Rack interface - creates a new instance and calls it
+    def call(env)
+      new.call(env)
+    end
+
+    private
+
+    def add_route(method, pattern, block)
+      routes[method] << [compile_pattern(pattern), pattern, block]
+    end
+
+    # Convert a route pattern like "/subjects/:subject/versions" to a regex
+    # with named capture groups: /^\/subjects\/(?<subject>[^\/]+)\/versions$/
+    def compile_pattern(pattern)
+      regex_str = Regexp.escape(pattern).gsub(/:(\w+)/) { "(?<#{$1}>[^/]+)" }
+      Regexp.new("^#{regex_str}$")
+    end
+  end
+
+  module InstanceMethods
+    attr_reader :request, :params
+
+    def call(env)
+      @request = Rack::Request.new(env)
+      @params = {}
+
+      # Check host authorization if configured
+      if (auth = self.class.host_authorization)
+        permitted = auth[:permitted_hosts] || []
+        unless permitted.include?(@request.host)
+          return [403, {"Content-Type" => "text/plain"}, ["Forbidden"]]
+        end
+      end
+
+      # Use catch/throw for halt mechanism (like Sinatra)
+      catch(:halt) do
+        route_and_dispatch(env)
+      end
+    end
+
+    # Early return from a route handler with a specific status and body
+    def halt(status, body)
+      throw :halt, [status, {"Content-Type" => "application/json"}, [body]]
+    end
+
+    private
+
+    def route_and_dispatch(env)
+      method = env["REQUEST_METHOD"]
+      path = env["PATH_INFO"]
+
+      # Parse query string into params (with both string and symbol keys for compatibility)
+      query_params = Rack::Utils.parse_query(env["QUERY_STRING"] || "")
+      @params = {}
+      query_params.each do |key, value|
+        @params[key] = value
+        @params[key.to_sym] = value
+      end
+
+      # Find matching route (check own class first, then ancestors)
+      matched = find_route(method, path)
+
+      if matched
+        regex, _pattern, block = matched
+
+        # Extract path parameters from the match
+        if (match = regex.match(path))
+          match.names.each do |name|
+            # Store with both symbol and string keys for compatibility
+            @params[name.to_sym] = match[name]
+            @params[name] = match[name]
+          end
+        end
+
+        # Execute the route block in the context of this instance
+        body = instance_exec(&block)
+        [200, {"Content-Type" => "text/html;charset=utf-8"}, [body]]
+      else
+        [404, {"Content-Type" => "text/plain"}, ["Not Found"]]
+      end
+    end
+
+    # Find a matching route by searching this class's routes first,
+    # then parent classes (to support inheritance)
+    def find_route(method, path)
+      klass = self.class
+      while klass
+        if klass.respond_to?(:routes, true) && klass.routes[method]
+          klass.routes[method].each do |route|
+            regex, _, _ = route
+            return route if regex.match(path)
+          end
+        end
+        # Move up the inheritance chain
+        klass = klass.superclass
+        # Stop if we've gone past classes that include FakeServer
+        break unless klass.respond_to?(:routes, true)
+      end
+      nil
+    end
+  end
+end

data/lib/avro_turf/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AvroTurf
-  VERSION = "1.19.0"
+  VERSION = "1.20.1"
 end

data/lib/avro_turf.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 begin
-  require 'avro-patches'
+  require "avro-patches"
 rescue LoadError
   false
 end
-require 'avro_turf/version'
-require 'avro'
-require 'json'
-require 'avro_turf/schema_store'
-require 'avro_turf/core_ext'
+require "avro_turf/version"
+require "avro"
+require "json"
+require "avro_turf/schema_store"
+require "avro_turf/core_ext"
 
 # check for something that indicates Avro v1.9.0 or later
 unless defined?(::Avro::LogicalTypes)
-  require 'avro_turf/schema_to_avro_patch'
+  require "avro_turf/schema_to_avro_patch"
 end
 
 class AvroTurf
@@ -69,10 +71,10 @@ class AvroTurf
   #
   # Returns nothing.
   def encode_to_stream(data, schema_name: nil, stream: nil, namespace: @namespace,
-                       validate: false,
-                       validate_options: { recursive: true,
-                                           encoded: false,
-                                           fail_on_extra_fields: true })
+    validate: false,
+    validate_options: {recursive: true,
+                       encoded: false,
+                       fail_on_extra_fields: true})
     schema = @schema_store.find(schema_name, namespace)
     writer = Avro::IO::DatumWriter.new(schema)
 
@@ -98,7 +100,7 @@ class AvroTurf
     decode_stream(stream, schema_name: schema_name, namespace: namespace)
   end
 
-  alias decode decode_first
+  alias_method :decode, :decode_first
 
   # Returns all entries encoded in the data.
   def decode_all(encoded_data, schema_name: nil, namespace: @namespace)
@@ -119,7 +121,7 @@ class AvroTurf
     data.first
   end
 
-  alias decode_stream decode_first_from_stream
+  alias_method :decode_stream, :decode_first_from_stream
 
   # Returns all entries encoded in the stream.
   def decode_all_from_stream(stream, schema_name: nil, namespace: @namespace)

data/perf/encoding_size.rb

@@ -1,11 +1,13 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 #
 # Measures the encoded size of messages of increasing size.
 
 $LOAD_PATH.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
 
-require 'benchmark'
-require 'avro_turf'
+require "benchmark"
+require "avro_turf"
 
 sizes = [1, 10, 100, 1_000, 10_000]
 avro = AvroTurf.new(schemas_path: File.dirname(__FILE__))

data/perf/encoding_speed.rb

@@ -1,11 +1,13 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 #
 # Measures the time it takes to encode messages of increasing size.
 
 $LOAD_PATH.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
 
-require 'benchmark'
-require 'avro_turf'
+require "benchmark"
+require "avro_turf"
 
 # Number of iterations per run.
 N = 10_000