defmastership 1.0.5 → 1.0.6

data/lib/defmastership/filters.rb

@@ -0,0 +1,30 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Contains regexp / action couples
+  Filter = Struct.new(:regexp, :event, :consumed_line)
+  private_constant :Filter
+
+  FILTERS_IN_LITERAL = [
+    Filter.new(DMRegexp::LITERAL_BLOCK, :code_block_delimiter, false),
+    Filter.new(DMRegexp::WHATEVER,      :new_line,             true)
+  ].freeze
+  private_constant :FILTERS_IN_LITERAL
+
+  FILTERS = [
+    Filter.new(DMRegexp::VARIABLE_DEF,  :new_variable_def,     false),
+    Filter.new(DMRegexp::VARIABLE_USE,  :new_variable_use,     false),
+    Filter.new(DMRegexp::DEFINITION,    :new_definition,       true),
+    Filter.new(DMRegexp::EREF_CONFIG,   :new_eref_setup,       true),
+    Filter.new(DMRegexp::EREF_DEF,      :new_eref_def,         false),
+    Filter.new(DMRegexp::IREF_DEF,      :new_iref_def,         false),
+    Filter.new(DMRegexp::ATTR_CONFIG,   :new_attribute_conf,   true),
+    Filter.new(DMRegexp::ATTR_SET,      :new_attribute_value,  false),
+    Filter.new(DMRegexp::BLOCK,         :block_delimiter,      true),
+    Filter.new(DMRegexp::LITERAL_BLOCK, :code_block_delimiter, true),
+    Filter.new(DMRegexp::EMPTY_LINE,    :empty_line,           false),
+    Filter.new(DMRegexp::WHATEVER,      :new_line,             true)
+  ].freeze
+  private_constant :FILTERS
+end

data/lib/defmastership/line_modifier_base.rb

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

@@ -0,0 +1,29 @@
+# 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 = line_modifier_class.from_config(@config)
+
+      adoc_texts =
+        replacements.reduce(adoc_texts) do |texts, method|
+          texts.transform_values do |text|
+            text.lines.map { |line| line_modifier.public_send(method, line) }.join
+          end
+        end
+
+      @config = line_modifier.config
+      @changes = line_modifier.changes
+      adoc_texts
+    end
+  end
+end

data/lib/defmastership/rename_included_files_line_modifier.rb

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

@@ -0,0 +1,30 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Change included filenames
+  class RenameIncludedFilesModifier < ModifierBase
+    def do_modifications(adoc_texts)
+      line_modifier = line_modifier_class.from_config(@config)
+
+      adoc_texts =
+        replacements.reduce(adoc_texts) do |texts, method|
+          texts.transform_values do |text|
+            text.lines.map { |line| line_modifier.public_send(method, line) }.join
+          end
+        end
+
+      @config = line_modifier.config
+      @changes = line_modifier.changes
+      adoc_texts
+    end
+
+    def replacements
+      %i[replace]
+    end
+
+    def line_modifier_class
+      RenameIncludedFilesLineModifier
+    end
+  end
+end

data/lib/defmastership/version.rb

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

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@
 
 require('bundler/setup')
 require('aruba/rspec')
+require('aasm/rspec')
 
 # formatter = [SimpleCov::Formatter::HTMLFormatter]
 # SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(formatter)

data/spec/unit/defmastership/batch_modifier_spec.rb

@@ -0,0 +1,115 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership')
+
+module DefMastership
+  class TotoClassModifier < ModifierBase
+  end
+
+  class TutuClassModifier < ModifierBase
+  end
+end
+
+RSpec.describe(DefMastership::BatchModifier) do
+  subject(:batchmodifier) do
+    described_class.new(config, adoc_texts)
+  end
+
+  let(:config) do
+    {
+      modifier1: { type: 'toto_class', config: { p: 1 } },
+      modifier2: { type: 'toto_class', config: { p: 'whatever1' } },
+      modifier3: { type: 'tutu_class', config: { p1: 'whatever2', p2: 'whatever3' } }
+    }
+  end
+  let(:adoc_texts) do
+    {
+      'file1.adoc' => 'some text',
+      'file2.adoc' => 'another text'
+    }
+  end
+
+  describe '.new' do
+    it { is_expected.not_to(be(nil)) }
+    it { is_expected.to(have_attributes(config: config)) }
+
+    it do
+      expect(batchmodifier).to(have_attributes(adoc_texts: adoc_texts))
+    end
+  end
+
+  describe '#apply' do
+    context 'with only one modification' do
+      let(:toto1) { instance_double(DefMastership::TotoClassModifier, 'toto1') }
+      let(:adoc_texts_modified) do
+        {
+          'file1.adoc' => 'some text modified',
+          'file2.adoc' => 'another text'
+        }
+      end
+
+      let(:config_modified) do
+        {
+          modifier1: { type: 'toto_class', config: { p: 'modified_param' } },
+          modifier2: { type: 'toto_class', config: { p: 'whatever1' } },
+          modifier3: { type: 'tutu_class', config: { p1: 'whatever2', p2: 'whatever3' } }
+        }
+      end
+
+      before do
+        allow(DefMastership::TotoClassModifier).to(receive(:new).once.and_return(toto1))
+        allow(toto1).to(receive(:do_modifications).once.and_return(adoc_texts_modified))
+        allow(toto1).to(receive(:config).once.and_return(p: 'modified_param'))
+        allow(toto1).to(receive(:changes).once.and_return([%w[from1 to1], %w[from2 to2]]))
+        batchmodifier.apply('modifier1')
+      end
+
+      it do
+        expect(DefMastership::TotoClassModifier).to(have_received(:new).with(p: 1))
+      end
+
+      it { expect(toto1).to(have_received(:do_modifications).with(adoc_texts)) }
+      it { is_expected.to(have_attributes(adoc_texts: adoc_texts_modified)) }
+      it { expect(toto1).to(have_received(:config).with(no_args)) }
+
+      it { is_expected.to(have_attributes(config: config_modified)) }
+      it { is_expected.to(have_attributes(changes: [%w[modifier1 from1 to1], %w[modifier1 from2 to2]])) }
+    end
+
+    context 'with two modifications' do
+      let(:toto2) { instance_double(DefMastership::TotoClassModifier, 'toto2') }
+      let(:tutu3) { instance_double(DefMastership::TutuClassModifier, 'tutu3') }
+
+      let(:config_modified) do
+        {
+          modifier1: { type: 'toto_class', config: { p: 1 } },
+          modifier2: { type: 'toto_class', config: :whatever },
+          modifier3: { type: 'tutu_class', config: :pouet }
+        }
+      end
+
+      before do
+        allow(DefMastership::TotoClassModifier).to(receive(:new).once.and_return(toto2))
+        allow(toto2).to(receive(:do_modifications).once.and_return(:adoc_texts_modified_mod2))
+        allow(toto2).to(receive(:config).once.and_return(:whatever))
+        allow(DefMastership::TutuClassModifier).to(receive(:new).once.and_return(tutu3))
+        allow(tutu3).to(receive(:do_modifications).once.and_return(:adoc_texts_modified_mod3))
+        allow(tutu3).to(receive(:config).once.and_return(:pouet))
+        allow(toto2).to(receive(:changes).once.and_return([%w[from1 to1]]))
+        allow(tutu3).to(receive(:changes).once.and_return([%w[from2 to2]]))
+        batchmodifier.apply('modifier2, modifier3')
+      end
+
+      it { expect(DefMastership::TotoClassModifier).to(have_received(:new).with(p: 'whatever1')) }
+      it { expect(DefMastership::TutuClassModifier).to(have_received(:new).with(p1: 'whatever2', p2: 'whatever3')) }
+      it { expect(toto2).to(have_received(:do_modifications).with(adoc_texts)) }
+      it { expect(toto2).to(have_received(:config).with(no_args)) }
+      it { expect(tutu3).to(have_received(:do_modifications).with(:adoc_texts_modified_mod2)) }
+      it { expect(tutu3).to(have_received(:config).with(no_args)) }
+      it { is_expected.to(have_attributes(adoc_texts: :adoc_texts_modified_mod3)) }
+      it { is_expected.to(have_attributes(config: config_modified)) }
+      it { is_expected.to(have_attributes(changes: [%w[modifier2 from1 to1], %w[modifier3 from2 to2]])) }
+    end
+  end
+end

data/spec/unit/defmastership/{ref_changer_spec.rb → change_ref_line_modifier_spec.rb}

@@ -3,7 +3,7 @@
 
 require('defmastership')
 
-RSpec.describe(DefMastership::RefChanger) do
+RSpec.describe(DefMastership::ChangeRefLineModifier) do
   subject(:refchanger) { described_class.new }
 
   describe '.new' do
@@ -15,9 +15,9 @@ RSpec.describe(DefMastership::RefChanger) do
     it { expect { refchanger.user_defined_attribute }.to(raise_error(NoMethodError)) }
   end
 
-  describe '.from_h' do
+  describe '.from_config' do
     subject(:refchanger) do
-      described_class.from_h(
+      described_class.from_config(
         from_regexp: 'Whatever.+',
         to_template: 'Whatever',
         next_ref: 17
@@ -30,9 +30,9 @@ RSpec.describe(DefMastership::RefChanger) do
     it { is_expected.to(have_attributes(next_ref:    17)) }
   end
 
-  describe '#from_h' do
+  describe '#from_config' do
     before do
-      refchanger.from_h(
+      refchanger.from_config(
         from_regexp: 'Whatever.+',
         to_template: 'Whatever',
         next_ref: 17,
@@ -46,36 +46,34 @@ RSpec.describe(DefMastership::RefChanger) do
     it { is_expected.to(have_attributes(user_defined_attribute: 'Tadaam')) }
   end
 
-  describe '#to_h' do
+  describe '#config' do
     context 'when not initalized' do
       it do
-        expect(refchanger.to_h).to(include(
-                                     from_regexp: '',
-                                     to_template: '',
-                                     next_ref: 0
-                                   ))
+        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_h(
+        refchanger.from_config(
           next_ref: 1256,
           user_defined_attribute: 'Tadaam'
         )
       end
 
-      it { expect(refchanger.to_h).to(include(from_regexp: '')) }
-      it { expect(refchanger.to_h).to(include(to_template: '')) }
-      it { expect(refchanger.to_h).to(include(next_ref: 1256)) }
-      it { expect(refchanger.to_h).to(include(user_defined_attribute: 'Tadaam')) }
+      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_definitions' do
+  describe '#replace_def' do
     context 'when really simple rule' do
       before do
-        refchanger.from_h(
+        refchanger.from_config(
           from_regexp: 'TEMP',
           to_template: 'TUTU'
         )
@@ -98,7 +96,7 @@ RSpec.describe(DefMastership::RefChanger) do
 
     context 'when template is variable' do
       before do
-        refchanger.from_h(
+        refchanger.from_config(
           from_regexp: 'TEMP',
           to_template: 'TOTO-%<next_ref>04d',
           next_ref: 124
@@ -118,7 +116,7 @@ RSpec.describe(DefMastership::RefChanger) do
 
     context 'when capture group in regexp' do
       before do
-        refchanger.from_h(
+        refchanger.from_config(
           from_regexp: '(?<cg>TOTO|TITI)-TEMP[\d]*',
           to_template: '%<cg>s-%<next_ref>04d',
           next_ref: 132
@@ -145,7 +143,7 @@ RSpec.describe(DefMastership::RefChanger) do
 
     context 'when definition is in literal block' do
       before do
-        refchanger.from_h(
+        refchanger.from_config(
           from_regexp: 'TEMP',
           to_template: 'TUTU'
         )
@@ -160,7 +158,7 @@ RSpec.describe(DefMastership::RefChanger) do
 
     context 'when defintion is after literal block' do
       before do
-        refchanger.from_h(
+        refchanger.from_config(
           from_regexp: 'TEMP',
           to_template: 'TUTU'
         )
@@ -178,7 +176,7 @@ RSpec.describe(DefMastership::RefChanger) do
 
   describe '#replace_irefs' do
     before do
-      refchanger.from_h(
+      refchanger.from_config(
         from_regexp: '(?<cg>TOTO|TITI)-TEMP[\d]*',
         to_template: '%<cg>s-%<next_ref>04d',
         next_ref: 132
@@ -198,9 +196,33 @@ RSpec.describe(DefMastership::RefChanger) do
     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'))
+      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
+      refchanger.replace(:refdef, '[define, whatever, TEMP]')
+      expect(refchanger.replace(:irefs, 'defs:iref[TEMP]'))
+        .to(eq('defs:iref[TUTU]'))
+    end
+
+    it { expect { refchanger.replace(:pouet, 'whatever') }.to(raise_error(NoMethodError)) }
   end
 end