defmastership 1.0.2 → 1.0.7

data/lib/defmastership/rename_included_files_modifier.rb

@@ -0,0 +1,15 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Change included filenames
+  class RenameIncludedFilesModifier < ModifierBase
+    def replacements
+      %i[replace]
+    end
+
+    def new_line_modifier(config, _adoc_texts)
+      RenameIncludedFilesLineModifier.from_config(config)
+    end
+  end
+end

data/lib/defmastership/update_def_checksum_line_modifier.rb

@@ -0,0 +1,39 @@
+# 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
+
+      explicit_checksum_str = match[:explicit_checksum].nil? ? '' : "(#{match[:explicit_checksum]})"
+      line.gsub("#{match[:reference]}#{explicit_checksum_str}") do
+        "#{match[:reference]}(#{@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_checksum_modifier.rb

@@ -0,0 +1,21 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Update definition checksum wih calculated one
+  class UpdateDefChecksumModifier < ModifierBase
+    def replacements
+      %i[replace]
+    end
+
+    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
+    end
+  end
+end

data/lib/defmastership/version.rb

@@ -1,6 +1,7 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
 module DefMastership
-  VERSION = '1.0.2'
+  VERSION = '1.0.7'
   public_constant :VERSION
 end

data/spec/spec_helper.rb

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

@@ -1,8 +1,9 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
 require('defmastership')
 
-RSpec.describe(DefMastership::RefChanger) do
+RSpec.describe(DefMastership::ChangeRefLineModifier) do
   subject(:refchanger) { described_class.new }
 
   describe '.new' do
@@ -14,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
@@ -29,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,
@@ -45,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'
         )
@@ -97,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
@@ -117,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
@@ -144,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'
         )
@@ -159,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'
         )
@@ -177,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
@@ -197,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

data/spec/unit/defmastership/change_ref_modifier_spec.rb

@@ -0,0 +1,76 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::ChangeRefModifier) do
+  subject(:modifier) do
+    described_class.new(
+      'fake config'
+    )
+  end
+
+  let(:adoc_texts) do
+    {
+      'file1.adoc' => "file1 line1\nfile1 line2",
+      'file2.adoc' => "file2 line1\nfile2 line2"
+    }
+  end
+
+  describe '.new' do
+    it { is_expected.not_to(be(nil)) }
+    it { is_expected.to(have_attributes(config: 'fake config')) }
+    it { is_expected.to(have_attributes(changes: [])) }
+  end
+
+  describe '#do_modifications' do
+    let(:line_modifier) { instance_double(DefMastership::ChangeRefLineModifier, 'lineModifier') }
+
+    before do
+      allow(DefMastership::ChangeRefLineModifier).to(
+        receive(:from_config).with('fake config').and_return(line_modifier)
+      )
+      allow(line_modifier).to(receive(:replace_refdef).with("file1 line1\n").and_return("new file1 line1\n"))
+      allow(line_modifier).to(receive(:replace_refdef).with('file1 line2').and_return('new file1 line2'))
+      allow(line_modifier).to(receive(:replace_refdef).with("file2 line1\n").and_return("new file2 line1\n"))
+      allow(line_modifier).to(receive(:replace_refdef).with('file2 line2').and_return('new file2 line2'))
+      allow(line_modifier).to(receive(:replace_irefs).with("new file1 line1\n").and_return("new2 file1 line1\n"))
+      allow(line_modifier).to(receive(:replace_irefs).with('new file1 line2').and_return('new2 file1 line2'))
+      allow(line_modifier).to(receive(:replace_irefs).with("new file2 line1\n").and_return("new2 file2 line1\n"))
+      allow(line_modifier).to(receive(:replace_irefs).with('new file2 line2').and_return('new2 file2 line2'))
+      allow(line_modifier).to(receive(:config).and_return('new fake config'))
+      allow(line_modifier).to(receive(:changes).and_return([%w[from1 to1], %w[from2 to2]]))
+    end
+
+    context 'when detailed expectations' do
+      before { modifier.do_modifications(adoc_texts) }
+
+      it do
+        expect(DefMastership::ChangeRefLineModifier).to(
+          have_received(:from_config).with('fake config')
+        )
+      end
+
+      it { expect(line_modifier).to(have_received(:replace_refdef).with("file1 line1\n")) }
+      it { expect(line_modifier).to(have_received(:replace_refdef).with('file1 line2')) }
+      it { expect(line_modifier).to(have_received(:replace_refdef).with("file2 line1\n")) }
+      it { expect(line_modifier).to(have_received(:replace_refdef).with('file2 line2')) }
+      it { expect(line_modifier).to(have_received(:replace_irefs).with("new file1 line1\n")) }
+      it { expect(line_modifier).to(have_received(:replace_irefs).with('new file1 line2')) }
+      it { expect(line_modifier).to(have_received(:replace_irefs).with("new file2 line1\n")) }
+      it { expect(line_modifier).to(have_received(:replace_irefs).with('new file2 line2')) }
+      it { expect(line_modifier).to(have_received(:config)) }
+      it { expect(line_modifier).to(have_received(:changes)) }
+      it { is_expected.to(have_attributes(config: 'new fake config')) }
+      it { is_expected.to(have_attributes(changes: [%w[from1 to1], %w[from2 to2]])) }
+    end
+
+    it do
+      expected_adoc = {
+        'file1.adoc' => "new2 file1 line1\nnew2 file1 line2",
+        'file2.adoc' => "new2 file2 line1\nnew2 file2 line2"
+      }
+      expect(modifier.do_modifications(adoc_texts)).to(eq(expected_adoc))
+    end
+  end
+end