defmastership 1.3.3 → 1.3.4

data/spec/unit/defmastership/modifier/rename_included_files_spec.rb

@@ -33,14 +33,14 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
       context 'when the include statement do not match' do
         before do
           ['[define,requirement,REFERENCE]', '--'].each do |line|
-            includeschanger.replace(line)
+            includeschanger.replace('', line)
           end
         end
 
-        it { expect(includeschanger.replace('badinclude::orig[]')).to(eq('badinclude::orig[]')) }
+        it { expect(includeschanger.replace('', 'badinclude::orig[]')).to(eq('badinclude::orig[]')) }
 
         it do
-          includeschanger.replace('badinclude::orig[]')
+          includeschanger.replace('', 'badinclude::orig[]')
           expect(includeschanger).to(have_attributes(changes: []))
         end
       end
@@ -48,25 +48,25 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
       context 'when the include is not in a definition' do
         before do
           ['[define,requirement,REFERENCE]', '--', 'text', '--'].each do |line|
-            includeschanger.replace(line)
+            includeschanger.replace('', line)
           end
         end
 
-        it { expect(includeschanger.replace('include::orig[]')).to(eq('include::orig[]')) }
+        it { expect(includeschanger.replace('', 'include::orig[]')).to(eq('include::orig[]')) }
 
         it do
-          includeschanger.replace('include::orig[]')
+          includeschanger.replace('', 'include::orig[]')
           expect(includeschanger).to(have_attributes(changes: []))
         end
       end
 
       context 'when the line is commented' do
         before do
-          includeschanger.replace('[define,requirement,REFERENCE]')
-          includeschanger.replace('--')
+          includeschanger.replace('', '[define,requirement,REFERENCE]')
+          includeschanger.replace('', '--')
         end
 
-        it { expect(includeschanger.replace('// include::orig[]')).to(eq('// include::orig[]')) }
+        it { expect(includeschanger.replace('', '// include::orig[]')).to(eq('// include::orig[]')) }
       end
 
       context 'when the cancel regexp is met' do
@@ -75,11 +75,11 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
         end
 
         before do
-          includeschanger.replace('[define,requirement,REFERENCE]')
-          includeschanger.replace('--')
+          includeschanger.replace('', '[define,requirement,REFERENCE]')
+          includeschanger.replace('', '--')
         end
 
-        it { expect(includeschanger.replace("include::orig[]\n")).to(eq("include::orig[]\n")) }
+        it { expect(includeschanger.replace('', "include::orig[]\n")).to(eq("include::orig[]\n")) }
       end
     end
 
@@ -94,48 +94,48 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
         end
 
         before do
-          includeschanger.replace('[define,requirement,REFERENCE]')
-          includeschanger.replace('--')
+          includeschanger.replace('sub/one_file.adoc', '[define,requirement,REFERENCE]')
+          includeschanger.replace('sub/one_file.adoc', '--')
         end
 
         it do
-          expect(includeschanger.replace("include::orig[]\n"))
+          expect(includeschanger.replace('sub/one_file.adoc', "include::orig[]\n"))
             .to(eq("include::dest[]\n"))
         end
 
         it do
-          includeschanger.replace("include::orig[]\n")
-          expect(File).to(have_received(:rename).with('orig', 'dest'))
+          includeschanger.replace('sub/one_file.adoc', "include::orig[]\n")
+          expect(File).to(have_received(:rename).with('sub/orig', 'sub/dest'))
         end
 
         it do
-          expect(includeschanger.replace("include::orig[leveloffset=offset,lines=ranges]\n"))
+          expect(includeschanger.replace('', "include::orig[leveloffset=offset,lines=ranges]\n"))
             .to(eq("include::dest[leveloffset=offset,lines=ranges]\n"))
         end
 
         it do
-          includeschanger.replace("include::orig[leveloffset=offset,lines=ranges]\n")
-          expect(File).to(have_received(:rename).with('orig', 'dest'))
+          includeschanger.replace('sub/one_file.adoc', "include::orig[leveloffset=offset,lines=ranges]\n")
+          expect(File).to(have_received(:rename).with('sub/orig', 'sub/dest'))
         end
 
         it do
-          includeschanger.replace("include::orig[]\n")
-          expect(includeschanger).to(have_attributes(changes: [%w[orig dest]]))
+          includeschanger.replace('', "include::orig[]\n")
+          expect(includeschanger).to(have_attributes(changes: [%w[./orig ./dest]]))
         end
 
         it do
-          expect(includeschanger.replace("include::toto/orig[]\n"))
+          expect(includeschanger.replace('sub/one_file.adoc', "include::toto/orig[]\n"))
             .to(eq("include::toto/dest[]\n"))
         end
 
         it do
-          includeschanger.replace("include::toto/orig[]\n")
-          expect(File).to(have_received(:rename).with('toto/orig', 'toto/dest'))
+          includeschanger.replace('sub/one_file.adoc', "include::toto/orig[]\n")
+          expect(File).to(have_received(:rename).with('sub/toto/orig', 'sub/toto/dest'))
         end
 
         it do
-          includeschanger.replace("include::toto/orig[]\n")
-          expect(includeschanger).to(have_attributes(changes: [%w[toto/orig toto/dest]]))
+          includeschanger.replace('sub/one_file.adoc', "include::toto/orig[]\n")
+          expect(includeschanger).to(have_attributes(changes: [%w[sub/toto/orig sub/toto/dest]]))
         end
       end
 
@@ -145,22 +145,24 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
         end
 
         before do
-          includeschanger.replace('[define,requirement,REF]')
+          includeschanger.replace('sub/one_file.adoc', '[define,requirement,REF]')
         end
 
         it do
-          expect(includeschanger.replace('include::any_path/one_file.extension[]'))
+          expect(includeschanger.replace('sub/one_file.adoc', 'include::any_path/one_file.extension[]'))
             .to(eq('include::any_path/REF_one_file.extension[]'))
         end
 
         it do
-          includeschanger.replace('include::any_path/one_file.extension[]')
-          expect(File).to(have_received(:rename).with('any_path/one_file.extension', 'any_path/REF_one_file.extension'))
+          includeschanger.replace('sub/one_file.adoc', 'include::any_path/one_file.extension[]')
+          expect(File).to(
+            have_received(:rename).with('sub/any_path/one_file.extension', 'sub/any_path/REF_one_file.extension')
+          )
         end
 
         it do
-          changes = [%w[any_path/one_file.extension any_path/REF_one_file.extension]]
-          includeschanger.replace('include::any_path/one_file.extension[]')
+          changes = [%w[sub/any_path/one_file.extension sub/any_path/REF_one_file.extension]]
+          includeschanger.replace('sub/one_file.adoc', 'include::any_path/one_file.extension[]')
           expect(includeschanger).to(have_attributes(changes: changes))
         end
       end
@@ -169,33 +171,35 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
         subject(:includeschanger) { described_class.new(from_regexp: 'orig', to_template: 'dest') }
 
         before do
-          includeschanger.replace(':any: one')
-          includeschanger.replace(':path: two')
-          includeschanger.replace(':var: three')
-          includeschanger.replace('[define,requirement,REFERENCE]')
-          includeschanger.replace('--')
+          includeschanger.replace('sub/one_file.adoc', ':any: one')
+          includeschanger.replace('sub/one_file.adoc', ':path: two')
+          includeschanger.replace('sub/one_file.adoc', ':var: three')
+          includeschanger.replace('sub/one_file.adoc', '[define,requirement,REFERENCE]')
+          includeschanger.replace('sub/one_file.adoc', '--')
         end
 
-        it { expect(includeschanger.replace('include::{any}/orig[]')).to(eq('include::{any}/dest[]')) }
+        it do
+          expect(includeschanger.replace('sub/one_file.adoc', 'include::{any}/orig[]')).to(eq('include::{any}/dest[]'))
+        end
 
         it do
-          includeschanger.replace('include::{any}{var}/orig[]')
-          expect(File).to(have_received(:rename).with('onethree/orig', 'onethree/dest'))
+          includeschanger.replace('sub/one_file.adoc', 'include::{any}{var}/orig[]')
+          expect(File).to(have_received(:rename).with('sub/onethree/orig', 'sub/onethree/dest'))
         end
 
         it do
-          includeschanger.replace('include::{any}_{path}/orig[]')
-          expect(File).to(have_received(:rename).with('one_two/orig', 'one_two/dest'))
+          includeschanger.replace('sub/one_file.adoc', 'include::{any}_{path}/orig[]')
+          expect(File).to(have_received(:rename).with('sub/one_two/orig', 'sub/one_two/dest'))
         end
 
         it do
-          expect { includeschanger.replace('include::{bad_variable}/orig[]') }
+          expect { includeschanger.replace('sub/one_file.adoc', 'include::{bad_variable}/orig[]') }
             .to(raise_error(KeyError, 'key not found: :bad_variable'))
         end
 
         it do
-          includeschanger.replace('include::{any}_{path}/orig[]')
-          expect(includeschanger).to(have_attributes(changes: [%w[one_two/orig one_two/dest]]))
+          includeschanger.replace('sub/one_file.adoc', 'include::{any}_{path}/orig[]')
+          expect(includeschanger).to(have_attributes(changes: [%w[sub/one_two/orig sub/one_two/dest]]))
         end
       end
 
@@ -205,16 +209,16 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
         end
 
         it do
-          includeschanger.replace('[define,whatever,REFERENCE]')
-          includeschanger.replace('--')
-          expect(includeschanger.replace("include::orig[]\n"))
+          includeschanger.replace('sub/one_file.adoc', '[define,whatever,REFERENCE]')
+          includeschanger.replace('sub/one_file.adoc', '--')
+          expect(includeschanger.replace('sub/one_file.adoc', "include::orig[]\n"))
             .to(eq("include::orig[]\n"))
         end
 
         it do
-          includeschanger.replace('[define,requirement,REFERENCE]')
-          includeschanger.replace('--')
-          expect(includeschanger.replace("include::orig[]\n"))
+          includeschanger.replace('sub/one_file.adoc', '[define,requirement,REFERENCE]')
+          includeschanger.replace('sub/one_file.adoc', '--')
+          expect(includeschanger.replace('sub/one_file.adoc', "include::orig[]\n"))
             .to(eq("include::dest[]\n"))
         end
       end
@@ -225,28 +229,28 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
         end
 
         it do
-          expect(includeschanger.replace("include::orig[]\n"))
+          expect(includeschanger.replace('sub/one_file.adoc', "include::orig[]\n"))
             .to(eq("include::orig[]\n"))
         end
 
         it do
-          includeschanger.replace('[define,whatever,REFERENCE]')
-          includeschanger.replace('--')
-          expect(includeschanger.replace("include::orig[]\n"))
+          includeschanger.replace('sub/one_file.adoc', '[define,whatever,REFERENCE]')
+          includeschanger.replace('sub/one_file.adoc', '--')
+          expect(includeschanger.replace('sub/one_file.adoc', "include::orig[]\n"))
             .to(eq("include::orig[]\n"))
         end
 
         it do
-          includeschanger.replace('[define,requirement,REFERENCE]')
-          includeschanger.replace('--')
-          expect(includeschanger.replace("include::orig[]\n"))
+          includeschanger.replace('sub/one_file.adoc', '[define,requirement,REFERENCE]')
+          includeschanger.replace('sub/one_file.adoc', '--')
+          expect(includeschanger.replace('sub/one_file.adoc', "include::orig[]\n"))
             .to(eq("include::dest[]\n"))
         end
 
         it do
-          includeschanger.replace('[define,pouet,REFERENCE]')
-          includeschanger.replace('--')
-          expect(includeschanger.replace("include::orig[]\n"))
+          includeschanger.replace('sub/one_file.adoc', '[define,pouet,REFERENCE]')
+          includeschanger.replace('sub/one_file.adoc', '--')
+          expect(includeschanger.replace('sub/one_file.adoc', "include::orig[]\n"))
             .to(eq("include::dest[]\n"))
         end
       end

data/spec/unit/defmastership/modifier/update_def_checksum_spec.rb

@@ -66,7 +66,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefChecksum) do
     end
 
     context 'when definition has not the good type' do
-      it { expect(modifier.replace_reference('[define,req,REFERENCE]')).to(eq('[define,req,REFERENCE]')) }
+      it { expect(modifier.replace_reference('', '[define,req,REFERENCE]')).to(eq('[define,req,REFERENCE]')) }
     end
 
     context 'when definition has the good type' do
@@ -77,22 +77,22 @@ RSpec.describe(Defmastership::Modifier::UpdateDefChecksum) do
       end
 
       it do
-        expect(modifier.replace_reference('[define,requirement,REFERENCE]'))
+        expect(modifier.replace_reference('', '[define,requirement,REFERENCE]'))
           .to(eq('[define,requirement,REFERENCE(~abcd1234)]'))
       end
 
       it do
-        expect(modifier.replace_reference('[define,requirement,REFERENCE(~bad)]'))
+        expect(modifier.replace_reference('', '[define,requirement,REFERENCE(~bad)]'))
           .to(eq('[define,requirement,REFERENCE(~abcd1234)]'))
       end
 
       it do
-        expect(modifier.replace_reference('[define,requirement,REFERENCE(toto~bad)]'))
+        expect(modifier.replace_reference('', '[define,requirement,REFERENCE(toto~bad)]'))
           .to(eq('[define,requirement,REFERENCE(toto~abcd1234)]'))
       end
 
       it do
-        expect(modifier.replace_reference('[define,requirement,REFERENCE(toto)]'))
+        expect(modifier.replace_reference('', '[define,requirement,REFERENCE(toto)]'))
           .to(eq('[define,requirement,REFERENCE(toto~abcd1234)]'))
       end
     end

data/spec/unit/defmastership/modifier/update_def_spec.rb

@@ -86,7 +86,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDef) do
       end
 
       it do
-        expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd)]'))
+        expect(modifier.replace_reference('', '[define,requirement,REFERENCE(abcd)]'))
           .to(eq('[define,requirement,REFERENCE_something_abcd]'))
       end
     end
@@ -103,7 +103,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDef) do
       end
 
       it do
-        expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd)]'))
+        expect(modifier.replace_reference('', '[define,requirement,REFERENCE(abcd)]'))
           .to(eq('[define,requirement,REFERENCE_something_abcd]'))
       end
     end
@@ -120,17 +120,17 @@ RSpec.describe(Defmastership::Modifier::UpdateDef) do
       end
 
       it do
-        expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd)]'))
+        expect(modifier.replace_reference('', '[define,requirement,REFERENCE(abcd)]'))
           .to(eq('[define,requirement,REFERENCE_something_abcd]'))
       end
 
       it do
-        expect(modifier.replace_reference('[define,pouet,REFERENCE(abcd)]'))
+        expect(modifier.replace_reference('', '[define,pouet,REFERENCE(abcd)]'))
           .to(eq('[define,pouet,REFERENCE_something_abcd]'))
       end
 
       it do
-        expect(modifier.replace_reference('[define,whatever,REFERENCE(abcd)]'))
+        expect(modifier.replace_reference('', '[define,whatever,REFERENCE(abcd)]'))
           .to(eq('[define,whatever,REFERENCE(abcd)]'))
       end
     end
@@ -140,13 +140,15 @@ RSpec.describe(Defmastership::Modifier::UpdateDef) do
 
       context 'when line do not match' do
         it do
-          expect(modifier.replace_reference('[define---,req,REFERENCE(abcd)]'))
+          expect(modifier.replace_reference('', '[define---,req,REFERENCE(abcd)]'))
             .to(eq('[define---,req,REFERENCE(abcd)]'))
         end
       end
 
       context 'when definition has not the good type' do
-        it { expect(modifier.replace_reference('[define,req,REFERENCE(abcd)]')).to(eq('[define,req,REFERENCE(abcd)]')) }
+        it do
+          expect(modifier.replace_reference('', '[define,req,REFERENCE(abcd)]')).to(eq('[define,req,REFERENCE(abcd)]'))
+        end
       end
 
       context 'when definition has the good type' do
@@ -157,17 +159,17 @@ RSpec.describe(Defmastership::Modifier::UpdateDef) do
         end
 
         it do
-          expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd)]'))
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE(abcd)]'))
             .to(eq('[define,requirement,REFERENCE_something_abcd]'))
         end
 
         it do
-          expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd~bad)]'))
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE(abcd~bad)]'))
             .to(eq('[define,requirement,REFERENCE_something_abcd]'))
         end
 
         it do
-          expect(modifier.replace_reference('// [define,requirement,REFERENCE(abcd~bad)]'))
+          expect(modifier.replace_reference('', '// [define,requirement,REFERENCE(abcd~bad)]'))
             .to(eq('// [define,requirement,REFERENCE(abcd~bad)]'))
         end
       end

data/spec/unit/defmastership/modifier/update_def_version_spec.rb

@@ -250,7 +250,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
     end
 
     context 'when definition has not the good type' do
-      it { expect(modifier.replace_reference('[define,req,REFERENCE]')).to(eq('[define,req,REFERENCE]')) }
+      it { expect(modifier.replace_reference('', '[define,req,REFERENCE]')).to(eq('[define,req,REFERENCE]')) }
     end
 
     context 'when definition has the good type' do
@@ -267,18 +267,20 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
 
         it do
           allow(ref_definition).to(receive(:explicit_version).and_return(nil))
-          expect(modifier.replace_reference('[define,requirement,REFERENCE]')).to(eq('[define,requirement,REFERENCE]'))
+          expect(
+            modifier.replace_reference('', '[define,requirement,REFERENCE]')
+          ).to(eq('[define,requirement,REFERENCE]'))
         end
 
         it do
           allow(ref_definition).to(receive(:explicit_version).and_return('c'))
-          expect(modifier.replace_reference('[define,requirement,REFERENCE]'))
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE]'))
             .to(eq('[define,requirement,REFERENCE(c)]'))
         end
 
         it do
           allow(ref_definition).to(receive(:explicit_version).and_return('c'))
-          expect(modifier.replace_reference('[define,requirement,REFERENCE(tyty~1234)]'))
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE(tyty~1234)]'))
             .to(eq('[define,requirement,REFERENCE(c~1234)]'))
         end
       end
@@ -299,7 +301,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
         ].each do |ref, from, to|
           it do
             allow(ref_definition).to(receive(:explicit_version).and_return(ref))
-            expect(modifier.replace_reference("[define,requirement,REFERENCE#{from}]"))
+            expect(modifier.replace_reference('', "[define,requirement,REFERENCE#{from}]"))
               .to(eq("[define,requirement,REFERENCE#{to}]"))
           end
         end
@@ -311,12 +313,12 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
         end
 
         it do
-          expect(modifier.replace_reference('[define,requirement,REFERENCE(whatever)]'))
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE(whatever)]'))
             .to(eq('[define,requirement,REFERENCE]'))
         end
 
         it do
-          expect(modifier.replace_reference('[define,requirement,REFERENCE(~1234)]'))
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE(~1234)]'))
             .to(eq('[define,requirement,REFERENCE(~1234)]'))
         end
       end

data/spec/unit/defmastership/modifier/update_eref_checksum_spec.rb

@@ -100,18 +100,20 @@ RSpec.describe(Defmastership::Modifier::UpdateErefChecksum) do
         ['(a~abcd1234)', '(a~a1b2c3d4)']
       ].each do |from, to|
         it do
-          modifier.replace_erefs("defs:eref[type, [THE_REF#{from}]]")
+          modifier.replace_erefs('', "defs:eref[type, [THE_REF#{from}]]")
           expect(ref_document).to(have_received(:ref_to_def).with('THE_REF'))
         end
 
         it do
-          modifier.replace_erefs("defs:eref[type, [THE_REF#{from}]]")
+          modifier.replace_erefs('', "defs:eref[type, [THE_REF#{from}]]")
           expect(ref_definition).to(have_received(:sha256_short))
         end
 
-        it {
-          expect(modifier.replace_erefs("defs:eref[type, [THE_REF#{from}]]")).to(eq("defs:eref[type, [THE_REF#{to}]]"))
-        }
+        it do
+          expect(
+            modifier.replace_erefs('', "defs:eref[type, [THE_REF#{from}]]")
+          ).to(eq("defs:eref[type, [THE_REF#{to}]]"))
+        end
       end
     end
 
@@ -121,21 +123,21 @@ RSpec.describe(Defmastership::Modifier::UpdateErefChecksum) do
       end
 
       it do
-        modifier.replace_erefs('defs:eref[type, [BAD_REF(a~abcd1234)]]')
+        modifier.replace_erefs('', 'defs:eref[type, [BAD_REF(a~abcd1234)]]')
         expect(ref_document).to(have_received(:ref_to_def).with('BAD_REF'))
       end
 
       it do
-        expect(modifier.replace_erefs('defs:eref[type, [BAD_REF(a~abcd1234)]]'))
+        expect(modifier.replace_erefs('', 'defs:eref[type, [BAD_REF(a~abcd1234)]]'))
           .to(eq('defs:eref[type, [BAD_REF(a~abcd1234)]]'))
       end
 
-      it { expect(modifier.replace_erefs('defs:eref[type, [BAD_REF]]')).to(eq('defs:eref[type, [BAD_REF]]')) }
-      it { expect(modifier.replace_erefs('defs:eref[type, [BAD_REF(a)]]')).to(eq('defs:eref[type, [BAD_REF(a)]]')) }
+      it { expect(modifier.replace_erefs('', 'defs:eref[type, [BAD_REF]]')).to(eq('defs:eref[type, [BAD_REF]]')) }
+      it { expect(modifier.replace_erefs('', 'defs:eref[type, [BAD_REF(a)]]')).to(eq('defs:eref[type, [BAD_REF(a)]]')) }
     end
 
     context 'when the line is not a valid eref' do
-      it { expect(modifier.replace_erefs('bla bla')).to(eq('bla bla')) }
+      it { expect(modifier.replace_erefs('', 'bla bla')).to(eq('bla bla')) }
     end
 
     context 'when the line is matching one external ref definition with more refs' do
@@ -146,7 +148,7 @@ RSpec.describe(Defmastership::Modifier::UpdateErefChecksum) do
         allow(ref_document).to(receive(:ref_to_def).with('REF2').and_return(other_ref_definition))
         allow(ref_definition).to(receive(:sha256_short).and_return('~a1b2c3d4'))
         allow(other_ref_definition).to(receive(:sha256_short).and_return('~e5f6abcd'))
-        modifier.replace_erefs('defs:eref[type, [REF1, REF2]]')
+        modifier.replace_erefs('', 'defs:eref[type, [REF1, REF2]]')
       end
 
       it { expect(ref_document).to(have_received(:ref_to_def).with('REF1')) }
@@ -155,7 +157,7 @@ RSpec.describe(Defmastership::Modifier::UpdateErefChecksum) do
       it { expect(other_ref_definition).to(have_received(:sha256_short)) }
 
       it do
-        expect(modifier.replace_erefs('defs:eref[type, [REF1, REF2]]'))
+        expect(modifier.replace_erefs('', 'defs:eref[type, [REF1, REF2]]'))
           .to(eq('defs:eref[type, [REF1(~a1b2c3d4), REF2(~e5f6abcd)]]'))
       end
     end
@@ -172,10 +174,12 @@ RSpec.describe(Defmastership::Modifier::UpdateErefChecksum) do
       end
 
       it do
-        expect(modifier.replace_erefs('defs:eref[implements, [REF]]')).to(eq('defs:eref[implements, [REF(~a1b2c3d4)]]'))
+        expect(
+          modifier.replace_erefs('', 'defs:eref[implements, [REF]]')
+        ).to(eq('defs:eref[implements, [REF(~a1b2c3d4)]]'))
       end
 
-      it { expect(modifier.replace_erefs('defs:eref[covers, [REF]]')).to(eq('defs:eref[covers, [REF]]')) }
+      it { expect(modifier.replace_erefs('', 'defs:eref[covers, [REF]]')).to(eq('defs:eref[covers, [REF]]')) }
     end
 
     context 'when the modifier modifies more than one eref_type' do
@@ -190,11 +194,16 @@ RSpec.describe(Defmastership::Modifier::UpdateErefChecksum) do
       end
 
       it do
-        expect(modifier.replace_erefs('defs:eref[implements, [REF]]')).to(eq('defs:eref[implements, [REF(~a1b2c3d4)]]'))
+        expect(
+          modifier.replace_erefs('', 'defs:eref[implements, [REF]]')
+        ).to(eq('defs:eref[implements, [REF(~a1b2c3d4)]]'))
+      end
+
+      it do
+        expect(modifier.replace_erefs('', 'defs:eref[covers, [REF]]')).to(eq('defs:eref[covers, [REF(~a1b2c3d4)]]'))
       end
 
-      it { expect(modifier.replace_erefs('defs:eref[covers, [REF]]')).to(eq('defs:eref[covers, [REF(~a1b2c3d4)]]')) }
-      it { expect(modifier.replace_erefs('defs:eref[covers_not, [REF]]')).to(eq('defs:eref[covers_not, [REF]]')) }
+      it { expect(modifier.replace_erefs('', 'defs:eref[covers_not, [REF]]')).to(eq('defs:eref[covers_not, [REF]]')) }
     end
   end
 end