defmastership 1.0.16 → 1.0.18

data/spec/unit/{defmastership/rename_included_files_line_modifier_spec.rb → def_mastership/rename_included_files_modifier_spec.rb}

@@ -1,40 +1,37 @@
 # Copyright (c) 2021 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/rename_included_files_modifier')
 
-RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
-  subject(:includeschanger) { described_class.new }
+RSpec.describe(DefMastership::RenameIncludedFilesModifier) do
+  subject(:includeschanger) { described_class.new({}) }
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { expect(described_class.ancestors).to(include(DefMastership::Modifier)) }
+    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
+  describe '.replacement_methods' do
+    it { expect(described_class.replacement_methods).to(eq(%i[replace])) }
+  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')) }
+  describe '.respond_to_missing?' do
+    it { expect(includeschanger.respond_to?(:add_new_definition)).to(be(true)) }
+    it { expect(includeschanger.respond_to?(:not_implemented_random_method)).to(be(false)) }
   end
 
   describe '#replace' do
     context 'when NOT valid include' do
-      before do
-        includeschanger.from_config(
+      subject(:includeschanger) do
+        described_class.new(
           from_regexp: 'orig',
-          cancel_if_match: 'REF',
           to_template: 'dest'
         )
+      end
+
+      before do
         allow(File).to(receive(:rename))
       end
 
@@ -74,21 +71,35 @@ RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
         end
       end
 
-      context 'when the cancel regexp is met' do
+      context 'when the line is commented' do
         before do
-          ['[define,requirement,REFERENCE]', '--'].each do |line|
-            includeschanger.replace(line)
-          end
+          includeschanger.replace('[define,requirement,REFERENCE]')
+          includeschanger.replace('--')
         end
 
         it do
-          expect(includeschanger.replace('include::REFERENCE_orig[]'))
-            .to(eq('include::REFERENCE_orig[]'))
+          expect(includeschanger.replace('// include::orig[]'))
+            .to(eq('// include::orig[]'))
+        end
+      end
+
+      context 'when the cancel regexp is met' do
+        subject(:includeschanger) do
+          described_class.new(
+            from_regexp: 'orig',
+            cancel_if_match: 'orig',
+            to_template: 'dest'
+          )
+        end
+
+        before do
+          includeschanger.replace('[define,requirement,REFERENCE]')
+          includeschanger.replace('--')
         end
 
         it do
-          includeschanger.replace('include::REFERENCE_orig[]')
-          expect(includeschanger).to(have_attributes(changes: []))
+          expect(includeschanger.replace("include::orig[]\n"))
+            .to(eq("include::orig[]\n"))
         end
       end
     end
@@ -99,12 +110,15 @@ RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
       end
 
       context 'when really simple rule' do
-        before do
-          includeschanger.from_config(
+        subject(:includeschanger) do
+          described_class.new(
             from_regexp: 'orig',
-            cancel_if_match: 'REF',
+            cancel_if_match: '_no_cancel_',
             to_template: 'dest'
           )
+        end
+
+        before do
           includeschanger.replace('[define,requirement,REFERENCE]')
           includeschanger.replace('--')
         end
@@ -119,6 +133,16 @@ RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
           expect(File).to(have_received(:rename).with('orig', 'dest'))
         end
 
+        it do
+          expect(includeschanger.replace("include::orig[leveloffset=offset,lines=ranges]\n"))
+            .to(eq("include::dest[leveloffset=offset,lines=ranges]\n"))
+        end
+
+        it do
+          includeschanger.replace("include::orig[leveloffset=offset,lines=ranges]\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]]))
@@ -141,11 +165,14 @@ RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
       end
 
       context 'when complex from_regexp' do
-        before do
-          includeschanger.from_config(
+        subject(:includeschanger) do
+          described_class.new(
             from_regexp: '(?<origin>.*\.extension)',
             to_template: '%<reference>s_%<origin>s'
           )
+        end
+
+        before do
           includeschanger.replace('[define,requirement,REF]')
         end
 
@@ -167,13 +194,17 @@ RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
       end
 
       context 'when path with variable' do
-        before do
-          includeschanger.from_config(
+        subject(:includeschanger) do
+          described_class.new(
             from_regexp: 'orig',
             to_template: 'dest'
           )
+        end
+
+        before do
           includeschanger.replace(':any: one')
           includeschanger.replace(':path: two')
+          includeschanger.replace(':var: three')
           includeschanger.replace('[define,requirement,REFERENCE]')
           includeschanger.replace('--')
         end
@@ -184,8 +215,8 @@ RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
         end
 
         it do
-          includeschanger.replace('include::{any}/orig[]')
-          expect(File).to(have_received(:rename).with('one/orig', 'one/dest'))
+          includeschanger.replace('include::{any}{var}/orig[]')
+          expect(File).to(have_received(:rename).with('onethree/orig', 'onethree/dest'))
         end
 
         it do
@@ -193,6 +224,11 @@ RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
           expect(File).to(have_received(:rename).with('one_two/orig', 'one_two/dest'))
         end
 
+        it do
+          expect { includeschanger.replace('include::{bad_variable}/orig[]') }
+            .to(raise_error(KeyError, 'key not found: :bad_variable'))
+        end
+
         it do
           includeschanger.replace('include::{any}_{path}/orig[]')
           expect(includeschanger).to(have_attributes(changes: [%w[one_two/orig one_two/dest]]))

data/spec/unit/{defmastership/comment_filter_spec.rb → def_mastership/string_spec.rb}

@@ -1,7 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/comment_filter')
 
 RSpec.describe(String) do
   context 'when .commented?' do

data/spec/unit/def_mastership/update_def_checksum_modifier_spec.rb

@@ -0,0 +1,107 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/update_def_checksum_modifier')
+
+RSpec.describe(DefMastership::UpdateDefChecksumModifier) do
+  subject(:modifier) { described_class.new({}) }
+
+  describe '.new' do
+    it { expect(described_class.ancestors).to(include(DefMastership::Modifier)) }
+    it { is_expected.not_to(be_nil) }
+    it { is_expected.to(have_attributes(def_type: '')) }
+  end
+
+  describe '.replacement_methods' do
+    it { expect(described_class.replacement_methods).to(eq(%i[replace_reference])) }
+  end
+
+  describe '#do_modifications' do
+    subject(:modifier) { described_class.new({ def_type: 'req' })                 }
+
+    let(:document)     { instance_double(DefMastership::Document, 'document')     }
+    let(:definition)   { instance_double(DefMastership::Definition, 'definition') }
+    let(:definitions)  { { 'REFERENCE' => definition }                            }
+    let(:adoc_sources) do
+      {
+        'file1.adoc' => "[define,req,REFERENCE]\nfile1 line2",
+        'file2.adoc' => "file2 line1\nfile2 line2"
+      }
+    end
+    let(:new_adoc_sources) { nil }
+
+    before do
+      allow(DefMastership::Document).to(receive(:new).and_return(document))
+      allow(document).to(receive(:parse_file_with_preprocessor))
+      allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+      allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+
+      modifier.do_modifications(adoc_sources)
+    end
+
+    it { expect(DefMastership::Document).to(have_received(:new)) }
+
+    it do
+      expect(document).to(
+        have_received(:parse_file_with_preprocessor)
+          .once.with('file1.adoc')
+          .once.with('file2.adoc')
+      )
+    end
+
+    it do
+      expect(modifier.do_modifications(adoc_sources).fetch('file1.adoc')).to(include('abcd1234'))
+    end
+  end
+
+  describe '#replace' do
+    subject(:modifier) do
+      described_class.new(
+        def_type: 'requirement'
+      )
+    end
+
+    let(:definition)  { instance_double(DefMastership::Definition, 'definition') }
+    let(:document)    { instance_double(DefMastership::Document, 'document')     }
+    let(:definitions) { { 'REFERENCE' => definition }                            }
+
+    before do
+      allow(File).to(receive(:rename))
+    end
+
+    context 'when definition has not the good type' do
+      it do
+        expect(modifier.replace_reference('[define,req,REFERENCE]'))
+          .to(eq('[define,req,REFERENCE]'))
+      end
+    end
+
+    context 'when definition has the good type' do
+      before do
+        allow(DefMastership::Document).to(receive(:new).and_return(document))
+        allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+        allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+      end
+
+      it do
+        expect(modifier.replace_reference('[define,requirement,REFERENCE]'))
+          .to(eq('[define,requirement,REFERENCE(~abcd1234)]'))
+      end
+
+      it do
+        expect(modifier.replace_reference('[define,requirement,REFERENCE(~bad)]'))
+          .to(eq('[define,requirement,REFERENCE(~abcd1234)]'))
+      end
+
+      it do
+        expect(modifier.replace_reference('[define,requirement,REFERENCE(toto~bad)]'))
+          .to(eq('[define,requirement,REFERENCE(toto~abcd1234)]'))
+      end
+
+      it do
+        expect(modifier.replace_reference('[define,requirement,REFERENCE(toto)]'))
+          .to(eq('[define,requirement,REFERENCE(toto~abcd1234)]'))
+      end
+    end
+  end
+end

data/spec/unit/def_mastership/update_def_modifier_spec.rb

@@ -0,0 +1,119 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/update_def_modifier')
+
+module DefMastership
+  class ConcreteRefModifier < UpdateDefModifier
+    private
+
+    def reference_replacement(reference, match)
+      "#{reference}_something_#{match[:explicit_version]}"
+    end
+  end
+end
+
+RSpec.describe(DefMastership::UpdateDefModifier) do
+  subject(:modifier) { DefMastership::ConcreteRefModifier.new({}) }
+
+  describe '.new' do
+    it { expect(described_class.ancestors).to(include(DefMastership::Modifier)) }
+    it { is_expected.not_to(be_nil) }
+    it { is_expected.to(have_attributes(def_type: '')) }
+  end
+
+  describe '.replacement_methods' do
+    it { expect(described_class.replacement_methods).to(eq(%i[replace_reference])) }
+  end
+
+  describe '#do_modifications' do
+    subject(:modifier) { DefMastership::ConcreteRefModifier.new({ def_type: 'req' }) }
+
+    let(:document)     { instance_double(DefMastership::Document, 'document')        }
+    let(:definition)   { instance_double(DefMastership::Definition, 'definition')    }
+    let(:definitions)  { { 'REFERENCE' => definition }                               }
+    let(:adoc_sources) do
+      {
+        'file1.adoc' => "[define,req,REFERENCE]\nfile1 line2",
+        'file2.adoc' => "file2 line1\nfile2 line2"
+      }
+    end
+    let(:new_adoc_sources) { nil }
+
+    before do
+      allow(DefMastership::Document).to(receive(:new).and_return(document))
+      allow(document).to(receive(:parse_file_with_preprocessor).with('file1.adoc'))
+      allow(document).to(receive(:parse_file_with_preprocessor).with('file2.adoc'))
+
+      modifier.do_modifications(adoc_sources)
+    end
+
+    it { expect(DefMastership::Document).to(have_received(:new)) }
+
+    it do
+      expect(document).to(
+        have_received(:parse_file_with_preprocessor)
+          .once.with('file1.adoc')
+          .once.with('file2.adoc')
+      )
+    end
+
+    it do
+      expect(modifier.do_modifications(adoc_sources).fetch('file1.adoc'))
+        .to(include('REFERENCE_something_'))
+    end
+  end
+
+  describe '#replace_reference' do
+    subject(:modifier) do
+      DefMastership::ConcreteRefModifier.new(
+        def_type: 'requirement'
+      )
+    end
+
+    let(:definition)  { instance_double(DefMastership::Definition, 'definition') }
+    let(:document)    { instance_double(DefMastership::Document, 'document')     }
+    let(:definitions) { { 'REFERENCE' => definition }                            }
+
+    before do
+      allow(File).to(receive(:rename))
+    end
+
+    context 'when line do not match' do
+      it do
+        expect(modifier.replace_reference('[define---,req,REFERENCE(abcd)]'))
+          .to(eq('[define---,req,REFERENCE(abcd)]'))
+      end
+    end
+
+    context 'when definition has not the good type' do
+      it do
+        expect(modifier.replace_reference('[define,req,REFERENCE(abcd)]'))
+          .to(eq('[define,req,REFERENCE(abcd)]'))
+      end
+    end
+
+    context 'when definition has the good type' do
+      before do
+        allow(DefMastership::Document).to(receive(:new).and_return(document))
+        allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+        allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+      end
+
+      it do
+        expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd)]'))
+          .to(eq('[define,requirement,REFERENCE_something_abcd]'))
+      end
+
+      it do
+        expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd~bad)]'))
+          .to(eq('[define,requirement,REFERENCE_something_abcd]'))
+      end
+
+      it do
+        expect(modifier.replace_reference('// [define,requirement,REFERENCE(abcd~bad)]'))
+          .to(eq('// [define,requirement,REFERENCE(abcd~bad)]'))
+      end
+    end
+  end
+end

data/spec/unit/def_mastership/update_def_version_modifier_spec.rb

@@ -0,0 +1,159 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/update_def_version_modifier')
+
+RSpec.describe(DefMastership::UpdateDefVersionModifier) do
+  subject(:modifier) { described_class.new({}) }
+
+  describe '.new' do
+    it { expect(described_class.ancestors).to(include(DefMastership::Modifier)) }
+    it { is_expected.not_to(be_nil) }
+    it { is_expected.to(have_attributes(def_type: '')) }
+    it { is_expected.to(have_attributes(ref_document: '')) }
+    it { is_expected.to(have_attributes(first_version: '')) }
+  end
+
+  describe '.replacement_methods' do
+    it { expect(described_class.replacement_methods).to(eq(%i[replace_reference])) }
+  end
+
+  describe '#do_modifications' do
+    subject(:modifier) do
+      described_class.new(
+        ref_document: 'ref_doc.adoc',
+        def_type: 'req',
+        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') }
+    let(:adoc_sources) do
+      {
+        'file1.adoc' => "[define,req,REFERENCE]\nfile1 line2",
+        'file2.adoc' => "file2 line1\nfile2 line2"
+      }
+    end
+
+    before do
+      allow(DefMastership::Document).to(receive(:new).twice.and_return(ref_document, document))
+      allow(document).to(receive(:parse_file_with_preprocessor).with('file1.adoc'))
+      allow(document).to(receive(:parse_file_with_preprocessor).with('file2.adoc'))
+      allow(ref_document).to(receive(:parse_file_with_preprocessor).with('ref_doc.adoc'))
+      allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+      allow(ref_document).to(receive(:ref_to_def).with('REFERENCE').and_return(ref_definition))
+      allow(ref_definition).to(receive(:explicit_version).with(no_args).and_return(nil))
+      allow(definition).to(receive(:sha256_short).with(no_args).and_return('something'))
+      allow(ref_definition).to(receive(:sha256_short).with(no_args).and_return('something_else'))
+
+      modifier.do_modifications(adoc_sources)
+    end
+
+    it { expect(DefMastership::Document).to(have_received(:new).twice) }
+    it { expect(document).to(have_received(:parse_file_with_preprocessor).twice) }
+    it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('ref_doc.adoc')) }
+
+    it do
+      expect(modifier.do_modifications(adoc_sources).fetch('file1.adoc')).to(include('REFERENCE(a)'))
+    end
+  end
+
+  describe '#replace_reference' do
+    subject(:modifier) do
+      described_class.new(
+        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
+      allow(File).to(receive(:rename))
+      allow(DefMastership::Document).to(receive(:new).with(no_args).and_return(ref_document, document))
+    end
+
+    context 'when definition has not the good type' do
+      it do
+        expect(modifier.replace_reference('[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_short).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_short).and_return('~abcd1234'))
+        end
+
+        it do
+          allow(ref_definition).to(receive(:explicit_version).and_return(nil))
+          expect(modifier.replace_reference('[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE]'))
+        end
+
+        it do
+          allow(ref_definition).to(receive(:explicit_version).and_return('c'))
+          expect(modifier.replace_reference('[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE(c)]'))
+        end
+
+        it do
+          allow(ref_definition).to(receive(:explicit_version).and_return('c'))
+          expect(modifier.replace_reference('[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_short).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(modifier.replace_reference("[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(modifier.replace_reference('[define,requirement,REFERENCE(whatever)]'))
+            .to(eq('[define,requirement,REFERENCE]'))
+        end
+
+        it do
+          expect(modifier.replace_reference('[define,requirement,REFERENCE(~1234)]'))
+            .to(eq('[define,requirement,REFERENCE(~1234)]'))
+        end
+      end
+    end
+  end
+end

data/spec/unit/{defmastership_spec.rb → def_mastership_spec.rb}

@@ -3,6 +3,6 @@
 
 RSpec.describe(DefMastership) do
   it 'has a version number' do
-    expect(DefMastership::VERSION).not_to(be(nil))
+    expect(DefMastership::VERSION).not_to(be_nil)
   end
 end

data/tasks/console.rake

@@ -0,0 +1,8 @@
+# Copyright (c) 2023 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+desc 'Starts the interactive console'
+task :console do
+  require 'pry'
+  Pry.start
+end

data/tasks/package.task

@@ -0,0 +1,9 @@
+# Copyright (c) 2023 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('rubygems')
+require('rubygems/package_task')
+
+spec = eval(File.read('defmastership.gemspec'))
+
+Gem::PackageTask.new(spec)

data/tasks/smelling_code.rake

@@ -0,0 +1,38 @@
+# Copyright (c) 2023 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+namespace 'quality' do
+  begin
+    require('rubocop/rake_task')
+
+    RuboCop::RakeTask.new do |task|
+      task.options << '--display-cop-names'
+    end
+  rescue LoadError
+    task(:rubocop) do
+      puts('Install rubocop to run its rake tasks')
+    end
+  end
+
+  begin
+    require('reek/rake/task')
+
+    Reek::Rake::Task.new do |t|
+      t.fail_on_error = true
+      t.verbose = false
+    end
+  rescue LoadError
+    task(:reek) do
+      puts('Install reek to run its rake tasks')
+    end
+  end
+
+  desc 'Runs all quality code check'
+  task(all: ['quality:rubocop', 'quality:reek'])
+end
+
+desc 'Synonym for quality:rubocop'
+task(rubocop: 'quality:rubocop')
+
+desc 'Synonym for quality:reek'
+task(reek: 'quality:reek')