defmastership 1.0.16 → 1.0.18

data/lib/defmastership/modifier.rb

@@ -0,0 +1,42 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # define methods for line modifiers
+  module Modifier
+    attr_reader :config, :changes
+
+    def setup_modifier_module(config)
+      @config = self.class.default_config.merge(config)
+      @changes = []
+    end
+
+    def method_missing(method_name, *args)
+      config_method_name = config[method_name]
+      return config_method_name if config_method_name
+
+      super
+    end
+
+    def respond_to_missing?(method_name, *args)
+      config.key?(method_name) || super
+    end
+
+    def apply_to_all(texts, method)
+      texts.transform_values do |text|
+        apply_to_one(text, method)
+      end
+    end
+
+    def apply_to_one(text, method)
+      text.lines.map { |line| public_send(method, line) }
+          .join
+    end
+
+    def do_modifications(adoc_sources)
+      self.class.replacement_methods.reduce(adoc_sources) do |texts, method|
+        apply_to_all(texts, method)
+      end
+    end
+  end
+end

data/lib/defmastership/modifier_factory.rb

@@ -0,0 +1,12 @@
+# Copyright (c) 2023 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # build midifers from a piece of configuration
+  module ModifierFactory
+    def self.from_config(config)
+      class_name = "#{config.fetch(:type).split('_').map(&:capitalize).join}Modifier"
+      DefMastership.const_get(class_name).new(config.fetch(:config))
+    end
+  end
+end

data/lib/defmastership/parsing_state.rb

@@ -4,22 +4,28 @@
 module DefMastership
   # Allow to know if we need to parse the line or simply ignore it
   class ParsingState
+    # mutant:disable (for mutant, aatribute initialization is useless)
     def initialize
       @last_disabling_line = nil
     end
 
     def enabled?(line)
-      return false if line.match(DMRegexp::SINGLE_LINE_COMMENT)
+      return false if line.match?(DMRegexp::SINGLE_LINE_COMMENT)
 
-      line = line.dup.chomp
-      if ['....', '----', '////'].include?(line)
-        if @last_disabling_line == line
-          @last_disabling_line = nil
-        elsif @last_disabling_line.nil?
-          @last_disabling_line = line
-        end
+      line = line.chomp
+      possibly_invert_last_disabling_line(line) if ['....', '----', '////'].include?(line)
+
+      !@last_disabling_line
+    end
+
+    private
+
+    def possibly_invert_last_disabling_line(line)
+      if @last_disabling_line == line
+        @last_disabling_line = nil
+      elsif !@last_disabling_line
+        @last_disabling_line = line
       end
-      @last_disabling_line.nil?
     end
   end
 end

data/lib/defmastership/rename_included_files_modifier.rb

@@ -1,15 +1,182 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require 'defmastership/constants'
+require('defmastership/matching_line')
+require 'defmastership/modifier'
+
+# defintion of the Rename Included Files Modifier
 module DefMastership
-  # Change included filenames
-  class RenameIncludedFilesModifier < ModifierBase
-    def replacements
+  LOCAL_FILTERS = [
+    Filter.new(DMRegexp::VARIABLE_DEF,  :new_variable_def),
+    Filter.new(DMRegexp::DEFINITION,    :new_definition),
+    Filter.new(DMRegexp::BLOCK,         :block_delimiter),
+    Filter.new(DMRegexp::EMPTY_LINE,    :empty_line),
+    Filter.new(DMRegexp::WHATEVER,      :new_line)
+  ].freeze
+  private_constant :LOCAL_FILTERS
+
+  # Change included filenames on one line at a time
+  class RenameIncludedFilesModifier
+    include Modifier
+
+    PARSER_ACTIONS = {
+      new_variable_def: lambda { |matching_line|
+        @variables.merge!(Helper.variable_def_hash(matching_line.match))
+      },
+      add_line: proc { |_| },
+      add_new_definition: lambda { |matching_line|
+        config[:reference] = matching_line.match[:reference]
+      }
+    }.freeze
+
+    private_constant :PARSER_ACTIONS
+
+    def self.replacement_methods
       %i[replace]
     end
 
-    def new_line_modifier(config, _adoc_texts)
-      RenameIncludedFilesLineModifier.from_config(config)
+    def self.default_config
+      {
+        from_regexp: '',
+        to_template: ''
+      }
+    end
+
+    def initialize(config)
+      @variables = {}
+      @definition_parser = DefinitionParser.new(self)
+
+      setup_modifier_module(config)
+    end
+
+    def method_missing(method_name, *args)
+      action = PARSER_ACTIONS[method_name]
+      return instance_exec(*args, &action) if action
+
+      super
+    end
+
+    def respond_to_missing?(method_name, *args)
+      PARSER_ACTIONS.key?(method_name) || super
+    end
+
+    def replace(line)
+      match = matched?(line)
+
+      return line unless match
+
+      new_line = build_new_include_line(match, line)
+
+      rename_file(line, new_line)
+
+      new_line
+    end
+
+    private
+
+    def build_new_include_line(match, line)
+      line.sub(Helper.complete_regexp_from(from_regexp)) do
+        Helper.text_with(match, to_template % Helper.hmerge(config, match))
+      end
+    end
+
+    def matched?(line)
+      return false unless concerned_line?(line)
+      return false unless line =~ Helper.complete_regexp_from(from_regexp)
+
+      match = Regexp.last_match
+
+      return false if config.key?(:cancel_if_match) && match[:filename].match?(cancel_if_match)
+
+      match
+    end
+
+    def concerned_line?(line)
+      return false if line.commented?
+
+      parse(line)
+
+      return false if @definition_parser.idle?
+
+      true
+    end
+
+    def parse(line)
+      Helper.apply_filters_until_consumed(line) do |event, match|
+        generate_event(event, MatchingLine.new(match))
+      end
+    end
+
+    def rename_file(from, to)
+      filename_from = Helper.extract_filename(from, @variables)
+      filename_to = Helper.extract_filename(to, @variables)
+      changes << [filename_from, filename_to]
+      File.rename(filename_from, filename_to)
+    end
+
+    def generate_event(event, matching_line)
+      if PARSER_ACTIONS.key?(event)
+        public_send(event, matching_line)
+      else
+        @definition_parser.public_send(event, matching_line)
+      end
+    end
+
+    # Helper functions
+    module Helper
+      def self.extract_filename(include_statement, variables)
+        filename = filename_from_include_statement(include_statement)
+
+        filename_replace_all_variables(filename, variables).chomp
+      end
+
+      def self.filename_from_include_statement(include_statement)
+        include_statement
+          .sub(Regexp.new(DMRegexp::INCLUDE_KEYWORD), '')
+          .sub(Regexp.new(DMRegexp::INCLUDE_OPTIONS), '')
+      end
+
+      def self.filename_replace_all_variables(filename, variables)
+        filename.scan(DMRegexp::VARIABLE_USE) do
+          varname = Regexp.last_match[:varname]
+          value = variables.fetch(varname.to_sym)
+          filename = filename_replace_one_variable(filename, varname, value)
+        end
+        filename
+      end
+
+      def self.filename_replace_one_variable(filename, varname, value)
+        filename.sub("{#{varname}}", value)
+      end
+
+      def self.complete_regexp_from(from)
+        Regexp.new(
+          DMRegexp::INCLUDE_KEYWORD + DMRegexp::INCLUDE_PATH +
+          "(?<filename>#{from})" + DMRegexp::INCLUDE_OPTIONS
+        )
+      end
+
+      def self.text_with(match, to)
+        "include::#{match[:path]}#{to}[#{match[:options]}]"
+      end
+
+      def self.hmerge(config, match)
+        config.merge(match.names.map(&:to_sym).zip(match.captures).to_h)
+      end
+
+      def self.variable_def_hash(match)
+        { match[:varname].to_sym => match[:value] }
+      end
+
+      def self.apply_filters_until_consumed(line)
+        LOCAL_FILTERS.each do |filter|
+          next unless line.match(filter.regexp)
+
+          yield(filter.event, Regexp.last_match)
+          break
+        end
+      end
     end
   end
 end

data/lib/defmastership/set_join_hack.rb

@@ -0,0 +1,11 @@
+# Copyright (c) 2024 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+if RUBY_VERSION < '3.0'
+  # Ruby 2.7 do not implement join for Set
+  class Set
+    def join(*args)
+      to_a.join(*args)
+    end
+  end
+end

data/lib/defmastership/update_def_checksum_modifier.rb

@@ -1,21 +1,16 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require 'defmastership/constants'
+require 'defmastership/update_def_modifier'
+
 module DefMastership
-  # Update definition checksum with calculated one
-  class UpdateDefChecksumModifier < ModifierBase
-    def replacements
-      %i[replace]
-    end
+  # modify one line after another
+  class UpdateDefChecksumModifier < UpdateDefModifier
+    private
 
-    def new_line_modifier(config, adoc_texts)
-      document = Document.new
-      adoc_texts.each do |adoc_file, _|
-        document.parse_file_with_preprocessor(adoc_file)
-      end
-      line_modifier = UpdateDefChecksumLineModifier.from_config(config)
-      line_modifier.document = document
-      line_modifier
+    def reference_replacement(reference, match)
+      "#{reference}(#{match[:explicit_version]}#{document.ref_to_def(reference).sha256_short})"
     end
   end
 end

data/lib/defmastership/update_def_modifier.rb

@@ -0,0 +1,49 @@
+# Copyright (c) 2024 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # absttrac class for modififier that need o update defintion references
+  class UpdateDefModifier
+    include Modifier
+
+    attr_reader :document
+
+    def self.default_config
+      {
+        def_type: ''
+      }
+    end
+
+    def self.replacement_methods
+      %i[replace_reference]
+    end
+
+    def self.reference_regexp(reference)
+      Regexp.new("#{reference}#{DMRegexp::DEF_VERSION_AND_CHECKSUM}")
+    end
+
+    def initialize(config)
+      @document = Document.new
+
+      setup_modifier_module(config)
+    end
+
+    def do_modifications(adoc_sources)
+      adoc_sources.each_key do |adoc_file|
+        document.parse_file_with_preprocessor(adoc_file)
+      end
+
+      super(adoc_sources)
+    end
+
+    def replace_reference(line)
+      match = line.match(DMRegexp::DEFINITION)
+
+      return line unless match
+      return line unless match[:type] == def_type
+
+      reference = match[:reference]
+      line.sub(self.class.reference_regexp(reference), reference_replacement(reference, match))
+    end
+  end
+end

data/lib/defmastership/update_def_version_modifier.rb

@@ -1,25 +1,66 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require 'defmastership/constants'
+require 'defmastership/update_def_modifier'
+
 module DefMastership
-  # Update definition version if the definition has change since
-  # reference document
-  class UpdateDefVersionModifier < ModifierBase
-    def replacements
-      %i[replace]
+  # modify one line after another
+  class UpdateDefVersionModifier < UpdateDefModifier
+    def self.default_config
+      {
+        def_type: '',
+        ref_document: '',
+        first_version: ''
+      }
+    end
+
+    def initialize(config)
+      @ref_document = Document.new
+
+      super(config)
+    end
+
+    def do_modifications(adoc_sources)
+      @ref_document.parse_file_with_preprocessor(config.fetch(:ref_document))
+
+      super(adoc_sources)
+    end
+
+    private
+
+    def reference_replacement(reference, match)
+      "#{reference}#{version_and_checksum_str(match)}"
     end
 
-    def new_line_modifier(config, adoc_texts)
-      document = Document.new
-      adoc_texts.each do |adoc_file, _|
-        document.parse_file_with_preprocessor(adoc_file)
+    def version_and_checksum_str(match)
+      explicit_checksum = match[:explicit_checksum]
+      version = version_string(match)
+      return unless explicit_checksum || version
+
+      "(#{version}#{explicit_checksum})"
+    end
+
+    def version_string(match)
+      ref_definition = Helper.def_from_match(@ref_document, match)
+      definition = Helper.def_from_match(document, match)
+      return unless ref_definition
+
+      Helper.ref_version(ref_definition, definition, config.fetch(:first_version))
+    end
+
+    # Helper functions
+    module Helper
+      def self.def_from_match(doc, match)
+        doc.ref_to_def(match[:reference])
+      end
+
+      def self.ref_version(ref_definition, definition, first_version)
+        new_ref_version = ref_definition.explicit_version
+        return new_ref_version if definition.sha256_short == ref_definition.sha256_short
+
+        new_ref_version ? new_ref_version.next : first_version
       end
-      ref_document = Document.new
-      ref_document.parse_file_with_preprocessor(config[:ref_document])
-      line_modifier = UpdateDefVersionLineModifier.from_config(config)
-      line_modifier.document = document
-      line_modifier.ref_document = ref_document
-      line_modifier
     end
   end
 end

data/lib/defmastership/version.rb

@@ -2,6 +2,6 @@
 # frozen_string_literal: true
 
 module DefMastership
-  VERSION = '1.0.16'
+  VERSION = '1.0.18'
   public_constant :VERSION
 end

data/lib/defmastership.rb

@@ -5,27 +5,17 @@ require('defmastership/version')
 
 # Add requires for other files you add to your project here, so
 # you just need to require this one file in your bin file
+require('defmastership/batch_modifier')
+require('defmastership/change_ref_modifier')
+require('defmastership/comment_filter')
 require('defmastership/constants')
-require('defmastership/parsing_state')
+require('defmastership/csv_formatter')
 require('defmastership/definition')
 require('defmastership/definition_parser')
-require('defmastership/filters')
 require('defmastership/document')
-require('defmastership/comment_filter')
-require('defmastership/csv_formatter')
-
-require('defmastership/modifier_base')
-require('defmastership/line_modifier_base')
-require('defmastership/batch_modifier')
-
-require('defmastership/change_ref_modifier')
-require('defmastership/change_ref_line_modifier')
-
+require('defmastership/filters')
+require('defmastership/modifier_factory')
+require('defmastership/parsing_state')
 require('defmastership/rename_included_files_modifier')
-require('defmastership/rename_included_files_line_modifier')
-
 require('defmastership/update_def_checksum_modifier')
-require('defmastership/update_def_checksum_line_modifier')
-
 require('defmastership/update_def_version_modifier')
-require('defmastership/update_def_version_line_modifier')

data/spec/spec_helper.rb

@@ -1,9 +1,8 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('bundler/setup')
-require('aruba/rspec')
 require('aasm/rspec')
+require('aruba/rspec')
 
 # formatter = [SimpleCov::Formatter::HTMLFormatter]
 # SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(formatter)
@@ -18,8 +17,11 @@ SimpleCov.start do
 
   add_filter 'config'
   add_filter 'vendor'
+  add_filter 'set_join_hack'
 
   minimum_coverage 100
+
+  enable_coverage :branch
 end
 
 RSpec.configure do |config|