defmastership 1.3.2 → 1.3.4

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

@@ -0,0 +1,209 @@
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/document')
+require('defmastership/modifier/update_eref_checksum')
+
+RSpec.describe(Defmastership::Modifier::UpdateErefChecksum) do
+  describe '.new' do
+    context 'when default config' do
+      subject(:modifier) { described_class.new({}) }
+
+      it { is_expected.not_to(be_nil) }
+      it { expect(described_class.ancestors).to(include(Defmastership::Modifier::ModifierCommon)) }
+      it { is_expected.to(have_attributes(config: { eref_type: '', ref_document: '' })) }
+    end
+
+    context 'when config with simple options' do
+      subject(:modifier) { described_class.new({ eref_type: 'type', ref_document: 'ref.adoc' }) }
+
+      it { is_expected.to(have_attributes(config: { eref_type: 'type', ref_document: 'ref.adoc' })) }
+    end
+  end
+
+  describe '.replacement_methods' do
+    it { expect(described_class.replacement_methods).to(eq(%i[replace_erefs])) }
+  end
+
+  describe '#do_modifications' do
+    context 'when only one ref doc' do
+      subject(:modifier) { described_class.new({ ref_document: 'ref_doc.adoc' }) }
+
+      let(:ref_document)   { instance_double(Defmastership::Document, 'ref_document') }
+      let(:adoc_sources) do
+        {
+          'file1.adoc' => 'pouet',
+          'file2.adoc' => 'tagada'
+        }
+      end
+
+      before do
+        allow(Defmastership::Document).to(receive(:new).once.and_return(ref_document))
+        allow(ref_document).to(receive(:parse_file_with_preprocessor))
+        allow_any_instance_of(Defmastership::Modifier::ModifierCommon).to(receive(:do_modifications).and_return(adoc_sources))
+
+        modifier.do_modifications(adoc_sources)
+      end
+
+      it { expect(Defmastership::Document).to(have_received(:new).once) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('ref_doc.adoc')) }
+
+      it 'call the parent method' do
+        expect_any_instance_of(Defmastership::Modifier::ModifierCommon).to(receive(:do_modifications).with(adoc_sources))
+        modifier.do_modifications(adoc_sources)
+      end
+    end
+
+    context 'when more ref docs' do
+      subject(:modifier) { described_class.new({ ref_document: ['ref_doc1.adoc', 'ref_doc2.adoc'] }) }
+
+      let(:ref_document)   { instance_double(Defmastership::Document, 'ref_document') }
+      let(:adoc_sources) do
+        {
+          'file1.adoc' => 'pouet',
+          'file2.adoc' => 'tagada'
+        }
+      end
+
+      before do
+        allow(Defmastership::Document).to(receive(:new).once.and_return(ref_document))
+        allow(ref_document).to(receive(:parse_file_with_preprocessor))
+
+        modifier.do_modifications(adoc_sources)
+      end
+
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('ref_doc1.adoc')) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('ref_doc2.adoc')) }
+    end
+  end
+
+  describe '#replace_erefs' do
+    subject(:modifier) { described_class.new({ ref_document: 'ref_doc.adoc' }) }
+
+    let(:ref_document)   { instance_double(Defmastership::Document, 'document')     }
+    let(:ref_definition) { instance_double(Defmastership::Definition, 'definition') }
+
+    before do
+      allow(Defmastership::Document).to(receive(:new).and_return(ref_document))
+    end
+
+    context 'when the line is matching one external ref definition with only one ref' do
+      before do
+        allow(ref_document).to(receive(:ref_to_def).and_return(ref_definition))
+        allow(ref_definition).to(receive(:sha256_short).and_return('~a1b2c3d4'))
+      end
+
+      [
+        ['',             '(~a1b2c3d4)'],
+        ['(~abcd1234)',  '(~a1b2c3d4)'],
+        ['(a)',          '(a~a1b2c3d4)'],
+        ['(a~abcd1234)', '(a~a1b2c3d4)']
+      ].each do |from, to|
+        it do
+          modifier.replace_erefs('', "defs:eref[type, [THE_REF#{from}]]")
+          expect(ref_document).to(have_received(:ref_to_def).with('THE_REF'))
+        end
+
+        it do
+          modifier.replace_erefs('', "defs:eref[type, [THE_REF#{from}]]")
+          expect(ref_definition).to(have_received(:sha256_short))
+        end
+
+        it do
+          expect(
+            modifier.replace_erefs('', "defs:eref[type, [THE_REF#{from}]]")
+          ).to(eq("defs:eref[type, [THE_REF#{to}]]"))
+        end
+      end
+    end
+
+    context 'when the definition does not exist' do
+      before do
+        allow(ref_document).to(receive(:ref_to_def).and_return(nil))
+      end
+
+      it do
+        modifier.replace_erefs('', 'defs:eref[type, [BAD_REF(a~abcd1234)]]')
+        expect(ref_document).to(have_received(:ref_to_def).with('BAD_REF'))
+      end
+
+      it do
+        expect(modifier.replace_erefs('', 'defs:eref[type, [BAD_REF(a~abcd1234)]]'))
+          .to(eq('defs:eref[type, [BAD_REF(a~abcd1234)]]'))
+      end
+
+      it { expect(modifier.replace_erefs('', 'defs:eref[type, [BAD_REF]]')).to(eq('defs:eref[type, [BAD_REF]]')) }
+      it { expect(modifier.replace_erefs('', 'defs:eref[type, [BAD_REF(a)]]')).to(eq('defs:eref[type, [BAD_REF(a)]]')) }
+    end
+
+    context 'when the line is not a valid eref' do
+      it { expect(modifier.replace_erefs('', 'bla bla')).to(eq('bla bla')) }
+    end
+
+    context 'when the line is matching one external ref definition with more refs' do
+      let(:other_ref_definition) { instance_double(Defmastership::Definition, 'other_ref_definition') }
+
+      before do
+        allow(ref_document).to(receive(:ref_to_def).with('REF1').and_return(ref_definition))
+        allow(ref_document).to(receive(:ref_to_def).with('REF2').and_return(other_ref_definition))
+        allow(ref_definition).to(receive(:sha256_short).and_return('~a1b2c3d4'))
+        allow(other_ref_definition).to(receive(:sha256_short).and_return('~e5f6abcd'))
+        modifier.replace_erefs('', 'defs:eref[type, [REF1, REF2]]')
+      end
+
+      it { expect(ref_document).to(have_received(:ref_to_def).with('REF1')) }
+      it { expect(ref_document).to(have_received(:ref_to_def).with('REF2')) }
+      it { expect(ref_definition).to(have_received(:sha256_short)) }
+      it { expect(other_ref_definition).to(have_received(:sha256_short)) }
+
+      it do
+        expect(modifier.replace_erefs('', 'defs:eref[type, [REF1, REF2]]'))
+          .to(eq('defs:eref[type, [REF1(~a1b2c3d4), REF2(~e5f6abcd)]]'))
+      end
+    end
+
+    context 'when the modifier modifies only one eref_type' do
+      subject(:modifier) { described_class.new({ eref_type: 'implements', ref_document: 'ref_doc.adoc' }) }
+
+      let(:ref_document)   { instance_double(Defmastership::Document, 'document')       }
+      let(:ref_definition) { instance_double(Defmastership::Definition, 'definition')   }
+
+      before do
+        allow(ref_document).to(receive(:ref_to_def).with('REF').and_return(ref_definition))
+        allow(ref_definition).to(receive(:sha256_short).and_return('~a1b2c3d4'))
+      end
+
+      it do
+        expect(
+          modifier.replace_erefs('', 'defs:eref[implements, [REF]]')
+        ).to(eq('defs:eref[implements, [REF(~a1b2c3d4)]]'))
+      end
+
+      it { expect(modifier.replace_erefs('', 'defs:eref[covers, [REF]]')).to(eq('defs:eref[covers, [REF]]')) }
+    end
+
+    context 'when the modifier modifies more than one eref_type' do
+      subject(:modifier) { described_class.new({ eref_type: %w[implements covers], ref_document: 'ref_doc.adoc' }) }
+
+      let(:ref_document) { instance_double(Defmastership::Document, 'document') }
+      let(:ref_definition) { instance_double(Defmastership::Definition, 'definition') }
+
+      before do
+        allow(ref_document).to(receive(:ref_to_def).with('REF').and_return(ref_definition))
+        allow(ref_definition).to(receive(:sha256_short).and_return('~a1b2c3d4'))
+      end
+
+      it do
+        expect(
+          modifier.replace_erefs('', 'defs:eref[implements, [REF]]')
+        ).to(eq('defs:eref[implements, [REF(~a1b2c3d4)]]'))
+      end
+
+      it do
+        expect(modifier.replace_erefs('', 'defs:eref[covers, [REF]]')).to(eq('defs:eref[covers, [REF(~a1b2c3d4)]]'))
+      end
+
+      it { expect(modifier.replace_erefs('', 'defs:eref[covers_not, [REF]]')).to(eq('defs:eref[covers_not, [REF]]')) }
+    end
+  end
+end

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

@@ -0,0 +1,227 @@
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/document')
+require('defmastership/modifier/update_eref_version')
+
+RSpec.describe(Defmastership::Modifier::UpdateErefVersion) do
+  describe '.new' do
+    context 'when default config' do
+      subject(:modifier) { described_class.new({}) }
+
+      it { is_expected.not_to(be_nil) }
+      it { expect(described_class.ancestors).to(include(Defmastership::Modifier::ModifierCommon)) }
+      it { is_expected.to(have_attributes(config: { eref_type: '', ref_document: '' })) }
+    end
+
+    context 'when config with simple options' do
+      subject(:modifier) { described_class.new({ eref_type: 'type', ref_document: 'ref.adoc' }) }
+
+      it { is_expected.to(have_attributes(config: { eref_type: 'type', ref_document: 'ref.adoc' })) }
+    end
+  end
+
+  describe '.replacement_methods' do
+    it { expect(described_class.replacement_methods).to(eq(%i[replace_erefs])) }
+  end
+
+  describe '#do_modifications' do
+    context 'when only one ref doc' do
+      subject(:modifier) { described_class.new({ ref_document: 'ref_doc.adoc' }) }
+
+      let(:ref_document)   { instance_double(Defmastership::Document, 'ref_document') }
+      let(:adoc_sources) do
+        {
+          'file1.adoc' => 'pouet',
+          'file2.adoc' => 'tagada'
+        }
+      end
+
+      before do
+        allow(Defmastership::Document).to(receive(:new).once.and_return(ref_document))
+        allow(ref_document).to(receive(:parse_file_with_preprocessor))
+        allow_any_instance_of(Defmastership::Modifier::ModifierCommon).to(receive(:do_modifications).and_return(adoc_sources))
+
+        modifier.do_modifications(adoc_sources)
+      end
+
+      it { expect(Defmastership::Document).to(have_received(:new).once) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('ref_doc.adoc')) }
+
+      it 'call the parent method' do
+        expect_any_instance_of(Defmastership::Modifier::ModifierCommon).to(receive(:do_modifications).with(adoc_sources))
+        modifier.do_modifications(adoc_sources)
+      end
+    end
+
+    context 'when more ref docs' do
+      subject(:modifier) { described_class.new({ ref_document: ['ref_doc1.adoc', 'ref_doc2.adoc'] }) }
+
+      let(:ref_document)   { instance_double(Defmastership::Document, 'ref_document') }
+      let(:adoc_sources) do
+        {
+          'file1.adoc' => 'pouet',
+          'file2.adoc' => 'tagada'
+        }
+      end
+
+      before do
+        allow(Defmastership::Document).to(receive(:new).once.and_return(ref_document))
+        allow(ref_document).to(receive(:parse_file_with_preprocessor))
+
+        modifier.do_modifications(adoc_sources)
+      end
+
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('ref_doc1.adoc')) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('ref_doc2.adoc')) }
+    end
+  end
+
+  describe '#replace_erefs' do
+    subject(:modifier) { described_class.new({ ref_document: 'ref_doc.adoc' }) }
+
+    let(:ref_document)   { instance_double(Defmastership::Document, 'document')     }
+    let(:ref_definition) { instance_double(Defmastership::Definition, 'definition') }
+
+    before do
+      allow(Defmastership::Document).to(receive(:new).and_return(ref_document))
+    end
+
+    context 'when the line is matching one external ref definition with only one ref' do
+      before do
+        allow(ref_document).to(receive(:ref_to_def).and_return(ref_definition))
+        allow(ref_definition).to(receive(:explicit_version).and_return('z'))
+      end
+
+      [
+        ['',             '(z)'],
+        ['(~abcd1234)',  '(z~abcd1234)'],
+        ['(a)',          '(z)'],
+        ['(a~abcd1234)', '(z~abcd1234)']
+      ].each do |from, to|
+        it do
+          modifier.replace_erefs('', "defs:eref[type, [THE_REF#{from}]]")
+          expect(ref_document).to(have_received(:ref_to_def).with('THE_REF'))
+        end
+
+        it do
+          modifier.replace_erefs('', "defs:eref[type, [THE_REF#{from}]]")
+          expect(ref_definition).to(have_received(:explicit_version))
+        end
+
+        it do
+          expect(
+            modifier.replace_erefs('', "defs:eref[type, [THE_REF#{from}]]")
+          ).to(eq("defs:eref[type, [THE_REF#{to}]]"))
+        end
+      end
+    end
+
+    context 'when the line is matching one external ref definition with only one ref withot version' do
+      before do
+        allow(ref_document).to(receive(:ref_to_def).and_return(ref_definition))
+        allow(ref_definition).to(receive(:explicit_version).and_return(nil))
+      end
+
+      [
+        ['',             ''],
+        ['(~abcd1234)',  '(~abcd1234)'],
+        ['(a)',          ''],
+        ['(a~abcd1234)', '(~abcd1234)']
+      ].each do |from, to|
+        it do
+          modifier.replace_erefs('', "defs:eref[type, [THE_REF#{from}]]")
+          expect(ref_document).to(have_received(:ref_to_def).with('THE_REF'))
+        end
+
+        it do
+          modifier.replace_erefs('', "defs:eref[type, [THE_REF#{from}]]")
+          expect(ref_definition).to(have_received(:explicit_version))
+        end
+
+        it do
+          expect(
+            modifier.replace_erefs('', "defs:eref[type, [THE_REF#{from}]]")
+          ).to(eq("defs:eref[type, [THE_REF#{to}]]"))
+        end
+      end
+    end
+
+    context 'when the definition does not exist' do
+      before do
+        allow(ref_document).to(receive(:ref_to_def).and_return(nil))
+      end
+
+      it do
+        modifier.replace_erefs('', 'defs:eref[type, [BAD_REF(a)]]')
+        expect(ref_document).to(have_received(:ref_to_def).with('BAD_REF'))
+      end
+
+      it { expect(modifier.replace_erefs('', 'defs:eref[type, [BAD_REF(a)]]')).to(eq('defs:eref[type, [BAD_REF(a)]]')) }
+    end
+
+    context 'when the line is not a valid eref' do
+      it { expect(modifier.replace_erefs('', 'bla bla')).to(eq('bla bla')) }
+    end
+
+    context 'when the line is matching one external ref definition with more refs' do
+      let(:other_ref_definition) { instance_double(Defmastership::Definition, 'other_ref_definition') }
+
+      before do
+        allow(ref_document).to(receive(:ref_to_def).with('REF1').and_return(ref_definition))
+        allow(ref_document).to(receive(:ref_to_def).with('REF2').and_return(other_ref_definition))
+        allow(ref_definition).to(receive(:explicit_version).and_return('a'))
+        allow(other_ref_definition).to(receive(:explicit_version).and_return('z'))
+        modifier.replace_erefs('', 'defs:eref[type, [REF1, REF2]]')
+      end
+
+      it { expect(ref_document).to(have_received(:ref_to_def).with('REF1')) }
+      it { expect(ref_document).to(have_received(:ref_to_def).with('REF2')) }
+      it { expect(ref_definition).to(have_received(:explicit_version)) }
+      it { expect(other_ref_definition).to(have_received(:explicit_version)) }
+
+      it do
+        expect(
+          modifier.replace_erefs('', 'defs:eref[type, [REF1, REF2]]')
+        ).to(eq('defs:eref[type, [REF1(a), REF2(z)]]'))
+      end
+    end
+
+    context 'when the modifier modifies only one eref_type' do
+      subject(:modifier) { described_class.new({ eref_type: 'implements', ref_document: 'ref_doc.adoc' }) }
+
+      let(:ref_document)   { instance_double(Defmastership::Document, 'document')       }
+      let(:ref_definition) { instance_double(Defmastership::Definition, 'definition')   }
+
+      before do
+        allow(ref_document).to(receive(:ref_to_def).with('REF').and_return(ref_definition))
+        allow(ref_definition).to(receive(:explicit_version).and_return('a'))
+      end
+
+      it do
+        expect(modifier.replace_erefs('', 'defs:eref[implements, [REF]]')).to(eq('defs:eref[implements, [REF(a)]]'))
+      end
+
+      it { expect(modifier.replace_erefs('', 'defs:eref[covers, [REF]]')).to(eq('defs:eref[covers, [REF]]')) }
+    end
+
+    context 'when the modifier modifies more than one eref_type' do
+      subject(:modifier) { described_class.new({ eref_type: %w[implements covers], ref_document: 'ref_doc.adoc' }) }
+
+      let(:ref_document) { instance_double(Defmastership::Document, 'document') }
+      let(:ref_definition) { instance_double(Defmastership::Definition, 'definition') }
+
+      before do
+        allow(ref_document).to(receive(:ref_to_def).with('REF').and_return(ref_definition))
+        allow(ref_definition).to(receive(:explicit_version).and_return('a'))
+      end
+
+      it do
+        expect(modifier.replace_erefs('', 'defs:eref[implements, [REF]]')).to(eq('defs:eref[implements, [REF(a)]]'))
+      end
+
+      it { expect(modifier.replace_erefs('', 'defs:eref[covers, [REF]]')).to(eq('defs:eref[covers, [REF(a)]]')) }
+      it { expect(modifier.replace_erefs('', 'defs:eref[covers_not, [REF]]')).to(eq('defs:eref[covers_not, [REF]]')) }
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/modifier/update_iref_checksum')
+
+RSpec.describe(Defmastership::Modifier::UpdateIrefChecksum) do
+  subject(:modifier) { described_class.new({}) }
+
+  describe '.new' do
+    it { is_expected.not_to(be_nil) }
+    it { expect(described_class.ancestors).to(include(Defmastership::Modifier::ModifierCommon)) }
+    it { is_expected.to(have_attributes(config: {})) }
+  end
+
+  describe '.replacement_methods' do
+    it { expect(described_class.replacement_methods).to(eq(%i[replace_irefs])) }
+  end
+
+  describe '#do_modifications' do
+    let(:document) { instance_double(Defmastership::Document, 'document') }
+    let(:adoc_sources) do
+      {
+        'file1.adoc' => 'pouet',
+        'file2.adoc' => 'tagada'
+      }
+    end
+
+    before do
+      allow(Defmastership::Document).to(receive(:new).and_return(document))
+      allow(document).to(receive(:parse_file_with_preprocessor))
+      allow_any_instance_of(Defmastership::Modifier::ModifierCommon).to(receive(:do_modifications).and_return(adoc_sources))
+
+      modifier.do_modifications(adoc_sources)
+    end
+
+    it { expect(Defmastership::Document).to(have_received(:new)) }
+
+    it do
+      expect(document).to(
+        have_received(:parse_file_with_preprocessor)
+          .once.with('file1.adoc')
+          .once.with('file2.adoc')
+      )
+    end
+
+    it { expect(modifier.do_modifications(adoc_sources)).to(eq(adoc_sources)) }
+
+    it 'call the parent method' do
+      expect_any_instance_of(Defmastership::Modifier::ModifierCommon).to(receive(:do_modifications).with(adoc_sources))
+      modifier.do_modifications(adoc_sources)
+    end
+  end
+
+  describe '#replace_irefs' do
+    let(:document) { instance_double(Defmastership::Document, 'document') }
+    let(:definition) { instance_double(Defmastership::Definition, 'definition') }
+
+    before do
+      allow(Defmastership::Document).to(receive(:new).and_return(document))
+    end
+
+    context 'when the line is matching a good internal ref definition' do
+      before do
+        allow(document).to(receive(:ref_to_def).and_return(definition))
+        allow(definition).to(receive(:sha256_short).and_return('~a1b2c3d4'))
+      end
+
+      [
+        ['',             '(~a1b2c3d4)'],
+        ['(~abcd1234)',  '(~a1b2c3d4)'],
+        ['(a)',          '(a~a1b2c3d4)'],
+        ['(a~abcd1234)', '(a~a1b2c3d4)']
+      ].each do |from, to|
+        it do
+          modifier.replace_irefs('', "whatever defs:iref[THE_REF#{from}] whatever")
+          expect(document).to(have_received(:ref_to_def).with('THE_REF'))
+        end
+
+        it do
+          modifier.replace_irefs('', "whatever defs:iref[THE_REF#{from}] whatever")
+          expect(definition).to(have_received(:sha256_short))
+        end
+
+        it {
+          expect(modifier.replace_irefs('', "whatever defs:iref[THE_REF#{from}] whatever"))
+            .to(eq("whatever defs:iref[THE_REF#{to}] whatever"))
+        }
+      end
+    end
+
+    context 'when the definition does not exist' do
+      before do
+        allow(document).to(receive(:ref_to_def).and_return(nil))
+      end
+
+      it do
+        modifier.replace_irefs('', 'whatever defs:iref[BAD_REF(a~abcd1234)] whatever')
+        expect(document).to(have_received(:ref_to_def).with('BAD_REF'))
+      end
+
+      it {
+        expect(modifier.replace_irefs('', 'whatever defs:iref[BAD_REF(a~abcd1234)] whatever'))
+          .to(eq('whatever defs:iref[BAD_REF(a~abcd1234)] whatever'))
+      }
+    end
+
+    context 'when the line is not a valid iref' do
+      it { expect(modifier.replace_irefs('', 'bla bla')).to(eq('bla bla')) }
+    end
+
+    context 'when the line is matching more than one iref' do
+      let(:other_definition) { instance_double(Defmastership::Definition, 'other_definition') }
+
+      before do
+        allow(document).to(receive(:ref_to_def).with('REF1').and_return(definition))
+        allow(document).to(receive(:ref_to_def).with('REF2').and_return(other_definition))
+        allow(definition).to(receive(:sha256_short).and_return('~a1b2c3d4'))
+        allow(other_definition).to(receive(:sha256_short).and_return('~e5f6abcd'))
+        modifier.replace_irefs('', 'defs:iref[REF1], defs:iref[REF2]')
+      end
+
+      it { expect(document).to(have_received(:ref_to_def).with('REF1')) }
+      it { expect(document).to(have_received(:ref_to_def).with('REF2')) }
+      it { expect(definition).to(have_received(:sha256_short)) }
+      it { expect(other_definition).to(have_received(:sha256_short)) }
+
+      it {
+        expect(modifier.replace_irefs('', 'defs:iref[REF1], defs:iref[REF2]'))
+          .to(eq('defs:iref[REF1(~a1b2c3d4)], defs:iref[REF2(~e5f6abcd)]'))
+      }
+    end
+  end
+end