defmastership 1.3.7 → 1.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e4fb0225a55bdddfb2c4f0c3dbca650f991c9c018ea1d80bd9f6b7481b9e8b2
-  data.tar.gz: d70ae41ef99b5437241cec107f99ed924be71419c3c2c704e52035367c06c8bd
+  metadata.gz: 12ede2830cace7dbc8665f7db780d2bb60acf8f5beb771b4ec9bfdb9fbd74c5b
+  data.tar.gz: 92010c0156be9e4c74f36789b4c269097d61d9bde4d87ccfa2fc1a8869aa4475
 SHA512:
-  metadata.gz: b698312e2bd57eab8331876ec1b4284a682e319d870c037b21272467c1b6e0e44e822eb49228dbc8edfe34c1916c3593eebc294c5611b49605cebb1fc3eb0336
-  data.tar.gz: f24030b68f490ebe51fe60d0573876e3e9388c077ef7f1ee02561341db96a22955cd3071ffe2c33857e43b330f08fb19aa7d0b3bc0f413486b765499550cffcb
+  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

@@ -644,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/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
 
@@ -76,10 +77,16 @@ 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
@@ -113,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)
+
+          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)
 
-          new_ref_version ? new_ref_version.next : first_version
+          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.7'
+  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
@@ -502,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/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.7
+  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.12
+rubygems_version: 4.0.21
 specification_version: 4
 summary: Handling of references and definitions with asciidoctor
 test_files: []