avro_turf 1.18.0 → 1.20.0

data/lib/avro_turf/mutable_schema_store.rb

@@ -1,18 +1,39 @@
-require 'avro_turf/schema_store'
+# frozen_string_literal: true
+
+require "avro_turf/schema_store"
 
 class AvroTurf
   # A schema store that allows you to add or remove schemas, and to access
   # them externally.
+  #
+  # Only the top-level schema is cached. It is important to not register
+  # sub-schema as other schemas may define the same sub-schema and
+  # the Avro gem will raise an Avro::SchemaParseError when parsing another
+  # schema with a subschema with the same name as one encounted previously:
+  # <Avro::SchemaParseError: The name "foo.bar" is already in use.>
+  #
+  # Essentially, the only schemas that should be resolvable in @schemas
+  # are those that have their own .avsc files on disk.
+  #
+  # See https://github.com/dasch/avro_turf/pull/111
+  # and the implementation in AvroTurf::SchemaStore#load_schema!
   class MutableSchemaStore < SchemaStore
     attr_accessor :schemas
 
     # @param schema_hash [Hash]
     def add_schema(schema_hash)
-      name = schema_hash['name']
-      namespace = schema_hash['namespace']
+      name = schema_hash["name"]
+      namespace = schema_hash["namespace"]
       full_name = Avro::Name.make_fullname(name, namespace)
       return if @schemas.key?(full_name)
-      Avro::Schema.real_parse(schema_hash, @schemas)
+
+      # We pass in copy of @schemas which Avro can freely modify
+      # and register the sub-schema. It doesn't matter because
+      # we will discard it.
+      schema = Avro::Schema.real_parse(schema_hash, @schemas.dup)
+      @schemas[full_name] = schema
+
+      schema
     end
   end
 end

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,20 @@
-require 'sinatra/base'
+# frozen_string_literal: true
+
+require "sinatra/base"
 
 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
 
@@ -51,7 +53,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 +62,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 +76,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 +99,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 +172,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 "sinatra/base"
 
 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/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AvroTurf
-  VERSION = "1.18.0"
+  VERSION = "1.20.0"
 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

data/spec/avro_turf_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 describe AvroTurf do
   let(:avro) { AvroTurf.new(schemas_path: "spec/schemas/") }
 
@@ -56,7 +58,7 @@ describe AvroTurf do
       end
     end
 
-    context 'when using nested schemas' do
+    context "when using nested schemas" do
       before do
         define_schema "post.avsc", <<-AVSC
           {
@@ -138,7 +140,6 @@ describe AvroTurf do
         expect(avro.decode(encoded_data)).to eq(data)
       end
     end
-
   end
 
   describe "#decode" do
@@ -179,22 +180,22 @@ describe AvroTurf do
         }
       AVSC
 
-      encoded_data = avro.encode({ "x" => 42, "y" => 13 }, schema_name: "point")
+      encoded_data = avro.encode({"x" => 42, "y" => 13}, schema_name: "point")
       reader_avro = AvroTurf.new(schemas_path: "spec/schemas/reader")
 
-      expect(reader_avro.decode(encoded_data, schema_name: "point")).to eq({ "x" => 42 })
+      expect(reader_avro.decode(encoded_data, schema_name: "point")).to eq({"x" => 42})
     end
   end
 
   describe "#decode_all" do
     context "when data contains multiple entries" do
-      let(:encoded_data) {  "Obj\u0001\u0004\u0014avro.codec\bnull\u0016avro.schema\xB6\u0004[{\"type\": \"record\", \"name\": \"address\", \"fields\": [{\"type\": \"string\", \"name\": \"street\"}, {\"type\": \"string\", \"name\": \"city\"}]}, {\"type\": \"record\", \"name\": \"person\", \"fields\": [{\"type\": \"string\", \"name\": \"name\"}, {\"type\": \"int\", \"name\": \"age\"}, {\"type\": \"address\", \"name\": \"address\"}]}]\u0000\xF9u\x84\xA1c\u0010\x82B\xE2\xCF\xF1\x98\xF7\xF1JH\u0004\x96\u0001\u0002\u0014Python🐍\x80\u0004\u0018Green Street\u001ASan Francisco\u0002\u0010Mojo🐍\u0002\u0016Blue Street\u0014Saturn🪐\xF9u\x84\xA1c\u0010\x82B\xE2\xCF\xF1\x98\xF7\xF1JH" } 
+      let(:encoded_data) { "Obj\u0001\u0004\u0014avro.codec\bnull\u0016avro.schema\xB6\u0004[{\"type\": \"record\", \"name\": \"address\", \"fields\": [{\"type\": \"string\", \"name\": \"street\"}, {\"type\": \"string\", \"name\": \"city\"}]}, {\"type\": \"record\", \"name\": \"person\", \"fields\": [{\"type\": \"string\", \"name\": \"name\"}, {\"type\": \"int\", \"name\": \"age\"}, {\"type\": \"address\", \"name\": \"address\"}]}]\u0000\xF9u\x84\xA1c\u0010\x82B\xE2\xCF\xF1\x98\xF7\xF1JH\u0004\x96\u0001\u0002\u0014Python🐍\x80\u0004\u0018Green Street\u001ASan Francisco\u0002\u0010Mojo🐍\u0002\u0016Blue Street\u0014Saturn🪐\xF9u\x84\xA1c\u0010\x82B\xE2\xCF\xF1\x98\xF7\xF1JH" }
 
       it "returns array of entries decoded using the inlined writer's schema " do
         expect(avro.decode_all(encoded_data).entries).to eq(
           [
-            {"name"=>"Python🐍", "age"=>256, "address"=>{"street"=>"Green Street", "city"=>"San Francisco"}},
-            {"name"=>"Mojo🐍", "age"=>1, "address"=>{"street"=>"Blue Street", "city"=>"Saturn🪐"}}
+            {"name" => "Python🐍", "age" => 256, "address" => {"street" => "Green Street", "city" => "San Francisco"}},
+            {"name" => "Mojo🐍", "age" => 1, "address" => {"street" => "Blue Street", "city" => "Saturn🪐"}}
           ]
         )
       end
@@ -219,8 +220,8 @@ describe AvroTurf do
                   .decode_all(encoded_data, schema_name: "person").entries
         ).to eq(
           [
-            {"name"=>"Python🐍", "age"=>256, "fav_color"=>"red🟥"},
-            {"name"=>"Mojo🐍", "age"=>1, "fav_color"=>"red🟥"}
+            {"name" => "Python🐍", "age" => 256, "fav_color" => "red🟥"},
+            {"name" => "Mojo🐍", "age" => 1, "fav_color" => "red🟥"}
           ]
         )
       end
@@ -249,7 +250,7 @@ describe AvroTurf do
       end
 
       context "with a valid message" do
-        let(:message) { { "full_name" => "John Doe" } }
+        let(:message) { {"full_name" => "John Doe"} }
 
         it "does not raise any error" do
           define_schema "message.avsc", <<-AVSC
@@ -267,7 +268,7 @@ describe AvroTurf do
       end
 
       context "when message has wrong type" do
-        let(:message) { { "full_name" => 123 } }
+        let(:message) { {"full_name" => 123} }
 
         it "raises Avro::SchemaValidator::ValidationError with a message about type mismatch" do
           define_schema "message.avsc", <<-AVSC
@@ -285,7 +286,7 @@ describe AvroTurf do
       end
 
       context "when message contains extra fields (typo in key)" do
-        let(:message) { { "fulll_name" => "John Doe" } }
+        let(:message) { {"fulll_name" => "John Doe"} }
 
         it "raises Avro::SchemaValidator::ValidationError with a message about extra field" do
           define_schema "message.avsc", <<-AVSC
@@ -303,13 +304,12 @@ describe AvroTurf do
       end
 
       context "when the `fail_on_extra_fields` validation option is disabled" do
-        let(:message) { { "full_name" => "John Doe", "first_name" => "John", "last_name" => "Doe" } }
+        let(:message) { {"full_name" => "John Doe", "first_name" => "John", "last_name" => "Doe"} }
         subject(:encode_to_stream) do
           stream = StringIO.new
           avro.encode_to_stream(message, stream: stream, schema_name: "message",
-                                validate: true,
-                                validate_options: { recursive: true, encoded: false, fail_on_extra_fields: false }
-          )
+            validate: true,
+            validate_options: {recursive: true, encoded: false, fail_on_extra_fields: false})
         end
 
         it "should not raise Avro::SchemaValidator::ValidationError with a message about extra field" do
@@ -352,8 +352,8 @@ describe AvroTurf do
 
       expect(avro.decode_all_from_stream(stream).entries).to eq(
         [
-          {"name"=>"Python🐍", "age"=>256, "address"=>{"street"=>"Green Street", "city"=>"San Francisco"}},
-          {"name"=>"Mojo🐍", "age"=>1, "address"=>{"street"=>"Blue Street", "city"=>"Saturn🪐"}}
+          {"name" => "Python🐍", "age" => 256, "address" => {"street" => "Green Street", "city" => "San Francisco"}},
+          {"name" => "Mojo🐍", "age" => 1, "address" => {"street" => "Blue Street", "city" => "Saturn🪐"}}
         ]
       )
     end
@@ -390,7 +390,7 @@ describe AvroTurf do
         }
       AVSC
 
-      datum = { message: "hello" }
+      datum = {message: "hello"}
       expect(avro.valid?(datum, schema_name: "postcard")).to eq true
     end
 
@@ -423,7 +423,7 @@ describe AvroTurf do
     end
 
     context "when message contains extra fields (typo in key)" do
-      let(:message) { { "fulll_name" => "John Doe" } }
+      let(:message) { {"fulll_name" => "John Doe"} }
 
       before do
         define_schema "message.avsc", <<-AVSC
@@ -438,16 +438,17 @@ describe AvroTurf do
       end
 
       it "is valid" do
-        datum = { "full_name" => "John Doe", "extra" => "extra" }
+        datum = {"full_name" => "John Doe", "extra" => "extra"}
         expect(avro.valid?(datum, schema_name: "message")).to eq true
       end
 
       it "is invalid when passing fail_on_extra_fields" do
-        datum = { "full_name" => "John Doe", "extra" => "extra" }
+        datum = {"full_name" => "John Doe", "extra" => "extra"}
         validate_options = {
           recursive: true,
           encoded: false,
-          fail_on_extra_fields: true }
+          fail_on_extra_fields: true
+        }
         valid = avro.valid?(datum, schema_name: "message", validate_options: validate_options)
         expect(valid).to eq false
       end

data/spec/cached_confluent_schema_registry_spec.rb

@@ -1,17 +1,19 @@
-require 'webmock/rspec'
-require 'avro_turf/cached_confluent_schema_registry'
-require 'avro_turf/test/fake_confluent_schema_registry_server'
+# frozen_string_literal: true
+
+require "webmock/rspec"
+require "avro_turf/cached_confluent_schema_registry"
+require "avro_turf/test/fake_confluent_schema_registry_server"
 
 describe AvroTurf::CachedConfluentSchemaRegistry do
   let(:upstream) { instance_double(AvroTurf::ConfluentSchemaRegistry) }
   let(:registry) { described_class.new(upstream) }
   let(:id) { rand(999) }
-  let(:subject_name) { 'a_subject' }
+  let(:subject_name) { "a_subject" }
   let(:schema) do
     {
       type: "record",
       name: "person",
-      fields: [{ name: "name", type: "string" }]
+      fields: [{name: "name", type: "string"}]
     }.to_json
   end
 
@@ -57,7 +59,7 @@ describe AvroTurf::CachedConfluentSchemaRegistry do
     end
   end
 
-  describe '#subject_version' do
+  describe "#subject_version" do
     let(:version) { 1 }
     let(:schema_with_meta) do
       {
@@ -68,7 +70,7 @@ describe AvroTurf::CachedConfluentSchemaRegistry do
       }
     end
 
-    it 'caches the result of subject_version' do
+    it "caches the result of subject_version" do
       allow(upstream).to receive(:subject_version).with(subject_name, version).and_return(schema_with_meta)
       registry.subject_version(subject_name, version)
       registry.subject_version(subject_name, version)