defmastership 1.3.2 → 1.3.4

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

@@ -56,6 +56,33 @@ 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: change the filename of a file included in a definition (sub directory)
+    Given a file named "modifications.yml" with:
+    """
+    ---
+    :rename_included_png:
+      :type: rename_included_files
+      :config:
+        :from_regexp: (?<origin>.*\.png)
+        :to_template: "%<reference>s_%<origin>s"
+    """
+    And a directory named "any_path"
+    And a file named "any_path/thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-WHATEVER-123]
+    include::one_file.png[]
+    """
+    And an empty file named "any_path/one_file.png"
+    When I successfully run `defmastership modify --modifications rename_included_png any_path/thedoc.adoc`
+    Then the stdout should not contain anything
+    And the file "any_path/thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-WHATEVER-123]
+    include::TOTO-WHATEVER-123_one_file.png[]
+    """
+    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: change the filename with options in include macro
     Given a file named "modifications.yml" with:
     """
@@ -146,3 +173,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/features/step_definitions/git_steps.rb

@@ -9,6 +9,9 @@ end
 
 Given('I add and commit the {string} file') do |filename|
   git = Git.open(Aruba.config.home_directory)
+
+  git.config('user.name', 'Bob Léponge')
+  git.config('user.email', 'bob.léponge@example.com')
   git.add(filename)
   git.commit('whatever')
 end

data/lib/defmastership/app.rb

@@ -6,6 +6,9 @@ require('defmastership/batch_modifier')
 require('defmastership/config_preserver')
 require('defmastership/document')
 require('defmastership/export/csv/formatter')
+require('defmastership/export/json/formatter')
+require('defmastership/export/xlsx/formatter')
+require('defmastership/export/yaml/formatter')
 require('defmastership/version')
 require('gli')
 
@@ -23,22 +26,49 @@ 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.flag(%i[format f], desc: 'Output format', default_value: 'csv')
       command.switch(%i[no-fail], desc: 'Exit success even in case of wrong explicit checksum')
     end
 
+    # Helper method
+    def self.do_the_export(my_doc, options, first_adoc_file)
+      format = options.fetch('format')
+      formatter = create_formatter(my_doc, format, options)
+      output_file = determine_output_file(options, first_adoc_file, format)
+
+      formatter.export_to(output_file)
+    end
+
+    class << self
+      private
+
+      # Responsibility: Create the correct formatter instance with its specific options.
+      def create_formatter(doc, format, options)
+        formatter_class = Object.const_get("Defmastership::Export::#{format.upcase}::Formatter")
+        formatter_options = format == 'xlsx' ? {} : { separator: options.fetch(:separator) }
+
+        formatter_class.new(doc, **formatter_options)
+      end
+
+      # Responsibility: Determine the final output filename.
+      def determine_output_file(options, first_adoc_file, format)
+        options.fetch(:'output-file') || first_adoc_file.sub(/(?<=\.)adoc$/, format)
+      end
+    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')
-
-        Defmastership::Export::CSV::Formatter.new(my_doc, options['separator']).export_to(output_file)
+        App.do_the_export(my_doc, options, args.first)
 
         if my_doc.wrong_explicit_checksum?
           my_doc.definitions.each do |definition|
@@ -82,10 +112,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/export/csv/formatter.rb

@@ -1,9 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('csv')
-require('defmastership/export/body_formatter')
-require('defmastership/export/header_formatter')
+require('defmastership/export/formatter')
 
 module Defmastership
   # Module to host export classes
@@ -11,17 +9,17 @@ module Defmastership
     # Module to host CSV export classes
     module CSV
       # to export a CSV file
-      class Formatter
+      class Formatter < Defmastership::Export::Formatter
         # @param doc [Document] the document to export
-        # @param sep [String] the CSV separator
-        def initialize(doc, sep)
-          @doc = doc
-          @sep = sep
+        # @param separator [String] the CSV separator
+        def initialize(doc, separator: ',')
+          @sep = separator
+          super(doc)
         end
 
         # Export the document to a CSV file
         #
-        # @param output_file [Strinf] filename for the export
+        # @param output_file [String] filename for the export
         def export_to(output_file)
           column_list = build_column_list
           ::CSV.open(output_file, 'w:ISO-8859-1', col_sep: @sep) do |csv|
@@ -32,58 +30,8 @@ module Defmastership
 
         private
 
-        # Helper functions
-        module Helper
-          # @return [Array<Symbol>] the array of methods for columns inclusion
-          #
-          # @param column_spec [MethodSpec] the method to include or not with its guard
-          # @param doc [Document] the Document to export
-          def self.column_method(column_spec, doc)
-            column_spec.guard.call(doc) ? [column_spec.column_method] : []
-          end
-
-          # 2-uplet with  one method to include or not depending of a lambda guard
-          MethodSpec = Struct.new(:column_method, :guard)
-          public_constant :MethodSpec
-        end
-        private_constant :Helper
-
-        COLUMNS_METHODS_SPECIFICATIONS =
-          [
-            Helper::MethodSpec.new(:type,                    ->(_) { true }),
-            Helper::MethodSpec.new(:reference,               ->(_) { true }),
-            Helper::MethodSpec.new(:summary,                 lambda(&:summaries?)),
-            Helper::MethodSpec.new(:value,                   ->(_) { true }),
-            Helper::MethodSpec.new(:checksum,                ->(_) { true }),
-            Helper::MethodSpec.new(:wrong_explicit_checksum, lambda(&:wrong_explicit_checksum?)),
-            Helper::MethodSpec.new(:explicit_version,        lambda(&:explicit_version?)),
-            Helper::MethodSpec.new(:labels,                  ->(doc) { !doc.labels.empty? }),
-            Helper::MethodSpec.new(:eref,                    ->(doc) { !doc.eref.empty? }),
-            Helper::MethodSpec.new(:iref,                    lambda(&:iref)),
-            Helper::MethodSpec.new(:attributes,              ->(doc) { !doc.attributes.empty? })
-          ].freeze
-        private_constant :COLUMNS_METHODS_SPECIFICATIONS
-
         def export_definitions_in(csv, column_list)
-          @doc.definitions.each { |definition| csv << body(definition, column_list) }
-        end
-
-        def header(column_list)
-          header_formatter = HeaderFormatter.new(@doc)
-          header_line = column_list.map { |part| header_formatter.public_send(part) }
-          header_line.flatten
-        end
-
-        def body(definition, column_list)
-          body_formatter = BodyFormatter.new(@doc, definition)
-          body_line = column_list.map { |part| body_formatter.public_send(part) }
-          body_line.flatten
-        end
-
-        def build_column_list
-          COLUMNS_METHODS_SPECIFICATIONS.reduce([]) do |acc, column|
-            acc + Helper.column_method(column, @doc)
-          end
+          doc.definitions.each { |definition| csv << body(definition, column_list) }
         end
       end
     end

data/lib/defmastership/export/formatter.rb

@@ -0,0 +1,88 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/export/body_formatter')
+require('defmastership/export/header_formatter')
+
+module Defmastership
+  # Module to host export classes
+  module Export
+    # to export a CSV file
+    class Formatter
+      attr_reader :doc
+
+      # @param doc [Document] the document to export
+      def initialize(doc)
+        @doc = doc
+      end
+
+      # Export the document to a CSV file
+      #
+      # @param _output_file [String] filename for the export
+      def export_to(_output_file)
+        raise(NotImplementedError, "#{self.class} has not implemented the 'export_to' method")
+      end
+
+      # Build content of the header from the list of columns
+      #
+      # @param column_list [Array<Symbol>] List of columns to include
+      # @return [Array<String>] List of colums values
+      def header(column_list)
+        header_formatter = HeaderFormatter.new(doc)
+        header_line = column_list.map { |part| header_formatter.public_send(part) }
+        header_line.flatten
+      end
+
+      # Build content of a row from the list of columns
+      #
+      # @param definition [Definition] sourec of data
+      # @param column_list [Array<Symbol>] List of columns to include
+      # @return [Array<String>] List of colums values
+      def body(definition, column_list)
+        body_formatter = BodyFormatter.new(doc, definition)
+        body_line = column_list.map { |part| body_formatter.public_send(part) }
+        body_line.flatten
+      end
+
+      private
+
+      # Helper functions
+      module Helper
+        # @return [Array<Symbol>] the array of methods for columns inclusion
+        #
+        # @param column_spec [MethodSpec] the method to include or not with its guard
+        # @param doc [Document] the Document to export
+        def self.column_method(column_spec, doc)
+          column_spec.guard.call(doc) ? [column_spec.column_method] : []
+        end
+
+        # 2-uplet with  one method to include or not depending of a lambda guard
+        MethodSpec = Struct.new(:column_method, :guard)
+        public_constant :MethodSpec
+      end
+      public_constant :Helper
+
+      COLUMNS_METHODS_SPECIFICATIONS =
+        [
+          Helper::MethodSpec.new(:type,                    ->(_) { true }),
+          Helper::MethodSpec.new(:reference,               ->(_) { true }),
+          Helper::MethodSpec.new(:summary,                 lambda(&:summaries?)),
+          Helper::MethodSpec.new(:value,                   ->(_) { true }),
+          Helper::MethodSpec.new(:checksum,                ->(_) { true }),
+          Helper::MethodSpec.new(:wrong_explicit_checksum, lambda(&:wrong_explicit_checksum?)),
+          Helper::MethodSpec.new(:explicit_version,        lambda(&:explicit_version?)),
+          Helper::MethodSpec.new(:labels,                  ->(doc) { !doc.labels.empty? }),
+          Helper::MethodSpec.new(:eref,                    ->(doc) { !doc.eref.empty? }),
+          Helper::MethodSpec.new(:iref,                    lambda(&:iref)),
+          Helper::MethodSpec.new(:attributes,              ->(doc) { !doc.attributes.empty? })
+        ].freeze
+      private_constant :COLUMNS_METHODS_SPECIFICATIONS
+
+      def build_column_list
+        COLUMNS_METHODS_SPECIFICATIONS.reduce([]) do |acc, column|
+          acc + Helper.column_method(column, doc)
+        end
+      end
+    end
+  end
+end

data/lib/defmastership/export/json/formatter.rb

@@ -0,0 +1,34 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/export/formatter')
+require('json')
+
+module Defmastership
+  # Module to host export classes
+  module Export
+    # Module to host JSON export classes
+    module JSON
+      # to export a JSON file
+      class Formatter < Defmastership::Export::Formatter
+        # @param doc [Document] the document to export
+        # @param _options [Hash{Symbol => Object}] unused options
+        def initialize(doc, _options = {})
+          super(doc)
+        end
+
+        # Export the document to a JSON file
+        # @param output_file [String] filename for the export
+        def export_to(output_file)
+          column_list = build_column_list
+          header_column_list = header(column_list).map(&:to_sym)
+          definitions =
+            doc.definitions.map do |definition|
+              header_column_list.zip(body(definition, column_list)).to_h
+            end
+          File.write(output_file, ::JSON.pretty_generate(definitions))
+        end
+      end
+    end
+  end
+end

data/lib/defmastership/export/xlsx/formatter.rb

@@ -0,0 +1,87 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/export/body_formatter')
+require('defmastership/export/header_formatter')
+require('memoist')
+require('rubyXL')
+
+module Defmastership
+  # Module to host export classes
+  module Export
+    # Module to host XLSX export classes
+    module XLSX
+      # to export a XSLX file
+      class Formatter < Defmastership::Export::Formatter
+        # @param doc [Document] the document to export
+        # @param [Hash{Symbol => Object}] _options
+        def initialize(doc, _options = {})
+          super(doc)
+        end
+
+        # Export the document to a XSLX file
+        #
+        # @param output_file [String] filename for the export
+        def export_to(output_file)
+          workbook = RubyXL::Workbook.new
+          column_list = build_column_list
+          xlsx_data = XLSXData.new(self, workbook, doc, column_list)
+
+          # Delegate the entire process to the XLSXData object
+          xlsx_data.export_to(output_file, doc.definitions)
+        end
+      end
+
+      # Encapsulate the data clump
+      class XLSXData
+        extend Memoist
+
+        attr_reader :column_list
+
+        # @param formatter [XLSX::Formatter] the concerned formatter
+        # @param workbook [XLSXData] the workbook to save
+        # @param doc [Document] the document to export
+        # @param column_list [Array<Symbol>] the list of columns to export
+        def initialize(formatter, workbook, doc, column_list)
+          @formatter = formatter
+          @workbook = workbook
+          @doc = doc
+          @column_list = column_list
+        end
+
+        # Build an write the exported Excel Spreasheet
+        #
+        # @param output_file [String] filename for the export
+        # @param definitions [Array<Definition>] the list of definitions
+        def export_to(output_file, definitions)
+          add_header(@formatter.header(@column_list))
+
+          definitions.each_with_index do |definition, def_index|
+            add_row(@formatter.body(definition, @column_list), def_index + 1)
+          end
+
+          @workbook.write(output_file)
+        end
+
+        private
+
+        def add_header(header_data)
+          header_data.each_with_index do |val, index|
+            worksheet.add_cell(0, index, val)
+          end
+        end
+
+        def add_row(row_data, row_index)
+          row_data.each_with_index do |val, index|
+            worksheet.add_cell(row_index, index, val)
+          end
+        end
+
+        def worksheet
+          @workbook.worksheets.first
+        end
+        memoize :worksheet
+      end
+    end
+  end
+end

data/lib/defmastership/export/yaml/formatter.rb

@@ -0,0 +1,34 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/export/formatter')
+require('yaml')
+
+module Defmastership
+  # Module to host export classes
+  module Export
+    # Module to host YAML export classes
+    module YAML
+      # to export a YAML file
+      class Formatter < Defmastership::Export::Formatter
+        # @param doc [Document] the document to export
+        # @param  _options [Hash{Symbol => Object}] unused options
+        def initialize(doc, _options = {})
+          super(doc)
+        end
+
+        # Export the document to a YAML file
+        # @param output_file [String] filename for the export
+        def export_to(output_file)
+          column_list = build_column_list
+          header_column_list = header(column_list).map(&:to_sym)
+          definitions =
+            doc.definitions.map do |definition|
+              header_column_list.zip(body(definition, column_list)).to_h
+            end
+          File.write(output_file, ::YAML.dump(definitions))
+        end
+      end
+    end
+  end
+end