defmastership 1.0.5 → 1.0.10

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

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

data/spec/unit/defmastership/comment_filter_spec.rb

@@ -75,8 +75,10 @@ RSpec.describe(DefMastership::CommentFilter) do
     end
 
     before do
-      allow(DefMastership).to(receive(:comment_filter)
-        .and_return(comment_filter))
+      allow(DefMastership).to(
+        receive(:comment_filter)
+          .and_return(comment_filter)
+      )
     end
 
     context 'when not .commented?' do
@@ -94,8 +96,10 @@ RSpec.describe(DefMastership::CommentFilter) do
 
     context 'when .commented?' do
       before do
-        allow(comment_filter).to(receive(:accept?)
-          .with('blabla').and_return(false))
+        allow(comment_filter).to(
+          receive(:accept?)
+            .with('blabla').and_return(false)
+        )
       end
 
       it do

data/spec/unit/defmastership/csv_formatter_body_spec.rb

@@ -13,156 +13,162 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     it { is_expected.not_to(be(nil)) }
   end
 
-  describe '#fixed_body' do
+  describe '#fixed' do
     before do
       allow(definition).to(receive(:type).with(no_args).and_return('a'))
       allow(definition).to(receive(:reference).with(no_args).and_return('b'))
       allow(definition).to(receive(:value).with(no_args).and_return('c'))
-      formatter.fixed_body(definition)
+      allow(definition).to(receive(:sha256).with(no_args).and_return('d'))
+      formatter.fixed(definition)
     end
 
     it { expect(definition).to(have_received(:type).with(no_args)) }
-
     it { expect(definition).to(have_received(:reference).with(no_args)) }
-
     it { expect(definition).to(have_received(:value).with(no_args)) }
-
-    it { expect(formatter.fixed_body(definition)).to(eq(%w[a b c])) }
+    it { expect(definition).to(have_received(:sha256).with(no_args)) }
+    it { expect(formatter.fixed(definition)).to(eq(%w[a b c d])) }
   end
 
-  describe '#labels_body' do
-    context 'when no labels on document' do
+  describe '#wrong_explicit_checksum' do
+    context 'when no wrong_explicit checksum' do
       before do
-        allow(document).to(receive(:labels).with(no_args).and_return([]))
-        formatter.labels_body(definition)
+        allow(definition).to(receive(:wrong_explicit_checksum).with(no_args).and_return(nil))
+        formatter.wrong_explicit_checksum(definition)
       end
 
-      it { expect(document).to(have_received(:labels).once.with(no_args)) }
-
-      it { expect(formatter.labels_body(definition)).to(eq([])) }
+      it { expect(definition).to(have_received(:wrong_explicit_checksum).with(no_args)) }
+      it { expect(formatter.wrong_explicit_checksum(definition)).to(eq([''])) }
     end
 
-    context 'when labels on document' do
-      before { allow(document).to(receive(:labels).with(no_args).and_return(['whatever'])) }
+    context 'when explicit checksum' do
+      before do
+        allow(definition).to(receive(:wrong_explicit_checksum).with(no_args).and_return('ab12'))
+        formatter.wrong_explicit_checksum(definition)
+      end
+
+      it { expect(formatter.wrong_explicit_checksum(definition)).to(eq(['ab12'])) }
+    end
+  end
 
-      context 'when no labels on definition' do
-        before do
-          allow(definition).to(receive(:labels).with(no_args).and_return([]))
-          formatter.labels_body(definition)
-        end
+  describe '#explicit_version' do
+    context 'when no explicit_version' do
+      before do
+        allow(definition).to(receive(:explicit_version).with(no_args).and_return(nil))
+        formatter.explicit_version(definition)
+      end
 
-        it { expect(definition).to(have_received(:labels).once.with(no_args)) }
+      it { expect(definition).to(have_received(:explicit_version).with(no_args)) }
+      it { expect(formatter.explicit_version(definition)).to(eq([''])) }
+    end
 
-        it { expect(formatter.labels_body(definition)).to(eq([''])) }
+    context 'when explicit_version' do
+      before do
+        allow(definition).to(receive(:explicit_version).with(no_args).and_return('ab12'))
+        formatter.explicit_version(definition)
       end
 
-      context 'when labels on definition' do
-        before do
-          allow(definition).to(receive(:labels).with(no_args).and_return(%w[toto tutu]))
-          formatter.labels_body(definition)
-        end
+      it { expect(formatter.explicit_version(definition)).to(eq(['ab12'])) }
+    end
+  end
 
-        it { expect(definition).to(have_received(:labels).once.with(no_args)) }
+  describe '#labels' do
+    before { allow(document).to(receive(:labels).with(no_args).and_return(['whatever'])) }
 
-        it { expect(formatter.labels_body(definition)).to(eq(["toto\ntutu"])) }
+    context 'when no labels on definition' do
+      before do
+        allow(definition).to(receive(:labels).with(no_args).and_return([]))
+        formatter.labels(definition)
       end
+
+      it { expect(definition).to(have_received(:labels).once.with(no_args)) }
+      it { expect(formatter.labels(definition)).to(eq([''])) }
+    end
+
+    context 'when labels on definition' do
+      before do
+        allow(definition).to(receive(:labels).with(no_args).and_return(%w[toto tutu]))
+        formatter.labels(definition)
+      end
+
+      it { expect(definition).to(have_received(:labels).once.with(no_args)) }
+      it { expect(formatter.labels(definition)).to(eq(["toto\ntutu"])) }
     end
   end
 
-  describe '#eref_body' do
+  describe '#eref' do
     context 'when no eref on the document' do
       before do
         allow(document).to(receive(:eref).with(no_args).and_return({}))
-        formatter.eref_body(definition)
+        formatter.eref(definition)
       end
 
       it { expect(document).to(have_received(:eref).with(no_args)) }
-
-      it { expect(formatter.eref_body(nil)).to(eq([])) }
+      it { expect(formatter.eref(nil)).to(eq([])) }
     end
 
     context 'when eref on the document' do
       before do
-        allow(document).to(receive(:eref).with(no_args).and_return(
-                             a: 'whatever',
-                             b: 'whatever',
-                             c: 'whatever'
-                           ))
+        allow(document).to(
+          receive(:eref).with(no_args).and_return(
+            a: 'whatever', b: 'whatever', c: 'whatever'
+          )
+        )
         allow(definition).to(receive(:eref).with(no_args).and_return(a: %w[A B], b: [], c: ['C']))
-        formatter.eref_body(definition)
+        formatter.eref(definition)
       end
 
       it { expect(definition).to(have_received(:eref).exactly(3).times.with(no_args)) }
-
-      it { expect(formatter.eref_body(definition)).to(eq(["A\nB", '', 'C'])) }
+      it { expect(formatter.eref(definition)).to(eq(["A\nB", '', 'C'])) }
     end
   end
 
-  describe '#iref_body' do
-    context 'when no iref on the document' do
+  describe '#iref' do
+    before { allow(document).to(receive(:iref).with(no_args).and_return(true)) }
+
+    context 'when no iref on the definition' do
       before do
-        allow(document).to(receive(:iref).with(no_args).and_return(false))
-        formatter.iref_body(definition)
+        allow(definition).to(receive(:iref).with(no_args).and_return([]))
+        formatter.iref(definition)
       end
 
-      it { expect(document).to(have_received(:iref).with(no_args)) }
-
-      it { expect(formatter.iref_body(definition)).to(eq([])) }
+      it { expect(definition).to(have_received(:iref).with(no_args)) }
+      it { expect(formatter.iref(definition)).to(eq([''])) }
     end
 
-    context 'when iref on the document' do
-      before { allow(document).to(receive(:iref).with(no_args).and_return(true)) }
-
-      context 'when no iref on the definition' do
-        before do
-          allow(definition).to(receive(:iref).with(no_args).and_return([]))
-          formatter.iref_body(definition)
-        end
-
-        it { expect(definition).to(have_received(:iref).with(no_args)) }
-
-        it { expect(formatter.iref_body(definition)).to(eq([''])) }
+    context 'when iref on the definition' do
+      before do
+        allow(definition).to(receive(:iref).with(no_args).and_return(%w[A B]))
+        formatter.iref(definition)
       end
 
-      context 'when iref on the definition' do
-        before do
-          allow(definition).to(receive(:iref).with(no_args).and_return(%w[A B]))
-          formatter.iref_body(definition)
-        end
-
-        it { expect(definition).to(have_received(:iref).with(no_args)) }
-
-        it { expect(formatter.iref_body(definition)).to(eq(["A\nB"])) }
-      end
+      it { expect(definition).to(have_received(:iref).with(no_args)) }
+      it { expect(formatter.iref(definition)).to(eq(["A\nB"])) }
     end
   end
 
-  describe '#attributes_body' do
+  describe '#attributes' do
     context 'when no attributes on the document' do
       before do
         allow(document).to(receive(:attributes).with(no_args).and_return({}))
-        formatter.attributes_body(definition)
+        formatter.attributes(definition)
       end
 
       it { expect(document).to(have_received(:attributes).with(no_args)) }
-
-      it { expect(formatter.attributes_body(nil)).to(eq([])) }
+      it { expect(formatter.attributes(nil)).to(eq([])) }
     end
 
     context 'when attributes on the document' do
       before do
-        allow(document).to(receive(:attributes).with(no_args).and_return(
-                             a: 'whatever',
-                             b: 'whatever',
-                             c: 'whatever'
-                           ))
+        allow(document).to(
+          receive(:attributes).with(no_args)
+            .and_return(a: 'whatever', b: 'whatever', c: 'whatever')
+        )
         allow(definition).to(receive(:attributes).and_return(a: 'X', b: '', c: 'Y'))
-        formatter.attributes_body(definition)
+        formatter.attributes(definition)
       end
 
       it { expect(definition).to(have_received(:attributes).exactly(3).times) }
-
-      it { expect(formatter.attributes_body(definition)).to(eq(['X', '', 'Y'])) }
+      it { expect(formatter.attributes(definition)).to(eq(['X', '', 'Y'])) }
     end
   end
 end