defmastership 1.0.16 → 1.0.18

data/lib/defmastership/change_ref_modifier.rb

@@ -1,15 +1,99 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require 'defmastership/constants'
+require 'defmastership/modifier'
+
 module DefMastership
-  # Change all refs of a given project
-  class ChangeRefModifier < ModifierBase
-    def replacements
+  # 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 new_line_modifier(config, _adoc_texts)
-      ChangeRefLineModifier.from_config(config)
+    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/comment_filter.rb

@@ -5,6 +5,6 @@
 # not.
 class String
   def commented?
-    !match(DefMastership::DMRegexp::SINGLE_LINE_COMMENT).nil?
+    !!match(DefMastership::DMRegexp::SINGLE_LINE_COMMENT)
   end
 end

data/lib/defmastership/constants.rb

@@ -3,6 +3,7 @@
 
 module DefMastership
   # set of regexp of added asciidoctor constructions
+  # This module smells of :reek:TooManyConstants
   module DMRegexp
     SINGLE_LINE_COMMENT = %r{^//[^/]}.freeze
 
@@ -27,8 +28,8 @@ module DefMastership
       Regexp::EXTENDED
     )
 
-    VARIABLE_DEF = /^\s*:(?<varname>[\w:_-]+):\s*
-                   \s*(?<value>\S.*\S)\s*$/x.freeze
+    VARIABLE_DEF = /^\s*:(?<varname>[\w:_-]+):\s+
+                   (?<value>\S.*\S)\s*$/x.freeze
 
     VARIABLE_USE = /{(?<varname>[\w:_-]+)}/x.freeze
 
@@ -37,7 +38,7 @@ module DefMastership
     EREF_DEF = /^\s*
                defs:eref\[
                \s*(?<refname>[\w:_-]+)\s*,
-               \s*\[(?<extrefs>[^\]]+)\]\s*\]/x.freeze
+               \s*\[\s*(?<extrefs>[^\]]+?)\s*\]\s*\]/x.freeze
     BLOCK = /^--\s*$/.freeze
 
     IREF_DEF_BEF = 'defs:iref\[\s*'
@@ -61,7 +62,7 @@ module DefMastership
     INCLUDE_KEYWORD  = '\binclude::'
     INCLUDE_PATH     = '(?<path>.*/)?'
     INCLUDE_FILENAME = '(?<filename>[^\\/]+)'
-    INCLUDE_OPTIONS  = '\[(?<options>[\]]*)\]'
+    INCLUDE_OPTIONS  = '\[(?<options>[^\]]*)\]'
 
     INCLUDE = Regexp.new(
       INCLUDE_KEYWORD + INCLUDE_PATH + INCLUDE_FILENAME + INCLUDE_OPTIONS,

data/lib/defmastership/csv_formatter.rb

@@ -2,48 +2,52 @@
 # frozen_string_literal: true
 
 require('csv')
-require('defmastership/csv_formatter_header')
 require('defmastership/csv_formatter_body')
+require('defmastership/csv_formatter_header')
 
 module DefMastership
   # to export a CSV file
   class CSVFormatter
-    def initialize(doc, sep = ',')
+    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.open(output_file, 'w:ISO-8859-1', col_sep: @sep) do |csv|
         csv << header(column_list)
-        @doc.definitions.each { |definition| csv << body(definition, 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.reduce(:+)
+      header_line.flatten
     end
 
     def body(definition, column_list)
-      body_formatter = CSVFormatterBody.new(@doc)
-      body_line = column_list.map { |part| body_formatter.public_send(part, definition) }
-      body_line.reduce(:+)
+      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
-      column_list = [:fixed]
-      column_list += [:wrong_explicit_checksum] if @doc.wrong_explicit_checksum?
-      column_list += [:explicit_version] if @doc.explicit_version?
-      column_list += [:labels] unless @doc.labels.empty?
-      column_list += [:eref] unless @doc.eref.empty?
-      column_list += [:iref] if @doc.iref
-      column_list += [:attributes] unless @doc.attributes.empty?
-      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

@@ -3,41 +3,44 @@
 
 require('csv')
 
+require('defmastership/set_join_hack')
+
 module DefMastership
   # format lines per definition
   class CSVFormatterBody
-    def initialize(doc)
+    def initialize(doc, definition)
       @doc = doc
+      @definition = definition
     end
 
-    def fixed(definition)
-      [definition.type, definition.reference, definition.value, definition.sha256]
+    def fixed
+      [@definition.type, @definition.reference, @definition.value, @definition.sha256_short]
     end
 
-    def wrong_explicit_checksum(definition)
-      wrong_explicit_checksum = definition.wrong_explicit_checksum
+    def wrong_explicit_checksum
+      wrong_explicit_checksum = @definition.wrong_explicit_checksum
       wrong_explicit_checksum ? [wrong_explicit_checksum] : ['']
     end
 
-    def explicit_version(definition)
-      explicit_version = definition.explicit_version
+    def explicit_version
+      explicit_version = @definition.explicit_version
       explicit_version ? [explicit_version] : ['']
     end
 
-    def labels(definition)
-      [definition.labels.to_a.join("\n")]
+    def labels
+      [@definition.labels.join("\n")]
     end
 
-    def eref(definition)
-      @doc.eref.map { |key, _| definition.eref[key].join("\n") }
+    def eref
+      @doc.eref.map { |key,| @definition.eref.fetch(key, []).join("\n") }
     end
 
-    def iref(definition)
-      [definition.iref.join("\n")]
+    def iref
+      [@definition.iref.join("\n")]
     end
 
-    def attributes(definition)
-      @doc.attributes.map { |key, _| definition.attributes[key] }
+    def attributes
+      @doc.attributes.map { |key,| @definition.attributes.fetch(key, '') }
     end
   end
 end

data/lib/defmastership/csv_formatter_header.rb

@@ -27,7 +27,7 @@ module DefMastership
     end
 
     def eref
-      @doc.eref.map { |_, ref| ref[:prefix] }
+      @doc.eref.map { |_, ref| ref.fetch(:prefix) }
     end
 
     def iref

data/lib/defmastership/definition.rb

@@ -3,51 +3,90 @@
 
 require 'digest'
 
+# Contains the content of a DefMastership definition
 module DefMastership
+  BUILD_FROM_MATCH = {
+    type: ->(match) { match[:type] },
+    reference: ->(match) { match[:reference] },
+    lines: ->(_) { [] },
+    labels: lambda do |match|
+      labels = Set.new
+      labels.merge(match[:labels].split(/\s*,\s*/).to_set) if match[:labels]
+      labels
+    end,
+    eref: ->(_) { Hash.new([]) },
+    iref: ->(_) { [] },
+    attributes: ->(_) { {} },
+    explicit_checksum: ->(match) { match[:explicit_checksum] },
+    explicit_version: ->(match) { match[:explicit_version] }
+  }.freeze
+
+  private_constant :BUILD_FROM_MATCH
+
+  # Class to host data of Definition class
+  DefinitionData = Struct.new(
+    :type,
+    :reference,
+    :lines,
+    :labels,
+    :eref,
+    :iref,
+    :attributes,
+    :explicit_checksum,
+    :explicit_version
+  )
+
+  private_constant :DefinitionData
+
   # DefMastership definition: contains all data of a definition
   class Definition
-    attr_reader :type, :reference, :lines, :labels, :eref, :iref, :attributes, :explicit_version
+    extend Forwardable
+    def_delegators :@data,
+                   :type,
+                   :reference,
+                   :lines,
+                   :labels,
+                   :eref,
+                   :iref,
+                   :attributes,
+                   :explicit_checksum,
+                   :explicit_version
 
     def initialize(match)
-      @type = match[:type]
-      @reference = match[:reference]
-      @lines = []
-      @labels = Set.new
-      @labels.merge(match[:labels].split(/\s*,\s*/).to_set) if match[:labels]
-      @eref = Hash.new([])
-      @iref = []
-      @attributes = {}
-      @explicit_checksum = match[:explicit_checksum]
-      @explicit_version = match[:explicit_version]
+      @data = DefinitionData.new(
+        *BUILD_FROM_MATCH.transform_values { |lamb| lamb.call(match) }
+           .fetch_values(*DefinitionData.members)
+      )
     end
 
     def <<(new_line)
-      @lines << new_line
+      lines << new_line
       self
     end
 
     def value
-      @lines.join("\n")
+      lines.join("\n")
     end
 
-    def sha256
-      "~#{Digest::SHA2.new(256).hexdigest(value).chars.last(8).join}"
+    def sha256_short
+      "~#{Digest::SHA2.hexdigest(value).chars.last(8).join}"
     end
 
     def wrong_explicit_checksum
-      @explicit_checksum if @explicit_checksum != sha256
+      explicit_checksum unless explicit_checksum.eql?(sha256_short)
     end
 
     def add_eref(refname, extrefs)
-      @eref[refname] = extrefs.strip.split(/\s*,\s*/)
+      eref[refname] = extrefs.strip.split(/\s*,\s*/)
     end
 
     def add_iref(ref)
-      @iref << ref
+      iref << ref
     end
 
     def set_attribute(key, value)
-      @attributes[key] = value
+      attributes[key] = value
     end
   end
+  public_constant :Definition
 end

data/lib/defmastership/document.rb

@@ -2,21 +2,87 @@
 # frozen_string_literal: true
 
 require('asciidoctor')
+require('defmastership/matching_line')
 
+# Contains the content of a DefMastership document: mainly definitions
 module DefMastership
-  # Contains the content of a DefMastership document: mainly definitions
+  # Class to host data of Document class
+  DocumentData = Struct.new(
+    :definitions,
+    :labels,
+    :eref,
+    :iref,
+    :attributes,
+    :variables
+  )
+
+  private_constant :DocumentData
+
+  PARSER_ACTIONS = {
+    add_new_definition: lambda { |matching_line|
+      definition = Definition.new(matching_line.match)
+      labels.merge(definition.labels)
+      definitions << definition
+      matching_line.line
+    },
+    add_line: lambda { |matching_line|
+      line = matching_line.line
+      definitions.last << line
+      line
+    },
+    new_eref_setup: lambda { |matching_line|
+      refname = matching_line[:refname].to_sym
+      eref[refname] ||= {}
+      eref[refname][matching_line[:symb].to_sym] = matching_line[:value]
+      matching_line.line
+    },
+    new_eref_def: lambda { |matching_line|
+      definitions.last.add_eref(matching_line[:refname].to_sym, matching_line[:extrefs])
+      matching_line.line
+    },
+    new_iref_def: lambda { |matching_line|
+      self.iref = true
+      line = matching_line.line
+      line.scan(DMRegexp::IREF_DEF) do |_|
+        definitions.last.add_iref(Regexp.last_match[:intref])
+      end
+      line
+    },
+    new_attribute_conf: lambda { |matching_line|
+      attributes[matching_line[:attr].to_sym] = matching_line[:prefix]
+      matching_line.line
+    },
+    new_attribute_value: lambda { |matching_line|
+      definitions.last.set_attribute(matching_line[:attr].to_sym, matching_line[:value])
+      matching_line.line
+    },
+    new_variable_def: lambda { |matching_line|
+      variables[matching_line[:varname].to_sym] = matching_line[:value]
+      matching_line.line
+    },
+    new_variable_use: lambda { |matching_line|
+      line = matching_line.line
+      line.scan(DMRegexp::VARIABLE_USE) do |_|
+        varname = Regexp.last_match[:varname]
+        value = variables[varname.to_sym]
+
+        next unless value
+
+        line = line.gsub("{#{varname}}", value)
+      end
+      line
+    }
+  }.freeze
+
+  private_constant :PARSER_ACTIONS
 
   # Reflects document structure from a definition point of view
   class Document
-    attr_reader :definitions, :labels, :eref, :iref, :attributes, :variables
+    extend Forwardable
+    def_delegators :@data, :definitions, :labels, :eref, :iref, :attributes, :variables
 
     def initialize
-      @definitions   = []
-      @labels        = Set.new
-      @eref          = {}
-      @iref          = false
-      @attributes    = {}
-      @variables     = {}
+      @data = DocumentData.new([], Set.new, {}, false, {}, {})
       @parsing_state = ParsingState.new
       @definition_parser = DefinitionParser.new(self)
     end
@@ -26,7 +92,7 @@ module DefMastership
         if @parsing_state.enabled?(line)
           apply_filters(line)
         else
-          generate_event(:new_line, nil, line)
+          generate_event(:new_line, MatchingLine.new(nil, line))
         end
       end
     end
@@ -36,96 +102,65 @@ module DefMastership
     end
 
     def wrong_explicit_checksum?
-      @definitions.reduce(false) do |res, definition|
-        res || !definition.wrong_explicit_checksum.nil?
+      definitions.reduce(false) do |res, definition|
+        res || !!definition.wrong_explicit_checksum
       end
     end
 
     def explicit_version?
-      @definitions.reduce(false) do |res, definition|
-        res || !definition.explicit_version.nil?
+      definitions.reduce(false) do |res, definition|
+        res || !!definition.explicit_version
       end
     end
 
-    def add_new_definition(match, line)
-      definition = Definition.new(match)
-      @labels.merge(definition.labels)
-      @definitions << definition
-      line
-    end
-
-    def ref_to_def(ref)
-      @definitions.find { |definition| definition.reference == ref }
-    end
+    def method_missing(method_name, *args)
+      action = PARSER_ACTIONS[method_name]
+      return instance_exec(*args, &action) if action
 
-    def add_line(_match, line)
-      @definitions.last << line
-      line
+      super
     end
 
-    def new_eref_setup(match, line)
-      @eref[match[:refname].to_sym] ||= {}
-      @eref[match[:refname].to_sym][match[:symb].to_sym] = match[:value]
-      line
+    # This method smells of :reek:UtilityFunction
+    def respond_to_missing?(method_name, *_args)
+      PARSER_ACTIONS.key?(method_name)
     end
 
-    def new_eref_def(match, line)
-      @definitions.last.add_eref(match[:refname].to_sym, match[:extrefs])
-      line
-    end
-
-    def new_iref_def(_match, line)
-      @iref = true
-      line.scan(DMRegexp::IREF_DEF) do |_|
-        @definitions.last.add_iref(Regexp.last_match[:intref])
-      end
-      line
+    def ref_to_def(ref)
+      definitions.find { |definition| definition.reference == ref }
     end
 
-    def new_attribute_conf(match, line)
-      @attributes[match[:attr].to_sym] = match[:prefix]
-      line
+    def iref=(value)
+      @data.iref = value
     end
 
-    def new_attribute_value(match, line)
-      @definitions.last.set_attribute(match[:attr].to_sym, match[:value])
-      line
-    end
+    private
 
-    def new_variable_def(match, line)
-      @variables[match[:varname].to_sym] = match[:value]
-      line
+    def apply_filters(line)
+      Helper.reduce_filters_until_consumed(line) do |event, match, updated_line|
+        generate_event(event, MatchingLine.new(match, updated_line))
+      end
     end
 
-    def new_variable_use(_match, line)
-      line.scan(DMRegexp::VARIABLE_USE) do |_|
-        varname = Regexp.last_match[:varname]
-        next if @variables[varname.to_sym].nil?
-
-        line = line.gsub("{#{varname}}", @variables[varname.to_sym])
+    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
-      line
     end
 
-    private
-
-    def apply_filters(line)
-      FILTERS.each do |filter|
-        next unless line.match(filter.regexp)
+    # Helper functions
+    module Helper
+      def self.reduce_filters_until_consumed(line)
+        FILTERS.reduce(line) do |res, filter|
+          next res unless line.match(filter.regexp)
 
-        line = generate_event(filter.event, Regexp.last_match, line)
+          res = yield(filter.event, Regexp.last_match, res)
+          break if filter.consumed_line
 
-        break if filter.consumed_line
-      end
-    end
-
-    def generate_event(event, match, line)
-      if respond_to?(event)
-        line = public_send(event, match, line)
-      else
-        @definition_parser.public_send(event, match, line)
+          res
+        end
       end
-      line
     end
   end
 end

data/lib/defmastership/matching_line.rb

@@ -0,0 +1,17 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # a composite class
+  MatchingLine =
+    Struct.new(:match, :line) do
+      def [](key)
+        value = match[key]
+        return value if value
+
+        super
+      end
+    end
+
+  public_constant :MatchingLine
+end