defmastership 1.3.6 → 1.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b282623e3f26fd7e1b8f88df3605ffb8a536c5d7a71e3f8f6b41d937d740c77c
-  data.tar.gz: af43d982dc66141dced00cf731300759631b5730fda62b250c43bde1d026d844
+  metadata.gz: 12ede2830cace7dbc8665f7db780d2bb60acf8f5beb771b4ec9bfdb9fbd74c5b
+  data.tar.gz: 92010c0156be9e4c74f36789b4c269097d61d9bde4d87ccfa2fc1a8869aa4475
 SHA512:
-  metadata.gz: dbcdd3fc1b665dd867760123c43927f6f27b83726000a8e567f20fc716269ae073ca4c70f3362c029ff4347d6f0371068b6e15ab893e74fef89cf6419cbd9487
-  data.tar.gz: 67e21c19f23d236f53bda017cfd5fdf1ce7700490b8e68c805c042f3f902123c7d1f275b06046a2c3ecc6614e5bf527dc3db0d5fb6addbc24c0a002337ae06bd
+  metadata.gz: 10b08062de66121b2a7785bb4a169ad8bf367566cd18dfad55d068324b8efa78075d8b6ec27362bf20256d306e73fd8f57a08e9d509ded3c415690cfd2f7ddb8
+  data.tar.gz: 27a73e65de9d300640b068dc4e4131bd0059e777cf4bcae2e1b0ea9d93d42795420e6e61c9678298ebb64aab3cbf33c6c9fda8218151e63709d0aa5d7cbf36ee

data/Gemfile

@@ -54,5 +54,5 @@ end
 
 group :debugging do
   # Sometimes, we need to debug
-  gem 'pry',                   '~> 0.16'
+  gem 'pry', '~> 0.16'
 end

data/features/definition_version.feature

@@ -221,6 +221,47 @@ Feature: definitions version
         :ref_tag: THE_TAG
     """
 
+  Scenario: Update explicit version based on git tag with definitions inside a git submodule
+    Given I initialize a git repo in "submodule_origin"
+    And a file named "submodule_origin/ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    initial text.
+    --
+    """
+    And I add and commit the changes in repo "submodule_origin"
+    And I initialize a git repo
+    And I set the environment variable "GIT_ALLOW_PROTOCOL" to "file"
+    And I add the repo "submodule_origin" as a submodule "submodule"
+    And I set the "THE_TAG" tag
+    And a file named "submodule/ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(whatever)]
+    --
+    modified text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :first_version: a
+        :ref_tag: 'THE_TAG'
+    """
+    And I set the environment variable "GIT_ALLOW_PROTOCOL" to "file"
+    When I successfully run `defmastership modify --modifications update_requirement_version submodule/ref_doc.adoc`
+    Then the file "submodule/ref_doc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0001(a)]
+    --
+    modified text.
+    --
+    """
+
   Scenario: Update explicit version based on git tag on a different git repo
     And a file named "defmastership-example.adoc" with:
     """
@@ -603,3 +644,244 @@ Feature: definitions version
     Whatever: modified text.
     --
     """
+
+  Scenario: Set forced explicit version when definition has changed and had a previous version
+    Given a file named "ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(3)]
+    --
+    initial text.
+    --
+    """
+    Given a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(whatever)]
+    --
+    modified text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :force_version: '42'
+        :ref_document: ./ref_doc.adoc
+    """
+    When I successfully run `defmastership modify --modifications update_requirement_version thedoc.adoc`
+    And the stdout should not contain anything
+    Then the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0001(42)]
+    --
+    modified text.
+    --
+    """
+
+  Scenario: Set forced explicit version when definition has changed and had no previous version
+    Given a file named "ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    initial text.
+    --
+    """
+    Given a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(whatever)]
+    --
+    modified text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :force_version: '42'
+        :ref_document: ./ref_doc.adoc
+    """
+    When I successfully run `defmastership modify --modifications update_requirement_version thedoc.adoc`
+    And the stdout should not contain anything
+    Then the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0001(42)]
+    --
+    modified text.
+    --
+    """
+
+  Scenario: Do not set forced explicit version when definition has NOT changed and had a previous version
+    Given a file named "ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(3)]
+    --
+    initial text.
+    --
+    """
+    Given a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(whatever)]
+    --
+    initial text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :force_version: '42'
+        :ref_document: ./ref_doc.adoc
+    """
+    When I successfully run `defmastership modify --modifications update_requirement_version thedoc.adoc`
+    And the stdout should not contain anything
+    Then the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0001(3)]
+    --
+    initial text.
+    --
+    """
+
+  Scenario: Do not set forced explicit version when definition has NOT changed and had no previous version
+    Given a file named "ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    initial text.
+    --
+    """
+    Given a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(whatever)]
+    --
+    initial text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :force_version: '42'
+        :ref_document: ./ref_doc.adoc
+    """
+    When I successfully run `defmastership modify --modifications update_requirement_version thedoc.adoc`
+    And the stdout should not contain anything
+    Then the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    initial text.
+    --
+    """
+
+  Scenario: Generate an error when the definition has changed but the reference version is already equal to force_version
+    Given a file named "ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(42)]
+    --
+    initial text.
+    --
+    """
+    Given a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(whatever)]
+    --
+    modified text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :force_version: '42'
+        :ref_document: ./ref_doc.adoc
+    """
+    When I run `defmastership modify --modifications update_requirement_version thedoc.adoc`
+    Then it should fail with:
+    """
+    error: TOTO-0001 has changed but its version in reference document is already at force_version (42)
+    """
+
+  Scenario: Do not set version when definition is new and first_version is configured
+    Given a file named "ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0002]
+    --
+    initial text.
+    --
+    """
+    Given a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    modified text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :first_version: '1'
+        :ref_document: ./ref_doc.adoc
+    """
+    When I successfully run `defmastership modify --modifications update_requirement_version thedoc.adoc`
+    And the stdout should not contain anything
+    Then the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    modified text.
+    --
+    """
+
+  Scenario: Set forced explicit version when definition is new and force_version is configured
+    Given a file named "ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0002]
+    --
+    initial text.
+    --
+    """
+    Given a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    modified text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :force_version: '42'
+        :ref_document: ./ref_doc.adoc
+    """
+    When I successfully run `defmastership modify --modifications update_requirement_version thedoc.adoc`
+    And the stdout should not contain anything
+    Then the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0001(42)]
+    --
+    modified text.
+    --
+    """

data/features/step_definitions/git_steps.rb

@@ -20,3 +20,33 @@ Given('I set the {string} tag') do |tag_name|
   git = Git.open(Aruba.config.home_directory)
   git.add_tag(tag_name)
 end
+
+Given('I initialize a git repo in {string}') do |repo_dir|
+  require 'fileutils'
+  repo_path = File.join(Aruba.config.home_directory, repo_dir)
+  FileUtils.mkdir_p(repo_path)
+
+  git = Git.init(repo_path)
+  git.config('user.name', 'Bob Léponge')
+  git.config('user.email', 'bob.léponge@example.com')
+end
+
+Given('I add and commit the changes in repo {string}') do |repo_dir|
+  repo_path = File.join(Aruba.config.home_directory, repo_dir)
+  git = Git.open(repo_path)
+
+  git.config('user.name', 'Bob Léponge')
+  git.config('user.email', 'bob.léponge@example.com')
+  git.add(all: true)
+  git.commit('Commit changes')
+end
+
+Given('I add the repo {string} as a submodule {string}') do |remote_dir, submodule_dir|
+  run_command("git submodule add ./#{remote_dir} #{submodule_dir}")
+  last_command_started.wait
+
+  main_git = Git.open(Aruba.config.home_directory)
+  main_git.add('.gitmodules')
+  main_git.add(submodule_dir)
+  main_git.commit("Add submodule #{submodule_dir}")
+end

data/lib/defmastership/modifier/modifier_common.rb

@@ -64,7 +64,7 @@ module Defmastership
 
       def apply_to_one(filename, text, method)
         text.lines.map { |line| public_send(method, filename, line) }
-                  .join
+            .join
       end
     end
   end

data/lib/defmastership/modifier/update_def_version.rb

@@ -15,7 +15,8 @@ module Defmastership
           ref_document: [],
           ref_tag: '',
           ref_repo: '.',
-          first_version: ''
+          first_version: '',
+          force_version: ''
         }
       end
 
@@ -49,8 +50,14 @@ module Defmastership
       private
 
       def parse_ref_files_from_git(adoc_sources, tmpdir)
-        Git.clone(ref_repo, tmpdir, branch: ref_tag)
+        repo_url = Helper.resolve_remote_url(ref_repo)
+
+        Git.clone(repo_url, tmpdir, branch: ref_tag, recursive: true)
         ref_sources = ref_document.empty? ? adoc_sources.keys : ref_document
+        parse_tmpdir_files(tmpdir, ref_sources)
+      end
+
+      def parse_tmpdir_files(tmpdir, ref_sources)
         ref_sources.each do |adoc_file|
           @ref_document.parse_file_with_preprocessor("#{tmpdir}/#{adoc_file}")
         end
@@ -70,14 +77,40 @@ module Defmastership
 
       def version_string(match)
         ref_definition = Helper.def_from_match(@ref_document, match)
+        return force_version_for_new unless ref_definition
+
         definition = Helper.def_from_match(document, match)
-        return unless ref_definition
+        Helper.ref_version(ref_definition, definition, self)
+      end
 
-        Helper.ref_version(ref_definition, definition, first_version)
+      # @return [String, nil] the forced version if configured and the definition is new
+      def force_version_for_new
+        forced = config.fetch(:force_version).to_s
+        forced unless forced.empty?
       end
 
       # Helper functions
       module Helper
+        # @param path [String] the repository path
+        # @return [String, nil] the origin URL if found
+        def self.find_origin_url(path)
+          local_git = Git.open(path)
+          origin_remote = local_git.remotes.find { |remote| remote.name.eql?('origin') }
+          origin_remote&.url
+        rescue ArgumentError
+          nil
+        end
+
+        # @param path [String] the repository path
+        # @return [String] the resolved remote URL
+        def self.resolve_remote_url(path)
+          if File.directory?(path)
+            find_origin_url(path) || path
+          else
+            path
+          end
+        end
+
         # @param doc [Document] the document with defintions
         # @param match [MatchData] Regexp match matching a reference
         # @return [Definition] the definition from a +Document+ with a matching reference
@@ -87,13 +120,44 @@ module Defmastership
 
         # @param ref_definition [Definition] the definition from the reference document
         # @param definition [Definition] the definition from the current document
-        # @param first_version [String] first version from configuration
+        # @param modifier [UpdateDefVersion] the modifier configuration
         # @return [String] the current definition version
-        def self.ref_version(ref_definition, definition, first_version)
-          new_ref_version = ref_definition.explicit_version
-          return new_ref_version if definition.sha256_short.eql?(ref_definition.sha256_short)
+        def self.ref_version(ref_definition, definition, modifier)
+          ref_ver = ref_definition.explicit_version
+          return ref_ver if definition.sha256_short.eql?(ref_definition.sha256_short)
 
-          new_ref_version ? new_ref_version.next : first_version
+          forced = modifier.config.fetch(:force_version).to_s
+          return next_or_first(ref_ver, modifier.first_version) if forced.empty?
+
+          check_and_return_forced(ref_definition, ref_ver, forced)
+        end
+
+        # @param explicit_version [String, nil] the explicit version from the reference document
+        # @param first_version [String] the first version
+        # @return [String] the selected version
+        def self.next_or_first(explicit_version, first_version)
+          explicit_version ? explicit_version.next : first_version
+        end
+
+        # @param ref_definition [Definition] the definition from the reference document
+        # @param ref_ver [String, nil] the explicit version from the reference document
+        # @param forced [String] the forced version
+        # @return [String] the forced version
+        def self.check_and_return_forced(ref_definition, ref_ver, forced)
+          raise_already_forced(ref_definition, forced) if ref_ver.eql?(forced)
+
+          forced
+        end
+
+        # @param ref_definition [Definition] the definition from the reference document
+        # @param force_version [String] forced version from configuration
+        def self.raise_already_forced(ref_definition, force_version)
+          raise(
+            ArgumentError,
+            "#{ref_definition.reference} has changed " \
+            'but its version in reference document is ' \
+            "already at force_version (#{force_version})"
+          )
         end
 
         # Make sure that ref_document configuration is an Array

data/lib/defmastership/version.rb

@@ -3,6 +3,6 @@
 
 module Defmastership
   # [String] Gem version
-  VERSION = '1.3.6'
+  VERSION = '1.3.8'
   public_constant :VERSION
 end

data/spec/unit/defmastership/modifier/update_def_version_spec.rb

@@ -12,6 +12,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
     it { is_expected.to(have_attributes(def_type: '')) }
     it { is_expected.to(have_attributes(ref_document: [])) }
     it { is_expected.to(have_attributes(first_version: '')) }
+    it { is_expected.to(have_attributes(force_version: '')) }
   end
 
   describe '.replacement_methods' do
@@ -116,6 +117,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
       before do
         allow(Dir).to(receive(:mktmpdir).and_yield('tmp'))
         allow(Git).to(receive(:clone))
+        allow(Git).to(receive(:open)).and_raise(ArgumentError)
         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'))
@@ -131,7 +133,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
       end
 
       it { expect(Dir).to(have_received(:mktmpdir).with('defmastership')) }
-      it { expect(Git).to(have_received(:clone).with('.', 'tmp', branch: 'THE_TAG')) }
+      it { expect(Git).to(have_received(:clone).with('.', 'tmp', branch: 'THE_TAG', recursive: true)) }
       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')) }
@@ -142,6 +144,111 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
       end
     end
 
+    context 'when ref_repo is not a directory' do
+      subject(:modifier) do
+        described_class.new(ref_tag: 'THE_TAG', ref_repo: 'not_a_directory', def_type: 'req', first_version: 'a')
+      end
+
+      let(:adoc_sources) do
+        {
+          'file1.adoc' => "[define,req,REFERENCE]\nfile1 line2"
+        }
+      end
+
+      before do
+        document = instance_double(Defmastership::Document, 'document')
+        ref_document = instance_double(Defmastership::Document, 'ref_document')
+        definition = instance_double(Defmastership::Definition, 'definition')
+        ref_definition = instance_double(Defmastership::Definition, 'ref_definitions')
+
+        allow(Dir).to(receive(:mktmpdir).and_yield('tmp'))
+        allow(Git).to(receive(:clone))
+        allow(File).to(receive(:directory?).with('not_a_directory').and_return(false))
+
+        allow(Defmastership::Document).to(receive(:new).twice.and_return(ref_document, document))
+        allow(document).to(receive_messages(parse_file_with_preprocessor: nil, ref_to_def: definition))
+        allow(ref_document).to(receive_messages(parse_file_with_preprocessor: nil, ref_to_def: ref_definition))
+        allow(ref_definition).to(receive_messages(explicit_version: nil, sha256_short: 'something_else'))
+        allow(definition).to(receive(:sha256_short).and_return('something'))
+      end
+
+      it 'clones the non-directory path directly as the repository URL' do
+        modifier.do_modifications(adoc_sources)
+        expect(Git).to(have_received(:clone).with('not_a_directory', 'tmp', branch: 'THE_TAG', recursive: true))
+      end
+    end
+
+    context 'when ref_repo is a local git repository' do
+      subject(:modifier) { described_class.new(ref_tag: 'THE_TAG', def_type: 'req', first_version: 'a') }
+
+      let(:local_git) { instance_double(Git::Base) }
+      let(:remote)    { instance_double(Git::Remote, name: 'origin', url: 'https://gitlab.example.com/repo.git') }
+      let(:adoc_sources) do
+        {
+          'file1.adoc' => "[define,req,REFERENCE]\nfile1 line2"
+        }
+      end
+
+      before do
+        document = instance_double(Defmastership::Document, 'document')
+        ref_document = instance_double(Defmastership::Document, 'ref_document')
+        definition = instance_double(Defmastership::Definition, 'definition')
+        ref_definition = instance_double(Defmastership::Definition, 'ref_definitions')
+
+        allow(Dir).to(receive(:mktmpdir).and_yield('tmp'))
+        allow(Git).to(receive(:clone))
+        allow(File).to(receive(:directory?).with('.').and_return(true))
+        allow(Git).to(receive(:open)).with('.').and_return(local_git)
+        allow(local_git).to(receive(:remotes)).and_return([remote])
+
+        allow(Defmastership::Document).to(receive(:new).twice.and_return(ref_document, document))
+        allow(document).to(receive_messages(parse_file_with_preprocessor: nil, ref_to_def: definition))
+        allow(ref_document).to(receive_messages(parse_file_with_preprocessor: nil, ref_to_def: ref_definition))
+        allow(ref_definition).to(receive_messages(explicit_version: nil, sha256_short: 'something_else'))
+        allow(definition).to(receive(:sha256_short).and_return('something'))
+
+        modifier.do_modifications(adoc_sources)
+      end
+
+      it { expect(Git).to(have_received(:clone).with('https://gitlab.example.com/repo.git', 'tmp', branch: 'THE_TAG', recursive: true)) }
+    end
+
+    context 'when ref_repo is a local git repository without an origin remote' do
+      subject(:modifier) { described_class.new(ref_tag: 'THE_TAG', def_type: 'req', first_version: 'a') }
+
+      let(:local_git) { instance_double(Git::Base) }
+      let(:remote)    { instance_double(Git::Remote, name: 'upstream', url: 'https://gitlab.example.com/repo.git') }
+      let(:adoc_sources) do
+        {
+          'file1.adoc' => "[define,req,REFERENCE]\nfile1 line2"
+        }
+      end
+
+      before do
+        document = instance_double(Defmastership::Document, 'document')
+        ref_document = instance_double(Defmastership::Document, 'ref_document')
+        definition = instance_double(Defmastership::Definition, 'definition')
+        ref_definition = instance_double(Defmastership::Definition, 'ref_definitions')
+
+        allow(Dir).to(receive(:mktmpdir).and_yield('tmp'))
+        allow(Git).to(receive(:clone))
+        allow(File).to(receive(:directory?).with('.').and_return(true))
+        allow(Git).to(receive(:open)).with('.').and_return(local_git)
+        # Setup the mock so it doesn't find 'origin'
+        allow(local_git).to(receive(:remotes)).and_return([remote])
+
+        allow(Defmastership::Document).to(receive(:new).twice.and_return(ref_document, document))
+        allow(document).to(receive_messages(parse_file_with_preprocessor: nil, ref_to_def: definition))
+        allow(ref_document).to(receive_messages(parse_file_with_preprocessor: nil, ref_to_def: ref_definition))
+        allow(ref_definition).to(receive_messages(explicit_version: nil, sha256_short: 'something_else'))
+        allow(definition).to(receive(:sha256_short).and_return('something'))
+
+        modifier.do_modifications(adoc_sources)
+      end
+
+      it { expect(Git).to(have_received(:clone).with('.', 'tmp', branch: 'THE_TAG', recursive: true)) }
+    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')
@@ -161,6 +268,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
       before do
         allow(Dir).to(receive(:mktmpdir).and_yield('tmp'))
         allow(Git).to(receive(:clone))
+        allow(Git).to(receive(:open)).and_raise(ArgumentError)
         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'))
@@ -176,7 +284,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
       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(Git).to(have_received(:clone).with('not dot', 'tmp', branch: 'THE_TAG', recursive: true)) }
       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')) }
@@ -211,6 +319,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
       before do
         allow(Dir).to(receive(:mktmpdir).and_yield('tmp'))
         allow(Git).to(receive(:clone))
+        allow(Git).to(receive(:open)).and_raise(ArgumentError)
         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'))
@@ -225,7 +334,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
       end
 
       it { expect(Dir).to(have_received(:mktmpdir).with('defmastership')) }
-      it { expect(Git).to(have_received(:clone).with('.', 'tmp', branch: 'THE_TAG')) }
+      it { expect(Git).to(have_received(:clone).with('.', 'tmp', branch: 'THE_TAG', recursive: true)) }
       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) }
@@ -236,6 +345,77 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
     end
   end
 
+  describe '.resolve_remote_url' do
+    subject(:resolved_url) { described_class.const_get(:Helper).resolve_remote_url(path) }
+
+    context 'when the path is not a directory' do
+      let(:path) { 'git@github.com:org/repo.git' }
+
+      before do
+        allow(File).to(receive(:directory?).with(path).and_return(false))
+      end
+
+      it 'returns the exact path itself' do
+        expect(resolved_url).to(be(path))
+      end
+
+      it 'queries File.directory?' do
+        resolved_url
+        expect(File).to(have_received(:directory?).with(path))
+      end
+    end
+
+    context 'when the path is a directory and has an origin remote' do
+      let(:path)      { '/path/to/local/repo'                                                                    }
+      let(:local_git) { instance_double(Git::Base)                                                               }
+      let(:remote)    { instance_double(Git::Remote, name: 'origin', url: 'https://gitlab.example.com/repo.git') }
+
+      before do
+        allow(File).to(receive(:directory?).with(path).and_return(true))
+        allow(Git).to(receive(:open)).with(path).and_return(local_git)
+        allow(local_git).to(receive(:remotes)).and_return([remote])
+      end
+
+      it 'returns the origin remote url' do
+        expect(resolved_url).to(eq('https://gitlab.example.com/repo.git'))
+      end
+
+      it 'queries File.directory?' do
+        resolved_url
+        expect(File).to(have_received(:directory?).with(path))
+      end
+    end
+
+    context 'when the path is a directory but does not have an origin remote' do
+      let(:path) { '/path/to/local/repo' }
+      let(:local_git) { instance_double(Git::Base)                                                                 }
+      let(:remote)    { instance_double(Git::Remote, name: 'upstream', url: 'https://gitlab.example.com/repo.git') }
+
+      before do
+        allow(File).to(receive(:directory?).with(path).and_return(true))
+        allow(Git).to(receive(:open)).with(path).and_return(local_git)
+        allow(local_git).to(receive(:remotes)).and_return([remote])
+      end
+
+      it 'returns the path itself' do
+        expect(resolved_url).to(eq(path))
+      end
+    end
+
+    context 'when Git.open raises an ArgumentError' do
+      let(:path) { '/path/to/local/repo' }
+
+      before do
+        allow(File).to(receive(:directory?).with(path).and_return(true))
+        allow(Git).to(receive(:open)).with(path).and_raise(ArgumentError)
+      end
+
+      it 'returns the path itself' do
+        expect(resolved_url).to(eq(path))
+      end
+    end
+  end
+
   describe '#replace_reference' do
     subject(:modifier) { described_class.new(def_type: 'requirement', first_version: 'a') }
 
@@ -323,5 +503,127 @@ RSpec.describe(Defmastership::Modifier::UpdateDefVersion) do
         end
       end
     end
+
+    context 'when force_version is provided' do
+      subject(:modifier) { described_class.new(def_type: 'requirement', force_version: '42') }
+
+      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 'retains the previous reference version if it had one' do
+          allow(ref_definition).to(receive(:explicit_version).and_return('3'))
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE(3)]'))
+        end
+
+        it 'does not add a version if it had none' do
+          allow(ref_definition).to(receive(:explicit_version).and_return(nil))
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE]'))
+        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_messages(sha256_short: +'~4321aaaa', reference: 'REFERENCE'))
+        end
+
+        it 'sets the version to the forced version if it had a previous version' do
+          allow(ref_definition).to(receive(:explicit_version).and_return('3'))
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE(42)]'))
+        end
+
+        it 'sets the version to the forced version if it had no previous version' do
+          allow(ref_definition).to(receive(:explicit_version).and_return(nil))
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE(42)]'))
+        end
+
+        it 'raises an error if the previous version is already equal to the forced version' do
+          allow(ref_definition).to(receive(:explicit_version).and_return('42'))
+          msg = 'REFERENCE has changed but its version in reference document is already at force_version (42)'
+          expect { modifier.replace_reference('', '[define,requirement,REFERENCE]') }
+            .to(raise_error(ArgumentError, msg))
+        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 'sets the version to the forced version' do
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE(42)]'))
+        end
+      end
+    end
+
+    context 'when force_version is an integer' do
+      subject(:modifier) { described_class.new(def_type: 'requirement', force_version: 42) }
+
+      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 is new' do
+        before do
+          allow(ref_document).to(receive(:ref_to_def).with('REFERENCE').and_return(nil))
+        end
+
+        it 'sets the version to the string representation' do
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE(42)]'))
+        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_messages(sha256_short: +'~4321aaaa', reference: 'REFERENCE'))
+        end
+
+        it 'converts force_version to string' do
+          allow(ref_definition).to(receive(:explicit_version).and_return('3'))
+          expect(modifier.replace_reference('', '[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE(42)]'))
+        end
+      end
+    end
+
+    context 'when force_version is nil' do
+      subject(:modifier) { described_class.new(def_type: 'requirement', force_version: nil) }
+
+      before do
+        allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+        allow(definition).to(receive(:sha256_short).and_return(+'~abcd1234'))
+        allow(ref_document).to(receive(:ref_to_def).with('REFERENCE').and_return(nil))
+      end
+
+      it 'does not add a version if the definition is new' do
+        expect(modifier.replace_reference('', '[define,requirement,REFERENCE]'))
+          .to(eq('[define,requirement,REFERENCE]'))
+      end
+    end
+
+    context 'when force_version is missing from config' do
+      it 'raises a KeyError' do
+        obj = described_class.new(def_type: 'requirement')
+        allow(obj).to(receive(:config).and_return({}))
+        expect { obj.__send__(:force_version_for_new) }
+          .to(raise_error(KeyError))
+      end
+    end
   end
 end

data/spec/unit/defmastership/modifier/update_iref_checksum_spec.rb

@@ -29,23 +29,26 @@ RSpec.describe(Defmastership::Modifier::UpdateIrefChecksum) do
       allow(Defmastership::Document).to(receive(:new).and_return(document))
       allow(document).to(receive(:parse_file_with_preprocessor))
       allow_any_instance_of(Defmastership::Modifier::ModifierCommon).to(receive(:do_modifications).and_return(adoc_sources))
+    end
 
+    it 'creates a new document' do
       modifier.do_modifications(adoc_sources)
+      expect(Defmastership::Document).to(have_received(:new))
     end
 
-    it { expect(Defmastership::Document).to(have_received(:new)) }
+    it 'parses the first adoc file with preprocessor' do
+      modifier.do_modifications(adoc_sources)
+      expect(document).to(have_received(:parse_file_with_preprocessor).with('file1.adoc'))
+    end
 
-    it do
-      expect(document).to(
-        have_received(:parse_file_with_preprocessor)
-          .once.with('file1.adoc')
-          .once.with('file2.adoc')
-      )
+    it 'parses the second adoc file with preprocessor' do
+      modifier.do_modifications(adoc_sources)
+      expect(document).to(have_received(:parse_file_with_preprocessor).with('file2.adoc'))
     end
 
     it { expect(modifier.do_modifications(adoc_sources)).to(eq(adoc_sources)) }
 
-    it 'call the parent method' do
+    it 'call the parent method with arguments' do
       expect_any_instance_of(Defmastership::Modifier::ModifierCommon).to(receive(:do_modifications).with(adoc_sources))
       modifier.do_modifications(adoc_sources)
     end

data/spec/unit/defmastership/modifier/update_iref_version_spec.rb

@@ -29,23 +29,26 @@ RSpec.describe(Defmastership::Modifier::UpdateIrefVersion) do
       allow(Defmastership::Document).to(receive(:new).and_return(document))
       allow(document).to(receive(:parse_file_with_preprocessor))
       allow_any_instance_of(Defmastership::Modifier::ModifierCommon).to(receive(:do_modifications).and_return(adoc_sources))
+    end
 
+    it 'creates a new document' do
       modifier.do_modifications(adoc_sources)
+      expect(Defmastership::Document).to(have_received(:new))
     end
 
-    it { expect(Defmastership::Document).to(have_received(:new)) }
+    it 'parses the first adoc file with preprocessor' do
+      modifier.do_modifications(adoc_sources)
+      expect(document).to(have_received(:parse_file_with_preprocessor).with('file1.adoc'))
+    end
 
-    it do
-      expect(document).to(
-        have_received(:parse_file_with_preprocessor)
-          .once.with('file1.adoc')
-          .once.with('file2.adoc')
-      )
+    it 'parses the second adoc file with preprocessor' do
+      modifier.do_modifications(adoc_sources)
+      expect(document).to(have_received(:parse_file_with_preprocessor).with('file2.adoc'))
     end
 
     it { expect(modifier.do_modifications(adoc_sources)).to(eq(adoc_sources)) }
 
-    it 'call the parent method' do
+    it 'call the parent method with arguments' do
       expect_any_instance_of(Defmastership::Modifier::ModifierCommon).to(receive(:do_modifications).with(adoc_sources))
       modifier.do_modifications(adoc_sources)
     end

data/tasks/code_quality.rake

@@ -1,7 +1,7 @@
 # Copyright (c) 2023 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/BlockLength
+# rubocop:disable-next Metrics/BlockLength
 namespace 'quality' do
   begin
     require('rubocop/rake_task')
@@ -58,7 +58,6 @@ namespace 'quality' do
   desc 'Runs all quality code check'
   task(all: ['quality:rubocop', 'quality:reek', 'quality:flay'])
 end
-# rubocop:enable Metrics/BlockLength
 
 desc 'Synonym for quality:rubocop'
 task(rubocop: 'quality:rubocop')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: defmastership
 version: !ruby/object:Gem::Version
-  version: 1.3.6
+  version: 1.3.8
 platform: ruby
 authors:
 - Jérôme Arbez-Gindre
@@ -272,7 +272,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.9
+rubygems_version: 4.0.21
 specification_version: 4
 summary: Handling of references and definitions with asciidoctor
 test_files: []