defmastership 1.3.2 → 1.3.3

data/features/internal_ref_version.feature

@@ -0,0 +1,81 @@
+Feature: internal ref version
+  As a Responsible of definitions for a given document
+  In order to detect impacts of the modifications of definitions
+  I want defmastership update version in definitions internal references
+
+  Scenario Outline: Update one internal ref (<comment>)
+    Given a file named "modifications.yml" with:
+    """
+    ---
+    :update_internal_ref_version:
+      :type: update_iref_version
+    """
+    And a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-TEMP-XXX1<ref version>]
+    --
+    the requirement value.
+    --
+
+    See defs:iref[TOTO-TEMP-XXX1<before>]
+    """
+    When I successfully run `defmastership modify --modifications update_internal_ref_version thedoc.adoc`
+    Then the stdout should not contain anything
+    And the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-TEMP-XXX1<ref version>]
+    --
+    the requirement value.
+    --
+
+    See defs:iref[TOTO-TEMP-XXX1<after>]
+    """
+
+    Examples:
+      | ref version | before       | after        | comment                            |
+      | (z)         |              | (z)          | No initial version                 |
+      | (z)         | (a)          | (z)          | With initial version               |
+      | (z)         | (~abcd1234)  | (z~abcd1234) | With checksum                      |
+      | (z)         | (a~abcd1234) | (z~abcd1234) | With checksum and initial versions |
+      |             |              |              | No initial version                 |
+      |             | (a)          |              | With initial version               |
+      |             | (~abcd1234)  | (~abcd1234)  | With checksum                      |
+      |             | (a~abcd1234) | (~abcd1234)  | With checksum and initial versions |
+
+  Scenario: Update more internal refs
+    Given a file named "modifications.yml" with:
+    """
+    ---
+    :update_internal_ref_version:
+      :type: update_iref_version
+    """
+    And a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-TEMP-XXX1(b)]
+    --
+    the requirement value.
+    --
+
+    [define, requirement, TOTO-TEMP-XXX2(z)]
+    --
+    Another requirement value.
+    --
+
+    See defs:iref[TOTO-TEMP-XXX1] and defs:iref[TOTO-TEMP-XXX2]
+    """
+    When I successfully run `defmastership modify --modifications update_internal_ref_version thedoc.adoc`
+    Then the stdout should not contain anything
+    And the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-TEMP-XXX1(b)]
+    --
+    the requirement value.
+    --
+
+    [define, requirement, TOTO-TEMP-XXX2(z)]
+    --
+    Another requirement value.
+    --
+
+    See defs:iref[TOTO-TEMP-XXX1(b)] and defs:iref[TOTO-TEMP-XXX2(z)]
+    """

data/features/rename_included_files.feature

@@ -146,3 +146,31 @@ Feature: The rename_included_files command
     And the file "any_path/one_file.png" should not exist
     And the file "any_path/TOTO-WHATEVER-123_one_file.png" should exist
 
+  Scenario: do NOT change the filename of a file when definition's type does not fit a value
+    Given a file named "modifications.yml" with:
+    """
+    ---
+    :rename_included_png:
+      :type: rename_included_files
+      :config:
+        :def_type:
+        - requirement
+        :from_regexp: (?<origin>.*\.png)
+        :to_template: "%<reference>s_%<origin>s"
+    """
+    And a file named "thedoc.adoc" with:
+    """
+    [define, whatever, TOTO-WHATEVER-123]
+    include::any_path/one_file.png[]
+    """
+    And a directory named "any_path"
+    And an empty file named "any_path/one_file.png"
+    When I successfully run `defmastership modify --modifications rename_included_png thedoc.adoc`
+    Then the stdout should not contain anything
+    And the file "thedoc.adoc" should contain:
+    """
+    [define, whatever, TOTO-WHATEVER-123]
+    include::any_path/one_file.png[]
+    """
+    And the file "any_path/one_file.png" should exist
+    And the file "any_path/TOTO-WHATEVER-123_one_file.png" should not exist

data/lib/defmastership/app.rb

@@ -23,20 +23,22 @@ module Defmastership
     # Helper method
     def self.configure_export_flags(command)
       command.flag(%i[separator sep s], default_value: ',', desc: 'CSV separator')
+      command.flag(%i[output-file o], desc: 'CSV output filename')
       command.switch(%i[no-fail], desc: 'Exit success even in case of wrong explicit checksum')
     end
 
     desc 'Export the definition database in CSV'
     arg 'asciidoctor_file'
+    arg 'asciidoctor_file', %i[optional multiple]
     command :export do |command|
       configure_export_flags(command)
       command.action do |_global_options, options, args|
         @results = { number_of_args_give_to_action: args.size }
 
         my_doc = Defmastership::Document.new
-        my_doc.parse_file_with_preprocessor(args.first)
+        args.each { |adoc_file| my_doc.parse_file_with_preprocessor(adoc_file) }
 
-        output_file = args.first.sub(/\.adoc$/, '.csv')
+        output_file = options[:'output-file'] || args.first.sub(/\.adoc$/, '.csv')
 
         Defmastership::Export::CSV::Formatter.new(my_doc, options['separator']).export_to(output_file)
 
@@ -82,10 +84,7 @@ module Defmastership
 
     # Helper method
     def self.configure_modify_changes_summary_flag(command)
-      command.flag(
-        %i[changes-summary s],
-        desc: 'generates a change summary in a CSV file'
-      )
+      command.flag(%i[changes-summary s], desc: 'generates a change summary in a CSV file')
     end
 
     desc 'Apply one or more modifications'

data/lib/defmastership/comment_filter.rb

@@ -1,6 +1,8 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require('defmastership/core/constants')
+
 # adding a method to string to figure out if a string is commented or
 # not.
 class String

data/lib/defmastership/def_type_list.rb

@@ -0,0 +1,25 @@
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module Defmastership
+  # Handle the possible configurations of def_type
+  class DefTypeList
+    # @param def_type_config [String,Array<String>] the definition's type configuration
+    def initialize(def_type_config)
+      if ['', 'all'].include?(def_type_config)
+        @allow_all = true
+      else
+        @allowed_types = Array(def_type_config)
+      end
+    end
+
+    # @param def_type [String] the definition's type to test
+    #
+    # @return [Boolean] true if the type is included in the DefTypeList instance
+    def include?(def_type)
+      return true if @allow_all
+
+      @allowed_types.include?(def_type)
+    end
+  end
+end

data/lib/defmastership/definition_parser.rb

@@ -28,12 +28,8 @@ module Defmastership
       end
 
       event :new_line do
-        transitions from: %i[wait_content single_para],
-                    to: :single_para,
-                    after: ->(*args) { @document.add_line(*args) }
-        transitions from: :in_block,
-                    to: :in_block,
-                    after: ->(*args) { @document.add_line(*args) }
+        transitions from: %i[wait_content single_para], to: :single_para, after: ->(*args) { @document.add_line(*args) }
+        transitions from: :in_block, to: :in_block, after: ->(*args) { @document.add_line(*args) }
         transitions from: :idle, to: :idle
       end
 

data/lib/defmastership/document.rb

@@ -13,14 +13,7 @@ require('forwardable')
 # Contains the content of a Defmastership document: mainly definitions
 module Defmastership
   # Class to host data of Document class
-  DocumentData = Struct.new(
-    :definitions,
-    :labels,
-    :eref,
-    :iref,
-    :attributes,
-    :variables
-  )
+  DocumentData = Struct.new(:definitions, :labels, :eref, :iref, :attributes, :variables)
 
   private_constant :DocumentData
 
@@ -48,7 +41,11 @@ module Defmastership
       self.has_iref = true
       line = matching_line.line
       line.scan(Core::DMRegexp::IREF_DEF) do |_|
-        definitions.last.add_iref(Regexp.last_match[:intref])
+        reference = Regexp.last_match[:intref]
+        if Regexp.last_match[:explicit_version] || Regexp.last_match[:explicit_checksum]
+          reference += "(#{Regexp.last_match[:explicit_version]}#{Regexp.last_match[:explicit_checksum]})"
+        end
+        definitions.last.add_iref(reference)
       end
     },
     new_attribute_conf: lambda { |matching_line|

data/lib/defmastership/modifier/change_ref.rb

@@ -2,6 +2,8 @@
 # frozen_string_literal: true
 
 require('defmastership/core/constants')
+require('defmastership/core/parsing_state')
+require('defmastership/def_type_list')
 require('defmastership/modifier/modifier_common')
 require('facets/file/writelines')
 
@@ -11,43 +13,14 @@ module Defmastership
     class ChangeRef
       include ModifierCommon
 
-      # [Regexp] match all text before the definition's reference
-      DEF_BEFORE_REF = <<~"BEF".freeze
-        ^
-        \\s*
-        \\[
-        #{Core::DMRegexp::DEF_KEYWORD}
-        #{Core::DMRegexp::DEF_TYPE}
-        ,
-        \\s*
-      BEF
-      private_constant :DEF_BEFORE_REF
-
-      # [Regexp] match all text after the definition's reference
-      DEF_AFTER_REF = <<~"AFT".freeze
-        \\s*
-        #{Core::DMRegexp::DEF_SUMMARY}
-        #{Core::DMRegexp::DEF_LABELS}
-        \\s*
-        \\]
-      AFT
-      private_constant :DEF_AFTER_REF
-
-      # [Regexp] match the begining of an internal cross reference
-      IREF_DEF_BEF = 'defs:iref\[\s*'
-      private_constant :IREF_DEF_BEF
-      # [Regexp] match the end of an internal cross reference
-      IREF_DEF_AFT = '\s*\]'
-      private_constant :IREF_DEF_AFT
-
       REGEXP_FROM = {
         definition: {
-          before: DEF_BEFORE_REF,
-          after: DEF_AFTER_REF
+          before: Core::DMRegexp::DEF_BEFORE_REF,
+          after: Core::DMRegexp::DEF_AFTER_REF
         },
         iref: {
-          before: IREF_DEF_BEF,
-          after: IREF_DEF_AFT
+          before: Core::DMRegexp::IREF_DEF_BEF,
+          after: Core::DMRegexp::IREF_DEF_AFT
         }
       }.freeze
 
@@ -63,6 +36,7 @@ module Defmastership
       # @return [Hash{Symbol => Object}] the default configuration
       def self.default_config
         {
+          def_type: '',
           from_regexp: '',
           to_template: '',
           next_ref: 0
@@ -127,7 +101,10 @@ module Defmastership
 
       def do_replace_refdef(line)
         line.sub(Helper.regexp_from(:definition, from_regexp)) do
-          replacement_from(Regexp.last_match)
+          last_match = Regexp.last_match
+          return line unless DefTypeList.new(config.fetch(:def_type)).include?(last_match[:type])
+
+          replacement_from(last_match)
         end
       end
 

data/lib/defmastership/modifier/factory.rb

@@ -5,6 +5,10 @@ require('defmastership/modifier/change_ref')
 require('defmastership/modifier/rename_included_files')
 require('defmastership/modifier/update_def_checksum')
 require('defmastership/modifier/update_def_version')
+require('defmastership/modifier/update_eref_checksum')
+require('defmastership/modifier/update_eref_version')
+require('defmastership/modifier/update_iref_checksum')
+require('defmastership/modifier/update_iref_version')
 
 module Defmastership
   module Modifier
@@ -15,7 +19,7 @@ module Defmastership
       # @param config [YAML] piece of configuration for this Modifier
       def self.from_config(config)
         class_name = config.fetch(:type).split('_').map(&:capitalize).join
-        Modifier.const_get(class_name).new(config.fetch(:config))
+        Modifier.const_get(class_name).new(config.fetch(:config, {}))
       end
     end
   end

data/lib/defmastership/modifier/rename_included_files.rb

@@ -1,7 +1,11 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require('defmastership/def_type_list')
+require('defmastership/definition_parser')
 require('defmastership/filters')
+require('defmastership/matching_line')
+require('defmastership/modifier/modifier_common')
 
 module Defmastership
   # defintion of the Rename Included Files Modifier
@@ -26,6 +30,7 @@ module Defmastership
         add_line: proc { |_| },
         add_new_definition: lambda { |matching_line|
           config[:reference] = matching_line.match[:reference]
+          @current_def_type = matching_line.match[:type]
         }
       }.freeze
 
@@ -39,15 +44,18 @@ module Defmastership
       # @return [Hash{Symbol => Object}] the default configuration
       def self.default_config
         {
+          def_type: '',
           from_regexp: '',
           to_template: ''
         }
       end
 
       # @param config [YAML] the modifier's provided configurations
+      # mutant:disable
       def initialize(config)
         @variables = {}
         @definition_parser = DefinitionParser.new(self)
+        @current_def_type = nil
 
         setup_modifier_module(config)
       end
@@ -109,6 +117,7 @@ module Defmastership
         parse(line)
 
         return false if @definition_parser.idle?
+        return false unless DefTypeList.new(config.fetch(:def_type)).include?(@current_def_type)
 
         true
       end

data/lib/defmastership/modifier/replacement_formatter.rb

@@ -0,0 +1,37 @@
+# lib/defmastership/modifier/replacement_formatter.rb
+
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require 'memoist'
+
+module Defmastership
+  module Modifier
+    # A small, single-purpose class to format a ref replacement string.
+    class ReplacementFormatter
+      extend Memoist
+
+      # @param match_data [MatchData] of the ref statement
+      # @param document [Document] the overall parsed document
+      # @param key [Symbol] the key to access the reference in match_data
+      def initialize(match_data, document, key)
+        @match_data = match_data
+        @document = document
+        @key = key
+      end
+
+      private
+
+      attr_reader :match_data, :document, :key
+
+      def reference_string
+        match_data[key]
+      end
+
+      def definition
+        document.ref_to_def(reference_string)
+      end
+      memoize :definition
+    end
+  end
+end

data/lib/defmastership/modifier/update_def.rb

@@ -1,6 +1,10 @@
 # Copyright (c) 2024 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require 'defmastership/def_type_list'
+require 'defmastership/document'
+require 'defmastership/modifier/modifier_common'
+
 module Defmastership
   module Modifier
     # @abstract Subclass and define +reference_replacement+ to implement a
@@ -60,7 +64,7 @@ module Defmastership
         match = line.match(Core::DMRegexp::DEFINITION)
 
         return line unless match
-        return line unless match[:type].eql?(def_type)
+        return line unless DefTypeList.new(def_type).include?(match[:type])
 
         reference = match[:reference]
         line.sub(self.class.reference_regexp(reference), reference_replacement(reference, match))

data/lib/defmastership/modifier/update_eref_checksum.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require 'defmastership/modifier/update_eref_common'
+
+module Defmastership
+  module Modifier
+    # Update external refs checksum
+    class UpdateErefChecksum < UpdateEref
+      # Methods's symbols will be called in sequence to perform the document modifications
+      #
+      # @return [Array<Symbol>] the two symbols of replacement methods
+      def self.replacement_methods
+        %i[replace_erefs]
+      end
+
+      private
+
+      # Provides the specific formatter class for checksum replacements.
+      def formatter_class
+        Helper::ErefReplacementFormatterChecksum
+      end
+
+      # Helper functions/classes
+      module Helper
+        # A small, single-purpose class to format the eref replacement string.
+        class ErefReplacementFormatterChecksum < ReplacementFormatter
+          # @param match_data [MatchData] of the ref statement
+          # @param document [Document] the overall parsed document
+          def initialize(match_data, document)
+            super(match_data, document, :reference)
+          end
+
+          # @return [String] the formatted string or the original match if no definition is found.
+          def to_s
+            version = match_data[:explicit_version]
+            checksum = definition ? definition.sha256_short : match_data[:explicit_checksum]
+            return reference_string unless version || checksum
+
+            "#{reference_string}(#{version}#{checksum})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/defmastership/modifier/update_eref_common.rb

@@ -0,0 +1,77 @@
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require 'defmastership/def_type_list'
+require 'defmastership/modifier/modifier_common'
+require 'defmastership/modifier/replacement_formatter'
+
+module Defmastership
+  module Modifier
+    # Update external refs version
+    class UpdateEref
+      include ModifierCommon
+
+      # @return [Hash{Symbol => Object}] the default configuration
+      def self.default_config
+        {
+          eref_type: '',
+          ref_document: ''
+        }
+      end
+
+      # @param config [YAML] the modifier's provided configurations
+      def initialize(config)
+        @the_ref_document = Document.new
+
+        setup_modifier_module(config)
+      end
+
+      # Apply the modifier on all provided asciidoc sources based on modifier's
+      # +self.replacement_methods+ list
+      #
+      # @param adoc_sources [Hash{String => String}] asciidoc sources
+      #  * :key filename
+      #  * :value file content
+      def do_modifications(adoc_sources)
+        Array(ref_document).each { |ref_doc| the_ref_document.parse_file_with_preprocessor(ref_doc) }
+
+        super
+      end
+
+      # Replace the definition's external ref in the line if relevant
+      #
+      # @param line [String] the current line
+      # @return [String] the modified line
+      def replace_erefs(line)
+        match = line.match(Core::DMRegexp::EREF_DEF)
+        # Return early if there's no match or the type is not valid
+        return line unless match && eref_type_valid?(match[:reference])
+
+        # Delegate the actual replacement to a separate method
+        perform_replacement(line, match[:extrefs])
+      end
+
+      private
+
+      # Performs the nested gsub replacement
+      #
+      # @param line [String] the current line
+      # @param extrefs [String] all teh matched external references
+      # @return [String] the modified line
+      def perform_replacement(line, extrefs)
+        line.sub(extrefs) do
+          extrefs.gsub(Regexp.new(Core::DMRegexp::REF_WITH_OPT_VER_CHK)) do
+            formatter_class.new(Regexp.last_match, the_ref_document)
+          end
+        end
+      end
+
+      attr_reader :the_ref_document
+
+      # Checks if the given eref type should be processed
+      def eref_type_valid?(this_eref_type)
+        DefTypeList.new(eref_type).include?(this_eref_type)
+      end
+    end
+  end
+end

data/lib/defmastership/modifier/update_eref_version.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require 'defmastership/modifier/update_eref_common'
+
+module Defmastership
+  module Modifier
+    # Update external refs version
+    class UpdateErefVersion < UpdateEref
+      # Methods's symbols will be called in sequence to perform the document modifications
+      #
+      # @return [Array<Symbol>] the two symbols of replacement methods
+      def self.replacement_methods
+        %i[replace_erefs]
+      end
+
+      private
+
+      # Provides the specific formatter class for checksum replacements.
+      def formatter_class
+        Helper::ErefReplacementFormatterVersion
+      end
+
+      # Helper functions/classes
+      module Helper
+        # A small, single-purpose class to format the eref replacement string.
+        class ErefReplacementFormatterVersion < ReplacementFormatter
+          # @param match_data [MatchData] of the ref statement
+          # @param document [Document] the overall parsed document
+          def initialize(match_data, document)
+            super(match_data, document, :reference)
+          end
+
+          # @return [String] the formatted string or the original match if no definition is found.
+          def to_s
+            version = definition ? definition.explicit_version : match_data[:explicit_version]
+            checksum = match_data[:explicit_checksum]
+            return reference_string unless version || checksum
+
+            "#{reference_string}(#{version}#{checksum})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/defmastership/modifier/update_iref_checksum.rb

@@ -0,0 +1,51 @@
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/core/constants')
+require('defmastership/modifier/replacement_formatter')
+require('defmastership/modifier/update_iref_common')
+
+module Defmastership
+  module Modifier
+    # Update internal refs checksum
+    class UpdateIrefChecksum < UpdateIref
+      include ModifierCommon
+
+      # Methods's symbols will be called in sequence to perform the document modifications
+      #
+      # @return [Array<Symbol>] the two symbols of replacement methods
+      def self.replacement_methods
+        %i[replace_irefs]
+      end
+
+      # Replace the definition's internal ref in the line if relevant
+      #
+      # @param line [String] the current line
+      # @return [String] the modified line
+      def replace_irefs(line)
+        line.gsub(Core::DMRegexp::IREF_DEF) do
+          Helper::IrefReplacementFormatterChecksum.new(Regexp.last_match, document).to_s
+        end
+      end
+
+      # Helper functions/classes
+      module Helper
+        # A small, single-purpose class to format the iref replacement string.
+        class IrefReplacementFormatterChecksum < ReplacementFormatter
+          # @param match_data [MatchData] of the ref statement
+          # @param document [Document] the overall parsed document
+          def initialize(match_data, document)
+            super(match_data, document, :intref)
+          end
+
+          # @return [String] the formatted string or the original match if no definition is found.
+          def to_s
+            return match_data unless definition
+
+            "defs:iref[#{reference_string}(#{match_data[:explicit_version]}#{definition.sha256_short})]"
+          end
+        end
+      end
+    end
+  end
+end