defmastership 1.0.7 → 1.0.12

data/spec/unit/defmastership/definition_spec.rb

@@ -23,6 +23,7 @@ RSpec.describe(DefMastership::Definition) do
       it { is_expected.to(have_attributes(attributes: {})) }
       it { is_expected.to(have_attributes(labels:     Set.new)) }
       it { is_expected.to(have_attributes(wrong_explicit_checksum: nil)) }
+      it { is_expected.to(have_attributes(explicit_version: nil)) }
     end
 
     context 'with labels' do
@@ -42,13 +43,13 @@ RSpec.describe(DefMastership::Definition) do
         described_class.new(
           type: 'req',
           reference: 'TUTU-001',
-          explicit_checksum: '8cc259e6'
+          explicit_checksum: '~8cc259e6'
         )
       end
 
       it do
-        definition << 'def value with a checksum != 8cc259e6'
-        expect(definition).to(have_attributes(wrong_explicit_checksum: '8cc259e6'))
+        definition << 'def value with a checksum != ~8cc259e6'
+        expect(definition).to(have_attributes(wrong_explicit_checksum: '~8cc259e6'))
       end
 
       it do
@@ -56,6 +57,20 @@ RSpec.describe(DefMastership::Definition) do
         expect(definition).to(have_attributes(wrong_explicit_checksum: nil))
       end
     end
+
+    context 'with explicit_version' do
+      subject(:definition) do
+        described_class.new(
+          type: 'req',
+          reference: 'TUTU-001',
+          explicit_version: 'pouet'
+        )
+      end
+
+      it do
+        expect(definition).to(have_attributes(explicit_version: 'pouet'))
+      end
+    end
   end
 
   describe '#<<' do
@@ -88,7 +103,7 @@ RSpec.describe(DefMastership::Definition) do
 
     it 'calculates sha256 of value' do
       definition << 'first line' << 'second line'
-      expect(definition.sha256).to(eq('beb0535a'))
+      expect(definition.sha256).to(eq('~beb0535a'))
     end
   end
 

data/spec/unit/defmastership/document_spec.rb

@@ -52,12 +52,12 @@ RSpec.describe(DefMastership::Document) do
       end
 
       context 'when simple definition line with explicit checksum' do
-        let(:input_lines) { ['[define, requirement, TOTO-0001(ab12)]'] }
+        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')
+              matchdata_including(type: 'requirement', reference: 'TOTO-0001', explicit_checksum: '~ab12')
             ).and_return(definition)
           )
           document.parse(input_lines)
@@ -66,7 +66,28 @@ RSpec.describe(DefMastership::Document) do
         it do
           expect(DefMastership::Definition).to(
             have_received(:new).with(
-              matchdata_including(type: 'requirement', reference: 'TOTO-0001', explicit_checksum: 'ab12')
+              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
@@ -503,6 +524,52 @@ RSpec.describe(DefMastership::Document) do
     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') }
@@ -511,7 +578,7 @@ RSpec.describe(DefMastership::Document) do
         '[define, requirement, TOTO-0001]',
         'def one',
         '',
-        '[define, requirement, TOTO-0002(1234)]',
+        '[define, requirement, TOTO-0002(~1234)]',
         'def two'
       ]
     end

data/spec/unit/defmastership/rename_included_files_line_modifier_spec.rb

@@ -110,32 +110,32 @@ RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
         end
 
         it do
-          expect(includeschanger.replace('include::orig[]'))
-            .to(eq('include::dest[]'))
+          expect(includeschanger.replace("include::orig[]\n"))
+            .to(eq("include::dest[]\n"))
         end
 
         it do
-          includeschanger.replace('include::orig[]')
+          includeschanger.replace("include::orig[]\n")
           expect(File).to(have_received(:rename).with('orig', 'dest'))
         end
 
         it do
-          includeschanger.replace('include::orig[]')
+          includeschanger.replace("include::orig[]\n")
           expect(includeschanger).to(have_attributes(changes: [%w[orig dest]]))
         end
 
         it do
-          expect(includeschanger.replace('include::toto/orig[]'))
-            .to(eq('include::toto/dest[]'))
+          expect(includeschanger.replace("include::toto/orig[]\n"))
+            .to(eq("include::toto/dest[]\n"))
         end
 
         it do
-          includeschanger.replace('include::toto/orig[]')
+          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[]')
+          includeschanger.replace("include::toto/orig[]\n")
           expect(includeschanger).to(have_attributes(changes: [%w[toto/orig toto/dest]]))
         end
       end

data/spec/unit/defmastership/update_def_checksum_line_modifier_spec.rb

@@ -51,17 +51,27 @@ RSpec.describe(DefMastership::UpdateDefChecksumLineModifier) do
     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'))
+        allow(definition).to(receive(:sha256).and_return('~abcd1234'))
       end
 
       it do
         expect(linemodifier.replace('[define,requirement,REFERENCE]'))
-          .to(eq('[define,requirement,REFERENCE(abcd1234)]'))
+          .to(eq('[define,requirement,REFERENCE(~abcd1234)]'))
       end
 
       it do
-        expect(linemodifier.replace('[define,requirement,REFERENCE(bad)]'))
-          .to(eq('[define,requirement,REFERENCE(abcd1234)]'))
+        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

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

data/spec/unit/defmastership/update_def_version_modifier_spec.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: defmastership
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.12
 platform: ruby
 authors:
 - Jérôme Arbez-Gindre
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-27 00:00:00.000000000 Z
+date: 2021-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aruba
@@ -193,7 +193,8 @@ files:
 - defmastership.gemspec
 - defmastership.rdoc
 - features/changeref.feature
-- features/checksum.feature
+- features/definition_checksum.feature
+- features/definition_version.feature
 - features/defmastership.feature
 - features/export.feature
 - features/modify.feature
@@ -219,6 +220,8 @@ files:
 - lib/defmastership/rename_included_files_modifier.rb
 - lib/defmastership/update_def_checksum_line_modifier.rb
 - lib/defmastership/update_def_checksum_modifier.rb
+- lib/defmastership/update_def_version_line_modifier.rb
+- lib/defmastership/update_def_version_modifier.rb
 - lib/defmastership/version.rb
 - spec/spec_helper.rb
 - spec/unit/defmastership/batch_modifier_spec.rb
@@ -235,6 +238,8 @@ files:
 - spec/unit/defmastership/rename_included_files_modifier_spec.rb
 - spec/unit/defmastership/update_def_checksum_line_modifier_spec.rb
 - spec/unit/defmastership/update_def_checksum_modifier_spec.rb
+- spec/unit/defmastership/update_def_version_line_modifier_spec.rb
+- spec/unit/defmastership/update_def_version_modifier_spec.rb
 - spec/unit/defmastership_spec.rb
 homepage: https://gitlab.com/jjag/defmastership/
 licenses: