defmastership 1.3.3 → 1.3.4

data/lib/defmastership/modifier/change_ref.rb

@@ -10,6 +10,7 @@ require('facets/file/writelines')
 module Defmastership
   module Modifier
     # Change references from temporary to definitive with multiple RefChangers
+    # This class smells of :reek:DataClump
     class ChangeRef
       include ModifierCommon
 
@@ -52,9 +53,11 @@ module Defmastership
 
       # Replace the definition's ref in the line if relevant
       #
+      # @param _filename [String] the filename of the file beeing modified
       # @param line [String] the current line
       # @return [String] the modified line
-      def replace_refdef(line)
+      # This method smells of :reek:DataClump
+      def replace_refdef(_filename, line)
         if @parsing_state.enabled?(line)
           do_replace_refdef(line)
         else
@@ -64,9 +67,10 @@ module Defmastership
 
       # Replace the definition's refs in intenal refs
       #
+      # @param _filename [String] the filename of the file beeing modified
       # @param line [String] the current line
       # @return [String] the modified line
-      def replace_irefs(line)
+      def replace_irefs(_filename, line)
         changes.reduce(line) do |res_line, (from, to)|
           res_line.gsub(Helper.regexp_from(:iref, from)) do
             Helper.text_with(Regexp.last_match, to)
@@ -76,9 +80,10 @@ module Defmastership
 
       # Replace the definition's refs in tags of include statements
       #
+      # @param _filename [String] the filename of the file beeing modified
       # @param line [String] the current line
       # @return [String] the modified line
-      def replace_include_tags(line)
+      def replace_include_tags(_filename, line)
         return line unless line.match?(Core::DMRegexp::INCLUDE)
 
         changes.reduce(line) do |res_line, (from, to)|
@@ -88,11 +93,14 @@ module Defmastership
 
       # Replace the definition's refs in included files
       #
+      # @param filename [String] the filename of the file beeing modified
       # @param line [String] the current line
       # @return [String] the (unmodified) line
-      def replace_tags_in_included_files(line)
+      def replace_tags_in_included_files(filename, line)
         if line.match(Core::DMRegexp::INCLUDE)
-          Helper.replace_tags_in_included_files(Helper::ParsedFilename.full_filename(Regexp.last_match), changes)
+          Helper.replace_tags_in_included_files(
+            "#{Pathname(filename).dirname}/#{Helper::ParsedFilename.full_filename(Regexp.last_match)}", changes
+          )
         end
         line
       end

data/lib/defmastership/modifier/modifier_common.rb

@@ -57,13 +57,13 @@ module Defmastership
       private
 
       def apply_to_all(texts, method)
-        texts.transform_values do |text|
-          apply_to_one(text, method)
+        texts.to_h do |filename, text|
+          [filename, apply_to_one(filename, text, method)]
         end
       end
 
-      def apply_to_one(text, method)
-        text.lines.map { |line| public_send(method, line) }
+      def apply_to_one(filename, text, method)
+        text.lines.map { |line| public_send(method, filename, line) }
             .join
       end
     end

data/lib/defmastership/modifier/rename_included_files.rb

@@ -81,15 +81,17 @@ module Defmastership
 
       # Modify line if it match
       #
+      # @param filename [String] the filename of the file beeing modified
+      # @param line [String] the current line
       # @return [String] the modified line
-      def replace(line)
+      def replace(filename, line)
         match = matched?(line)
 
         return line unless match
 
         new_line = build_new_include_line(match, line)
 
-        rename_file(line, new_line)
+        rename_file(Pathname(filename).dirname, line, new_line)
 
         new_line
       end
@@ -128,9 +130,9 @@ module Defmastership
         end
       end
 
-      def rename_file(from, to)
-        filename_from = Helper.extract_filename(from, @variables)
-        filename_to = Helper.extract_filename(to, @variables)
+      def rename_file(dirname, from, to)
+        filename_from = "#{dirname}/#{Helper.extract_filename(from, @variables)}"
+        filename_to = "#{dirname}/#{Helper.extract_filename(to, @variables)}"
         changes << [filename_from, filename_to]
         File.rename(filename_from, filename_to)
       end

data/lib/defmastership/modifier/update_def.rb

@@ -58,9 +58,10 @@ module Defmastership
 
       # Called on each line for an opportunity for text replacement
       #
+      # @param _filename [String] the filename of the file beeing modified
       # @param line [String] line from asciidoc sources files
       # @return [String] the modified line
-      def replace_reference(line)
+      def replace_reference(_filename, line)
         match = line.match(Core::DMRegexp::DEFINITION)
 
         return line unless match

data/lib/defmastership/modifier/update_eref_common.rb

@@ -40,9 +40,10 @@ module Defmastership
 
       # Replace the definition's external ref in the line if relevant
       #
+      # @param _filename [String] the filename of the file beeing modified
       # @param line [String] the current line
       # @return [String] the modified line
-      def replace_erefs(line)
+      def replace_erefs(_filename, line)
         match = line.match(Core::DMRegexp::EREF_DEF)
         # Return early if there's no match or the type is not valid
         return line unless match && eref_type_valid?(match[:reference])

data/lib/defmastership/modifier/update_iref_checksum.rb

@@ -20,9 +20,10 @@ module Defmastership
 
       # Replace the definition's internal ref in the line if relevant
       #
+      # @param _filename [String] the filename of the file beeing modified
       # @param line [String] the current line
       # @return [String] the modified line
-      def replace_irefs(line)
+      def replace_irefs(_filename, line)
         line.gsub(Core::DMRegexp::IREF_DEF) do
           Helper::IrefReplacementFormatterChecksum.new(Regexp.last_match, document).to_s
         end

data/lib/defmastership/modifier/update_iref_version.rb

@@ -20,9 +20,10 @@ module Defmastership
 
       # Replace the definition's internal ref in the line if relevant
       #
+      # @param _filename [String] the filename of the file beeing modified
       # @param line [String] the current line
       # @return [String] the modified line
-      def replace_irefs(line)
+      def replace_irefs(_filename, line)
         line.gsub(Core::DMRegexp::IREF_DEF) do
           Helper::IrefReplacementFormatterVersion.new(Regexp.last_match, document).to_s
         end

data/lib/defmastership/version.rb

@@ -3,6 +3,6 @@
 
 module Defmastership
   # [String] Gem version
-  VERSION = '1.3.3'
+  VERSION = '1.3.4'
   public_constant :VERSION
 end

data/spec/unit/defmastership/app_spec.rb

@@ -32,7 +32,8 @@ RSpec.describe(Defmastership::App) do
         /--separator, --sep, -s arg.*CSV\s+separator\s+\(default: ,\)$/,
         /--\[no-\]no-fail.*Exit\s+success\s+even\s+in\s+
            case\s+of\s+wrong\s+explicit\s+checksum$/mx,
-        /--output-file, -o arg.*CSV\s+output\s+filename\s+\(default:\s+none\)$/
+        /--output-file, -o arg.*CSV\s+output\s+filename\s+\(default:\s+none\)$/,
+        /--format, -f arg.*Output\s+format\s+\(default: csv\)$/
       ].each do |content|
         it do
           expect { described_class.run(['export', '--help']) }
@@ -76,7 +77,7 @@ RSpec.describe(Defmastership::App) do
 
         it { expect(Defmastership::Document).to(have_received(:new).with(no_args)) }
         it { expect(document).to(have_received(:parse_file_with_preprocessor).once.with('toto.adoc')) }
-        it { expect(Defmastership::Export::CSV::Formatter).to(have_received(:new).with(document, ',')) }
+        it { expect(Defmastership::Export::CSV::Formatter).to(have_received(:new).with(document, separator: ',')) }
         it { expect(formatter).to(have_received(:export_to).once.with('toto.csv')) }
         it { expect(document).to(have_received(:wrong_explicit_checksum?)) }
 
@@ -100,6 +101,29 @@ RSpec.describe(Defmastership::App) do
       end
     end
 
+    context('when "export --format=xslx toto.adoc" subcommand') do
+      let(:document)  { instance_double(Defmastership::Document, 'document') }
+      let(:formatter) { instance_double(Defmastership::Export::XLSX::Formatter, 'formatter') }
+      let(:defs) do
+        [
+          instance_double(Defmastership::Definition, 'def1'),
+          instance_double(Defmastership::Definition, 'def2')
+        ]
+      end
+
+      before do
+        allow(Defmastership::Document).to(receive(:new).and_return(document))
+        allow(Defmastership::Export::XLSX::Formatter).to(receive(:new).and_return(formatter))
+        allow(formatter).to(receive(:export_to).with(an_instance_of(String)))
+        allow(document).to(receive(:parse_file_with_preprocessor).with(an_instance_of(String)))
+        allow(document).to(receive_messages(definitions: defs, wrong_explicit_checksum?: nil))
+        described_class.run(['export', '--format=xlsx', 'toto.adoc'])
+      end
+
+      it { expect(Defmastership::Export::XLSX::Formatter).to(have_received(:new).with(document)) }
+      it { expect(formatter).to(have_received(:export_to).once.with('toto.xlsx')) }
+    end
+
     context('when "export" with more than one argument') do
       let(:document)  { instance_double(Defmastership::Document, 'document')                     }
       let(:formatter) { instance_double(Defmastership::Export::CSV::Formatter, 'formatter')      }
@@ -123,7 +147,7 @@ RSpec.describe(Defmastership::App) do
       it { expect(Defmastership::Document).to(have_received(:new).with(no_args)) }
       it { expect(document).to(have_received(:parse_file_with_preprocessor).once.with('toto.adoc')) }
       it { expect(document).to(have_received(:parse_file_with_preprocessor).once.with('tutu.adoc')) }
-      it { expect(Defmastership::Export::CSV::Formatter).to(have_received(:new).with(document, ',')) }
+      it { expect(Defmastership::Export::CSV::Formatter).to(have_received(:new).with(document, separator: ',')) }
       it { expect(formatter).to(have_received(:export_to).once.with('pouet.csv')) }
       it { expect(described_class.run(['export', '--output-file=pouet.csv', 'toto.adoc', 'tutu.adoc'])).to(be(0)) }
     end

data/spec/unit/defmastership/export/csv/formatter_spec.rb

@@ -4,8 +4,10 @@
 require('defmastership/document')
 require('defmastership/export/csv/formatter')
 
+COLUMN_METHODS = %i[type reference value checksum].freeze
+
 RSpec.describe(Defmastership::Export::CSV::Formatter) do
-  subject(:formatter) { described_class.new(document, ';') }
+  subject(:formatter) { described_class.new(document, separator: ';') }
 
   let(:document) { instance_double(Defmastership::Document, 'document') }
 
@@ -21,6 +23,7 @@ RSpec.describe(Defmastership::Export::CSV::Formatter) do
         instance_double(Defmastership::Export::BodyFormatter, 'bodies[1]')
       ]
     end
+
     let(:csv) { instance_double(CSV, 'csv') }
 
     before do
@@ -46,10 +49,8 @@ RSpec.describe(Defmastership::Export::CSV::Formatter) do
     end
 
     context 'when no variable columns' do
-      methods = %i[type reference value checksum]
-
       before do
-        methods.each do |method|
+        COLUMN_METHODS.each do |method|
           allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
           bodies.each_with_index do |body, index|
             allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
@@ -60,88 +61,7 @@ RSpec.describe(Defmastership::Export::CSV::Formatter) do
 
       it { expect(CSV).to(have_received(:open).with('whatever', 'w:ISO-8859-1', col_sep: ';')) }
 
-      methods.each do |method|
-        it { expect(header).to(have_received(method).with(no_args)) }
-
-        2.times do |index|
-          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
-        end
-      end
-
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-    end
-
-    context 'when summary' do
-      methods = %i[type reference summary value checksum]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          bodies.each_with_index do |body, index|
-            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
-          end
-        end
-        allow(document).to(receive(:summaries?).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)) }
-
-        2.times do |index|
-          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
-        end
-      end
-
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-    end
-
-    context 'when wrong_explicit_checksum' do
-      methods = %i[type reference value checksum wrong_explicit_checksum]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          bodies.each_with_index do |body, index|
-            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
-          end
-        end
-        allow(document).to(receive(:wrong_explicit_checksum?).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)) }
-
-        2.times do |index|
-          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
-        end
-      end
-
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-    end
-
-    context 'when explicit_version' do
-      methods = %i[type reference value checksum explicit_version]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          bodies.each_with_index do |body, index|
-            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
-          end
-        end
-        allow(document).to(receive(:explicit_version?).with(no_args).and_return(true))
-        formatter.export_to('whatever')
-      end
-
-      methods.each do |method|
+      COLUMN_METHODS.each do |method|
         it { expect(header).to(have_received(method).with(no_args)) }
 
         2.times do |index|
@@ -149,162 +69,55 @@ RSpec.describe(Defmastership::Export::CSV::Formatter) do
         end
       end
 
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(COLUMN_METHODS.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(COLUMN_METHODS.map { |method| "#{method} def0 body" })) }
+      it { expect(csv).to(have_received(:<<).with(COLUMN_METHODS.map { |method| "#{method} def1 body" })) }
     end
+  end
 
-    context 'when labels' do
-      methods = %i[type reference value checksum labels]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          bodies.each_with_index do |body, index|
-            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
-          end
-        end
-        allow(document).to(receive(:labels).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)) }
-
-        2.times do |index|
-          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
-        end
-      end
-
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-    end
-
-    context 'when eref' do
-      methods = %i[type reference value checksum eref]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          bodies.each_with_index do |body, index|
-            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
-          end
-        end
-        allow(document).to(receive(:eref).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)) }
-
-        2.times do |index|
-          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
-        end
-      end
-
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-    end
-
-    context 'when iref' do
-      methods = %i[type reference value checksum iref]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          bodies.each_with_index do |body, index|
-            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
-          end
-        end
-        allow(document).to(receive(:iref).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)) }
+  describe '#export_to with default separator' do
+    subject(:formatter) { described_class.new(document) }
 
-        2.times do |index|
-          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
-        end
-      end
-
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+    let(:header) { instance_double(Defmastership::Export::HeaderFormatter, 'header') }
+    let(:bodies) do
+      [
+        instance_double(Defmastership::Export::BodyFormatter, 'bodies[0]'),
+        instance_double(Defmastership::Export::BodyFormatter, 'bodies[1]')
+      ]
     end
 
-    context 'when attributes' do
-      methods = %i[type reference value checksum attributes]
+    let(:csv) { instance_double(CSV, 'csv') }
 
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          bodies.each_with_index do |body, index|
-            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
-          end
-        end
-        allow(document).to(receive(:attributes).with(no_args).and_return([:whatever]))
-        formatter.export_to('whatever')
+    before do
+      allow(CSV).to(receive(:open).with('whatever', 'w:ISO-8859-1', col_sep: ',').and_yield(csv))
+      allow(csv).to(receive(:<<))
+      allow(Defmastership::Export::HeaderFormatter).to(receive(:new).with(document).and_return(header))
+      bodies.each_with_index do |body, index|
+        allow(Defmastership::Export::BodyFormatter).to(
+          receive(:new).with(
+            document,
+            :"def#{index}"
+          ).and_return(body)
+        )
       end
+      allow(document).to(receive(:definitions).and_return(%i[def0 def1]))
+      allow(document).to(receive(:summaries?).with(no_args).and_return(false))
+      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([]))
 
-      methods.each do |method|
-        it { expect(header).to(have_received(method).with(no_args)) }
-
-        2.times do |index|
-          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+      %i[type reference value checksum].each do |method|
+        allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+        bodies.each_with_index do |body, index|
+          allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
         end
       end
-
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      formatter.export_to('whatever')
     end
 
-    context 'when every colums' do
-      methods = %i[
-        type
-        reference
-        summary
-        value
-        checksum
-        wrong_explicit_checksum
-        explicit_version
-        labels
-        eref
-        iref
-        attributes
-      ]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          bodies.each_with_index do |body, index|
-            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
-          end
-        end
-        allow(document).to(receive(:summaries?).with(no_args).and_return(true))
-        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)) }
-
-        2.times do |index|
-          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
-        end
-      end
-
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-    end
+    it { expect(CSV).to(have_received(:open).with('whatever', 'w:ISO-8859-1', col_sep: ',')) }
   end
 end

data/spec/unit/defmastership/export/formatter_spec.rb

@@ -0,0 +1,97 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/export/formatter')
+
+# Defmastership::Export::Formatter is an abstract class and need to be derived for test
+class ConcreteFormatter < Defmastership::Export::Formatter
+  def export_to(_filename)
+    # allow to indirectly test a private method
+    build_column_list
+  end
+end
+
+RSpec.describe(Defmastership::Export::Formatter) do
+  context('when class is not derived') do
+    subject(:formatter) { described_class.new(:whatever) }
+
+    describe '#export_to' do
+      it {
+        expect { formatter.export_to(:something) }
+          .to(raise_error(
+                NotImplementedError,
+                'Defmastership::Export::Formatter has not implemented the \'export_to\' method'
+              ))
+      }
+    end
+  end
+
+  context('when class is derived') do
+    subject(:formatter) { ConcreteFormatter.new(document) }
+
+    let(:document) { instance_double(Defmastership::Document, 'document') }
+
+    describe '#export_to' do
+      it {
+        expect { formatter.export_to(:something) }
+          .not_to(raise_error(NotImplementedError))
+      }
+    end
+
+    describe '#header' do
+      let(:header_formatter) { instance_double(Defmastership::Export::HeaderFormatter, 'header_formatter') }
+
+      before do
+        allow(Defmastership::Export::HeaderFormatter).to(receive(:new).and_return(header_formatter))
+        allow(header_formatter).to(receive_messages(type: ['type value'], reference: ['reference value']))
+        formatter.header(%i[type reference])
+      end
+
+      it { expect(Defmastership::Export::HeaderFormatter).to(have_received(:new).with(document)) }
+      it { expect(header_formatter).to(have_received(:type)) }
+      it { expect(header_formatter).to(have_received(:reference)) }
+      it { expect(formatter.header(%i[type reference])).to(eq(['type value', 'reference value'])) }
+    end
+
+    describe '#body' do
+      let(:body_formatter) { instance_double(Defmastership::Export::BodyFormatter, 'body_formatter') }
+
+      before do
+        allow(Defmastership::Export::BodyFormatter).to(receive(:new).and_return(body_formatter))
+        allow(body_formatter).to(receive_messages(type: ['type value'], reference: ['reference value']))
+        formatter.body(:definition, %i[type reference])
+      end
+
+      it { expect(Defmastership::Export::BodyFormatter).to(have_received(:new).with(document, :definition)) }
+      it { expect(body_formatter).to(have_received(:type)) }
+      it { expect(body_formatter).to(have_received(:reference)) }
+      it { expect(formatter.body(:definition, %i[type reference])).to(eq(['type value', 'reference value'])) }
+    end
+
+    describe '#build_column_list' do
+      before do
+        allow(document).to(
+          receive_messages(
+            summaries?: true,
+            wrong_explicit_checksum?: false,
+            explicit_version?: false,
+            labels: ['toto'],
+            eref: [],
+            iref: false,
+            attributes: []
+          )
+        )
+        formatter.export_to(:whatever)
+      end
+
+      it { expect(document).to(have_received(:summaries?)) }
+      it { expect(document).to(have_received(:wrong_explicit_checksum?)) }
+      it { expect(document).to(have_received(:explicit_version?)) }
+      it { expect(document).to(have_received(:labels)) }
+      it { expect(document).to(have_received(:eref)) }
+      it { expect(document).to(have_received(:iref)) }
+      it { expect(document).to(have_received(:attributes)) }
+      it { expect(formatter.export_to(:whatever)).to(eq(%i[type reference summary value checksum labels])) }
+    end
+  end
+end