defmastership 1.0.17 → 1.0.18

data/spec/unit/def_mastership/rename_included_files_line_modifier_spec.rb

@@ -1,207 +0,0 @@
-# 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 do
-      expect { includeschanger.user_defined_attribute }
-        .to(raise_error(NoMethodError))
-    end
-  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[]\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
-          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
-        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/def_mastership/update_def_checksum_line_modifier_spec.rb

@@ -1,82 +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 do
-      expect { linemodifier.user_defined_attribute }
-        .to(raise_error(NoMethodError))
-    end
-  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/def_mastership/update_def_version_line_modifier_spec.rb

@@ -1,131 +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 do
-      expect { linemodifier.user_defined_attribute }
-        .to(raise_error(NoMethodError))
-    end
-  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