defmastership 1.3.2 → 1.3.4

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

@@ -24,12 +24,7 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
 
   describe '#replace' do
     context 'when NOT valid include' do
-      subject(:includeschanger) do
-        described_class.new(
-          from_regexp: 'orig',
-          to_template: 'dest'
-        )
-      end
+      subject(:includeschanger) { described_class.new(from_regexp: 'orig', to_template: 'dest') }
 
       before do
         allow(File).to(receive(:rename))
@@ -38,17 +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 do
-          expect(includeschanger.replace('badinclude::orig[]'))
-            .to(eq('badinclude::orig[]'))
-        end
+        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
@@ -56,51 +48,38 @@ 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 do
-          expect(includeschanger.replace('include::orig[]'))
-            .to(eq('include::orig[]'))
-        end
+        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 do
-          expect(includeschanger.replace('// include::orig[]'))
-            .to(eq('// include::orig[]'))
-        end
+        it { expect(includeschanger.replace('', '// include::orig[]')).to(eq('// include::orig[]')) }
       end
 
       context 'when the cancel regexp is met' do
         subject(:includeschanger) do
-          described_class.new(
-            from_regexp: 'orig',
-            cancel_if_match: 'orig',
-            to_template: 'dest'
-          )
+          described_class.new(from_regexp: 'orig', cancel_if_match: 'orig', to_template: 'dest')
         end
 
         before do
-          includeschanger.replace('[define,requirement,REFERENCE]')
-          includeschanger.replace('--')
+          includeschanger.replace('', '[define,requirement,REFERENCE]')
+          includeschanger.replace('', '--')
         end
 
-        it do
-          expect(includeschanger.replace("include::orig[]\n"))
-            .to(eq("include::orig[]\n"))
-        end
+        it { expect(includeschanger.replace('', "include::orig[]\n")).to(eq("include::orig[]\n")) }
       end
     end
 
@@ -111,127 +90,168 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
 
       context 'when really simple rule' do
         subject(:includeschanger) do
-          described_class.new(
-            from_regexp: 'orig',
-            cancel_if_match: '_no_cancel_',
-            to_template: 'dest'
-          )
+          described_class.new(from_regexp: 'orig', cancel_if_match: '_no_cancel_', to_template: 'dest')
         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
 
       context 'when complex from_regexp' do
         subject(:includeschanger) do
-          described_class.new(
-            from_regexp: '(?<origin>.*\.extension)',
-            to_template: '%<reference>s_%<origin>s'
-          )
+          described_class.new(from_regexp: '(?<origin>.*\.extension)', to_template: '%<reference>s_%<origin>s')
         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
 
       context 'when path with variable' do
-        subject(:includeschanger) do
-          described_class.new(
-            from_regexp: 'orig',
-            to_template: 'dest'
-          )
-        end
+        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 do
-          expect(includeschanger.replace('include::{any}/orig[]'))
-            .to(eq('include::{any}/dest[]'))
+          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
+
+      context 'when definition\'s type does not fit a value' do
+        subject(:includeschanger) do
+          described_class.new(def_type: 'requirement', from_regexp: 'orig', to_template: 'dest')
+        end
+
+        it do
+          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('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
+
+      context 'when definition\'s type is not included in a list' do
+        subject(:includeschanger) do
+          described_class.new(def_type: %w[requirement pouet], from_regexp: 'orig', to_template: 'dest')
+        end
+
+        it do
+          expect(includeschanger.replace('sub/one_file.adoc', "include::orig[]\n"))
+            .to(eq("include::orig[]\n"))
+        end
+
+        it do
+          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('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('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
     end

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

@@ -55,11 +55,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefChecksum) do
   end
 
   describe '#replace' do
-    subject(:modifier) do
-      described_class.new(
-        def_type: 'requirement'
-      )
-    end
+    subject(:modifier) { described_class.new(def_type: 'requirement') }
 
     let(:definition)  { instance_double(Defmastership::Definition, 'definition') }
     let(:document)    { instance_double(Defmastership::Document, 'document')     }
@@ -70,10 +66,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefChecksum) do
     end
 
     context 'when definition has not the good type' do
-      it do
-        expect(modifier.replace_reference('[define,req,REFERENCE]'))
-          .to(eq('[define,req,REFERENCE]'))
-      end
+      it { expect(modifier.replace_reference('', '[define,req,REFERENCE]')).to(eq('[define,req,REFERENCE]')) }
     end
 
     context 'when definition has the good type' do
@@ -84,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

@@ -1,6 +1,8 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require('defmastership/modifier/update_def')
+
 module Defmastership
   module Modifier
     # Just a class for tests
@@ -60,19 +62,10 @@ RSpec.describe(Defmastership::Modifier::UpdateDef) do
       )
     end
 
-    it do
-      expect(modifier.do_modifications(adoc_sources).fetch('file1.adoc'))
-        .to(include('REFERENCE_something_'))
-    end
+    it { expect(modifier.do_modifications(adoc_sources).fetch('file1.adoc')).to(include('REFERENCE_something_')) }
   end
 
   describe '#replace_reference' do
-    subject(:modifier) do
-      Defmastership::Modifier::ConcreteRef.new(
-        def_type: 'requirement'
-      )
-    end
-
     let(:definition)  { instance_double(Defmastership::Definition, 'definition') }
     let(:document)    { instance_double(Defmastership::Document, 'document')     }
     let(:definitions) { { 'REFERENCE' => definition }                            }
@@ -81,21 +74,45 @@ RSpec.describe(Defmastership::Modifier::UpdateDef) do
       allow(File).to(receive(:rename))
     end
 
-    context 'when line do not match' do
+    context 'when def_type is not specified' do
+      subject(:modifier) do
+        Defmastership::Modifier::ConcreteRef.new(def_type: '')
+      end
+
+      before do
+        allow(Defmastership::Document).to(receive(:new).and_return(document))
+        allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+        allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+      end
+
       it do
-        expect(modifier.replace_reference('[define---,req,REFERENCE(abcd)]'))
-          .to(eq('[define---,req,REFERENCE(abcd)]'))
+        expect(modifier.replace_reference('', '[define,requirement,REFERENCE(abcd)]'))
+          .to(eq('[define,requirement,REFERENCE_something_abcd]'))
       end
     end
 
-    context 'when definition has not the good type' do
+    context 'when def_type is \'all\'' do
+      subject(:modifier) do
+        Defmastership::Modifier::ConcreteRef.new(def_type: 'all')
+      end
+
+      before do
+        allow(Defmastership::Document).to(receive(:new).and_return(document))
+        allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+        allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+      end
+
       it do
-        expect(modifier.replace_reference('[define,req,REFERENCE(abcd)]'))
-          .to(eq('[define,req,REFERENCE(abcd)]'))
+        expect(modifier.replace_reference('', '[define,requirement,REFERENCE(abcd)]'))
+          .to(eq('[define,requirement,REFERENCE_something_abcd]'))
       end
     end
 
-    context 'when definition has the good type' do
+    context 'when def_type is a list' do
+      subject(:modifier) do
+        Defmastership::Modifier::ConcreteRef.new(def_type: %w[requirement pouet])
+      end
+
       before do
         allow(Defmastership::Document).to(receive(:new).and_return(document))
         allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
@@ -103,18 +120,58 @@ 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)]'))
-          .to(eq('[define,requirement,REFERENCE_something_abcd]'))
+        expect(modifier.replace_reference('', '[define,pouet,REFERENCE(abcd)]'))
+          .to(eq('[define,pouet,REFERENCE_something_abcd]'))
       end
 
       it do
-        expect(modifier.replace_reference('// [define,requirement,REFERENCE(abcd~bad)]'))
-          .to(eq('// [define,requirement,REFERENCE(abcd~bad)]'))
+        expect(modifier.replace_reference('', '[define,whatever,REFERENCE(abcd)]'))
+          .to(eq('[define,whatever,REFERENCE(abcd)]'))
+      end
+    end
+
+    context 'when modifier is specific' do
+      subject(:modifier) { Defmastership::Modifier::ConcreteRef.new(def_type: 'requirement') }
+
+      context 'when line do not match' do
+        it do
+          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 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
+        before do
+          allow(Defmastership::Document).to(receive(:new).and_return(document))
+          allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+          allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+        end
+
+        it do
+          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)]'))
+            .to(eq('[define,requirement,REFERENCE_something_abcd]'))
+        end
+
+        it do
+          expect(modifier.replace_reference('', '// [define,requirement,REFERENCE(abcd~bad)]'))
+            .to(eq('// [define,requirement,REFERENCE(abcd~bad)]'))
+        end
       end
     end
   end

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

@@ -20,13 +20,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
 
   describe '#do_modifications' do
     context 'when only one ref document' do
-      subject(:modifier) do
-        described_class.new(
-          ref_document: 'ref_doc.adoc',
-          def_type: 'req',
-          first_version: 'a'
-        )
-      end
+      subject(:modifier) { described_class.new(ref_document: 'ref_doc.adoc', def_type: 'req', first_version: 'a') }
 
       let(:document)       { instance_double(Defmastership::Document, 'document')          }
       let(:ref_document)   { instance_double(Defmastership::Document, 'ref_document')      }
@@ -106,13 +100,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
     end
 
     context 'when ref_tag is provided' do
-      subject(:modifier) do
-        described_class.new(
-          ref_tag: 'THE_TAG',
-          def_type: 'req',
-          first_version: 'a'
-        )
-      end
+      subject(:modifier) { described_class.new(ref_tag: 'THE_TAG', def_type: 'req', first_version: 'a') }
 
       let(:document)       { instance_double(Defmastership::Document, 'document')          }
       let(:ref_document)   { instance_double(Defmastership::Document, 'ref_document')      }
@@ -156,12 +144,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
 
     context 'when ref_tag and ref_repo is provided' do
       subject(:modifier) do
-        described_class.new(
-          ref_tag: 'THE_TAG',
-          ref_repo: 'not dot',
-          def_type: 'req',
-          first_version: 'a'
-        )
+        described_class.new(ref_tag: 'THE_TAG', ref_repo: 'not dot', def_type: 'req', first_version: 'a')
       end
 
       let(:document)       { instance_double(Defmastership::Document, 'document')          }
@@ -254,12 +237,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
   end
 
   describe '#replace_reference' do
-    subject(:modifier) do
-      described_class.new(
-        def_type: 'requirement',
-        first_version: 'a'
-      )
-    end
+    subject(:modifier) { described_class.new(def_type: 'requirement', first_version: 'a') }
 
     let(:document)       { instance_double(Defmastership::Document, 'document')          }
     let(:ref_document)   { instance_double(Defmastership::Document, 'ref_document')      }
@@ -272,10 +250,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
     end
 
     context 'when definition has not the good type' do
-      it do
-        expect(modifier.replace_reference('[define,req,REFERENCE]'))
-          .to(eq('[define,req,REFERENCE]'))
-      end
+      it { expect(modifier.replace_reference('', '[define,req,REFERENCE]')).to(eq('[define,req,REFERENCE]')) }
     end
 
     context 'when definition has the good type' do
@@ -292,19 +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
@@ -325,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
@@ -337,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