defmastership 1.2.0 → 1.3.1

data/spec/unit/defmastership/app_spec.rb

@@ -0,0 +1,235 @@
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/app')
+
+RSpec.describe(Defmastership::App) do
+  it { expect(described_class.singleton_class).to(include(GLI::App)) }
+
+  describe('.run') do
+    context('when "help" command') do
+      it { expect(described_class.run(['help'])).to(be(0)) }
+
+      it do
+        expect { described_class.run(['help']) }
+          .to(output(/Tool to handle Asciidoctor definition extension/).to_stdout_from_any_process)
+      end
+    end
+
+    context('when "--version" option') do
+      it {
+        expect { described_class.run(['--version']) }
+          .to(output(/version/).to_stdout)
+      }
+    end
+
+    context('when "export --help" subcommand') do
+      it { expect(described_class.run(['export', '--help'])).to(be(0)) }
+
+      [
+        /Export\s+the\s+definition\s+database\s+in\s+CSV$/,
+        /\bexport\b.*\basciidoctor_file\b$/,
+        /--separator, --sep, -s arg.*CSV\s+separator\s+\(default: ,\)$/,
+        /--\[no-\]no-fail.*Exit\s+success\s+even\s+in\s+
+           case\s+of\s+wrong\s+explicit\s+checksum$/mx
+      ].each do |content|
+        it do
+          expect { described_class.run(['export', '--help']) }
+            .to(output(content).to_stdout_from_any_process)
+        end
+      end
+    end
+
+    context('when "export" with more than one argument') do
+      it { expect(described_class.run(%w[export arg1 arg2])).to(be(64)) }
+
+      it do
+        expect { described_class.run(%w[export arg1 arg2]) }
+          .to(output(/error: export expected only 1 arguments, but received 2/).to_stderr_from_any_process)
+      end
+
+      it { expect(described_class.run(['export'])).to(be(64)) }
+
+      it do
+        expect { described_class.run(['export']) }
+          .to(output(/error: export expected at least 1 arguments, but was given only 0/).to_stderr_from_any_process)
+      end
+    end
+
+    context('when "export toto.adoc" subcommand') do
+      let(:document)  { instance_double(Defmastership::Document, 'document')                     }
+      let(:formatter) { instance_double(Defmastership::Export::CSV::Formatter, 'formatter')      }
+      let(:defs) do
+        [
+          instance_double(Defmastership::Definition, 'def1'),
+          instance_double(Defmastership::Definition, 'def2')
+        ]
+      end
+
+      before do
+        allow(Defmastership::Document).to(receive(:new).and_return(document))
+        allow(Defmastership::Export::CSV::Formatter).to(receive(:new).and_return(formatter))
+        allow(formatter).to(receive(:export_to).with(an_instance_of(String)))
+        allow(document).to(receive(:parse_file_with_preprocessor).with(an_instance_of(String)))
+        allow(document).to(receive(:definitions).and_return(defs))
+        allow(defs.first).to(receive(:wrong_explicit_checksum).and_return(nil))
+        allow(defs.last).to(
+          receive_messages(
+            wrong_explicit_checksum: true,
+            reference: 'the_ref',
+            sha256_short: '1234'
+          )
+        )
+
+        described_class.run(['export', 'toto.adoc'])
+      end
+
+      context 'when there is wrong_explicit_checksum' do
+        before do
+          allow(document).to(receive(:wrong_explicit_checksum?).and_return(true))
+        end
+
+        it { expect(Defmastership::Document).to(have_received(:new).with(no_args)) }
+        it { expect(document).to(have_received(:parse_file_with_preprocessor).once.with('toto.adoc')) }
+        it { expect(Defmastership::Export::CSV::Formatter).to(have_received(:new).with(document, ',')) }
+        it { expect(formatter).to(have_received(:export_to).once.with('toto.csv')) }
+        it { expect(document).to(have_received(:wrong_explicit_checksum?)) }
+
+        # the commented test does not work whereas the following one needs the call to :definitions
+        # it { expect(document).to(have_received(:definitions).with(no_args)) }
+        it do
+          expect { described_class.run(['export', 'toto.adoc']) }
+            .to(output(/warning: the_ref has a wrong explicit checksum \(should be 1234\)/).to_stderr_from_any_process)
+        end
+
+        it { expect(described_class.run(['export', 'toto.adoc'])).to(be(1)) }
+        it { expect(described_class.run(['export', '--no-fail', 'toto.adoc'])).to(be(0)) }
+      end
+
+      context 'when there is NO wrong_explicit_checksum' do
+        before do
+          allow(document).to(receive(:wrong_explicit_checksum?).and_return(nil))
+        end
+
+        it { expect(described_class.run(['export', 'toto.adoc'])).to(be(0)) }
+      end
+    end
+
+    context('when "modify --help" subcommand') do
+      it { expect(described_class.run(['modify', '--help'])).to(be(0)) }
+
+      [
+        /Apply\s+one\s+or\s+more\s+modifications$/,
+        /\bmodify\b.*\basciidoctor_file\b\s+\[asciidoctor_file\]\.\.\.$/,
+        /--modifications,\s+--mod,\s+-m\s+arg\s+-\s+comma\s+separated\s+
+           list\s+of\s+modifications\s+to\s+apply\s+\(default:\s+all\)$/mx,
+        /--modifications-file,\s+--mf=arg\s+-\s+modifications\s+description\s+
+           file\s+\(default:\s+modifications.yml\)$/mx,
+        /--changes-summary,\s+-s\s+arg\s+-\s+generates\s+a\s+change\s+summary\s+
+           in\s+a\s+CSV\s+file\s+\(default:\s+none\)$/mx
+      ].each do |content|
+        it do
+          expect { described_class.run(['modify', '--help']) }
+            .to(output(content).to_stdout_from_any_process)
+        end
+      end
+    end
+
+    context('when "modify" with more than one argument') do
+      it do
+        expect { described_class.run(['modify']) }
+          .to(output(/error: modify expected at least 1 arguments, but was given only 0/).to_stderr_from_any_process)
+      end
+    end
+
+    context('when "modify -m=,mod1 toto.adoc tutu.adoc" subcommand') do
+      it {
+        expect(described_class.run(['modify', '--modifications="modif11!modif2"', 'toto.adoc', 'tutu.adoc'])).to(be(64))
+      }
+
+      it { expect(described_class.run(['modify', '-m=,modif1', 'toto.adoc', 'tutu.adoc'])).to(be(64)) }
+    end
+
+    context('when "modify --modifications=mod1,mod2 toto.adoc" subcommand') do
+      let(:config_preserver) { instance_double(Defmastership::ConfigPreserver, 'config_preserver') }
+      let(:changer) { instance_double(Defmastership::BatchModifier, 'changer') }
+      let(:csv)     { instance_double(CSV, 'csv')                              }
+
+      before do
+        allow(Defmastership::ConfigPreserver).to(receive(:new).and_return(config_preserver))
+        allow(config_preserver).to(receive(:config).and_return(:one_config))
+        allow(Defmastership::BatchModifier).to(receive(:new).and_return(changer))
+        allow(File).to(receive(:read).with('toto.adoc').and_return('content toto_adoc'))
+        allow(File).to(receive(:read).with('tutu.adoc').and_return('content tutu_adoc'))
+        allow(changer).to(receive(:apply))
+        allow(File).to(receive(:write).with('toto.adoc', 'new content toto_adoc'))
+        allow(File).to(receive(:write).with('tutu.adoc', 'new content tutu_adoc'))
+        allow(config_preserver).to(receive(:save))
+        allow(changer).to(
+          receive_messages(
+            adoc_sources: { 'toto.adoc' => 'new content toto_adoc', 'tutu.adoc' => 'new content tutu_adoc' },
+            config: :the_new_config,
+            changes: []
+          )
+        )
+        described_class.run(['modify', '--modifications=mod1,mod2', 'toto.adoc', 'tutu.adoc'])
+      end
+
+      it { expect(described_class.run(['modify', '--modifications=mod1,mod2', 'toto.adoc', 'tutu.adoc'])).to(be(0)) }
+
+      it { expect(Defmastership::ConfigPreserver).to(have_received(:new).with('modifications.yml')) }
+      it { expect(config_preserver).to(have_received(:config)) }
+
+      it do
+        expect(Defmastership::BatchModifier)
+          .to(have_received(:new)
+                .with(:one_config,
+                      { 'toto.adoc' => 'content toto_adoc', 'tutu.adoc' => 'content tutu_adoc' }))
+      end
+
+      it { expect(changer).to(have_received(:apply).with(%i[mod1 mod2])) }
+      it { expect(changer).to(have_received(:adoc_sources)) }
+      it { expect(File).to(have_received(:write).with('toto.adoc', 'new content toto_adoc')) }
+      it { expect(File).to(have_received(:write).with('tutu.adoc', 'new content tutu_adoc')) }
+      it { expect(changer).to(have_received(:config)) }
+      it { expect(config_preserver).to(have_received(:save).with(:the_new_config)) }
+    end
+
+    context('when "modify" subcommand with changes summary') do
+      let(:config_preserver) { instance_double(Defmastership::ConfigPreserver, 'config_preserver') }
+      let(:changer) { instance_double(Defmastership::BatchModifier, 'changer') }
+      let(:csv)     { instance_double(CSV, 'csv')                              }
+
+      before do
+        allow(Defmastership::ConfigPreserver).to(receive(:new).and_return(config_preserver))
+        allow(config_preserver).to(receive(:config).and_return(:one_config))
+        allow(Defmastership::BatchModifier).to(receive(:new).and_return(changer))
+        allow(File).to(receive(:read).with('toto.adoc').and_return('content toto_adoc'))
+        allow(changer).to(receive(:apply))
+        allow(File).to(receive(:write).with('toto.adoc', 'new content toto_adoc'))
+        allow(config_preserver).to(receive(:save))
+        allow(changer).to(
+          receive_messages(
+            adoc_sources: { 'toto.adoc' => 'new content toto_adoc' },
+            config: :the_new_config,
+            changes: []
+          )
+        )
+        allow(CSV).to(receive(:open).and_yield(csv))
+        allow(csv).to(receive(:<<))
+        allow(changer).to(receive(:changes).and_return(%w[row1 row2]))
+        described_class.run(['modify', '--modifications=mod1', '--changes-summary=changes.csv', 'toto.adoc'])
+      end
+
+      it do
+        params = ['modify', '--modifications=mod1', '--changes-summary=changes.csv', 'toto.adoc']
+        expect(described_class.run(params)).to(be(0))
+      end
+
+      it { expect(CSV).to(have_received(:open).with('changes.csv', 'wb')) }
+      it { expect(csv).to(have_received(:<<).with(%w[Modifier Was Becomes])) }
+      it { expect(csv).to(have_received(:<<).with('row1')) }
+      it { expect(csv).to(have_received(:<<).with('row2')) }
+    end
+  end
+end

data/spec/unit/defmastership/config_preserver_spec.rb

@@ -0,0 +1,127 @@
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/config_preserver')
+
+RSpec.describe(Defmastership::ConfigPreserver) do
+  subject(:preserver) do
+    described_class.new('configuration.yml')
+  end
+
+  describe '.new' do
+    it { is_expected.not_to(be_nil) }
+  end
+
+  describe '.config' do
+    let(:original_config) do
+      {
+        simple_item: 12,
+        nested_item: { subitem: 123 }
+      }
+    end
+
+    before do
+      allow(YAML).to(receive(:load_file).with('configuration.yml').and_return(original_config))
+    end
+
+    it do
+      preserver.config
+      expect(YAML).to(have_received(:load_file).with('configuration.yml'))
+    end
+
+    it { expect(preserver.config).to(eq(original_config)) }
+    it { expect(preserver.config).not_to(be(original_config)) }
+    it { expect(preserver.config[:nested_item]).not_to(be(original_config[:nested_item])) }
+  end
+
+  describe '.save' do
+    context 'when one Modifier has modified config items' do
+      let(:original_config) do
+        {
+          simple_item: 12,
+          nested_item: { subitem: 123 }
+        }
+      end
+      let(:original_file_content) do
+        <<~YAML_CONFIG
+          ---
+          :simple_item: 12
+          :nested_item:
+            :subitem: 123
+        YAML_CONFIG
+      end
+      let(:file) { instance_double(File, 'file') }
+      let(:new_file_content) do
+        <<~YAML_CONFIG
+          ---
+          :simple_item: pouet
+          :nested_item:
+            :subitem: 132
+        YAML_CONFIG
+      end
+
+      before do
+        allow(YAML).to(receive(:load_file).with('configuration.yml').and_return(original_config))
+        allow(File).to(receive(:open).with('configuration.yml', 'r').and_return(file))
+        allow(file).to(receive(:each_line).with(chomp: true).and_return(original_file_content.each_line(chomp: true)))
+        allow(File).to(receive(:write))
+      end
+
+      it do
+        preserver.save({ simple_item: 'pouet', nested_item: { subitem: 132 } })
+        expect(File).to(have_received(:write).with('configuration.yml', new_file_content))
+      end
+
+      it do
+        preserver.save({ simple_item: 'pouet', new_item: 'titi', nested_item: { subitem: 132, new_subitem: 345 } })
+        expect(File).to(have_received(:write).with('configuration.yml', new_file_content))
+      end
+    end
+
+    context 'when there are some empty lines and comments' do
+      let(:original_config) do
+        {
+          simple_item: 12,
+          nested_item: { subitem: 123, subitem2: 'abcd' }
+        }
+      end
+      let(:original_file_content) do
+        <<~YAML_CONFIG
+          ---
+          :simple_item: 12 #
+
+          :nested_item:
+            # comment on its own line
+            #
+            :subitem: 123     # comment on a useful line
+            :subitem2: abcd# comment on a useful line
+        YAML_CONFIG
+      end
+      let(:file) { instance_double(File, 'file') }
+      let(:new_file_content) do
+        <<~YAML_CONFIG
+          ---
+          :simple_item: pouet #
+
+          :nested_item:
+            # comment on its own line
+            #
+            :subitem: 132     # comment on a useful line
+            :subitem2: abcd# comment on a useful line
+        YAML_CONFIG
+      end
+
+      before do
+        allow(YAML).to(receive(:load_file).with('configuration.yml').and_return(original_config))
+        allow(File).to(receive(:open).with('configuration.yml', 'r').and_return(file))
+        allow(file).to(receive(:each_line).with(chomp: true).and_return(original_file_content.each_line(chomp: true)))
+        allow(File).to(receive(:write))
+      end
+
+      it do
+        preserver.save({ simple_item: 'pouet', nested_item: { subitem: 132 } })
+        expect(File).to(have_received(:write).with('configuration.yml', new_file_content))
+      end
+    end
+  end
+end

data/spec/unit/defmastership/document_spec.rb

@@ -492,6 +492,23 @@ RSpec.describe(Defmastership::Document) do
           )
         end
       end
+
+      context 'when comma in definition summary' do
+        let(:input_lines) do
+          [
+            ':one_variable: the substituted variable',
+            '[define, requirement, TOTO-0001, " a summary with a, comma "]'
+          ]
+        end
+
+        it do
+          expect(Defmastership::Definition).to(
+            have_received(:new).with(
+              matchdata_including(summary: 'a summary with a, comma')
+            )
+          )
+        end
+      end
     end
 
     context 'with invalid definitions' do

data/spec/unit/defmastership/export/csv/formatter_spec.rb

@@ -1,9 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('csv')
 require('defmastership/export/csv/formatter')
-require('ostruct')
 
 RSpec.describe(Defmastership::Export::CSV::Formatter) do
   subject(:formatter) { described_class.new(document, ';') }

data/spec/unit/defmastership/hash_spec.rb

@@ -0,0 +1,27 @@
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+RSpec.describe(Hash) do
+  describe '.merge_no_new' do
+    context 'when we don\'t want to modiy original Hash' do
+      subject(:hash) { { key1: :toto } }
+
+      let(:other) { { key1: :titi } }
+
+      it { expect(hash.merge_no_new(hash)).not_to(equal(hash)) }
+      it { expect(hash.merge_no_new(other)).not_to(equal(other)) }
+    end
+
+    [
+      [{ key1: :foo }, { key1: :bar }, { key1: :bar }],
+      [{ key1: :foo }, {}, { key1: :foo }],
+      [{ key1: { key1key1: :foo } }, {}, { key1: { key1key1: :foo } }],
+      [{ key1: :foo }, { key2: :bar }, { key1: :foo }],
+      [{ key1: :foo1, key2: :foo2 }, { key1: :bar1, key2: :foo2 }, { key1: :bar1, key2: :foo2 }],
+      [{ key1: { key1key1: :foo } }, { key1: { key1key1: :bar } }, { key1: { key1key1: :bar } }],
+      [{ key1: { key1key1: :foo } }, { key1: { key1key2: :bar } }, { key1: { key1key1: :foo } }]
+    ].each do |original, modified, updated|
+      it { expect(original.merge_no_new(modified)).to(eq(updated)) }
+    end
+  end
+end

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

@@ -15,7 +15,10 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
   end
 
   describe '.replacement_methods' do
-    it { expect(described_class.replacement_methods).to(eq(%i[replace_refdef replace_irefs])) }
+    it do
+      expect(described_class.replacement_methods)
+        .to(eq(%i[replace_refdef replace_irefs replace_include_tags replace_tags_in_included_files]))
+    end
   end
 
   describe '#config' do
@@ -193,4 +196,116 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
       ).to(eq('defs:iref[TOTO-0132] defs:iref[TOTO-0132] bla'))
     end
   end
+
+  describe '#replace_include_tags' do
+    subject(:refchanger) do
+      described_class.new(
+        from_regexp: '(?<cg>TOTO|TITI)-TEMP[\d]*',
+        to_template: '%<cg>s-%<next_ref>04d',
+        next_ref: 132
+      )
+    end
+
+    before do
+      refchanger.replace_refdef('[define, whatever, TOTO-TEMP123]')
+      refchanger.replace_refdef('[define, whatever, TITI-TEMP421]')
+    end
+
+    it do
+      expect(refchanger.replace_irefs('include::target[tags=TOTO-TEMP1234]'))
+        .to(eq('include::target[tags=TOTO-TEMP1234]'))
+    end
+
+    [
+      ['tags=TOTO-TEMP123', 'tags=TOTO-0132'],
+      ['tag=TITI-TEMP421', 'tag=TITI-0133'],
+      ['tag=!TOTO-TEMP123', 'tag=!TOTO-0132'],
+      ['lines = "1..7,9", tag=TOTO-TEMP123, leveloffset=1', 'lines = "1..7,9", tag=TOTO-0132, leveloffset=1'],
+      ['lines=1..7;9, tag=TOTO-TEMP123', 'lines=1..7;9, tag=TOTO-0132'],
+      ['tag=!TITI-TEMP421;TOTO-TEMP123', 'tag=!TITI-0133;TOTO-0132']
+    ].each do |from, to|
+      it do
+        expect(refchanger.replace_include_tags("include::path/target[#{from}]"))
+          .to(eq("include::path/target[#{to}]"))
+      end
+    end
+
+    [
+      'include::target[tag=TITI-TEMP42112]',
+      'inc::target[tag=TITI-TEMP421]',
+      'include:target[tag=TITI-TEMP421]',
+      '# include::target[tag=TITI-TEMP421]'
+    ].each do |unchanged|
+      it { expect(refchanger.replace_include_tags(unchanged)).to(eq(unchanged)) }
+    end
+  end
+
+  describe '#replace_tags_in_included_files' do
+    subject(:refchanger) do
+      described_class.new(
+        from_regexp: '(?<cg>TOTO|TITI)-TEMP[\d]*',
+        to_template: '%<cg>s-%<next_ref>04d',
+        next_ref: 132
+      )
+    end
+
+    let(:original_included_file) do
+      <<OIF
+      # tag::TOTO-TEMP123[]
+      # end::TOTO-TEMP123[]
+      /* tag::TOTO-TEMP123[] */
+      <!-- tag::TOTO-TEMP123[] -->
+      ; end::TOTO-TEMP123[]
+      # wrong tags
+      ; tags::TOTO-TEMP123[]
+      ; end::TOTO-TEMP123
+      ; ends::TOTO-TEMP123[]
+      ; tag:TOTO-TEMP123[]
+      ; end:TOTO-TEMP123[]
+OIF
+    end
+
+    let(:mofified_included_file) do
+      <<MIF
+      # tag::TOTO-0132[]
+      # end::TOTO-0132[]
+      /* tag::TOTO-0132[] */
+      <!-- tag::TOTO-0132[] -->
+      ; end::TOTO-0132[]
+      # wrong tags
+      ; tags::TOTO-TEMP123[]
+      ; end::TOTO-TEMP123
+      ; ends::TOTO-TEMP123[]
+      ; tag:TOTO-TEMP123[]
+      ; end:TOTO-TEMP123[]
+MIF
+    end
+
+    before do
+      refchanger.replace_refdef('[define, whatever, TOTO-TEMP123]')
+      refchanger.replace_refdef('[define, whatever, TITI-TEMP421]')
+
+      allow(File).to(receive(:readlines)).with('target').and_return(['# tag::TOTO-TEMP123'])
+      allow(File).to(receive(:readlines)).with('path/target').and_return(original_included_file.split)
+
+      allow(File).to(receive(:writelines))
+
+      refchanger.replace_tags_in_included_files('include::path/target[]')
+      refchanger.replace_tags_in_included_files('includ::otherpath/othertarget[]')
+    end
+
+    it { expect(File).to(have_received(:readlines).with('path/target')) }
+
+    it do
+      expect(File).to(
+        have_received(:writelines).with('path/target', mofified_included_file.split)
+      )
+    end
+
+    it { expect(File).not_to(have_received(:readlines).with('otherpath/othertarget')) }
+
+    it { expect(refchanger.replace_tags_in_included_files('include::target[]')).to(eq('include::target[]')) }
+
+    it { expect(refchanger.replace_tags_in_included_files('include::path/target[]')).to(eq('include::path/target[]')) }
+  end
 end

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

@@ -1,8 +1,6 @@
 # Copyright (c) 2023 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership/modifier/modifier_common')
-
 # just a class for test
 class DummyClassParent
   # This method smells of :reek:ControlParameter

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

@@ -1,8 +1,6 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership/modifier/update_def')
-
 module Defmastership
   module Modifier
     # Just a class for tests

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

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require('defmastership/modifier/update_def_version')
-require('git')
 
 RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
   subject(:modifier) { described_class.new({}) }
@@ -69,6 +68,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
         described_class.new(
           ref_document: ['ref_doc1.adoc', 'ref_doc2.adoc'],
           def_type: 'req',
+          ref_tag: +'',
           first_version: 'a'
         )
       end
@@ -281,13 +281,13 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
     context 'when definition has the good type' do
       before do
         allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
-        allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+        allow(definition).to(receive(:sha256_short).and_return(+'~abcd1234'))
       end
 
       context 'when definition has NOT changed' do
         before do
           allow(ref_document).to(receive(:ref_to_def).with('REFERENCE').and_return(ref_definition))
-          allow(ref_definition).to(receive(:sha256_short).and_return('~abcd1234'))
+          allow(ref_definition).to(receive(:sha256_short).and_return(+'~abcd1234'))
         end
 
         it do
@@ -312,7 +312,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
       context 'when definition has changed' do
         before do
           allow(ref_document).to(receive(:ref_to_def).with('REFERENCE').and_return(ref_definition))
-          allow(ref_definition).to(receive(:sha256_short).and_return('~4321aaaa'))
+          allow(ref_definition).to(receive(:sha256_short).and_return(+'~4321aaaa'))
         end
 
         [