defmastership 1.0.6 → 1.0.11

data/lib/defmastership/modifier_base.rb

@@ -12,7 +12,7 @@ module DefMastership
     end
 
     def do_modifications(adoc_texts)
-      line_modifier = line_modifier_class.from_config(@config)
+      line_modifier = new_line_modifier(@config, adoc_texts)
 
       adoc_texts =
         replacements.reduce(adoc_texts) do |texts, method|

data/lib/defmastership/rename_included_files_modifier.rb

@@ -4,27 +4,12 @@
 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
+    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,38 @@
+# 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_checksum_modifier.rb

@@ -0,0 +1,21 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Update definition checksum with 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/update_def_version_line_modifier.rb

@@ -0,0 +1,58 @@
+# 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/lib/defmastership/update_def_version_modifier.rb

@@ -0,0 +1,25 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Update definition version if the definition has change since
+  # reference document
+  class UpdateDefVersionModifier < 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
+      ref_document = Document.new
+      ref_document.parse_file_with_preprocessor(config[:ref_document])
+      line_modifier = UpdateDefVersionLineModifier.from_config(config)
+      line_modifier.document = document
+      line_modifier.ref_document = ref_document
+      line_modifier
+    end
+  end
+end

data/lib/defmastership/version.rb

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

data/spec/unit/defmastership/batch_modifier_spec.rb

@@ -111,5 +111,13 @@ RSpec.describe(DefMastership::BatchModifier) do
       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')
+        )
+      end
+    end
   end
 end

data/spec/unit/defmastership/change_ref_line_modifier_spec.rb

@@ -217,6 +217,21 @@ RSpec.describe(DefMastership::ChangeRefLineModifier) do
         .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]'))

data/spec/unit/defmastership/csv_formatter_body_spec.rb

@@ -23,13 +23,9 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     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])) }
   end
 
@@ -41,7 +37,6 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       end
 
       it { expect(definition).to(have_received(:wrong_explicit_checksum).with(no_args)) }
-
       it { expect(formatter.wrong_explicit_checksum(definition)).to(eq([''])) }
     end
 
@@ -55,42 +50,48 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     end
   end
 
-  describe '#labels' do
-    context 'when no labels on document' do
+  describe '#explicit_version' do
+    context 'when no explicit_version' do
       before do
-        allow(document).to(receive(:labels).with(no_args).and_return([]))
-        formatter.labels(definition)
+        allow(definition).to(receive(:explicit_version).with(no_args).and_return(nil))
+        formatter.explicit_version(definition)
       end
 
-      it { expect(document).to(have_received(:labels).once.with(no_args)) }
-
-      it { expect(formatter.labels(definition)).to(eq([])) }
+      it { expect(definition).to(have_received(:explicit_version).with(no_args)) }
+      it { expect(formatter.explicit_version(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_version' do
+      before do
+        allow(definition).to(receive(:explicit_version).with(no_args).and_return('ab12'))
+        formatter.explicit_version(definition)
+      end
 
-      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(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(definition)).to(eq([''])) }
+    context 'when no labels on definition' do
+      before do
+        allow(definition).to(receive(:labels).with(no_args).and_return([]))
+        formatter.labels(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(definition)
-        end
-
-        it { expect(definition).to(have_received(:labels).once.with(no_args)) }
+      it { expect(definition).to(have_received(:labels).once.with(no_args)) }
+      it { expect(formatter.labels(definition)).to(eq([''])) }
+    end
 
-        it { expect(formatter.labels(definition)).to(eq(["toto\ntutu"])) }
+    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
 
@@ -102,7 +103,6 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       end
 
       it { expect(document).to(have_received(:eref).with(no_args)) }
-
       it { expect(formatter.eref(nil)).to(eq([])) }
     end
 
@@ -118,47 +118,31 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       end
 
       it { expect(definition).to(have_received(:eref).exactly(3).times.with(no_args)) }
-
       it { expect(formatter.eref(definition)).to(eq(["A\nB", '', 'C'])) }
     end
   end
 
   describe '#iref' do
-    context 'when no 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(document).to(receive(:iref).with(no_args).and_return(false))
+        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(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(definition)
-        end
-
-        it { expect(definition).to(have_received(:iref).with(no_args)) }
-
-        it { expect(formatter.iref(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(definition)
-        end
-
-        it { expect(definition).to(have_received(:iref).with(no_args)) }
-
-        it { expect(formatter.iref(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
 
@@ -170,7 +154,6 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       end
 
       it { expect(document).to(have_received(:attributes).with(no_args)) }
-
       it { expect(formatter.attributes(nil)).to(eq([])) }
     end
 
@@ -185,7 +168,6 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       end
 
       it { expect(definition).to(have_received(:attributes).exactly(3).times) }
-
       it { expect(formatter.attributes(definition)).to(eq(['X', '', 'Y'])) }
     end
   end

data/spec/unit/defmastership/csv_formatter_header_spec.rb

@@ -14,7 +14,29 @@ RSpec.describe(DefMastership::CSVFormatterHeader) do
 
   describe '#header' do
     describe '#fixed' do
-      it { expect(formatter.fixed).to(eq(%w[Type Reference Value sha256])) }
+      it { expect(formatter.fixed).to(eq(%w[Type Reference Value Checksum])) }
+    end
+
+    describe '#explicit_version' do
+      context 'when no explicit version' do
+        before do
+          allow(document).to(receive(:explicit_version?).and_return(false))
+          formatter.explicit_version
+        end
+
+        it { expect(document).to(have_received(:explicit_version?)) }
+
+        it { expect(formatter.explicit_version).to(eq([])) }
+      end
+
+      context 'when explicit version' do
+        before do
+          allow(document).to(receive(:explicit_version?).and_return(true))
+          formatter.explicit_version
+        end
+
+        it { expect(formatter.explicit_version).to(eq(['Version'])) }
+      end
     end
 
     describe '#wrong_explicit_checksum' do

data/spec/unit/defmastership/csv_formatter_spec.rb

@@ -15,20 +15,29 @@ RSpec.describe(DefMastership::CSVFormatter) do
   end
 
   describe '#export_to' do
-    context 'when wrong explicit checksum' do
-      let(:header) { instance_double(DefMastership::CSVFormatterHeader, 'header') }
-      let(:body) { instance_double(DefMastership::CSVFormatterBody, 'body') }
-      let(:csv)  { instance_double(CSV, 'csv')                              }
+    let(:header) { instance_double(DefMastership::CSVFormatterHeader, 'header') }
+    let(:body) { instance_double(DefMastership::CSVFormatterBody, 'body') }
+    let(:csv)  { instance_double(CSV, 'csv')                              }
+
+    before do
+      allow(CSV).to(receive(:open).and_yield(csv))
+      allow(csv).to(receive(:<<))
+      allow(DefMastership::CSVFormatterHeader).to(receive(:new).with(document).and_return(header))
+      allow(DefMastership::CSVFormatterBody).to(receive(:new).with(document).and_return(body))
+      allow(document).to(receive(:definitions).and_return(%i[def1 def2]))
+      allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(false))
+      allow(document).to(receive(:explicit_version?).with(no_args).and_return(false))
+      allow(document).to(receive(:labels).with(no_args).and_return([]))
+      allow(document).to(receive(:eref).with(no_args).and_return([]))
+      allow(document).to(receive(:iref).with(no_args).and_return(false))
+      allow(document).to(receive(:attributes).with(no_args).and_return([]))
+    end
+
+    context 'when no variable columns' do
+      methods = %i[fixed]
 
-      methods1 = %i[fixed wrong_explicit_checksum labels eref iref attributes]
       before do
-        allow(CSV).to(receive(:open).and_yield(csv))
-        allow(csv).to(receive(:<<))
-        allow(DefMastership::CSVFormatterHeader).to(receive(:new).with(document).and_return(header))
-        allow(DefMastership::CSVFormatterBody).to(receive(:new).with(document).and_return(body))
-        allow(document).to(receive(:definitions).and_return(%i[def1 def2]))
-        allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(true))
-        methods1.each do |method|
+        methods.each do |method|
           allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
           allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
           allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
@@ -36,98 +45,226 @@ RSpec.describe(DefMastership::CSVFormatter) do
         formatter.export_to('whatever')
       end
 
-      methods1.each do |method|
+      methods.each do |method|
         it { expect(header).to(have_received(method).with(no_args)) }
         it { expect(body).to(have_received(method).with(:def1)) }
         it { expect(body).to(have_received(method).with(:def2)) }
       end
 
-      it do
-        expect(csv).to(have_received(:<<).with(methods1.map { |method| "#{method} header" }))
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
+    end
+
+    context 'when wrong_explicit_checksum' do
+      methods = %i[fixed wrong_explicit_checksum]
+
+      before do
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(true))
+        formatter.export_to('whatever')
       end
 
-      it do
-        expect(csv).to(have_received(:<<).with(methods1.map { |method| "#{method} def1 body" }))
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
       end
 
-      it do
-        expect(csv).to(have_received(:<<).with(methods1.map { |method| "#{method} def2 body" }))
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
+    end
+
+    context 'when explicit_version' do
+      methods = %i[fixed explicit_version]
+
+      before do
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        allow(document).to(receive(:explicit_version?).with(no_args).and_return(true))
+        formatter.export_to('whatever')
+      end
+
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
       end
+
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
 
-    context 'when no wrong explicit checksum' do
-      let(:header) { instance_double(DefMastership::CSVFormatterHeader, 'header') }
-      let(:body) { instance_double(DefMastership::CSVFormatterBody, 'body') }
-      let(:csv)  { instance_double(CSV, 'csv')                              }
+    context 'when labels' do
+      methods = %i[fixed labels]
 
-      methods2 = %i[fixed labels eref iref attributes]
       before do
-        allow(CSV).to(receive(:open).and_yield(csv))
-        allow(csv).to(receive(:<<))
-        allow(DefMastership::CSVFormatterHeader).to(receive(:new).with(document).and_return(header))
-        allow(DefMastership::CSVFormatterBody).to(receive(:new).with(document).and_return(body))
-        allow(document).to(receive(:definitions).and_return(%i[def1 def2]))
-        allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(false))
-        methods2.each do |method|
+        methods.each do |method|
           allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
           allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
           allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
         end
+        allow(document).to(receive(:labels).with(no_args).and_return([:whatever]))
         formatter.export_to('whatever')
       end
 
-      methods2.each do |method|
+      methods.each do |method|
         it { expect(header).to(have_received(method).with(no_args)) }
         it { expect(body).to(have_received(method).with(:def1)) }
         it { expect(body).to(have_received(method).with(:def2)) }
       end
 
-      it do
-        expect(csv).to(have_received(:<<).with(methods2.map { |method| "#{method} header" }))
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
+    end
+
+    context 'when eref' do
+      methods = %i[fixed eref]
+
+      before do
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        allow(document).to(receive(:eref).with(no_args).and_return([:whatever]))
+        formatter.export_to('whatever')
       end
 
-      it do
-        expect(csv).to(have_received(:<<).with(methods2.map { |method| "#{method} def1 body" }))
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
+      end
+
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
+    end
+
+    context 'when iref' do
+      methods = %i[fixed iref]
+
+      before do
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        allow(document).to(receive(:iref).with(no_args).and_return(true))
+        formatter.export_to('whatever')
       end
 
-      it do
-        expect(csv).to(have_received(:<<).with(methods2.map { |method| "#{method} def2 body" }))
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
       end
+
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
 
-    context 'when #export_to csv file' do
-      let(:target_file) { 'export.csv' }
-      let(:definitions) do
-        [
-          OpenStruct.new(type: 'a', reference: 'b', value: 'c', sha256: 'd'),
-          OpenStruct.new(type: 'd', reference: 'e', value: 'f', sha256: 'g')
-        ]
+    context 'when attributes' do
+      methods = %i[fixed attributes]
+
+      before do
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        allow(document).to(receive(:attributes).with(no_args).and_return([:whatever]))
+        formatter.export_to('whatever')
+      end
+
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
       end
 
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
+    end
+
+    context 'when every colums' do
+      methods = %i[fixed wrong_explicit_checksum explicit_version labels eref iref attributes]
+
       before do
-        setup_aruba
-        allow(document).to(receive(:labels).exactly(3).times.with(no_args).and_return([]))
-        allow(document).to(receive(:eref).exactly(3).times.with(no_args).and_return({}))
-        allow(document).to(receive(:iref).exactly(3).times.with(no_args).and_return(false))
-        allow(document).to(receive(:attributes).exactly(3).times.with(no_args).and_return({}))
-        allow(document).to(receive(:definitions).with(no_args).and_return(definitions))
-        allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(false))
-        formatter.export_to("#{aruba.current_directory}/#{target_file}")
-      end
-
-      it { expect(document).to(have_received(:labels).exactly(3).times.with(no_args)) }
-      it { expect(document).to(have_received(:eref).exactly(3).times.with(no_args)) }
-      it { expect(document).to(have_received(:iref).exactly(3).times.with(no_args)) }
-      it { expect(document).to(have_received(:attributes).exactly(3).times.with(no_args)) }
-      it { expect(document).to(have_received(:definitions).with(no_args)) }
-
-      it do
-        expect(target_file).to(have_file_content(<<~CSV_FILE))
-          Type;Reference;Value;sha256
-          a;b;c;d
-          d;e;f;g
-        CSV_FILE
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(true))
+        allow(document).to(receive(:explicit_version?).with(no_args).and_return(true))
+        allow(document).to(receive(:labels).with(no_args).and_return([:whatever]))
+        allow(document).to(receive(:eref).with(no_args).and_return([:whatever]))
+        allow(document).to(receive(:iref).with(no_args).and_return(true))
+        allow(document).to(receive(:attributes).with(no_args).and_return([:whatever]))
+        formatter.export_to('whatever')
       end
+
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
+      end
+
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
+    end
+  end
+
+  context 'when #export_to csv file' do
+    let(:target_file) { 'export.csv' }
+    let(:definitions) do
+      [
+        OpenStruct.new(type: 'a', reference: 'b', value: 'c', sha256: 'd'),
+        OpenStruct.new(type: 'd', reference: 'e', value: 'f', sha256: 'g')
+      ]
+    end
+
+    before do
+      setup_aruba
+      allow(document).to(receive(:labels).with(no_args).and_return([]))
+      allow(document).to(receive(:eref).with(no_args).and_return({}))
+      allow(document).to(receive(:iref).with(no_args).and_return(false))
+      allow(document).to(receive(:attributes).with(no_args).and_return({}))
+      allow(document).to(receive(:definitions).with(no_args).and_return(definitions))
+      allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(false))
+      allow(document).to(receive(:explicit_version?).with(no_args).and_return(false))
+      formatter.export_to("#{aruba.current_directory}/#{target_file}")
+    end
+
+    it { expect(document).to(have_received(:labels).with(no_args)) }
+    it { expect(document).to(have_received(:eref).with(no_args)) }
+    it { expect(document).to(have_received(:iref).with(no_args)) }
+    it { expect(document).to(have_received(:attributes).with(no_args)) }
+    it { expect(document).to(have_received(:definitions).with(no_args)) }
+    it { expect(document).to(have_received(:wrong_explicit_checksum?).with(no_args)) }
+    it { expect(document).to(have_received(:explicit_version?).with(no_args)) }
+
+    it do
+      expect(target_file).to(have_file_content(<<~CSV_FILE))
+        Type;Reference;Value;Checksum
+        a;b;c;d
+        d;e;f;g
+      CSV_FILE
     end
   end
 end