defmastership 1.0.16 → 1.0.18

data/spec/unit/{defmastership → def_mastership}/batch_modifier_spec.rb

@@ -1,29 +1,31 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/batch_modifier')
 
 module DefMastership
-  class TotoClassModifier < ModifierBase
+  class TotoModifier
+    include Modifier
   end
 
-  class TutuClassModifier < ModifierBase
+  class TuTuModifier
+    include Modifier
   end
 end
 
 RSpec.describe(DefMastership::BatchModifier) do
   subject(:batchmodifier) do
-    described_class.new(config, adoc_texts)
+    described_class.new(config, adoc_sources)
   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' } }
+      modifier1: { type: 'toto', config: { p: 1 } },
+      modifier2: { type: 'toto', config: { p: 'whatever1' } },
+      modifier3: { type: 'tu_tu', config: { p1: 'whatever2', p2: 'whatever3' } }
     }
   end
-  let(:adoc_texts) do
+  let(:adoc_sources) do
     {
       'file1.adoc' => 'some text',
       'file2.adoc' => 'another text'
@@ -31,18 +33,18 @@ RSpec.describe(DefMastership::BatchModifier) do
   end
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    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))
+      expect(batchmodifier).to(have_attributes(adoc_sources: adoc_sources))
     end
   end
 
   describe '#apply' do
     context 'with only one modification' do
-      let(:toto1) { instance_double(DefMastership::TotoClassModifier, 'toto1') }
-      let(:adoc_texts_modified) do
+      let(:toto1) { instance_double(DefMastership::TotoModifier, 'toto1') }
+      let(:adoc_sources_modified) do
         {
           'file1.adoc' => 'some text modified',
           'file2.adoc' => 'another text'
@@ -51,26 +53,26 @@ RSpec.describe(DefMastership::BatchModifier) do
 
       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' } }
+          modifier1: { type: 'toto', config: { p: 'modified_param' } },
+          modifier2: { type: 'toto', config: { p: 'whatever1' } },
+          modifier3: { type: 'tu_tu', 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(DefMastership::TotoModifier).to(receive(:new).once.and_return(toto1))
+        allow(toto1).to(receive(:do_modifications).once.and_return(adoc_sources_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')
+        batchmodifier.apply(%i[modifier1])
       end
 
       it do
-        expect(DefMastership::TotoClassModifier).to(have_received(:new).with(p: 1))
+        expect(DefMastership::TotoModifier).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(:do_modifications).with(adoc_sources)) }
+      it { is_expected.to(have_attributes(adoc_sources: adoc_sources_modified)) }
       it { expect(toto1).to(have_received(:config).with(no_args)) }
 
       it { is_expected.to(have_attributes(config: config_modified)) }
@@ -78,45 +80,46 @@ RSpec.describe(DefMastership::BatchModifier) do
     end
 
     context 'with two modifications' do
-      let(:toto2) { instance_double(DefMastership::TotoClassModifier, 'toto2') }
-      let(:tutu3) { instance_double(DefMastership::TutuClassModifier, 'tutu3') }
+      let(:toto2) { instance_double(DefMastership::TotoModifier, 'toto2') }
+      let(:tutu3) { instance_double(DefMastership::TuTuModifier, 'tutu3') }
 
       let(:config_modified) do
         {
-          modifier1: { type: 'toto_class', config: { p: 1 } },
-          modifier2: { type: 'toto_class', config: :whatever },
-          modifier3: { type: 'tutu_class', config: :pouet }
+          modifier1: { type: 'toto', config: { p: 1 } },
+          modifier2: { type: 'toto', config: :whatever },
+          modifier3: { type: 'tu_tu', 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(DefMastership::TotoModifier).to(receive(:new).once.and_return(toto2))
+        allow(toto2).to(receive(:do_modifications).once.and_return(:adoc_sources_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(DefMastership::TuTuModifier).to(receive(:new).once.and_return(tutu3))
+        allow(tutu3).to(receive(:do_modifications).once.and_return(:adoc_sources_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')
+        batchmodifier.apply(%i[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(DefMastership::TotoModifier).to(have_received(:new).with(p: 'whatever1')) }
+      it { expect(DefMastership::TuTuModifier).to(have_received(:new).with(p1: 'whatever2', p2: 'whatever3')) }
+      it { expect(toto2).to(have_received(:do_modifications).with(adoc_sources)) }
       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(:do_modifications).with(:adoc_sources_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(adoc_sources: :adoc_sources_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
 
     context 'with wrong modification' do
       it do
-        expect { batchmodifier.apply('wrong-modification') }.to(
-          raise_error(ArgumentError, 'wrong-modification is not a known modification')
-        )
+        expect { batchmodifier.apply(%i[wrong-modification]) }
+          .to(
+            raise_error(ArgumentError, 'wrong-modification is not a known modification')
+          )
       end
     end
   end

data/spec/unit/{defmastership/change_ref_line_modifier_spec.rb → def_mastership/change_ref_modifier_spec.rb}

@@ -1,49 +1,21 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/change_ref_modifier')
 
-RSpec.describe(DefMastership::ChangeRefLineModifier) do
-  subject(:refchanger) { described_class.new }
+RSpec.describe(DefMastership::ChangeRefModifier) do
+  subject(:refchanger) { described_class.new({}) }
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { expect(described_class.ancestors).to(include(DefMastership::Modifier)) }
+    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 { expect { refchanger.user_defined_attribute }.to(raise_error(NoMethodError)) }
   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')) }
+  describe '.replacement_methods' do
+    it { expect(described_class.replacement_methods).to(eq(%i[replace_refdef replace_irefs])) }
   end
 
   describe '#config' do
@@ -54,26 +26,12 @@ RSpec.describe(DefMastership::ChangeRefLineModifier) do
         )
       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(
+      subject(:refchanger) do
+        described_class.new(
           from_regexp: 'TEMP',
           to_template: 'TUTU'
         )
@@ -95,8 +53,8 @@ RSpec.describe(DefMastership::ChangeRefLineModifier) do
     end
 
     context 'when template is variable' do
-      before do
-        refchanger.from_config(
+      subject(:refchanger) do
+        described_class.new(
           from_regexp: 'TEMP',
           to_template: 'TOTO-%<next_ref>04d',
           next_ref: 124
@@ -115,8 +73,8 @@ RSpec.describe(DefMastership::ChangeRefLineModifier) do
     end
 
     context 'when capture group in regexp' do
-      before do
-        refchanger.from_config(
+      subject(:refchanger) do
+        described_class.new(
           from_regexp: '(?<cg>TOTO|TITI)-TEMP[\d]*',
           to_template: '%<cg>s-%<next_ref>04d',
           next_ref: 132
@@ -142,11 +100,14 @@ RSpec.describe(DefMastership::ChangeRefLineModifier) do
     end
 
     context 'when definition is in literal block' do
-      before do
-        refchanger.from_config(
+      subject(:refchanger) do
+        described_class.new(
           from_regexp: 'TEMP',
           to_template: 'TUTU'
         )
+      end
+
+      before do
         refchanger.replace_refdef('....')
       end
 
@@ -157,11 +118,14 @@ RSpec.describe(DefMastership::ChangeRefLineModifier) do
     end
 
     context 'when defintion is after literal block' do
-      before do
-        refchanger.from_config(
+      subject(:refchanger) do
+        described_class.new(
           from_regexp: 'TEMP',
           to_template: 'TUTU'
         )
+      end
+
+      before do
         refchanger.replace_refdef("....\n")
         refchanger.replace_refdef('[define, whatever, TEMP]')
         refchanger.replace_refdef("....\n")
@@ -175,12 +139,15 @@ RSpec.describe(DefMastership::ChangeRefLineModifier) do
   end
 
   describe '#replace_irefs' do
-    before do
-      refchanger.from_config(
+    subject(:refchanger) do
+      described_class.new(
         from_regexp: '(?<cg>TOTO|TITI)-TEMP[\d]*',
         to_template: '%<cg>s-%<next_ref>04d',
         next_ref: 132
       )
+    end
+
+    before do
       refchanger.replace_refdef('[define, whatever, TOTO-TEMP123]')
       refchanger.replace_refdef('[define, whatever, TITI-TEMP421]')
     end
@@ -202,11 +169,19 @@ RSpec.describe(DefMastership::ChangeRefLineModifier) do
         )
       ).to(eq('defs:iref[TOTO-0132] defs:iref[TITI-0133] bla'))
     end
+
+    it do
+      expect(
+        refchanger.replace_irefs(
+          'defs:iref[TOTO-TEMP123] defs:iref[TOTO-TEMP123] bla'
+        )
+      ).to(eq('defs:iref[TOTO-0132] defs:iref[TOTO-0132] bla'))
+    end
   end
 
   describe '#replace' do
-    before do
-      refchanger.from_config(
+    subject(:refchanger) do
+      described_class.new(
         from_regexp: 'TEMP',
         to_template: 'TUTU'
       )
@@ -234,10 +209,13 @@ RSpec.describe(DefMastership::ChangeRefLineModifier) do
 
     it do
       refchanger.replace(:refdef, '[define, whatever, TEMP]')
-      expect(refchanger.replace(:irefs, 'defs:iref[TEMP]'))
-        .to(eq('defs:iref[TUTU]'))
+      expect(refchanger.replace(:irefs, 'defs:iref[TEMP] defs:iref[TEMP]'))
+        .to(eq('defs:iref[TUTU] defs:iref[TUTU]'))
     end
 
-    it { expect { refchanger.replace(:pouet, 'whatever') }.to(raise_error(NoMethodError)) }
+    it do
+      expect { refchanger.replace(:pouet, 'whatever') }
+        .to(raise_error(NoMethodError))
+    end
   end
 end

data/spec/unit/{defmastership → def_mastership}/csv_formatter_body_spec.rb

@@ -1,16 +1,16 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/csv_formatter_body')
 
 RSpec.describe(DefMastership::CSVFormatterBody) do
-  subject(:formatter) { described_class.new(document) }
+  subject(:formatter) { described_class.new(document, definition) }
 
   let(:document)   { instance_double(DefMastership::Document, 'document')     }
   let(:definition) { instance_double(DefMastership::Definition, 'definition') }
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
   end
 
   describe '#fixed' do
@@ -18,35 +18,35 @@ RSpec.describe(DefMastership::CSVFormatterBody) 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'))
-      allow(definition).to(receive(:sha256).with(no_args).and_return('d'))
-      formatter.fixed(definition)
+      allow(definition).to(receive(:sha256_short).with(no_args).and_return('d'))
+      formatter.fixed
     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(definition).to(have_received(:sha256).with(no_args)) }
-    it { expect(formatter.fixed(definition)).to(eq(%w[a b c d])) }
+    it { expect(definition).to(have_received(:sha256_short).with(no_args)) }
+    it { expect(formatter.fixed).to(eq(%w[a b c d])) }
   end
 
   describe '#wrong_explicit_checksum' do
     context 'when no wrong_explicit checksum' do
       before do
         allow(definition).to(receive(:wrong_explicit_checksum).with(no_args).and_return(nil))
-        formatter.wrong_explicit_checksum(definition)
+        formatter.wrong_explicit_checksum
       end
 
       it { expect(definition).to(have_received(:wrong_explicit_checksum).with(no_args)) }
-      it { expect(formatter.wrong_explicit_checksum(definition)).to(eq([''])) }
+      it { expect(formatter.wrong_explicit_checksum).to(eq([''])) }
     end
 
     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)
+        formatter.wrong_explicit_checksum
       end
 
-      it { expect(formatter.wrong_explicit_checksum(definition)).to(eq(['ab12'])) }
+      it { expect(formatter.wrong_explicit_checksum).to(eq(['ab12'])) }
     end
   end
 
@@ -54,20 +54,20 @@ RSpec.describe(DefMastership::CSVFormatterBody) 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)
+        formatter.explicit_version
       end
 
       it { expect(definition).to(have_received(:explicit_version).with(no_args)) }
-      it { expect(formatter.explicit_version(definition)).to(eq([''])) }
+      it { expect(formatter.explicit_version).to(eq([''])) }
     end
 
     context 'when explicit_version' do
       before do
         allow(definition).to(receive(:explicit_version).with(no_args).and_return('ab12'))
-        formatter.explicit_version(definition)
+        formatter.explicit_version
       end
 
-      it { expect(formatter.explicit_version(definition)).to(eq(['ab12'])) }
+      it { expect(formatter.explicit_version).to(eq(['ab12'])) }
     end
   end
 
@@ -77,21 +77,21 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     context 'when no labels on definition' do
       before do
         allow(definition).to(receive(:labels).with(no_args).and_return([]))
-        formatter.labels(definition)
+        formatter.labels
       end
 
       it { expect(definition).to(have_received(:labels).once.with(no_args)) }
-      it { expect(formatter.labels(definition)).to(eq([''])) }
+      it { expect(formatter.labels).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)
+        allow(definition).to(receive(:labels).with(no_args).and_return(%w[toto tutu].to_set))
+        formatter.labels
       end
 
       it { expect(definition).to(have_received(:labels).once.with(no_args)) }
-      it { expect(formatter.labels(definition)).to(eq(["toto\ntutu"])) }
+      it { expect(formatter.labels).to(eq(["toto\ntutu"])) }
     end
   end
 
@@ -99,11 +99,11 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     context 'when no eref on the document' do
       before do
         allow(document).to(receive(:eref).with(no_args).and_return({}))
-        formatter.eref(definition)
+        formatter.eref
       end
 
       it { expect(document).to(have_received(:eref).with(no_args)) }
-      it { expect(formatter.eref(nil)).to(eq([])) }
+      it { expect(formatter.eref).to(eq([])) }
     end
 
     context 'when eref on the document' do
@@ -114,11 +114,26 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
           )
         )
         allow(definition).to(receive(:eref).with(no_args).and_return(a: %w[A B], b: [], c: ['C']))
-        formatter.eref(definition)
+        formatter.eref
       end
 
       it { expect(definition).to(have_received(:eref).exactly(3).times.with(no_args)) }
-      it { expect(formatter.eref(definition)).to(eq(["A\nB", '', 'C'])) }
+      it { expect(formatter.eref).to(eq(["A\nB", '', 'C'])) }
+    end
+
+    context 'when missing eref on the definition' do
+      before do
+        allow(document).to(
+          receive(:eref).with(no_args).and_return(
+            a: 'whatever', b: 'whatever'
+          )
+        )
+        allow(definition).to(receive(:eref).with(no_args).and_return(b: ['B']))
+        formatter.eref
+      end
+
+      it { expect(definition).to(have_received(:eref).exactly(2).times.with(no_args)) }
+      it { expect(formatter.eref).to(eq(['', 'B'])) }
     end
   end
 
@@ -128,21 +143,21 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     context 'when no iref on the definition' do
       before do
         allow(definition).to(receive(:iref).with(no_args).and_return([]))
-        formatter.iref(definition)
+        formatter.iref
       end
 
       it { expect(definition).to(have_received(:iref).with(no_args)) }
-      it { expect(formatter.iref(definition)).to(eq([''])) }
+      it { expect(formatter.iref).to(eq([''])) }
     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(definition)
+        formatter.iref
       end
 
       it { expect(definition).to(have_received(:iref).with(no_args)) }
-      it { expect(formatter.iref(definition)).to(eq(["A\nB"])) }
+      it { expect(formatter.iref).to(eq(["A\nB"])) }
     end
   end
 
@@ -150,11 +165,11 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     context 'when no attributes on the document' do
       before do
         allow(document).to(receive(:attributes).with(no_args).and_return({}))
-        formatter.attributes(definition)
+        formatter.attributes
       end
 
       it { expect(document).to(have_received(:attributes).with(no_args)) }
-      it { expect(formatter.attributes(nil)).to(eq([])) }
+      it { expect(formatter.attributes).to(eq([])) }
     end
 
     context 'when attributes on the document' do
@@ -164,11 +179,25 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
             .and_return(a: 'whatever', b: 'whatever', c: 'whatever')
         )
         allow(definition).to(receive(:attributes).and_return(a: 'X', b: '', c: 'Y'))
-        formatter.attributes(definition)
+        formatter.attributes
+      end
+
+      it { expect(definition).to(have_received(:attributes).exactly(3).times) }
+      it { expect(formatter.attributes).to(eq(['X', '', 'Y'])) }
+    end
+
+    context 'when miing attribute on the definition' do
+      before do
+        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: ''))
+        formatter.attributes
       end
 
       it { expect(definition).to(have_received(:attributes).exactly(3).times) }
-      it { expect(formatter.attributes(definition)).to(eq(['X', '', 'Y'])) }
+      it { expect(formatter.attributes).to(eq(['X', '', ''])) }
     end
   end
 end

data/spec/unit/{defmastership → def_mastership}/csv_formatter_header_spec.rb

@@ -1,7 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/csv_formatter_header')
 
 RSpec.describe(DefMastership::CSVFormatterHeader) do
   subject(:formatter) { described_class.new(document) }
@@ -9,7 +9,7 @@ RSpec.describe(DefMastership::CSVFormatterHeader) do
   let(:document) { instance_double(DefMastership::Document, 'document') }
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
   end
 
   describe '#header' do