defmastership 1.0.17 → 1.0.19

data/spec/unit/def_mastership/update_def_version_modifier_spec.rb

@@ -1,80 +1,351 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/update_def_version_modifier')
+require('git')
 
 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
+  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(config: { ref_document: 'ref.adoc' })) }
-    it { is_expected.to(have_attributes(changes: [])) }
+    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
-    let(:line_modifier) { instance_double(DefMastership::UpdateDefVersionLineModifier, 'lineModifier') }
-    let(:document)      { instance_double(DefMastership::Document, 'document')                         }
-    let(:ref_document)  { instance_double(DefMastership::Document, 'ref_document')                     }
+    context 'when only one ref document' do
+      subject(:modifier) do
+        described_class.new(
+          ref_document: 'ref_doc.adoc',
+          def_type: 'req',
+          first_version: 'a'
+        )
+      end
 
-    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]]))
+      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 { is_expected.to(have_attributes(ref_document: ['ref_doc.adoc'])) }
+      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
+
+    context 'when more ref document' do
+      subject(:modifier) do
+        described_class.new(
+          ref_document: ['ref_doc1.adoc', 'ref_doc2.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_doc1.adoc'))
+        allow(ref_document).to(receive(:parse_file_with_preprocessor).with('ref_doc2.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_doc1.adoc')) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('ref_doc2.adoc')) }
     end
 
-    context 'when detailed expectations' do
-      before { modifier.do_modifications(adoc_texts) }
+    context 'when ref_tag is provided' do
+      subject(:modifier) do
+        described_class.new(
+          ref_tag: 'THE_TAG',
+          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(Dir).to(receive(:mktmpdir).and_yield('tmp'))
+        allow(Git).to(receive(:clone))
+        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('tmp/file1.adoc'))
+        allow(ref_document).to(receive(:parse_file_with_preprocessor).with('tmp/file2.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(Dir).to(have_received(:mktmpdir).with('defmastership')) }
+      it { expect(Git).to(have_received(:clone).with('.', 'tmp', branch: 'THE_TAG')) }
+      it { expect(DefMastership::Document).to(have_received(:new).twice) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('tmp/file1.adoc')) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('tmp/file2.adoc')) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).twice) }
+
+      it do
+        expect(modifier.do_modifications(adoc_sources).fetch('file1.adoc')).to(include('REFERENCE(a)'))
+      end
+    end
+
+    context 'when ref_tag and ref_repo is provided' do
+      subject(:modifier) do
+        described_class.new(
+          ref_tag: 'THE_TAG',
+          ref_repo: 'not dot',
+          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(Dir).to(receive(:mktmpdir).and_yield('tmp'))
+        allow(Git).to(receive(:clone))
+        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('tmp/file1.adoc'))
+        allow(ref_document).to(receive(:parse_file_with_preprocessor).with('tmp/file2.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(Dir).to(have_received(:mktmpdir).with('defmastership')) }
+      it { expect(Git).to(have_received(:clone).with('not dot', 'tmp', branch: 'THE_TAG')) }
+      it { expect(DefMastership::Document).to(have_received(:new).twice) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('tmp/file1.adoc')) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('tmp/file2.adoc')) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).twice) }
 
       it do
-        expect(DefMastership::UpdateDefVersionLineModifier).to(
-          have_received(:from_config).with({ ref_document: 'ref.adoc' })
+        expect(modifier.do_modifications(adoc_sources).fetch('file1.adoc')).to(include('REFERENCE(a)'))
+      end
+    end
+
+    context 'when both ref_tag and ref_document are provided' do
+      subject(:modifier) do
+        described_class.new(
+          ref_tag: 'THE_TAG',
+          ref_document: './another/doc.adoc',
+          def_type: 'req',
+          first_version: 'a'
         )
       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]])) }
+      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(Dir).to(receive(:mktmpdir).and_yield('tmp'))
+        allow(Git).to(receive(:clone))
+        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))
+        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(Dir).to(have_received(:mktmpdir).with('defmastership')) }
+      it { expect(Git).to(have_received(:clone).with('.', 'tmp', branch: 'THE_TAG')) }
+      it { expect(DefMastership::Document).to(have_received(:new).twice) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('tmp/./another/doc.adoc')) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).once) }
+
+      it do
+        expect(modifier.do_modifications(adoc_sources).fetch('file1.adoc')).to(include('REFERENCE(a)'))
+      end
+    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
 
-    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))
+    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/tasks/code_quality.rake

@@ -0,0 +1,74 @@
+# Copyright (c) 2023 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+namespace 'quality' do
+  begin
+    require('rubocop/rake_task')
+
+    RuboCop::RakeTask.new do |task|
+      task.options << '--display-cop-names'
+      task.options << '--config=config/rubocop.yml'
+    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 |task|
+      task.fail_on_error = true
+      task.source_files = '{lib,spec}/**/*.rb'
+      task.reek_opts = '--config config/reek.yml --single-line'
+    end
+  rescue LoadError
+    task(:reek) do
+      puts('Install reek to run its rake tasks')
+    end
+  end
+
+  begin
+    require('flay_task')
+
+    FlayTask.new(:flay, 200, %w[bin lib]) do |task|
+      task.verbose = true
+    end
+  rescue LoadError
+    task(:flay) do
+      puts('Install flay to run its rake tasks')
+    end
+  end
+
+  begin
+    require('rubycritic/rake_task')
+
+    RubyCritic::RakeTask.new do |task|
+      task.verbose = true
+      task.options = '--no-browser'
+    end
+  rescue LoadError
+    task(:rubycritic) do
+      puts('Install rubycritic to run its rake tasks')
+    end
+  end
+
+  desc 'Runs all quality code check'
+  task(
+    all: [
+      'quality:rubocop',
+      'quality:reek',
+      'quality:flay',
+      'quality:rubycritic'
+    ]
+  )
+end
+# rubocop:enable Metrics/BlockLength
+
+desc 'Synonym for quality:rubocop'
+task(rubocop: 'quality:rubocop')
+
+desc 'Synonym for quality:reek'
+task(reek: 'quality:reek')

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/test.rake

@@ -0,0 +1,30 @@
+# Copyright (c) 2023 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('cucumber/rake/task')
+require('rspec/core/rake_task')
+
+namespace 'test' do
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = ['--options config/rspec']
+  end
+
+  CLEAN << 'features_results.html'
+
+  Cucumber::Rake::Task.new(:features)
+  Cucumber::Rake::Task.new('features:wip') do |t|
+    t.cucumber_opts = ['--profile wip']
+  end
+
+  desc 'Runs all unit tests and acceptance tests'
+  task(all: ['test:spec', 'test:features'])
+end
+
+desc 'Synonym for test:spec'
+task(spec: 'test:spec')
+
+desc 'Synonym for test:all'
+task(test: 'test:all')
+
+desc('Test all features')
+task(cucumber: 'test:features')