defmastership 1.0.17 → 1.0.19

data/spec/unit/def_mastership/document_spec.rb

@@ -1,7 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/document')
 
 RSpec.describe(DefMastership::Document) do
   subject(:document) { described_class.new }
@@ -15,16 +15,32 @@ RSpec.describe(DefMastership::Document) do
     it { is_expected.to(have_attributes(variables: {})) }
   end
 
+  describe '.method_missing' do
+    it do
+      expect { document.not_implemented_random_method }
+        .to(raise_error(NoMethodError))
+    end
+  end
+
+  describe '.respond_to_missing?' do
+    it { expect(document.respond_to?(:add_new_definition)).to(be(true)) }
+    it { expect(document.respond_to?(:not_implemented_random_method)).to(be(false)) }
+  end
+
   describe '#parse' do
     context 'with valid definitions' do
       let(:definition) { instance_double(DefMastership::Definition, 'definition') }
 
       before do
         allow(DefMastership::Definition).to(receive(:new).and_return(definition))
-        allow(definition).to(receive(:labels).and_return(Set.new))
-        allow(definition).to(receive(:<<).and_return(definition))
-        allow(definition).to(receive(:add_eref).and_return(definition))
-        allow(definition).to(receive(:add_iref).and_return(definition))
+        allow(definition).to(
+          receive_messages(
+            labels: Set.new,
+            '<<': definition,
+            add_eref: definition,
+            add_iref: definition
+          )
+        )
       end
 
       context 'when simple definition line' do
@@ -401,8 +417,12 @@ RSpec.describe(DefMastership::Document) do
 
       before do
         allow(DefMastership::Definition).to(receive(:new).and_return(definition))
-        allow(definition).to(receive(:labels).and_return(Set.new))
-        allow(definition).to(receive(:<<).and_return(definition))
+        allow(definition).to(
+          receive_messages(
+            labels: Set.new,
+            '<<': definition
+          )
+        )
         document.parse(input_lines)
       end
 
@@ -431,6 +451,18 @@ RSpec.describe(DefMastership::Document) do
         it { expect(definition).to(have_received(:<<).with('bef {variable} aft')) }
       end
 
+      context 'when badly defined variable' do
+        let(:input_lines) do
+          [
+            ':variable:one value',
+            '[define, requirement, TOTO-0001]',
+            'bef {variable} aft'
+          ]
+        end
+
+        it { expect(definition).to(have_received(:<<).with('bef {variable} aft')) }
+      end
+
       context 'when multiple defined variables' do
         let(:input_lines) do
           [
@@ -503,8 +535,12 @@ RSpec.describe(DefMastership::Document) do
       allow(adoc_doc).to(receive(:reader).and_return(adoc_reader))
       allow(adoc_reader).to(receive(:read_lines).and_return(input_lines))
       allow(DefMastership::Definition).to(receive(:new).and_return(definition))
-      allow(definition).to(receive(:<<).and_return(definition))
-      allow(definition).to(receive(:labels).and_return(Set.new))
+      allow(definition).to(
+        receive_messages(
+          '<<': definition,
+          labels: Set.new
+        )
+      )
       document.parse_file_with_preprocessor('the_file.adoc')
     end
 
@@ -539,30 +575,29 @@ RSpec.describe(DefMastership::Document) do
     end
 
     before do
-      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs[0], defs[1]))
-      allow(defs[0]).to(receive(:labels)).and_return([])
-      allow(defs[1]).to(receive(:labels)).and_return([])
-      allow(defs[0]).to(receive(:<<).and_return(defs[0]))
-      allow(defs[1]).to(receive(:<<).and_return(defs[1]))
+      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs.first, defs[1]))
+      defs.each do |definition|
+        allow(definition).to(receive(:labels)).and_return([])
+        allow(definition).to(receive(:<<)).and_return(definition)
+      end
     end
 
     context 'when no wrong explicit checksum' do
       before do
-        allow(defs[0]).to(receive(:wrong_explicit_checksum)).and_return(nil)
-        allow(defs[1]).to(receive(:wrong_explicit_checksum)).and_return(nil)
+        defs.each { |definition| allow(definition).to(receive(:wrong_explicit_checksum)).and_return(nil) }
         document.parse(input_lines)
         document.wrong_explicit_checksum?
       end
 
-      it { expect(defs[0]).to(have_received(:wrong_explicit_checksum)) }
+      it { expect(defs.first).to(have_received(:wrong_explicit_checksum)) }
       it { expect(defs[1]).to(have_received(:wrong_explicit_checksum)) }
       it { expect(document.wrong_explicit_checksum?).to(be(false)) }
     end
 
     context 'when one req has wrong explicit checksum' do
       before do
-        allow(defs[0]).to(receive(:wrong_explicit_checksum)).and_return(nil)
-        allow(defs[1]).to(receive(:wrong_explicit_checksum)).and_return('toto')
+        allow(defs.first).to(receive(:wrong_explicit_checksum)).and_return('toto')
+        allow(defs[1]).to(receive(:wrong_explicit_checksum)).and_return(nil)
         document.parse(input_lines)
         document.wrong_explicit_checksum?
       end
@@ -589,30 +624,30 @@ RSpec.describe(DefMastership::Document) do
     end
 
     before do
-      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs[0], defs[1]))
-      allow(defs[0]).to(receive(:labels)).and_return([])
+      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs.first, defs[1]))
+      allow(defs.first).to(receive(:labels)).and_return([])
       allow(defs[1]).to(receive(:labels)).and_return([])
-      allow(defs[0]).to(receive(:<<).and_return(defs[0]))
+      allow(defs.first).to(receive(:<<).and_return(defs.first))
       allow(defs[1]).to(receive(:<<).and_return(defs[1]))
     end
 
     context 'when no explicit version' do
       before do
-        allow(defs[0]).to(receive(:explicit_version)).and_return(nil)
+        allow(defs.first).to(receive(:explicit_version)).and_return(nil)
         allow(defs[1]).to(receive(:explicit_version)).and_return(nil)
         document.parse(input_lines)
         document.explicit_version?
       end
 
-      it { expect(defs[0]).to(have_received(:explicit_version)) }
+      it { expect(defs.first).to(have_received(:explicit_version)) }
       it { expect(defs[1]).to(have_received(:explicit_version)) }
       it { expect(document.explicit_version?).to(be(false)) }
     end
 
     context 'when one req has explicit version' do
       before do
-        allow(defs[0]).to(receive(:explicit_version)).and_return(nil)
-        allow(defs[1]).to(receive(:explicit_version)).and_return('toto')
+        allow(defs.first).to(receive(:explicit_version)).and_return('toto')
+        allow(defs[1]).to(receive(:explicit_version)).and_return(nil)
         document.parse(input_lines)
         document.explicit_version?
       end
@@ -622,10 +657,10 @@ RSpec.describe(DefMastership::Document) do
   end
 
   describe '#ref_to_def?' do
-    let(:defs) do
+    let(:definitions) do
       [
-        instance_double(DefMastership::Definition, 'definition'),
-        instance_double(DefMastership::Definition, 'definition')
+        instance_double(DefMastership::Definition, 'def1'),
+        instance_double(DefMastership::Definition, 'def2')
       ]
     end
     let(:input_lines) do
@@ -639,17 +674,25 @@ RSpec.describe(DefMastership::Document) do
     end
 
     before do
-      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs[0], defs[1]))
-      allow(defs[0]).to(receive(:labels)).and_return([])
-      allow(defs[1]).to(receive(:labels)).and_return([])
-      allow(defs[0]).to(receive(:<<).and_return(defs[0]))
-      allow(defs[1]).to(receive(:<<).and_return(defs[1]))
-      allow(defs[0]).to(receive(:reference).and_return('TOTO-0001'))
-      allow(defs[1]).to(receive(:reference).and_return('TOTO-0002'))
+      allow(DefMastership::Definition).to(receive(:new).twice.and_return(definitions.first, definitions[1]))
+      allow(definitions.first).to(
+        receive_messages(
+          labels: [],
+          '<<': definitions.first,
+          reference: 'TOTO-0001'
+        )
+      )
+      allow(definitions[1]).to(
+        receive_messages(
+          labels: [],
+          '<<': definitions[1],
+          reference: 'TOTO-0002'
+        )
+      )
       document.parse(input_lines)
     end
 
-    it { expect(document.ref_to_def('TOTO-0001')).to(eq(defs[0])) }
-    it { expect(document.ref_to_def('TOTO-0002')).to(eq(defs[1])) }
+    it { expect(document.ref_to_def('TOTO-0001')).to(eq(definitions.first)) }
+    it { expect(document.ref_to_def('TOTO-0002')).to(eq(definitions[1])) }
   end
 end

data/spec/unit/def_mastership/matching_line_spec.rb

@@ -0,0 +1,37 @@
+# Copyright (c) 2024 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/matching_line')
+
+RSpec.describe(DefMastership::MatchingLine) do
+  describe '.new' do
+    subject(:matching_line) do
+      described_class.new(:a_match, :a_line)
+    end
+
+    it { is_expected.not_to(be_nil) }
+    it { is_expected.to(have_attributes(match: :a_match)) }
+    it { is_expected.to(have_attributes(line: :a_line)) }
+  end
+
+  describe '#[]' do
+    subject(:matching_line) do
+      described_class.new(match, :a_line)
+    end
+
+    let(:match) { instance_double(Hash, 'match') }
+
+    before do
+      allow(match).to(receive(:[]).with(:whatever).and_return('Whatever'))
+      allow(match).to(receive(:[]).with(:line).and_return(nil))
+    end
+
+    it do
+      matching_line[:whatever]
+      expect(match).to(have_received(:[]).with(:whatever))
+    end
+
+    it { expect(matching_line[:whatever]).to(eq('Whatever')) }
+    it { expect(matching_line[:line]).to(eq(:a_line)) }
+  end
+end

data/spec/unit/def_mastership/modifier_factory_spec.rb

@@ -0,0 +1,38 @@
+# Copyright (c) 2023 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/modifier_factory')
+
+module DefMastership
+  # Modifier example
+  class TotoModifier
+    include Modifier
+  end
+end
+
+RSpec.describe(DefMastership::ModifierFactory) do
+  describe('.from_config') do
+    let(:toto)        { instance_double(DefMastership::TotoModifier, 'toto') }
+    let(:toto_config) { { type: 'toto', config: { p: 'whatever' } }          }
+    let(:tutu)        { instance_double(DefMastership::TotoModifier, 'tutu') }
+    let(:tutu_config) { { type: 'tu_tu', config: { p: 'whatever' } }         }
+
+    before do
+      allow(DefMastership::TotoModifier).to(receive(:new).with(toto_config[:config]).and_return(toto))
+      allow(DefMastership::TuTuModifier).to(receive(:new).with(tutu_config[:config]).and_return(tutu))
+    end
+
+    it { expect(described_class.from_config(toto_config)).to(be(toto)) }
+    it { expect(described_class.from_config(tutu_config)).to(be(tutu)) }
+
+    it do
+      described_class.from_config(toto_config)
+      expect(DefMastership::TotoModifier).to(have_received(:new).with(toto_config[:config]))
+    end
+
+    it do
+      described_class.from_config(tutu_config)
+      expect(DefMastership::TuTuModifier).to(have_received(:new).with(tutu_config[:config]))
+    end
+  end
+end

data/spec/unit/def_mastership/modifier_spec.rb

@@ -0,0 +1,85 @@
+# Copyright (c) 2023 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/modifier')
+
+# just a class for test
+class DummyClassParent
+  # This method smells of :reek:ControlParameter
+  # This method smells of :reek:UtilityFunction
+  def respond_to_missing?(method_name, *_)
+    return true if method_name == :ploup
+
+    false
+  end
+end
+
+# just a class for test
+class DummyClass < DummyClassParent
+  include DefMastership::Modifier
+
+  def self.replacement_methods
+    %i[replace_pouet_by_foo replace_foo_by_zoo]
+  end
+
+  def self.default_config
+    { something: :default }
+  end
+
+  def initialize(config)
+    setup_modifier_module(config)
+    super()
+  end
+
+  # This method smells of :reek:UtilityFunction
+  def replace_pouet_by_foo(line)
+    line.gsub('pouet', 'foo')
+  end
+
+  # This method smells of :reek:UtilityFunction
+  def replace_foo_by_zoo(line)
+    line.gsub('foo', 'zoo')
+  end
+end
+
+RSpec.describe(DefMastership::Modifier) do
+  subject(:modifier) { DummyClass.new({}) }
+
+  describe '.new' do
+    it { is_expected.not_to(be_nil) }
+    it { is_expected.to(have_attributes(config: { something: :default })) }
+    it { is_expected.to(have_attributes(changes: [])) }
+  end
+
+  context 'when want to use config smoothly' do
+    subject(:modifier) { DummyClass.new(plop: 'Whatever', something: :not_default) }
+
+    it { is_expected.to(have_attributes(config: { plop: 'Whatever', something: :not_default })) }
+    it { is_expected.to(have_attributes(plop: 'Whatever')) }
+    it { is_expected.not_to(respond_to(:pleeep)) }
+    it { is_expected.to(respond_to(:ploup)) }
+
+    it do
+      expect { modifier.plooooop }
+        .to(raise_error(NoMethodError))
+    end
+  end
+
+  describe '#apply_to_all' do
+    it do
+      texts = { first: "pouet\ntoto\npouet", second: "toto\npouet\ntoto" }
+
+      expect(modifier.apply_to_all(texts, :replace_pouet_by_foo))
+        .to(eq({ first: "foo\ntoto\nfoo", second: "toto\nfoo\ntoto" }))
+    end
+  end
+
+  describe '#do_modifications' do
+    it do
+      adoc_sources = { first: "pouet\ntoto\npouet", second: "toto\npouet\ntoto" }
+
+      expect(modifier.do_modifications(adoc_sources))
+        .to(eq({ first: "zoo\ntoto\nzoo", second: "toto\nzoo\ntoto" }))
+    end
+  end
+end

data/spec/unit/def_mastership/parsing_state_spec.rb

@@ -1,7 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/parsing_state')
 
 RSpec.describe(DefMastership::ParsingState) do
   subject(:parsing_state) do

data/spec/unit/def_mastership/rename_included_files_modifier_spec.rb

@@ -1,67 +1,239 @@
 # Copyright (c) 2021 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/rename_included_files_modifier')
 
 RSpec.describe(DefMastership::RenameIncludedFilesModifier) do
-  subject(:modifier) do
-    described_class.new(
-      'fake config'
-    )
-  end
-
-  let(:adoc_texts) do
-    {
-      'file1.adoc' => "file1 line1\nfile1 line2",
-      'file2.adoc' => "file2 line1\nfile2 line2"
-    }
-  end
+  subject(:includeschanger) { 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(config: 'fake config')) }
-    it { is_expected.to(have_attributes(changes: [])) }
+    it { is_expected.to(have_attributes(from_regexp: '')) }
+    it { is_expected.to(have_attributes(to_template: '')) }
   end
 
-  describe '#do_modifications' do
-    let(:line_modifier) { instance_double(DefMastership::RenameIncludedFilesLineModifier, 'lineModifier') }
-
-    before do
-      allow(DefMastership::RenameIncludedFilesLineModifier).to(
-        receive(:from_config).with('fake config').and_return(line_modifier)
-      )
-      allow(line_modifier).to(receive(:replace).with("file1 line1\n").and_return("new file1 line1\n"))
-      allow(line_modifier).to(receive(:replace).with('file1 line2').and_return('new file1 line2'))
-      allow(line_modifier).to(receive(:replace).with("file2 line1\n").and_return("new file2 line1\n"))
-      allow(line_modifier).to(receive(:replace).with('file2 line2').and_return('new file2 line2'))
-      allow(line_modifier).to(receive(:changes).and_return([%w[from1 to1], %w[from2 to2]]))
-      allow(line_modifier).to(receive(:config).and_return('fake config'))
-    end
+  describe '.replacement_methods' do
+    it { expect(described_class.replacement_methods).to(eq(%i[replace])) }
+  end
 
-    context 'when detailed expectations' do
-      before { modifier.do_modifications(adoc_texts) }
+  describe '.respond_to_missing?' do
+    it { expect(includeschanger.respond_to?(:add_new_definition)).to(be(true)) }
+    it { expect(includeschanger.respond_to?(:not_implemented_random_method)).to(be(false)) }
+  end
 
-      it do
-        expect(DefMastership::RenameIncludedFilesLineModifier).to(
-          have_received(:from_config).with('fake config')
+  describe '#replace' do
+    context 'when NOT valid include' do
+      subject(:includeschanger) do
+        described_class.new(
+          from_regexp: 'orig',
+          to_template: 'dest'
         )
       end
 
-      it { expect(line_modifier).to(have_received(:replace).with("file1 line1\n")) }
-      it { expect(line_modifier).to(have_received(:replace).with('file1 line2')) }
-      it { expect(line_modifier).to(have_received(:replace).with("file2 line1\n")) }
-      it { expect(line_modifier).to(have_received(:replace).with('file2 line2')) }
-      it { expect(line_modifier).to(have_received(:changes)) }
-      it { is_expected.to(have_attributes(config: 'fake config')) }
-      it { is_expected.to(have_attributes(changes: [%w[from1 to1], %w[from2 to2]])) }
+      before do
+        allow(File).to(receive(:rename))
+      end
+
+      context 'when the include statement do not match' do
+        before do
+          ['[define,requirement,REFERENCE]', '--'].each do |line|
+            includeschanger.replace(line)
+          end
+        end
+
+        it do
+          expect(includeschanger.replace('badinclude::orig[]'))
+            .to(eq('badinclude::orig[]'))
+        end
+
+        it do
+          includeschanger.replace('badinclude::orig[]')
+          expect(includeschanger).to(have_attributes(changes: []))
+        end
+      end
+
+      context 'when the include is not in a definition' do
+        before do
+          ['[define,requirement,REFERENCE]', '--', 'text', '--'].each do |line|
+            includeschanger.replace(line)
+          end
+        end
+
+        it do
+          expect(includeschanger.replace('include::orig[]'))
+            .to(eq('include::orig[]'))
+        end
+
+        it do
+          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('--')
+        end
+
+        it do
+          expect(includeschanger.replace('// include::orig[]'))
+            .to(eq('// include::orig[]'))
+        end
+      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'
+          )
+        end
+
+        before do
+          includeschanger.replace('[define,requirement,REFERENCE]')
+          includeschanger.replace('--')
+        end
+
+        it do
+          expect(includeschanger.replace("include::orig[]\n"))
+            .to(eq("include::orig[]\n"))
+        end
+      end
     end
 
-    it do
-      expected_adoc = {
-        'file1.adoc' => "new file1 line1\nnew file1 line2",
-        'file2.adoc' => "new file2 line1\nnew file2 line2"
-      }
-      expect(modifier.do_modifications(adoc_texts)).to(eq(expected_adoc))
+    context 'when valid include' do
+      before do
+        allow(File).to(receive(:rename))
+      end
+
+      context 'when really simple rule' do
+        subject(:includeschanger) do
+          described_class.new(
+            from_regexp: 'orig',
+            cancel_if_match: '_no_cancel_',
+            to_template: 'dest'
+          )
+        end
+
+        before do
+          includeschanger.replace('[define,requirement,REFERENCE]')
+          includeschanger.replace('--')
+        end
+
+        it do
+          expect(includeschanger.replace("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'))
+        end
+
+        it do
+          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'))
+        end
+
+        it do
+          includeschanger.replace("include::orig[]\n")
+          expect(includeschanger).to(have_attributes(changes: [%w[orig dest]]))
+        end
+
+        it do
+          expect(includeschanger.replace("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'))
+        end
+
+        it do
+          includeschanger.replace("include::toto/orig[]\n")
+          expect(includeschanger).to(have_attributes(changes: [%w[toto/orig 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'
+          )
+        end
+
+        before do
+          includeschanger.replace('[define,requirement,REF]')
+        end
+
+        it do
+          expect(includeschanger.replace('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'))
+        end
+
+        it do
+          changes = [%w[any_path/one_file.extension any_path/REF_one_file.extension]]
+          includeschanger.replace('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
+
+        before do
+          includeschanger.replace(':any: one')
+          includeschanger.replace(':path: two')
+          includeschanger.replace(':var: three')
+          includeschanger.replace('[define,requirement,REFERENCE]')
+          includeschanger.replace('--')
+        end
+
+        it do
+          expect(includeschanger.replace('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'))
+        end
+
+        it do
+          includeschanger.replace('include::{any}_{path}/orig[]')
+          expect(File).to(have_received(:rename).with('one_two/orig', 'one_two/dest'))
+        end
+
+        it do
+          expect { includeschanger.replace('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]]))
+        end
+      end
     end
   end
 end

data/spec/unit/def_mastership/string_spec.rb

@@ -1,7 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/comment_filter')
 
 RSpec.describe(String) do
   context 'when .commented?' do