defmastership 1.0.19 → 1.1.1

data/lib/defmastership/change_ref_modifier.rb

@@ -1,99 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require 'defmastership/constants'
-require 'defmastership/modifier'
-
-module DefMastership
-  # Change references from temporary to definitive with multiple RefChangers
-  class ChangeRefModifier
-    include Modifier
-
-    REGEXP_FROM = {
-      definition: {
-        before: DMRegexp::DEF_BEFORE_REF,
-        after: DMRegexp::DEF_AFTER_REF
-      },
-      iref: {
-        before: DMRegexp::IREF_DEF_BEF,
-        after: DMRegexp::IREF_DEF_AFT
-      }
-    }.freeze
-
-    private_constant :REGEXP_FROM
-
-    def self.replacement_methods
-      %i[replace_refdef replace_irefs]
-    end
-
-    def self.default_config
-      {
-        from_regexp: '',
-        to_template: '',
-        next_ref: 0
-      }
-    end
-
-    def initialize(config)
-      @parsing_state = ParsingState.new
-
-      setup_modifier_module(config)
-    end
-
-    def replace(method, line)
-      public_send(:"replace_#{method}", line)
-    end
-
-    def replace_refdef(line)
-      if @parsing_state.enabled?(line)
-        do_replace_refdef(line)
-      else
-        line
-      end
-    end
-
-    def replace_irefs(line)
-      changes.reduce(line) do |res_line, (from, to)|
-        res_line.gsub(Helper.regexp_from(:iref, from)) do
-          Helper.text_with(Regexp.last_match, to)
-        end
-      end
-    end
-
-    private
-
-    def do_replace_refdef(line)
-      line.sub(Helper.regexp_from(:definition, from_regexp)) do
-        replacement_from(Regexp.last_match)
-      end
-    end
-
-    def replacement_from(match)
-      replacement = to_template % hmerge(match)
-      changes << [match[:from], replacement]
-      config[:next_ref] += 1
-      Helper.text_with(match, replacement)
-    end
-
-    def hmerge(match)
-      config.merge(match.named_captures.transform_keys(&:to_sym))
-    end
-
-    # Helper functions
-    module Helper
-      def self.regexp_from(const, from)
-        regexps = REGEXP_FROM.fetch(const)
-        regexp_str =
-          "(?<before>#{regexps[:before]})" \
-          "(?<from>#{from})" \
-          "#{DMRegexp::DEF_VERSION_AND_CHECKSUM}" \
-          "(?<after>#{regexps[:after]})"
-        Regexp.new(regexp_str, Regexp::EXTENDED)
-      end
-
-      def self.text_with(match, replacement)
-        match[:before] + replacement + (match[:version_and_checksum] || '') + match[:after]
-      end
-    end
-  end
-end

data/lib/defmastership/constants.rb

@@ -1,91 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-module DefMastership
-  # set of regexp of added asciidoctor constructions
-  # This module smells of :reek:TooManyConstants
-  module DMRegexp
-    SINGLE_LINE_COMMENT = %r{^//[^/]}.freeze
-
-    DEF_BEFORE_REF = <<~'BEF'
-      ^\s*
-      \[\s*define\s*,
-      \s*(?<type>[\w:_-]+)\s*,
-      \s*
-    BEF
-
-    DEF_AFTER_REF = <<~'AFT'
-      \s*
-      (,\s*\[\s*(?<labels>.*?)\s*\])?\s*\]
-    AFT
-
-    DEF_VERSION_AND_CHECKSUM = '(?<version_and_checksum>' \
-                               '\((?<explicit_version>[^~]+)?(?<explicit_checksum>~[[:alnum:]]+)?\)' \
-                               ')?'
-
-    REFERENCE = '(?<reference>[\\w:_-]+)'
-
-    DEFINITION = Regexp.new(
-      "#{DEF_BEFORE_REF}#{REFERENCE}#{DEF_VERSION_AND_CHECKSUM}#{DEF_AFTER_REF}",
-      Regexp::EXTENDED
-    )
-
-    VARIABLE_DEF = /^\s*:(?<varname>[\w:_-]+):\s+
-                   (?<value>\S.*\S)\s*$/x.freeze
-
-    VARIABLE_USE = /{(?<varname>[\w:_-]+)}/x.freeze
-
-    EREF_CONFIG = /^\s*:eref-(?<reference>[\w:_-]+)-(?<symb>prefix|url):\s*
-                   \s*(?<value>\S.*\S)\s*/x.freeze
-    EREF_DEF = /^\s*
-               defs:eref\[
-               \s*(?<reference>[\w:_-]+)\s*,
-               \s*\[\s*(?<extrefs>[^\]]+?)\s*\]\s*\]/x.freeze
-    BLOCK = /^--\s*$/.freeze
-
-    IREF_DEF_BEF = 'defs:iref\[\s*'
-    IREF_DEF_AFT = '\s*\]'
-    IREF_DEF = Regexp.new(
-      "#{IREF_DEF_BEF}(?<intref>[\\w:_-]+)#{IREF_DEF_AFT}",
-      Regexp::EXTENDED
-    )
-
-    ATTR_CONFIG = /\s*:attr-(?<attr>[\w:_-]+)-prefix:
-                      \s+(?<prefix>.+?)\s*$/x.freeze
-    ATTR_SET = /\s*
-                defs:attribute\[
-                \s*(?<attr>[\w:_-]+)\s*,
-                \s*(?<value>.+?)\s*\]/x.freeze
-
-    EMPTY_LINE = /^\s*$/.freeze
-
-    WHATEVER = //.freeze
-
-    INCLUDE_KEYWORD  = '\binclude::'
-    INCLUDE_PATH     = '(?<path>.*/)?'
-    INCLUDE_FILENAME = '(?<filename>[^\\/]+)'
-    INCLUDE_OPTIONS  = '\[(?<options>[^\]]*)\]'
-
-    INCLUDE = Regexp.new(
-      INCLUDE_KEYWORD + INCLUDE_PATH + INCLUDE_FILENAME + INCLUDE_OPTIONS,
-      Regexp::EXTENDED
-    )
-
-    public_constant :SINGLE_LINE_COMMENT,
-                    :DEF_BEFORE_REF,
-                    :DEF_AFTER_REF,
-                    :DEFINITION,
-                    :VARIABLE_DEF,
-                    :VARIABLE_USE,
-                    :EREF_CONFIG,
-                    :EREF_DEF,
-                    :BLOCK,
-                    :IREF_DEF_BEF,
-                    :IREF_DEF_AFT,
-                    :IREF_DEF,
-                    :ATTR_CONFIG,
-                    :ATTR_SET,
-                    :EMPTY_LINE,
-                    :WHATEVER
-  end
-end

data/lib/defmastership/csv_formatter.rb

@@ -1,53 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require('csv')
-require('defmastership/csv_formatter_body')
-require('defmastership/csv_formatter_header')
-
-module DefMastership
-  # to export a CSV file
-  class CSVFormatter
-    def initialize(doc, sep)
-      @doc = doc
-      @sep = sep
-    end
-
-    def export_to(output_file)
-      column_list = build_column_list
-      CSV.open(output_file, 'w:ISO-8859-1', col_sep: @sep) do |csv|
-        csv << header(column_list)
-        export_definitions_in(csv, column_list)
-      end
-    end
-
-    private
-
-    def export_definitions_in(csv, column_list)
-      @doc.definitions.each { |definition| csv << body(definition, column_list) }
-    end
-
-    def header(column_list)
-      header_formatter = CSVFormatterHeader.new(@doc)
-      header_line = column_list.map { |part| header_formatter.public_send(part) }
-      header_line.flatten
-    end
-
-    def body(definition, column_list)
-      body_formatter = CSVFormatterBody.new(@doc, definition)
-      body_line = column_list.map { |part| body_formatter.public_send(part) }
-      body_line.flatten
-    end
-
-    def build_column_list
-      [
-        [:wrong_explicit_checksum, @doc.wrong_explicit_checksum?],
-        [:explicit_version, @doc.explicit_version?],
-        [:labels, !@doc.labels.empty?],
-        [:eref, !@doc.eref.empty?],
-        [:iref, @doc.iref],
-        [:attributes, !@doc.attributes.empty?]
-      ].reduce([:fixed]) { |acc, elem| acc + (elem.fetch(1) ? [elem.first] : []) }
-    end
-  end
-end

data/lib/defmastership/csv_formatter_body.rb

@@ -1,46 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require('csv')
-
-require('defmastership/set_join_hack')
-
-module DefMastership
-  # format lines per definition
-  class CSVFormatterBody
-    def initialize(doc, definition)
-      @doc = doc
-      @definition = definition
-    end
-
-    def fixed
-      [@definition.type, @definition.reference, @definition.value, @definition.sha256_short]
-    end
-
-    def wrong_explicit_checksum
-      wrong_explicit_checksum = @definition.wrong_explicit_checksum
-      wrong_explicit_checksum ? [wrong_explicit_checksum] : ['']
-    end
-
-    def explicit_version
-      explicit_version = @definition.explicit_version
-      explicit_version ? [explicit_version] : ['']
-    end
-
-    def labels
-      [@definition.labels.join("\n")]
-    end
-
-    def eref
-      @doc.eref.map { |key,| @definition.eref.fetch(key, []).join("\n") }
-    end
-
-    def iref
-      [@definition.iref.join("\n")]
-    end
-
-    def attributes
-      @doc.attributes.map { |key,| @definition.attributes.fetch(key, '') }
-    end
-  end
-end

data/lib/defmastership/csv_formatter_header.rb

@@ -1,41 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require('csv')
-
-module DefMastership
-  # format header for one document
-  class CSVFormatterHeader
-    def initialize(doc)
-      @doc = doc
-    end
-
-    def fixed
-      %w[Type Reference Value Checksum]
-    end
-
-    def wrong_explicit_checksum
-      @doc.wrong_explicit_checksum? ? ['Wrong explicit checksum'] : []
-    end
-
-    def explicit_version
-      @doc.explicit_version? ? ['Version'] : []
-    end
-
-    def labels
-      @doc.labels.empty? ? [] : %w[Labels]
-    end
-
-    def eref
-      @doc.eref.map { |_, ref| ref.fetch(:prefix) }
-    end
-
-    def iref
-      @doc.iref ? ['Internal links'] : []
-    end
-
-    def attributes
-      @doc.attributes.map { |_, value| value }
-    end
-  end
-end

data/lib/defmastership/modifier.rb

@@ -1,42 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-# 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

@@ -1,31 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-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)
-
-      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
-    end
-  end
-end

data/lib/defmastership/rename_included_files_modifier.rb

@@ -1,182 +0,0 @@
-# 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
-  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 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/update_def_checksum_modifier.rb

@@ -1,16 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require 'defmastership/constants'
-require 'defmastership/update_def_modifier'
-
-module DefMastership
-  # modify one line after another
-  class UpdateDefChecksumModifier < UpdateDefModifier
-    private
-
-    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

@@ -1,49 +0,0 @@
-# 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
-    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