defmastership 1.0.5 → 1.0.10

data/spec/unit/defmastership/rename_included_files_line_modifier_spec.rb

@@ -0,0 +1,203 @@
+# Copyright (c) 2021 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
+  subject(:includeschanger) { described_class.new }
+
+  describe '.new' do
+    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(changes:     [])) }
+    it { expect { includeschanger.user_defined_attribute }.to(raise_error(NoMethodError)) }
+  end
+
+  describe '.from_config' do
+    subject(:includeschanger) do
+      described_class.from_config(
+        from_regexp: 'Whatever.+',
+        to_template: 'Whatever'
+      )
+    end
+
+    it { is_expected.not_to(be(nil)) }
+    it { is_expected.to(have_attributes(from_regexp: 'Whatever.+')) }
+    it { is_expected.to(have_attributes(to_template: 'Whatever')) }
+  end
+
+  describe '#replace' do
+    context 'when NOT valid include' do
+      before do
+        includeschanger.from_config(
+          from_regexp: 'orig',
+          cancel_if_match: 'REF',
+          to_template: 'dest'
+        )
+        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 cancel regexp is met' do
+        before do
+          ['[define,requirement,REFERENCE]', '--'].each do |line|
+            includeschanger.replace(line)
+          end
+        end
+
+        it do
+          expect(includeschanger.replace('include::REFERENCE_orig[]'))
+            .to(eq('include::REFERENCE_orig[]'))
+        end
+
+        it do
+          includeschanger.replace('include::REFERENCE_orig[]')
+          expect(includeschanger).to(have_attributes(changes: []))
+        end
+      end
+    end
+
+    context 'when valid include' do
+      before do
+        allow(File).to(receive(:rename))
+      end
+
+      context 'when really simple rule' do
+        before do
+          includeschanger.from_config(
+            from_regexp: 'orig',
+            cancel_if_match: 'REF',
+            to_template: 'dest'
+          )
+          includeschanger.replace('[define,requirement,REFERENCE]')
+          includeschanger.replace('--')
+        end
+
+        it do
+          expect(includeschanger.replace('include::orig[]'))
+            .to(eq('include::dest[]'))
+        end
+
+        it do
+          includeschanger.replace('include::orig[]')
+          expect(File).to(have_received(:rename).with('orig', 'dest'))
+        end
+
+        it do
+          includeschanger.replace('include::orig[]')
+          expect(includeschanger).to(have_attributes(changes: [%w[orig dest]]))
+        end
+
+        it do
+          expect(includeschanger.replace('include::toto/orig[]'))
+            .to(eq('include::toto/dest[]'))
+        end
+
+        it do
+          includeschanger.replace('include::toto/orig[]')
+          expect(File).to(have_received(:rename).with('toto/orig', 'toto/dest'))
+        end
+
+        it do
+          includeschanger.replace('include::toto/orig[]')
+          expect(includeschanger).to(have_attributes(changes: [%w[toto/orig toto/dest]]))
+        end
+      end
+
+      context 'when complex from_regexp' do
+        before do
+          includeschanger.from_config(
+            from_regexp: '(?<origin>.*\.extension)',
+            to_template: '%<reference>s_%<origin>s'
+          )
+          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
+        before do
+          includeschanger.from_config(
+            from_regexp: 'orig',
+            to_template: 'dest'
+          )
+          includeschanger.replace(':any: one')
+          includeschanger.replace(':path: two')
+          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}/orig[]')
+          expect(File).to(have_received(:rename).with('one/orig', 'one/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
+          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/defmastership/rename_included_files_modifier_spec.rb

@@ -0,0 +1,67 @@
+# Copyright (c) 2021 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership')
+
+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
+
+  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: [])) }
+  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
+
+    context 'when detailed expectations' do
+      before { modifier.do_modifications(adoc_texts) }
+
+      it do
+        expect(DefMastership::RenameIncludedFilesLineModifier).to(
+          have_received(:from_config).with('fake config')
+        )
+      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]])) }
+    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))
+    end
+  end
+end

data/spec/unit/defmastership/update_def_checksum_line_modifier_spec.rb

@@ -0,0 +1,78 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::UpdateDefChecksumLineModifier) do
+  subject(:linemodifier) { described_class.new }
+
+  describe '.new' do
+    it { is_expected.not_to(be(nil)) }
+    it { is_expected.to(have_attributes(def_type: '')) }
+    it { is_expected.to(have_attributes(changes:  [])) }
+    it { expect { linemodifier.user_defined_attribute }.to(raise_error(NoMethodError)) }
+  end
+
+  describe '.from_config' do
+    subject(:linemodifier) do
+      described_class.from_config(
+        def_type: 'requirement'
+      )
+    end
+
+    it { is_expected.not_to(be(nil)) }
+    it { is_expected.to(have_attributes(def_type: 'requirement')) }
+    it { is_expected.to(have_attributes(document: nil)) }
+  end
+
+  describe '#replace' do
+    subject(:linemodifier) do
+      described_class.from_config(
+        def_type: 'requirement'
+      )
+    end
+
+    let(:definition)  { instance_double(DefMastership::Definition, 'definition') }
+    let(:document)    { instance_double(DefMastership::Document, 'document')     }
+    let(:definitions) { { 'REFERENCE' => definition }                            }
+
+    before do
+      linemodifier.document = document
+      allow(File).to(receive(:rename))
+    end
+
+    context 'when definition has not the good type' do
+      it do
+        expect(linemodifier.replace('[define,req,REFERENCE]'))
+          .to(eq('[define,req,REFERENCE]'))
+      end
+    end
+
+    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).and_return('~abcd1234'))
+      end
+
+      it do
+        expect(linemodifier.replace('[define,requirement,REFERENCE]'))
+          .to(eq('[define,requirement,REFERENCE(~abcd1234)]'))
+      end
+
+      it do
+        expect(linemodifier.replace('[define,requirement,REFERENCE(~bad)]'))
+          .to(eq('[define,requirement,REFERENCE(~abcd1234)]'))
+      end
+
+      it do
+        expect(linemodifier.replace('[define,requirement,REFERENCE(toto~bad)]'))
+          .to(eq('[define,requirement,REFERENCE(toto~abcd1234)]'))
+      end
+
+      it do
+        expect(linemodifier.replace('[define,requirement,REFERENCE(toto)]'))
+          .to(eq('[define,requirement,REFERENCE(toto~abcd1234)]'))
+      end
+    end
+  end
+end

data/spec/unit/defmastership/update_def_checksum_modifier_spec.rb

@@ -0,0 +1,75 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::UpdateDefChecksumModifier) 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
+
+  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: [])) }
+  end
+
+  describe '#do_modifications' do
+    let(:line_modifier) { instance_double(DefMastership::UpdateDefChecksumLineModifier, 'lineModifier') }
+    let(:document)      { instance_double(DefMastership::Document, 'document')                          }
+
+    before do
+      allow(DefMastership::UpdateDefChecksumLineModifier).to(
+        receive(:from_config).with('fake config').and_return(line_modifier)
+      )
+      allow(DefMastership::Document).to(receive(:new).and_return(document))
+      allow(document).to(receive(:parse_file_with_preprocessor))
+      allow(line_modifier).to(receive(:'document=').with(document))
+      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(:config).and_return('new fake config'))
+      allow(line_modifier).to(receive(:changes).and_return([%w[from1 to1], %w[from2 to2]]))
+    end
+
+    context 'when detailed expectations' do
+      before { modifier.do_modifications(adoc_texts) }
+
+      it do
+        expect(DefMastership::UpdateDefChecksumLineModifier).to(
+          have_received(:from_config).with('fake config')
+        )
+      end
+
+      it { expect(document).to(have_received(:parse_file_with_preprocessor).with('file1.adoc')) }
+      it { expect(document).to(have_received(:parse_file_with_preprocessor).with('file2.adoc')) }
+      it { expect(line_modifier).to(have_received(:'document=').with(document)) }
+      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(: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]])) }
+    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))
+    end
+  end
+end

data/spec/unit/defmastership/update_def_version_line_modifier_spec.rb

@@ -0,0 +1,127 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::UpdateDefVersionLineModifier) do
+  subject(:linemodifier) { described_class.new }
+
+  describe '.new' do
+    it { is_expected.not_to(be(nil)) }
+    it { is_expected.to(have_attributes(def_type: '')) }
+    it { is_expected.to(have_attributes(changes:  [])) }
+    it { expect { linemodifier.user_defined_attribute }.to(raise_error(NoMethodError)) }
+  end
+
+  describe '.from_config' do
+    subject(:linemodifier) do
+      described_class.from_config(
+        def_type: 'requirement',
+        first_version: 'a'
+      )
+    end
+
+    it { is_expected.not_to(be(nil)) }
+    it { is_expected.to(have_attributes(def_type: 'requirement')) }
+    it { is_expected.to(have_attributes(first_version: 'a')) }
+    it { is_expected.to(have_attributes(document: nil)) }
+    it { is_expected.to(have_attributes(ref_document: nil)) }
+  end
+
+  describe '#replace' do
+    subject(:linemodifier) do
+      described_class.from_config(
+        def_type: 'requirement',
+        first_version: 'a'
+      )
+    end
+
+    let(:document)       { instance_double(DefMastership::Document, 'document')          }
+    let(:ref_document)   { instance_double(DefMastership::Document, 'ref_document')      }
+    let(:definition)     { instance_double(DefMastership::Definition, 'definition')      }
+    let(:ref_definition) { instance_double(DefMastership::Definition, 'ref_definitions') }
+
+    before do
+      linemodifier.document = document
+      linemodifier.ref_document = ref_document
+      allow(File).to(receive(:rename))
+    end
+
+    context 'when definition has not the good type' do
+      it do
+        expect(linemodifier.replace('[define,req,REFERENCE]'))
+          .to(eq('[define,req,REFERENCE]'))
+      end
+    end
+
+    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).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).and_return('~abcd1234'))
+        end
+
+        it do
+          allow(ref_definition).to(receive(:explicit_version).and_return(nil))
+          expect(linemodifier.replace('[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE]'))
+        end
+
+        it do
+          allow(ref_definition).to(receive(:explicit_version).and_return('c'))
+          expect(linemodifier.replace('[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE(c)]'))
+        end
+
+        it do
+          allow(ref_definition).to(receive(:explicit_version).and_return('c'))
+          expect(linemodifier.replace('[define,requirement,REFERENCE(tyty~1234)]'))
+            .to(eq('[define,requirement,REFERENCE(c~1234)]'))
+        end
+      end
+
+      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).and_return('~4321aaaa'))
+        end
+
+        [
+          [nil,    '',            '(a)'],
+          ['c',    '',            '(d)'],
+          ['c',    '(tyty~1234)', '(d~1234)'],
+          ['2',    '',            '(3)'],
+          ['1222', '',            '(1223)'],
+          ['abb',  '',            '(abc)']
+        ].each do |ref, from, to|
+          it do
+            allow(ref_definition).to(receive(:explicit_version).and_return(ref))
+            expect(linemodifier.replace("[define,requirement,REFERENCE#{from}]"))
+              .to(eq("[define,requirement,REFERENCE#{to}]"))
+          end
+        end
+      end
+
+      context 'when definition is new' do
+        before do
+          allow(ref_document).to(receive(:ref_to_def).with('REFERENCE').and_return(nil))
+        end
+
+        it do
+          expect(linemodifier.replace('[define,requirement,REFERENCE(whatever)]'))
+            .to(eq('[define,requirement,REFERENCE]'))
+        end
+
+        it do
+          expect(linemodifier.replace('[define,requirement,REFERENCE(~1234)]'))
+            .to(eq('[define,requirement,REFERENCE(~1234)]'))
+        end
+      end
+    end
+  end
+end