defmastership 1.0.17 → 1.0.19

data/lib/defmastership/update_def_modifier.rb

@@ -0,0 +1,49 @@
+# Copyright (c) 2024 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # absttrac class for modififier that need o update defintion references
+  class UpdateDefModifier
+    include Modifier
+
+    attr_reader :document
+
+    def self.default_config
+      {
+        def_type: ''
+      }
+    end
+
+    def self.replacement_methods
+      %i[replace_reference]
+    end
+
+    def self.reference_regexp(reference)
+      Regexp.new("#{reference}#{DMRegexp::DEF_VERSION_AND_CHECKSUM}")
+    end
+
+    def initialize(config)
+      @document = Document.new
+
+      setup_modifier_module(config)
+    end
+
+    def do_modifications(adoc_sources)
+      adoc_sources.each_key do |adoc_file|
+        document.parse_file_with_preprocessor(adoc_file)
+      end
+
+      super
+    end
+
+    def replace_reference(line)
+      match = line.match(DMRegexp::DEFINITION)
+
+      return line unless match
+      return line unless match[:type] == def_type
+
+      reference = match[:reference]
+      line.sub(self.class.reference_regexp(reference), reference_replacement(reference, match))
+    end
+  end
+end

data/lib/defmastership/update_def_version_modifier.rb

@@ -1,25 +1,91 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require 'defmastership/constants'
+require 'defmastership/update_def_modifier'
+require 'git'
+require 'tmpdir'
+
 module DefMastership
-  # Update definition version if the definition has change since
-  # reference document
-  class UpdateDefVersionModifier < ModifierBase
-    def replacements
-      %i[replace]
+  # modify one line after another
+  class UpdateDefVersionModifier < UpdateDefModifier
+    def self.default_config
+      {
+        def_type: '',
+        ref_document: [],
+        ref_tag: '',
+        ref_repo: '.',
+        first_version: ''
+      }
+    end
+
+    def initialize(config)
+      @ref_document = Document.new
+
+      Helper.normalilize_config(config) if config.key?(:ref_document)
+
+      super
+    end
+
+    def do_modifications(adoc_sources)
+      if ref_tag == ''
+        ref_document.each { |ref_doc| @ref_document.parse_file_with_preprocessor(ref_doc) }
+      else
+        Dir.mktmpdir('defmastership') do |tmpdir|
+          parse_ref_files_from_git(adoc_sources, tmpdir)
+        end
+      end
+
+      super
+    end
+
+    private
+
+    def parse_ref_files_from_git(adoc_sources, tmpdir)
+      Git.clone(ref_repo, tmpdir, branch: ref_tag)
+      ref_sources = ref_document.empty? ? adoc_sources.keys : ref_document
+      ref_sources.each do |adoc_file|
+        @ref_document.parse_file_with_preprocessor("#{tmpdir}/#{adoc_file}")
+      end
     end
 
-    def new_line_modifier(config, adoc_texts)
-      document = Document.new
-      adoc_texts.each do |adoc_file, _|
-        document.parse_file_with_preprocessor(adoc_file)
+    def reference_replacement(reference, match)
+      "#{reference}#{version_and_checksum_str(match)}"
+    end
+
+    def version_and_checksum_str(match)
+      explicit_checksum = match[:explicit_checksum]
+      version = version_string(match)
+      return unless explicit_checksum || version
+
+      "(#{version}#{explicit_checksum})"
+    end
+
+    def version_string(match)
+      ref_definition = Helper.def_from_match(@ref_document, match)
+      definition = Helper.def_from_match(document, match)
+      return unless ref_definition
+
+      Helper.ref_version(ref_definition, definition, first_version)
+    end
+
+    # Helper functions
+    module Helper
+      def self.def_from_match(doc, match)
+        doc.ref_to_def(match[:reference])
+      end
+
+      def self.ref_version(ref_definition, definition, first_version)
+        new_ref_version = ref_definition.explicit_version
+        return new_ref_version if definition.sha256_short == ref_definition.sha256_short
+
+        new_ref_version ? new_ref_version.next : first_version
+      end
+
+      def self.normalilize_config(config)
+        ref_docs = config.fetch(:ref_document)
+        config[:ref_document] = [ref_docs] if ref_docs.instance_of?(String)
       end
-      ref_document = Document.new
-      ref_document.parse_file_with_preprocessor(config[:ref_document])
-      line_modifier = UpdateDefVersionLineModifier.from_config(config)
-      line_modifier.document = document
-      line_modifier.ref_document = ref_document
-      line_modifier
     end
   end
 end

data/lib/defmastership/version.rb

@@ -2,6 +2,6 @@
 # frozen_string_literal: true
 
 module DefMastership
-  VERSION = '1.0.17'
+  VERSION = '1.0.19'
   public_constant :VERSION
 end

data/lib/defmastership.rb

@@ -6,7 +6,6 @@ require('defmastership/version')
 # Add requires for other files you add to your project here, so
 # you just need to require this one file in your bin file
 require('defmastership/batch_modifier')
-require('defmastership/change_ref_line_modifier')
 require('defmastership/change_ref_modifier')
 require('defmastership/comment_filter')
 require('defmastership/constants')
@@ -15,12 +14,8 @@ require('defmastership/definition')
 require('defmastership/definition_parser')
 require('defmastership/document')
 require('defmastership/filters')
-require('defmastership/line_modifier_base')
-require('defmastership/modifier_base')
+require('defmastership/modifier_factory')
 require('defmastership/parsing_state')
-require('defmastership/rename_included_files_line_modifier')
 require('defmastership/rename_included_files_modifier')
-require('defmastership/update_def_checksum_line_modifier')
 require('defmastership/update_def_checksum_modifier')
-require('defmastership/update_def_version_line_modifier')
 require('defmastership/update_def_version_modifier')

data/spec/spec_helper.rb

@@ -3,7 +3,6 @@
 
 require('aasm/rspec')
 require('aruba/rspec')
-require('bundler/setup')
 
 # formatter = [SimpleCov::Formatter::HTMLFormatter]
 # SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(formatter)
@@ -18,8 +17,11 @@ SimpleCov.start do
 
   add_filter 'config'
   add_filter 'vendor'
+  add_filter 'set_join_hack'
 
   minimum_coverage 100
+
+  enable_coverage :branch
 end
 
 RSpec.configure do |config|

data/spec/unit/def_mastership/batch_modifier_spec.rb

@@ -1,29 +1,33 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/batch_modifier')
 
 module DefMastership
-  class TotoClassModifier < ModifierBase
+  # Modifier example
+  class TotoModifier
+    include Modifier
   end
 
-  class TutuClassModifier < ModifierBase
+  # Modifier example
+  class TuTuModifier
+    include Modifier
   end
 end
 
 RSpec.describe(DefMastership::BatchModifier) do
   subject(:batchmodifier) do
-    described_class.new(config, adoc_texts)
+    described_class.new(config, adoc_sources)
   end
 
   let(:config) do
     {
-      modifier1: { type: 'toto_class', config: { p: 1 } },
-      modifier2: { type: 'toto_class', config: { p: 'whatever1' } },
-      modifier3: { type: 'tutu_class', config: { p1: 'whatever2', p2: 'whatever3' } }
+      modifier1: { type: 'toto', config: { p: 1 } },
+      modifier2: { type: 'toto', config: { p: 'whatever1' } },
+      modifier3: { type: 'tu_tu', config: { p1: 'whatever2', p2: 'whatever3' } }
     }
   end
-  let(:adoc_texts) do
+  let(:adoc_sources) do
     {
       'file1.adoc' => 'some text',
       'file2.adoc' => 'another text'
@@ -35,14 +39,14 @@ RSpec.describe(DefMastership::BatchModifier) do
     it { is_expected.to(have_attributes(config: config)) }
 
     it do
-      expect(batchmodifier).to(have_attributes(adoc_texts: adoc_texts))
+      expect(batchmodifier).to(have_attributes(adoc_sources: adoc_sources))
     end
   end
 
   describe '#apply' do
     context 'with only one modification' do
-      let(:toto1) { instance_double(DefMastership::TotoClassModifier, 'toto1') }
-      let(:adoc_texts_modified) do
+      let(:toto1) { instance_double(DefMastership::TotoModifier, 'toto1') }
+      let(:adoc_sources_modified) do
         {
           'file1.adoc' => 'some text modified',
           'file2.adoc' => 'another text'
@@ -51,26 +55,26 @@ RSpec.describe(DefMastership::BatchModifier) do
 
       let(:config_modified) do
         {
-          modifier1: { type: 'toto_class', config: { p: 'modified_param' } },
-          modifier2: { type: 'toto_class', config: { p: 'whatever1' } },
-          modifier3: { type: 'tutu_class', config: { p1: 'whatever2', p2: 'whatever3' } }
+          modifier1: { type: 'toto', config: { p: 'modified_param' } },
+          modifier2: { type: 'toto', config: { p: 'whatever1' } },
+          modifier3: { type: 'tu_tu', config: { p1: 'whatever2', p2: 'whatever3' } }
         }
       end
 
       before do
-        allow(DefMastership::TotoClassModifier).to(receive(:new).once.and_return(toto1))
-        allow(toto1).to(receive(:do_modifications).once.and_return(adoc_texts_modified))
+        allow(DefMastership::TotoModifier).to(receive(:new).once.and_return(toto1))
+        allow(toto1).to(receive(:do_modifications).once.and_return(adoc_sources_modified))
         allow(toto1).to(receive(:config).once.and_return(p: 'modified_param'))
         allow(toto1).to(receive(:changes).once.and_return([%w[from1 to1], %w[from2 to2]]))
-        batchmodifier.apply('modifier1')
+        batchmodifier.apply(%i[modifier1])
       end
 
       it do
-        expect(DefMastership::TotoClassModifier).to(have_received(:new).with(p: 1))
+        expect(DefMastership::TotoModifier).to(have_received(:new).with(p: 1))
       end
 
-      it { expect(toto1).to(have_received(:do_modifications).with(adoc_texts)) }
-      it { is_expected.to(have_attributes(adoc_texts: adoc_texts_modified)) }
+      it { expect(toto1).to(have_received(:do_modifications).with(adoc_sources)) }
+      it { is_expected.to(have_attributes(adoc_sources: adoc_sources_modified)) }
       it { expect(toto1).to(have_received(:config).with(no_args)) }
 
       it { is_expected.to(have_attributes(config: config_modified)) }
@@ -78,43 +82,43 @@ RSpec.describe(DefMastership::BatchModifier) do
     end
 
     context 'with two modifications' do
-      let(:toto2) { instance_double(DefMastership::TotoClassModifier, 'toto2') }
-      let(:tutu3) { instance_double(DefMastership::TutuClassModifier, 'tutu3') }
+      let(:toto2) { instance_double(DefMastership::TotoModifier, 'toto2') }
+      let(:tutu3) { instance_double(DefMastership::TuTuModifier, 'tutu3') }
 
       let(:config_modified) do
         {
-          modifier1: { type: 'toto_class', config: { p: 1 } },
-          modifier2: { type: 'toto_class', config: :whatever },
-          modifier3: { type: 'tutu_class', config: :pouet }
+          modifier1: { type: 'toto', config: { p: 1 } },
+          modifier2: { type: 'toto', config: :whatever },
+          modifier3: { type: 'tu_tu', config: :pouet }
         }
       end
 
       before do
-        allow(DefMastership::TotoClassModifier).to(receive(:new).once.and_return(toto2))
-        allow(toto2).to(receive(:do_modifications).once.and_return(:adoc_texts_modified_mod2))
+        allow(DefMastership::TotoModifier).to(receive(:new).once.and_return(toto2))
+        allow(toto2).to(receive(:do_modifications).once.and_return(:adoc_sources_modified_mod2))
         allow(toto2).to(receive(:config).once.and_return(:whatever))
-        allow(DefMastership::TutuClassModifier).to(receive(:new).once.and_return(tutu3))
-        allow(tutu3).to(receive(:do_modifications).once.and_return(:adoc_texts_modified_mod3))
+        allow(DefMastership::TuTuModifier).to(receive(:new).once.and_return(tutu3))
+        allow(tutu3).to(receive(:do_modifications).once.and_return(:adoc_sources_modified_mod3))
         allow(tutu3).to(receive(:config).once.and_return(:pouet))
         allow(toto2).to(receive(:changes).once.and_return([%w[from1 to1]]))
         allow(tutu3).to(receive(:changes).once.and_return([%w[from2 to2]]))
-        batchmodifier.apply('modifier2, modifier3')
+        batchmodifier.apply(%i[modifier2 modifier3])
       end
 
-      it { expect(DefMastership::TotoClassModifier).to(have_received(:new).with(p: 'whatever1')) }
-      it { expect(DefMastership::TutuClassModifier).to(have_received(:new).with(p1: 'whatever2', p2: 'whatever3')) }
-      it { expect(toto2).to(have_received(:do_modifications).with(adoc_texts)) }
+      it { expect(DefMastership::TotoModifier).to(have_received(:new).with(p: 'whatever1')) }
+      it { expect(DefMastership::TuTuModifier).to(have_received(:new).with(p1: 'whatever2', p2: 'whatever3')) }
+      it { expect(toto2).to(have_received(:do_modifications).with(adoc_sources)) }
       it { expect(toto2).to(have_received(:config).with(no_args)) }
-      it { expect(tutu3).to(have_received(:do_modifications).with(:adoc_texts_modified_mod2)) }
+      it { expect(tutu3).to(have_received(:do_modifications).with(:adoc_sources_modified_mod2)) }
       it { expect(tutu3).to(have_received(:config).with(no_args)) }
-      it { is_expected.to(have_attributes(adoc_texts: :adoc_texts_modified_mod3)) }
+      it { is_expected.to(have_attributes(adoc_sources: :adoc_sources_modified_mod3)) }
       it { is_expected.to(have_attributes(config: config_modified)) }
       it { is_expected.to(have_attributes(changes: [%w[modifier2 from1 to1], %w[modifier3 from2 to2]])) }
     end
 
     context 'with wrong modification' do
       it do
-        expect { batchmodifier.apply('wrong-modification') }
+        expect { batchmodifier.apply(%i[wrong-modification]) }
           .to(
             raise_error(ArgumentError, 'wrong-modification is not a known modification')
           )

data/spec/unit/def_mastership/change_ref_modifier_spec.rb

@@ -1,76 +1,221 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/change_ref_modifier')
 
 RSpec.describe(DefMastership::ChangeRefModifier) do
-  subject(:modifier) do
-    described_class.new(
-      'fake config'
-    )
+  subject(:refchanger) { described_class.new({}) }
+
+  describe '.new' do
+    it { expect(described_class.ancestors).to(include(DefMastership::Modifier)) }
+    it { is_expected.not_to(be_nil) }
+    it { is_expected.to(have_attributes(from_regexp: '')) }
+    it { is_expected.to(have_attributes(to_template: '')) }
+    it { is_expected.to(have_attributes(next_ref:    0)) }
   end
 
-  let(:adoc_texts) do
-    {
-      'file1.adoc' => "file1 line1\nfile1 line2",
-      'file2.adoc' => "file2 line1\nfile2 line2"
-    }
+  describe '.replacement_methods' do
+    it { expect(described_class.replacement_methods).to(eq(%i[replace_refdef replace_irefs])) }
   end
 
-  describe '.new' do
-    it { is_expected.not_to(be_nil) }
-    it { is_expected.to(have_attributes(config: 'fake config')) }
-    it { is_expected.to(have_attributes(changes: [])) }
+  describe '#config' do
+    context 'when not initalized' do
+      it do
+        expect(refchanger.config).to(
+          include(from_regexp: '', to_template: '', next_ref: 0)
+        )
+      end
+    end
   end
 
-  describe '#do_modifications' do
-    let(:line_modifier) { instance_double(DefMastership::ChangeRefLineModifier, 'lineModifier') }
+  describe '#replace_def' do
+    context 'when really simple rule' do
+      subject(:refchanger) do
+        described_class.new(
+          from_regexp: 'TEMP',
+          to_template: 'TUTU'
+        )
+      end
 
-    before do
-      allow(DefMastership::ChangeRefLineModifier).to(
-        receive(:from_config).with('fake config').and_return(line_modifier)
-      )
-      allow(line_modifier).to(receive(:replace_refdef).with("file1 line1\n").and_return("new file1 line1\n"))
-      allow(line_modifier).to(receive(:replace_refdef).with('file1 line2').and_return('new file1 line2'))
-      allow(line_modifier).to(receive(:replace_refdef).with("file2 line1\n").and_return("new file2 line1\n"))
-      allow(line_modifier).to(receive(:replace_refdef).with('file2 line2').and_return('new file2 line2'))
-      allow(line_modifier).to(receive(:replace_irefs).with("new file1 line1\n").and_return("new2 file1 line1\n"))
-      allow(line_modifier).to(receive(:replace_irefs).with('new file1 line2').and_return('new2 file1 line2'))
-      allow(line_modifier).to(receive(:replace_irefs).with("new file2 line1\n").and_return("new2 file2 line1\n"))
-      allow(line_modifier).to(receive(:replace_irefs).with('new file2 line2').and_return('new2 file2 line2'))
-      allow(line_modifier).to(receive(:config).and_return('new fake config'))
-      allow(line_modifier).to(receive(:changes).and_return([%w[from1 to1], %w[from2 to2]]))
+      context 'when valid definition' do
+        it do
+          expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
+            .to(eq('[define, whatever, TUTU]'))
+        end
+      end
+
+      context 'when no valid definition' do
+        it do
+          expect(refchanger.replace_refdef('[pouet, whatever, TEMP]'))
+            .to(eq('[pouet, whatever, TEMP]'))
+        end
+      end
     end
 
-    context 'when detailed expectations' do
-      before { modifier.do_modifications(adoc_texts) }
+    context 'when template is variable' do
+      subject(:refchanger) do
+        described_class.new(
+          from_regexp: 'TEMP',
+          to_template: 'TOTO-%<next_ref>04d',
+          next_ref: 124
+        )
+      end
 
       it do
-        expect(DefMastership::ChangeRefLineModifier).to(
-          have_received(:from_config).with('fake config')
+        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
+          .to(eq('[define, whatever, TOTO-0124]'))
+      end
+
+      it do
+        refchanger.replace_refdef('[define, whatever, TEMP]')
+        expect(refchanger).to(have_attributes(next_ref: 125))
+      end
+    end
+
+    context 'when capture group in regexp' 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
+
+      it do
+        expect(refchanger.replace_refdef('[define, whatever, TOTO-TEMP]'))
+          .to(eq('[define, whatever, TOTO-0132]'))
+      end
+
+      it do
+        refchanger.replace_refdef('[define, whatever, TOTO-TEMP]')
+        expect(refchanger.replace_refdef('[define, whatever, TITI-TEMP]'))
+          .to(eq('[define, whatever, TITI-0133]'))
+      end
+
+      it do
+        refchanger.replace_refdef('[define, whatever, TOTO-TEMP1]')
+        refchanger.replace_refdef('[define, whatever, TITI-TEMP2]')
+        expect(refchanger).to(have_attributes(changes: [%w[TOTO-TEMP1 TOTO-0132], %w[TITI-TEMP2 TITI-0133]]))
+      end
+    end
+
+    context 'when definition is in literal block' do
+      subject(:refchanger) do
+        described_class.new(
+          from_regexp: 'TEMP',
+          to_template: 'TUTU'
+        )
+      end
+
+      before do
+        refchanger.replace_refdef('....')
+      end
+
+      it do
+        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
+          .to(eq('[define, whatever, TEMP]'))
+      end
+    end
+
+    context 'when defintion is after literal block' do
+      subject(:refchanger) do
+        described_class.new(
+          from_regexp: 'TEMP',
+          to_template: 'TUTU'
         )
       end
 
-      it { expect(line_modifier).to(have_received(:replace_refdef).with("file1 line1\n")) }
-      it { expect(line_modifier).to(have_received(:replace_refdef).with('file1 line2')) }
-      it { expect(line_modifier).to(have_received(:replace_refdef).with("file2 line1\n")) }
-      it { expect(line_modifier).to(have_received(:replace_refdef).with('file2 line2')) }
-      it { expect(line_modifier).to(have_received(:replace_irefs).with("new file1 line1\n")) }
-      it { expect(line_modifier).to(have_received(:replace_irefs).with('new file1 line2')) }
-      it { expect(line_modifier).to(have_received(:replace_irefs).with("new file2 line1\n")) }
-      it { expect(line_modifier).to(have_received(:replace_irefs).with('new file2 line2')) }
-      it { expect(line_modifier).to(have_received(:config)) }
-      it { expect(line_modifier).to(have_received(:changes)) }
-      it { is_expected.to(have_attributes(config: 'new fake config')) }
-      it { is_expected.to(have_attributes(changes: [%w[from1 to1], %w[from2 to2]])) }
+      before do
+        refchanger.replace_refdef("....\n")
+        refchanger.replace_refdef('[define, whatever, TEMP]')
+        refchanger.replace_refdef("....\n")
+      end
+
+      it do
+        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
+          .to(eq('[define, whatever, TUTU]'))
+      end
+    end
+  end
+
+  describe '#replace_irefs' 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('defs:iref[TOTO-TEMP1234]'))
+        .to(eq('defs:iref[TOTO-TEMP1234]'))
+    end
+
+    it do
+      expect(refchanger.replace_irefs('defs:iref[TOTO-TEMP123]'))
+        .to(eq('defs:iref[TOTO-0132]'))
+    end
+
+    it do
+      expect(
+        refchanger.replace_irefs(
+          'defs:iref[TOTO-TEMP123] defs:iref[TITI-TEMP421] bla'
+        )
+      ).to(eq('defs:iref[TOTO-0132] defs:iref[TITI-0133] bla'))
+    end
+
+    it do
+      expect(
+        refchanger.replace_irefs(
+          'defs:iref[TOTO-TEMP123] defs:iref[TOTO-TEMP123] bla'
+        )
+      ).to(eq('defs:iref[TOTO-0132] defs:iref[TOTO-0132] bla'))
+    end
+  end
+
+  describe '#replace' do
+    subject(:refchanger) do
+      described_class.new(
+        from_regexp: 'TEMP',
+        to_template: 'TUTU'
+      )
+    end
+
+    it do
+      expect(refchanger.replace(:refdef, '[define, whatever, TEMP]'))
+        .to(eq('[define, whatever, TUTU]'))
+    end
+
+    it do
+      expect(refchanger.replace(:refdef, '[define, whatever, TEMP(a~12345678)]'))
+        .to(eq('[define, whatever, TUTU(a~12345678)]'))
+    end
+
+    it do
+      expect(refchanger.replace(:refdef, '[define, whatever, TEMP(~12345678)]'))
+        .to(eq('[define, whatever, TUTU(~12345678)]'))
+    end
+
+    it do
+      expect(refchanger.replace(:refdef, '[define, whatever, TEMP(a)]'))
+        .to(eq('[define, whatever, TUTU(a)]'))
+    end
+
+    it do
+      refchanger.replace(:refdef, '[define, whatever, TEMP]')
+      expect(refchanger.replace(:irefs, 'defs:iref[TEMP] defs:iref[TEMP]'))
+        .to(eq('defs:iref[TUTU] defs:iref[TUTU]'))
     end
 
     it do
-      expected_adoc = {
-        'file1.adoc' => "new2 file1 line1\nnew2 file1 line2",
-        'file2.adoc' => "new2 file2 line1\nnew2 file2 line2"
-      }
-      expect(modifier.do_modifications(adoc_texts)).to(eq(expected_adoc))
+      expect { refchanger.replace(:pouet, 'whatever') }
+        .to(raise_error(NoMethodError))
     end
   end
 end