defmastership 1.0.3 → 1.0.8

data/spec/unit/defmastership/document_spec.rb

@@ -1,8 +1,11 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
 require('defmastership')
 
 RSpec.describe(DefMastership::Document) do
+  subject(:document) { described_class.new }
+
   describe '.new' do
     it { is_expected.not_to(be(nil)) }
     it { is_expected.to(have_attributes(definitions: [])) }
@@ -13,8 +16,6 @@ RSpec.describe(DefMastership::Document) do
   end
 
   describe '#parse' do
-    subject(:document) { described_class.new }
-
     context 'with valid definitions' do
       let(:definition) { instance_double(DefMastership::Definition, 'definition') }
 
@@ -30,22 +31,66 @@ RSpec.describe(DefMastership::Document) do
         let(:input_lines) { ['[define, requirement, TOTO-0001]'] }
 
         before do
-          allow(DefMastership::Definition).to(receive(:new).with(
-            matchdata_including(
-              type: 'requirement',
-              reference: 'TOTO-0001'
-            )
-          ).and_return(definition))
+          allow(DefMastership::Definition).to(
+            receive(:new).with(
+              matchdata_including(type: 'requirement', reference: 'TOTO-0001')
+            ).and_return(definition)
+          )
           document.parse(input_lines)
         end
 
         it do
-          expect(DefMastership::Definition).to(have_received(:new).with(
-                                                 matchdata_including(type: 'requirement', reference: 'TOTO-0001')
-                                               ))
+          expect(DefMastership::Definition).to(
+            have_received(:new).with(
+              matchdata_including(type: 'requirement', reference: 'TOTO-0001')
+            )
+          )
         end
 
         it { expect(document).to(have_attributes(definitions: [definition])) }
+        it { expect(definition).to(have_received(:labels)) }
+      end
+
+      context 'when simple definition line with explicit checksum' do
+        let(:input_lines) { ['[define, requirement, TOTO-0001(~ab12)]'] }
+
+        before do
+          allow(DefMastership::Definition).to(
+            receive(:new).with(
+              matchdata_including(type: 'requirement', reference: 'TOTO-0001', explicit_checksum: '~ab12')
+            ).and_return(definition)
+          )
+          document.parse(input_lines)
+        end
+
+        it do
+          expect(DefMastership::Definition).to(
+            have_received(:new).with(
+              matchdata_including(type: 'requirement', reference: 'TOTO-0001', explicit_checksum: '~ab12')
+            )
+          )
+        end
+      end
+
+      context 'when simple definition line with explicit version' do
+        let(:input_lines) { ['[define, requirement, TOTO-0001(pouet)]'] }
+
+        before do
+          allow(DefMastership::Definition).to(
+            receive(:new).with(
+              matchdata_including(type: 'requirement', reference: 'TOTO-0001', explicit_version: 'pouet')
+            ).and_return(definition)
+          )
+          document.parse(input_lines)
+        end
+
+        it do
+          expect(DefMastership::Definition).to(
+            have_received(:new).with(
+              matchdata_including(type: 'requirement', reference: 'TOTO-0001', explicit_version: 'pouet')
+            )
+          )
+        end
       end
 
       context 'when complete definition with content' do
@@ -132,11 +177,11 @@ RSpec.describe(DefMastership::Document) do
         end
 
         it do
-          expect(DefMastership::Definition).to(have_received(:new).with(matchdata_including(
-                                                                          type: 'requirement',
-                                                                          reference: 'TOTO-0001',
-                                                                          labels: 'label1, label2'
-                                                                        )))
+          expect(DefMastership::Definition).to(
+            have_received(:new).with(
+              matchdata_including(type: 'requirement', reference: 'TOTO-0001', labels: 'label1, label2')
+            )
+          )
         end
 
         it { expect(document.labels).to(eq(Set['bla1', 'bla2'])) }
@@ -157,11 +202,11 @@ RSpec.describe(DefMastership::Document) do
         end
 
         it do
-          expect(DefMastership::Definition).to(have_received(:new).with(matchdata_including(
-                                                                          type: 'requirement',
-                                                                          reference: 'TOTO-0001',
-                                                                          labels: 'label1,label2'
-                                                                        )))
+          expect(DefMastership::Definition).to(
+            have_received(:new).with(
+              matchdata_including(type: 'requirement', reference: 'TOTO-0001', labels: 'label1,label2')
+            )
+          )
         end
 
         it { expect(document.labels).to(eq(Set['bla1', 'bla2'])) }
@@ -208,8 +253,10 @@ RSpec.describe(DefMastership::Document) do
         end
 
         before do
-          allow(definition).to(receive(:add_eref).with(:implements, 'SYSTEM-0012, SYSTEM-0014')
-                                 .and_return(definition))
+          allow(definition).to(
+            receive(:add_eref).with(:implements, 'SYSTEM-0012, SYSTEM-0014')
+              .and_return(definition)
+          )
           document.parse(input_lines)
         end
 
@@ -288,18 +335,20 @@ RSpec.describe(DefMastership::Document) do
         end
 
         before do
-          allow(DefMastership::Definition).to(receive(:new).with(matchdata_including(
-                                                                   type: 'requirement',
-                                                                   reference: 'TOTO-0001'
-                                                                 )).and_return(definition))
+          allow(DefMastership::Definition).to(
+            receive(:new).with(
+              matchdata_including(type: 'requirement', reference: 'TOTO-0001')
+            ).and_return(definition)
+          )
           document.parse(input_lines)
         end
 
         it do
-          expect(DefMastership::Definition).to(have_received(:new).with(matchdata_including(
-                                                                          type: 'requirement',
-                                                                          reference: 'TOTO-0001'
-                                                                        )))
+          expect(DefMastership::Definition).to(
+            have_received(:new).with(
+              matchdata_including(type: 'requirement', reference: 'TOTO-0001')
+            )
+          )
         end
       end
     end
@@ -364,8 +413,9 @@ RSpec.describe(DefMastership::Document) do
         end
 
         before do
-          allow(DefMastership::Definition).to(receive(:new)
-            .and_raise('not a valide definition'))
+          allow(DefMastership::Definition).to(
+            receive(:new).and_raise('not a valide definition')
+          )
         end
 
         it do
@@ -384,8 +434,9 @@ RSpec.describe(DefMastership::Document) do
         end
 
         before do
-          allow(DefMastership::Definition).to(receive(:new)
-            .and_raise('not a valide definition'))
+          allow(DefMastership::Definition).to(
+            receive(:new).and_raise('not a valide definition')
+          )
         end
 
         it do
@@ -395,4 +446,155 @@ RSpec.describe(DefMastership::Document) do
       end
     end
   end
+
+  describe '#parse_file_with_preprocessor' do
+    let(:definition)  { instance_double(DefMastership::Definition, 'definition') }
+    let(:input_lines) { ['[define, requirement, TOTO-0001]']                     }
+    let(:adoc_doc)    { instance_double(Asciidoctor::Document, 'adoc_doc')       }
+    let(:adoc_reader) { instance_double(Asciidoctor::Reader, 'adoc_reader')      }
+
+    before do
+      allow(Asciidoctor).to(
+        receive(:load_file).with('the_file.adoc', { parse: false, safe: :unsafe }).and_return(adoc_doc)
+      )
+      allow(adoc_doc).to(receive(:reader).and_return(adoc_reader))
+      allow(adoc_reader).to(receive(:read_lines).and_return(input_lines))
+      allow(DefMastership::Definition).to(receive(:new).and_return(definition))
+      allow(definition).to(receive(:<<).and_return(definition))
+      allow(definition).to(receive(:labels).and_return(Set.new))
+      document.parse_file_with_preprocessor('the_file.adoc')
+    end
+
+    it { expect(Asciidoctor).to(have_received(:load_file).with('the_file.adoc', { parse: false, safe: :unsafe })) }
+    it { expect(adoc_doc).to(have_received(:reader).with(no_args)) }
+    it { expect(adoc_reader).to(have_received(:read_lines).with(no_args)) }
+
+    it do
+      expect(DefMastership::Definition).to(
+        have_received(:new).with(
+          matchdata_including(type: 'requirement', reference: 'TOTO-0001')
+        )
+      )
+    end
+  end
+
+  describe '#wrong_explicit_checksum?' do
+    let(:def1) { instance_double(DefMastership::Definition, 'definition') }
+    let(:def2) { instance_double(DefMastership::Definition, 'definition') }
+    let(:input_lines) do
+      [
+        '[define, requirement, TOTO-0001]',
+        'def one',
+        '',
+        '[define, requirement, TOTO-0002]',
+        'def two'
+      ]
+    end
+
+    before do
+      allow(DefMastership::Definition).to(receive(:new).twice.and_return(def1, def2))
+      allow(def1).to(receive(:labels)).and_return([])
+      allow(def2).to(receive(:labels)).and_return([])
+      allow(def1).to(receive(:<<).and_return(def1))
+      allow(def2).to(receive(:<<).and_return(def2))
+    end
+
+    context 'when no wrong explicit checksum' do
+      before do
+        allow(def1).to(receive(:wrong_explicit_checksum)).and_return(nil)
+        allow(def2).to(receive(:wrong_explicit_checksum)).and_return(nil)
+        document.parse(input_lines)
+        document.wrong_explicit_checksum?
+      end
+
+      it { expect(def1).to(have_received(:wrong_explicit_checksum)) }
+      it { expect(def2).to(have_received(:wrong_explicit_checksum)) }
+      it { expect(document.wrong_explicit_checksum?).to(eq(false)) }
+    end
+
+    context 'when one req has wrong explicit checksum' do
+      before do
+        allow(def1).to(receive(:wrong_explicit_checksum)).and_return(nil)
+        allow(def2).to(receive(:wrong_explicit_checksum)).and_return('toto')
+        document.parse(input_lines)
+        document.wrong_explicit_checksum?
+      end
+
+      it { expect(document.wrong_explicit_checksum?).to(eq(true)) }
+    end
+  end
+
+  describe '#explicit_version?' do
+    let(:def1) { instance_double(DefMastership::Definition, 'definition') }
+    let(:def2) { instance_double(DefMastership::Definition, 'definition') }
+    let(:input_lines) do
+      [
+        '[define, requirement, TOTO-0001]',
+        'def one',
+        '',
+        '[define, requirement, TOTO-0002]',
+        'def two'
+      ]
+    end
+
+    before do
+      allow(DefMastership::Definition).to(receive(:new).twice.and_return(def1, def2))
+      allow(def1).to(receive(:labels)).and_return([])
+      allow(def2).to(receive(:labels)).and_return([])
+      allow(def1).to(receive(:<<).and_return(def1))
+      allow(def2).to(receive(:<<).and_return(def2))
+    end
+
+    context 'when no explicit version' do
+      before do
+        allow(def1).to(receive(:explicit_version)).and_return(nil)
+        allow(def2).to(receive(:explicit_version)).and_return(nil)
+        document.parse(input_lines)
+        document.explicit_version?
+      end
+
+      it { expect(def1).to(have_received(:explicit_version)) }
+      it { expect(def2).to(have_received(:explicit_version)) }
+      it { expect(document.explicit_version?).to(eq(false)) }
+    end
+
+    context 'when one req has explicit version' do
+      before do
+        allow(def1).to(receive(:explicit_version)).and_return(nil)
+        allow(def2).to(receive(:explicit_version)).and_return('toto')
+        document.parse(input_lines)
+        document.explicit_version?
+      end
+
+      it { expect(document.explicit_version?).to(eq(true)) }
+    end
+  end
+
+  describe '#ref_to_def?' do
+    let(:def1) { instance_double(DefMastership::Definition, 'definition') }
+    let(:def2) { instance_double(DefMastership::Definition, 'definition') }
+    let(:input_lines) do
+      [
+        '[define, requirement, TOTO-0001]',
+        'def one',
+        '',
+        '[define, requirement, TOTO-0002(~1234)]',
+        'def two'
+      ]
+    end
+
+    before do
+      allow(DefMastership::Definition).to(receive(:new).twice.and_return(def1, def2))
+      allow(def1).to(receive(:labels)).and_return([])
+      allow(def2).to(receive(:labels)).and_return([])
+      allow(def1).to(receive(:<<).and_return(def1))
+      allow(def2).to(receive(:<<).and_return(def2))
+      allow(def1).to(receive(:reference).and_return('TOTO-0001'))
+      allow(def2).to(receive(:reference).and_return('TOTO-0002'))
+      document.parse(input_lines)
+    end
+
+    it { expect(document.ref_to_def('TOTO-0001')).to(eq(def1)) }
+    it { expect(document.ref_to_def('TOTO-0002')).to(eq(def2)) }
+  end
 end

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