defmastership 1.0.17 → 1.0.18

data/lib/defmastership/change_ref_line_modifier.rb

@@ -1,85 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require 'defmastership/constants'
-require 'defmastership/line_modifier_base'
-
-module DefMastership
-  # Change references from temporary to definitive with multiple RefChangers
-  class ChangeRefLineModifier < LineModifierBase
-    def self.from_config(hash)
-      new.from_config(hash)
-    end
-
-    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 initialize
-      super
-      @config = {
-        from_regexp: '',
-        to_template: '',
-        next_ref: 0
-      }
-      @parsing_state = ParsingState.new
-    end
-
-    def replace(method, line)
-      public_send("replace_#{method}".to_sym, 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(regexp_from(:iref, from)) do
-          text_with(Regexp.last_match, to)
-        end
-      end
-    end
-
-    private
-
-    def do_replace_refdef(line)
-      line.gsub(regexp_from(:definition, from_regexp)) do
-        replacement = to_template % hmerge(Regexp.last_match)
-        changes << [Regexp.last_match[:from], replacement]
-        @config[:next_ref] += 1
-        text_with(Regexp.last_match, replacement)
-      end
-    end
-
-    def regexp_from(const, from)
-      regexp_str =
-        "(?<before>#{REGEXP_FROM[const][:before]})" \
-        "(?<from>#{from})" \
-        "#{DMRegexp::DEF_VERSION_AND_CHECKSUM}" \
-        "(?<after>#{REGEXP_FROM[const][:after]})"
-      Regexp.new(regexp_str, Regexp::EXTENDED)
-    end
-
-    def text_with(match, replacement)
-      match[:before] + replacement + (match[:version_and_checksum] || '') + match[:after]
-    end
-
-    def hmerge(match)
-      @config.merge(match.names.map(&:to_sym).zip(match.captures).to_h)
-    end
-  end
-end

data/lib/defmastership/line_modifier_base.rb

@@ -1,29 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-module DefMastership
-  # Change references from temporary to definitive with multiple RefChangers
-  class LineModifierBase
-    attr_reader :changes, :config
-
-    def initialize
-      @config = {}
-      @changes = []
-    end
-
-    def method_missing(method_name, *args, &block)
-      return @config[method_name] if @config[method_name]
-
-      super
-    end
-
-    def respond_to_missing?(method_name, *args)
-      @config[method_name] || super
-    end
-
-    def from_config(config)
-      @config.merge!(config)
-      self
-    end
-  end
-end

data/lib/defmastership/modifier_base.rb

@@ -1,36 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-module DefMastership
-  # Change references from temporary to definitive with multiple RefChangers
-  class ModifierBase
-    attr_reader :config, :changes
-
-    def initialize(config)
-      @config = config
-      @changes = []
-    end
-
-    def do_modifications(adoc_texts)
-      line_modifier = new_line_modifier(@config, adoc_texts)
-
-      adoc_texts =
-        replacements.reduce(adoc_texts) do |texts, method|
-          transform_values(texts, line_modifier, method)
-        end
-
-      @config = line_modifier.config
-      @changes = line_modifier.changes
-      adoc_texts
-    end
-
-    private
-
-    def transform_values(texts, line_modifier, method)
-      texts.transform_values do |text|
-        text.lines.map { |line| line_modifier.public_send(method, line) }
-            .join
-      end
-    end
-  end
-end

data/lib/defmastership/rename_included_files_line_modifier.rb

@@ -1,126 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-module DefMastership
-  # Change included filenames on one line at a time
-  class RenameIncludedFilesLineModifier < LineModifierBase
-    LOCAL_FILTERS = [
-      Filter.new(DMRegexp::VARIABLE_DEF,  :new_variable_def,     false),
-      Filter.new(DMRegexp::DEFINITION,    :new_definition,       true),
-      Filter.new(DMRegexp::BLOCK,         :block_delimiter,      true),
-      Filter.new(DMRegexp::EMPTY_LINE,    :empty_line,           false),
-      Filter.new(DMRegexp::WHATEVER,      :new_line,             true)
-    ].freeze
-    private_constant :LOCAL_FILTERS
-
-    def self.from_config(config)
-      new.from_config(config)
-    end
-
-    def initialize
-      super
-      @config = {
-        from_regexp: '',
-        to_template: ''
-      }
-      @variables = {}
-      @definition_parser = DefinitionParser.new(self)
-    end
-
-    def replace(line)
-      match = matched?(line)
-
-      return line unless match
-
-      new_line =
-        line.gsub(complete_regexp_from(from_regexp)) do
-          text_with(match, to_template % hmerge(match))
-        end
-
-      rename_file(line, new_line)
-
-      new_line
-    end
-
-    def add_new_definition(match, _line)
-      @config[:reference] = match[:reference]
-    end
-
-    def add_line(_match, _line) end
-
-    def new_variable_def(match, line)
-      @variables[match[:varname].to_sym] = match[:value]
-      line
-    end
-
-    private
-
-    def matched?(line)
-      return if line.commented?
-
-      parse(line)
-
-      return if @definition_parser.idle?
-      return unless line =~ complete_regexp_from(from_regexp)
-
-      match = Regexp.last_match
-
-      return if @config[:cancel_if_match] && match[:filename] =~ Regexp.new(cancel_if_match)
-
-      match
-    end
-
-    def parse(line)
-      LOCAL_FILTERS.each do |filter|
-        next unless line.match(filter.regexp)
-
-        line = generate_event(filter.event, Regexp.last_match, line)
-
-        break if filter.consumed_line
-      end
-    end
-
-    def rename_file(from, to)
-      @changes << [extract_filename(from), extract_filename(to)]
-      File.rename(extract_filename(from), extract_filename(to))
-    end
-
-    def extract_filename(include_statement)
-      filename = include_statement
-                 .gsub(Regexp.new(DMRegexp::INCLUDE_KEYWORD), '')
-                 .gsub(Regexp.new(DMRegexp::INCLUDE_OPTIONS), '')
-
-      filename.dup.scan(DMRegexp::VARIABLE_USE) do |_|
-        varname = Regexp.last_match[:varname]
-        next if @variables[varname.to_sym].nil?
-
-        filename.gsub!("{#{varname}}", @variables[varname.to_sym])
-      end
-      filename.chomp
-    end
-
-    def complete_regexp_from(from)
-      Regexp.new(
-        DMRegexp::INCLUDE_KEYWORD + DMRegexp::INCLUDE_PATH +
-        "(?<filename>#{from})" + DMRegexp::INCLUDE_OPTIONS
-      )
-    end
-
-    def text_with(match, to)
-      "include::#{match[:path] || ''}#{to}[#{match[:options]}]"
-    end
-
-    def hmerge(match)
-      @config.merge(match.names.map(&:to_sym).zip(match.captures).to_h)
-    end
-
-    def generate_event(event, match, line)
-      if respond_to?(event)
-        public_send(event, match, line)
-      else
-        @definition_parser.public_send(event, match, line)
-      end
-      line
-    end
-  end
-end

data/lib/defmastership/update_def_checksum_line_modifier.rb

@@ -1,38 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-module DefMastership
-  # modify one line after another
-  class UpdateDefChecksumLineModifier < LineModifierBase
-    attr_accessor :document
-
-    def self.from_config(hash)
-      new.from_config(hash)
-    end
-
-    def initialize
-      super
-      @config = {
-        def_type: ''
-      }
-    end
-
-    def replace(line)
-      match = matched?(line)
-
-      return line unless match
-      return line unless match[:type] == def_type
-
-      line.gsub(Regexp.new("#{match[:reference]}#{DMRegexp::DEF_VERSION_AND_CHECKSUM}")) do
-        "#{match[:reference]}(#{match[:explicit_version]}#{@document.ref_to_def(match[:reference]).sha256})"
-      end
-    end
-
-    def matched?(line)
-      return if line.commented?
-      return unless line =~ DMRegexp::DEFINITION
-
-      Regexp.last_match
-    end
-  end
-end

data/lib/defmastership/update_def_version_line_modifier.rb

@@ -1,58 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-module DefMastership
-  # modify one line after another
-  class UpdateDefVersionLineModifier < LineModifierBase
-    attr_accessor :document, :ref_document
-
-    def self.from_config(hash)
-      new.from_config(hash)
-    end
-
-    def initialize
-      super
-      @config = {
-        def_type: '',
-        ref_document: '',
-        first_version: ''
-      }
-    end
-
-    def replace(line)
-      match = matched?(line)
-
-      return line unless match
-      return line unless match[:type] == def_type
-
-      version_and_checksum = ''
-      if match[:explicit_checksum] || version_string(match)
-        version_and_checksum = "(#{version_string(match)}#{match[:explicit_checksum]})"
-      end
-
-      line.gsub(Regexp.new("#{match[:reference]}#{DMRegexp::DEF_VERSION_AND_CHECKSUM}")) do
-        "#{match[:reference]}#{version_and_checksum}"
-      end
-    end
-
-    private
-
-    def matched?(line)
-      return if line.commented?
-      return unless line =~ DMRegexp::DEFINITION
-
-      Regexp.last_match
-    end
-
-    def version_string(match)
-      ref_definition = @ref_document.ref_to_def(match[:reference])
-      definition = @document.ref_to_def(match[:reference])
-
-      return if ref_definition.nil?
-      return ref_definition.explicit_version if definition.sha256 == ref_definition.sha256
-
-      ref_version = @ref_document.ref_to_def(match[:reference]).explicit_version
-      ref_version.nil? ? @config[:first_version] : ref_version.next
-    end
-  end
-end

data/spec/unit/def_mastership/change_ref_line_modifier_spec.rb

@@ -1,250 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require('defmastership')
-
-RSpec.describe(DefMastership::ChangeRefLineModifier) do
-  subject(:refchanger) { described_class.new }
-
-  describe '.new' do
-    it { is_expected.not_to(be_nil) }
-    it { is_expected.to(have_attributes(from_regexp: '')) }
-    it { is_expected.to(have_attributes(to_template: '')) }
-    it { is_expected.to(have_attributes(next_ref:    0)) }
-    it { is_expected.to(have_attributes(changes:     [])) }
-
-    it do
-      expect { refchanger.user_defined_attribute }
-        .to(raise_error(NoMethodError))
-    end
-  end
-
-  describe '.from_config' do
-    subject(:refchanger) do
-      described_class.from_config(
-        from_regexp: 'Whatever.+',
-        to_template: 'Whatever',
-        next_ref: 17
-      )
-    end
-
-    it { is_expected.not_to(be_nil) }
-    it { is_expected.to(have_attributes(from_regexp: 'Whatever.+')) }
-    it { is_expected.to(have_attributes(to_template: 'Whatever')) }
-    it { is_expected.to(have_attributes(next_ref:    17)) }
-  end
-
-  describe '#from_config' do
-    before do
-      refchanger.from_config(
-        from_regexp: 'Whatever.+',
-        to_template: 'Whatever',
-        next_ref: 17,
-        user_defined_attribute: 'Tadaam'
-      )
-    end
-
-    it { is_expected.to(have_attributes(from_regexp: 'Whatever.+')) }
-    it { is_expected.to(have_attributes(to_template: 'Whatever')) }
-    it { is_expected.to(have_attributes(next_ref:    17)) }
-    it { is_expected.to(have_attributes(user_defined_attribute: 'Tadaam')) }
-  end
-
-  describe '#config' do
-    context 'when not initalized' do
-      it do
-        expect(refchanger.config).to(
-          include(from_regexp: '', to_template: '', next_ref: 0)
-        )
-      end
-    end
-
-    context 'when initalized with additionnal keys' do
-      before do
-        refchanger.from_config(
-          next_ref: 1256,
-          user_defined_attribute: 'Tadaam'
-        )
-      end
-
-      it { expect(refchanger.config).to(include(from_regexp: '')) }
-      it { expect(refchanger.config).to(include(to_template: '')) }
-      it { expect(refchanger.config).to(include(next_ref: 1256)) }
-      it { expect(refchanger.config).to(include(user_defined_attribute: 'Tadaam')) }
-    end
-  end
-
-  describe '#replace_def' do
-    context 'when really simple rule' do
-      before do
-        refchanger.from_config(
-          from_regexp: 'TEMP',
-          to_template: 'TUTU'
-        )
-      end
-
-      context 'when valid definition' do
-        it do
-          expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-            .to(eq('[define, whatever, TUTU]'))
-        end
-      end
-
-      context 'when no valid definition' do
-        it do
-          expect(refchanger.replace_refdef('[pouet, whatever, TEMP]'))
-            .to(eq('[pouet, whatever, TEMP]'))
-        end
-      end
-    end
-
-    context 'when template is variable' do
-      before do
-        refchanger.from_config(
-          from_regexp: 'TEMP',
-          to_template: 'TOTO-%<next_ref>04d',
-          next_ref: 124
-        )
-      end
-
-      it do
-        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-          .to(eq('[define, whatever, TOTO-0124]'))
-      end
-
-      it do
-        refchanger.replace_refdef('[define, whatever, TEMP]')
-        expect(refchanger).to(have_attributes(next_ref: 125))
-      end
-    end
-
-    context 'when capture group in regexp' do
-      before do
-        refchanger.from_config(
-          from_regexp: '(?<cg>TOTO|TITI)-TEMP[\d]*',
-          to_template: '%<cg>s-%<next_ref>04d',
-          next_ref: 132
-        )
-      end
-
-      it do
-        expect(refchanger.replace_refdef('[define, whatever, TOTO-TEMP]'))
-          .to(eq('[define, whatever, TOTO-0132]'))
-      end
-
-      it do
-        refchanger.replace_refdef('[define, whatever, TOTO-TEMP]')
-        expect(refchanger.replace_refdef('[define, whatever, TITI-TEMP]'))
-          .to(eq('[define, whatever, TITI-0133]'))
-      end
-
-      it do
-        refchanger.replace_refdef('[define, whatever, TOTO-TEMP1]')
-        refchanger.replace_refdef('[define, whatever, TITI-TEMP2]')
-        expect(refchanger).to(have_attributes(changes: [%w[TOTO-TEMP1 TOTO-0132], %w[TITI-TEMP2 TITI-0133]]))
-      end
-    end
-
-    context 'when definition is in literal block' do
-      before do
-        refchanger.from_config(
-          from_regexp: 'TEMP',
-          to_template: 'TUTU'
-        )
-        refchanger.replace_refdef('....')
-      end
-
-      it do
-        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-          .to(eq('[define, whatever, TEMP]'))
-      end
-    end
-
-    context 'when defintion is after literal block' do
-      before do
-        refchanger.from_config(
-          from_regexp: 'TEMP',
-          to_template: 'TUTU'
-        )
-        refchanger.replace_refdef("....\n")
-        refchanger.replace_refdef('[define, whatever, TEMP]')
-        refchanger.replace_refdef("....\n")
-      end
-
-      it do
-        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-          .to(eq('[define, whatever, TUTU]'))
-      end
-    end
-  end
-
-  describe '#replace_irefs' do
-    before do
-      refchanger.from_config(
-        from_regexp: '(?<cg>TOTO|TITI)-TEMP[\d]*',
-        to_template: '%<cg>s-%<next_ref>04d',
-        next_ref: 132
-      )
-      refchanger.replace_refdef('[define, whatever, TOTO-TEMP123]')
-      refchanger.replace_refdef('[define, whatever, TITI-TEMP421]')
-    end
-
-    it do
-      expect(refchanger.replace_irefs('defs:iref[TOTO-TEMP1234]'))
-        .to(eq('defs:iref[TOTO-TEMP1234]'))
-    end
-
-    it do
-      expect(refchanger.replace_irefs('defs:iref[TOTO-TEMP123]'))
-        .to(eq('defs:iref[TOTO-0132]'))
-    end
-
-    it do
-      expect(
-        refchanger.replace_irefs(
-          'defs:iref[TOTO-TEMP123] defs:iref[TITI-TEMP421] bla'
-        )
-      ).to(eq('defs:iref[TOTO-0132] defs:iref[TITI-0133] bla'))
-    end
-  end
-
-  describe '#replace' do
-    before do
-      refchanger.from_config(
-        from_regexp: 'TEMP',
-        to_template: 'TUTU'
-      )
-    end
-
-    it do
-      expect(refchanger.replace(:refdef, '[define, whatever, TEMP]'))
-        .to(eq('[define, whatever, TUTU]'))
-    end
-
-    it do
-      expect(refchanger.replace(:refdef, '[define, whatever, TEMP(a~12345678)]'))
-        .to(eq('[define, whatever, TUTU(a~12345678)]'))
-    end
-
-    it do
-      expect(refchanger.replace(:refdef, '[define, whatever, TEMP(~12345678)]'))
-        .to(eq('[define, whatever, TUTU(~12345678)]'))
-    end
-
-    it do
-      expect(refchanger.replace(:refdef, '[define, whatever, TEMP(a)]'))
-        .to(eq('[define, whatever, TUTU(a)]'))
-    end
-
-    it do
-      refchanger.replace(:refdef, '[define, whatever, TEMP]')
-      expect(refchanger.replace(:irefs, 'defs:iref[TEMP]'))
-        .to(eq('defs:iref[TUTU]'))
-    end
-
-    it do
-      expect { refchanger.replace(:pouet, 'whatever') }
-        .to(raise_error(NoMethodError))
-    end
-  end
-end