defmastership 1.3.2 → 1.3.4

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

@@ -0,0 +1,85 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/document')
+require('defmastership/export/yaml/formatter')
+
+RSpec.describe(Defmastership::Export::YAML::Formatter) do
+  subject(:formatter) { described_class.new(document) }
+
+  let(:document) { instance_double(Defmastership::Document, 'document') }
+
+  describe '.new' do
+    it { is_expected.not_to(be_nil) }
+  end
+
+  describe '#export_to' do
+    let(:header) { instance_double(Defmastership::Export::HeaderFormatter, 'header') }
+    let(:bodies) do
+      [
+        instance_double(Defmastership::Export::BodyFormatter, 'bodies[0]'),
+        instance_double(Defmastership::Export::BodyFormatter, 'bodies[1]')
+      ]
+    end
+
+    let(:yaml) { instance_double(YAML, 'yaml') }
+    let(:expected_hash_array) do
+      [
+        {
+          'checksum header': 'checksum def0 body',
+          'reference header': 'reference def0 body',
+          'type header': 'type def0 body',
+          'value header': 'value def0 body'
+        },
+        {
+          'checksum header': 'checksum def1 body',
+          'reference header': 'reference def1 body',
+          'type header': 'type def1 body',
+          'value header': 'value def1 body'
+        }
+      ]
+    end
+
+    before do
+      allow(Defmastership::Export::HeaderFormatter).to(receive(:new).with(document).and_return(header))
+      bodies.each_with_index do |body, index|
+        allow(Defmastership::Export::BodyFormatter).to(
+          receive(:new).with(
+            document,
+            :"def#{index}"
+          ).and_return(body)
+        )
+      end
+      allow(document).to(receive(:definitions).and_return(%i[def0 def1]))
+      allow(document).to(receive(:summaries?).with(no_args).and_return(false))
+      allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(false))
+      allow(document).to(receive(:explicit_version?).with(no_args).and_return(false))
+      allow(document).to(receive(:labels).with(no_args).and_return([]))
+      allow(document).to(receive(:eref).with(no_args).and_return([]))
+      allow(document).to(receive(:iref).with(no_args).and_return(false))
+      allow(document).to(receive(:attributes).with(no_args).and_return([]))
+
+      COLUMN_METHODS.each do |method|
+        allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+        bodies.each_with_index do |body, index|
+          allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
+        end
+      end
+
+      allow(YAML).to(receive(:dump)).and_return('the generated yaml')
+      allow(File).to(receive(:write).with('filename', 'the generated yaml'))
+      formatter.export_to('filename')
+    end
+
+    COLUMN_METHODS.each do |method|
+      it { expect(header).to(have_received(method).with(no_args)) }
+
+      2.times do |index|
+        it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+      end
+    end
+
+    it { expect(YAML).to(have_received(:dump).with(expected_hash_array)) }
+    it { expect(File).to(have_received(:write).with('filename', 'the generated yaml')) }
+  end
+end

data/spec/unit/defmastership/hash_spec.rb

@@ -1,6 +1,8 @@
 # Copyright (c) 2025 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require('defmastership/hash_merge_no_new')
+
 RSpec.describe(Hash) do
   describe '.merge_no_new' do
     context 'when we don\'t want to modiy original Hash' do

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

@@ -12,6 +12,7 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
     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)) }
+    it { is_expected.to(have_attributes(config: { def_type: '', from_regexp: '', to_template: '', next_ref: 0 })) }
   end
 
   describe '.replacement_methods' do
@@ -21,71 +22,48 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
     end
   end
 
-  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 '#replace_refdef' do
     context 'when really simple rule' do
-      subject(:refchanger) do
-        described_class.new(
-          from_regexp: 'TEMP',
-          to_template: 'TUTU'
-        )
-      end
+      subject(:refchanger) { described_class.new(from_regexp: 'TEMP', to_template: 'TUTU') }
 
       context 'when valid definition' do
         it do
-          expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-            .to(eq('[define, whatever, TUTU]'))
+          expect(refchanger.replace_refdef('', '[define, whatever, TEMP]')).to(eq('[define, whatever, TUTU]'))
         end
 
         it do
-          expect(refchanger.replace_refdef('[define, whatever, TEMP(a~12345678)]'))
+          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)]'))
+          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)]'))
+          expect(refchanger.replace_refdef('', '[define, whatever, TEMP(a)]')).to(eq('[define, whatever, TUTU(a)]'))
         end
       end
 
       context 'when no valid definition' do
         it do
-          expect(refchanger.replace_refdef('[pouet, whatever, TEMP]'))
-            .to(eq('[pouet, whatever, TEMP]'))
+          expect(refchanger.replace_refdef('', '[pouet, whatever, TEMP]')).to(eq('[pouet, whatever, TEMP]'))
         end
       end
     end
 
     context 'when template is variable' do
       subject(:refchanger) do
-        described_class.new(
-          from_regexp: 'TEMP',
-          to_template: 'TOTO-%<next_ref>04d',
-          next_ref: 124
-        )
+        described_class.new(from_regexp: 'TEMP', to_template: 'TOTO-%<next_ref>04d', next_ref: 124)
       end
 
       it do
-        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-          .to(eq('[define, whatever, TOTO-0124]'))
+        expect(refchanger.replace_refdef('', '[define, whatever, TEMP]')).to(eq('[define, whatever, TOTO-0124]'))
       end
 
       it do
-        refchanger.replace_refdef('[define, whatever, TEMP]')
+        refchanger.replace_refdef('', '[define, whatever, TEMP]')
         expect(refchanger).to(have_attributes(next_ref: 125))
       end
     end
@@ -100,59 +78,58 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
       end
 
       it do
-        expect(refchanger.replace_refdef('[define, whatever, TOTO-TEMP]'))
-          .to(eq('[define, whatever, TOTO-0132]'))
+        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]'))
+        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]')
+        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
+      subject(:refchanger) { described_class.new(from_regexp: 'TEMP', to_template: 'TUTU') }
 
       before do
-        refchanger.replace_refdef('....')
+        refchanger.replace_refdef('', '....')
       end
 
-      it do
-        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-          .to(eq('[define, whatever, TEMP]'))
-      end
+      it { expect(refchanger.replace_refdef('', '[define, whatever, TEMP]')).to(eq('[define, whatever, TEMP]')) }
     end
 
-    context 'when defintion is after literal block' do
+    context 'when definition is after literal block' do
       subject(:refchanger) do
-        described_class.new(
-          from_regexp: 'TEMP',
-          to_template: 'TUTU'
-        )
+        described_class.new(from_regexp: 'TEMP', to_template: 'TUTU')
       end
 
       before do
-        refchanger.replace_refdef("....\n")
-        refchanger.replace_refdef('[define, whatever, TEMP]')
-        refchanger.replace_refdef("....\n")
+        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
+      it { expect(refchanger.replace_refdef('', '[define, whatever, TEMP]')).to(eq('[define, whatever, TUTU]')) }
+    end
+
+    context 'when definition do no fit with a definition\'s type value' do
+      subject(:refchanger) { described_class.new(def_type: 'req', from_regexp: 'TEMP', to_template: 'TUTU') }
+
+      it { expect(refchanger.replace_refdef('', '[define, whatever, TEMP]')).to(eq('[define, whatever, TEMP]')) }
+      it { expect(refchanger.replace_refdef('', '[define, req, TEMP]')).to(eq('[define, req, TUTU]')) }
+    end
+
+    context 'when definition do no fit with a definition\'s type list' do
+      subject(:refchanger) { described_class.new(def_type: %w[req pouet], from_regexp: 'TEMP', to_template: 'TUTU') }
+
+      it { expect(refchanger.replace_refdef('', '[define, whatever, TEMP]')).to(eq('[define, whatever, TEMP]')) }
+      it { expect(refchanger.replace_refdef('', '[define, req, TEMP]')).to(eq('[define, req, TUTU]')) }
+      it { expect(refchanger.replace_refdef('', '[define, pouet, TEMP]')).to(eq('[define, pouet, TUTU]')) }
     end
   end
 
@@ -166,33 +143,22 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
     end
 
     before do
-      refchanger.replace_refdef('[define, whatever, TOTO-TEMP123]')
-      refchanger.replace_refdef('[define, whatever, TITI-TEMP421]')
+      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 { expect(refchanger.replace_irefs('', 'defs:iref[TOTO-TEMP1234]')).to(eq('defs:iref[TOTO-TEMP1234]')) }
+    it { expect(refchanger.replace_irefs('', 'defs:iref[TOTO-TEMP123]')).to(eq('defs:iref[TOTO-0132]')) }
 
     it do
       expect(
-        refchanger.replace_irefs(
-          'defs:iref[TOTO-TEMP123] defs:iref[TITI-TEMP421] bla'
-        )
+        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'
-        )
+        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
@@ -207,12 +173,12 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
     end
 
     before do
-      refchanger.replace_refdef('[define, whatever, TOTO-TEMP123]')
-      refchanger.replace_refdef('[define, whatever, TITI-TEMP421]')
+      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]'))
+      expect(refchanger.replace_irefs('', 'include::target[tags=TOTO-TEMP1234]'))
         .to(eq('include::target[tags=TOTO-TEMP1234]'))
     end
 
@@ -225,8 +191,9 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
       ['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}]"))
+        expect(
+          refchanger.replace_include_tags('', "include::path/target[#{from}]")
+        ).to(eq("include::path/target[#{to}]"))
       end
     end
 
@@ -236,7 +203,7 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
       'include:target[tag=TITI-TEMP421]',
       '# include::target[tag=TITI-TEMP421]'
     ].each do |unchanged|
-      it { expect(refchanger.replace_include_tags(unchanged)).to(eq(unchanged)) }
+      it { expect(refchanger.replace_include_tags('', unchanged)).to(eq(unchanged)) }
     end
   end
 
@@ -282,30 +249,32 @@ MIF
     end
 
     before do
-      refchanger.replace_refdef('[define, whatever, TOTO-TEMP123]')
-      refchanger.replace_refdef('[define, whatever, TITI-TEMP421]')
+      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(:readlines)).with('sub/target').and_return(['whatever'])
+      allow(File).to(receive(:readlines)).with('sub/path/target').and_return(original_included_file.split)
+      allow(File).to(receive(:readlines)).with('./path/target').and_return(['whatever'])
+      allow(File).to(receive(:readlines)).with('./target').and_return(['whatever'])
 
       allow(File).to(receive(:writelines))
 
-      refchanger.replace_tags_in_included_files('include::path/target[]')
-      refchanger.replace_tags_in_included_files('includ::otherpath/othertarget[]')
+      refchanger.replace_tags_in_included_files('sub/one_file.adoc', 'include::path/target[]')
+      refchanger.replace_tags_in_included_files('', 'includ::otherpath/othertarget[]')
     end
 
-    it { expect(File).to(have_received(:readlines).with('path/target')) }
+    it { expect(File).to(have_received(:readlines).with('sub/path/target')) }
 
     it do
-      expect(File).to(
-        have_received(:writelines).with('path/target', mofified_included_file.split)
-      )
+      expect(File).to(have_received(:writelines).with('sub/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::target[]')).to(eq('include::target[]')) }
 
-    it { expect(refchanger.replace_tags_in_included_files('include::path/target[]')).to(eq('include::path/target[]')) }
+    it do
+      expect(refchanger.replace_tags_in_included_files('', 'include::path/target[]')).to(eq('include::path/target[]'))
+    end
   end
 end

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

@@ -14,32 +14,55 @@ module Defmastership
     class TuTu
       include ModifierCommon
     end
+
+    # Modifier example
+    class Nono
+      include ModifierCommon
+    end
   end
 end
 
 RSpec.describe(Defmastership::Modifier::Factory) do
   describe('.from_config') do
-    let(:toto)        { instance_double(Defmastership::Modifier::Toto, 'toto') }
-    let(:toto_config) { { type: 'toto', config: { p: 'whatever' } }            }
-    let(:tutu)        { instance_double(Defmastership::Modifier::TuTu, 'tutu') }
-    let(:tutu_config) { { type: 'tu_tu', config: { p: 'whatever' } }           }
-
-    before do
-      allow(Defmastership::Modifier::Toto).to(receive(:new).with(toto_config[:config]).and_return(toto))
-      allow(Defmastership::Modifier::TuTu).to(receive(:new).with(tutu_config[:config]).and_return(tutu))
-    end
+    context 'when :config is not empty' do
+      let(:toto)        { instance_double(Defmastership::Modifier::Toto, 'toto') }
+      let(:toto_config) { { type: 'toto', config: { p: 'whatever' } }            }
+      let(:tutu)        { instance_double(Defmastership::Modifier::TuTu, 'tutu') }
+      let(:tutu_config) { { type: 'tu_tu', config: { p: 'whatever' } }           }
 
-    it { expect(described_class.from_config(toto_config)).to(be(toto)) }
-    it { expect(described_class.from_config(tutu_config)).to(be(tutu)) }
+      before do
+        allow(Defmastership::Modifier::Toto).to(receive(:new).and_return(toto))
+        allow(Defmastership::Modifier::TuTu).to(receive(:new).and_return(tutu))
+      end
 
-    it do
-      described_class.from_config(toto_config)
-      expect(Defmastership::Modifier::Toto).to(have_received(:new).with(toto_config[:config]))
+      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::Modifier::Toto).to(have_received(:new).with(toto_config[:config]))
+      end
+
+      it do
+        described_class.from_config(tutu_config)
+        expect(Defmastership::Modifier::TuTu).to(have_received(:new).with(tutu_config[:config]))
+      end
     end
 
-    it do
-      described_class.from_config(tutu_config)
-      expect(Defmastership::Modifier::TuTu).to(have_received(:new).with(tutu_config[:config]))
+    context 'when :config is empty' do
+      let(:nono)        { instance_double(Defmastership::Modifier::Nono, 'nono') }
+      let(:nono_config) { { type: 'nono' }                                       }
+
+      before do
+        allow(Defmastership::Modifier::Nono).to(receive(:new).and_return(nono))
+      end
+
+      it { expect(described_class.from_config(nono_config)).to(be(nono)) }
+
+      it do
+        described_class.from_config(nono_config)
+        expect(Defmastership::Modifier::Nono).to(have_received(:new).with({}))
+      end
     end
   end
 end

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

@@ -1,6 +1,8 @@
 # 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
@@ -30,13 +32,13 @@ class DummyClass < DummyClassParent
   end
 
   # This method smells of :reek:UtilityFunction
-  def replace_pouet_by_foo(line)
-    line.gsub('pouet', 'foo')
+  def replace_pouet_by_foo(filename, line)
+    line.gsub('pouet', "foo(#{filename})")
   end
 
   # This method smells of :reek:UtilityFunction
-  def replace_foo_by_zoo(line)
-    line.gsub('foo', 'zoo')
+  def replace_foo_by_zoo(filename, line)
+    line.gsub('foo', "zoo(#{filename})")
   end
 end
 
@@ -68,7 +70,7 @@ RSpec.describe(Defmastership::Modifier::ModifierCommon) 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" }))
+        .to(eq({ first: "zoo(first)(first)\ntoto\nzoo(first)(first)", second: "toto\nzoo(second)(second)\ntoto" }))
     end
   end
 end