defmastership 1.0.16 → 1.0.18

data/spec/unit/defmastership/change_ref_modifier_spec.rb

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

data/spec/unit/defmastership/rename_included_files_modifier_spec.rb

@@ -1,67 +0,0 @@
-# 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

@@ -1,78 +0,0 @@
-# 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

@@ -1,75 +0,0 @@
-# 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

@@ -1,127 +0,0 @@
-# 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

data/spec/unit/defmastership/update_def_version_modifier_spec.rb

@@ -1,80 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require('defmastership')
-
-RSpec.describe(DefMastership::UpdateDefVersionModifier) do
-  subject(:modifier) do
-    described_class.new(
-      ref_document: 'ref.adoc'
-    )
-  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: { ref_document: 'ref.adoc' })) }
-    it { is_expected.to(have_attributes(changes: [])) }
-  end
-
-  describe '#do_modifications' do
-    let(:line_modifier) { instance_double(DefMastership::UpdateDefVersionLineModifier, 'lineModifier') }
-    let(:document)      { instance_double(DefMastership::Document, 'document')                         }
-    let(:ref_document)  { instance_double(DefMastership::Document, 'ref_document')                     }
-
-    before do
-      allow(DefMastership::UpdateDefVersionLineModifier).to(
-        receive(:from_config).with(ref_document: 'ref.adoc').and_return(line_modifier)
-      )
-      allow(DefMastership::Document).to(receive(:new).and_return(document, ref_document))
-      allow(document).to(receive(:parse_file_with_preprocessor))
-      allow(ref_document).to(receive(:parse_file_with_preprocessor))
-      allow(line_modifier).to(receive(:'document=').with(document))
-      allow(line_modifier).to(receive(:'ref_document=').with(ref_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(ref_document: 'ref.adoc'))
-      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::UpdateDefVersionLineModifier).to(
-          have_received(:from_config).with(ref_document: 'ref.adoc')
-        )
-      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(ref_document).to(have_received(:parse_file_with_preprocessor).with('ref.adoc')) }
-      it { expect(line_modifier).to(have_received(:'document=').with(document)) }
-      it { expect(line_modifier).to(have_received(:'ref_document=').with(ref_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: { ref_document: 'ref.adoc' })) }
-      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