defmastership 1.3.3 → 1.3.4

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

@@ -0,0 +1,85 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/document')
+require('defmastership/export/json/formatter')
+
+RSpec.describe(Defmastership::Export::JSON::Formatter) do
+  subject(:formatter) { described_class.new(document) }
+
+  let(:document) { instance_double(Defmastership::Document, 'document') }
+
+  describe '.new' do
+    it { is_expected.not_to(be_nil) }
+  end
+
+  describe '#export_to' do
+    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
+
+    let(:json) { instance_double(JSON, 'json') }
+    let(:expected_hash_array) do
+      [
+        {
+          'checksum header': 'checksum def0 body',
+          'reference header': 'reference def0 body',
+          'type header': 'type def0 body',
+          'value header': 'value def0 body'
+        },
+        {
+          'checksum header': 'checksum def1 body',
+          'reference header': 'reference def1 body',
+          'type header': 'type def1 body',
+          'value header': 'value def1 body'
+        }
+      ]
+    end
+
+    before do
+      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([]))
+
+      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"]))
+        end
+      end
+
+      allow(JSON).to(receive(:pretty_generate)).and_return('the generated json')
+      allow(File).to(receive(:write).with('filename', 'the generated json'))
+      formatter.export_to('filename')
+    end
+
+    COLUMN_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(JSON).to(have_received(:pretty_generate).with(expected_hash_array)) }
+    it { expect(File).to(have_received(:write).with('filename', 'the generated json')) }
+  end
+end

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

@@ -0,0 +1,82 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/export/xlsx/formatter')
+require('rubyXL')
+
+RSpec.describe(Defmastership::Export::XLSX::Formatter) do
+  subject(:formatter) { described_class.new(document) }
+
+  let(:document) { instance_double(Defmastership::Document, 'document') }
+
+  describe '.new' do
+    it { is_expected.not_to(be_nil) }
+  end
+
+  describe '#export_to' do
+    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
+    let(:workbook)  { instance_double(RubyXL::Workbook, 'workbook')   }
+    let(:worksheet) { instance_double(RubyXL::Worksheet, 'worksheet') }
+
+    before do
+      allow(RubyXL::Workbook).to(receive(:new).and_return(workbook))
+      allow(workbook).to(receive(:worksheets).with(no_args).and_return([worksheet]))
+      allow(worksheet).to(receive(:add_cell))
+      allow(workbook).to(receive(:write))
+      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([]))
+    end
+
+    context 'when no variable columns' do
+      before do
+        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"]))
+          end
+        end
+        formatter.export_to('whatever')
+      end
+
+      it { expect(RubyXL::Workbook).to(have_received(:new)) }
+      it { expect(workbook).to(have_received(:worksheets)) }
+
+      COLUMN_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
+
+      COLUMN_METHODS.each_with_index do |method, index|
+        it { expect(worksheet).to(have_received(:add_cell).with(0, index, "#{method} header")) }
+        it { expect(worksheet).to(have_received(:add_cell).with(1, index, "#{method} def0 body")) }
+        it { expect(worksheet).to(have_received(:add_cell).with(2, index, "#{method} def1 body")) }
+      end
+
+      it { expect(workbook).to(have_received(:write).with('whatever')) }
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/document')
+require('defmastership/export/yaml/formatter')
+
+RSpec.describe(Defmastership::Export::YAML::Formatter) do
+  subject(:formatter) { described_class.new(document) }
+
+  let(:document) { instance_double(Defmastership::Document, 'document') }
+
+  describe '.new' do
+    it { is_expected.not_to(be_nil) }
+  end
+
+  describe '#export_to' do
+    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
+
+    let(:yaml) { instance_double(YAML, 'yaml') }
+    let(:expected_hash_array) do
+      [
+        {
+          'checksum header': 'checksum def0 body',
+          'reference header': 'reference def0 body',
+          'type header': 'type def0 body',
+          'value header': 'value def0 body'
+        },
+        {
+          'checksum header': 'checksum def1 body',
+          'reference header': 'reference def1 body',
+          'type header': 'type def1 body',
+          'value header': 'value def1 body'
+        }
+      ]
+    end
+
+    before do
+      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([]))
+
+      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"]))
+        end
+      end
+
+      allow(YAML).to(receive(:dump)).and_return('the generated yaml')
+      allow(File).to(receive(:write).with('filename', 'the generated yaml'))
+      formatter.export_to('filename')
+    end
+
+    COLUMN_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(YAML).to(have_received(:dump).with(expected_hash_array)) }
+    it { expect(File).to(have_received(:write).with('filename', 'the generated yaml')) }
+  end
+end

data/spec/unit/defmastership/modifier/change_ref_spec.rb

@@ -28,25 +28,27 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
 
       context 'when valid definition' do
         it do
-          expect(refchanger.replace_refdef('[define, whatever, TEMP]')).to(eq('[define, whatever, TUTU]'))
+          expect(refchanger.replace_refdef('', '[define, whatever, TEMP]')).to(eq('[define, whatever, TUTU]'))
         end
 
         it do
-          expect(refchanger.replace_refdef('[define, whatever, TEMP(a~12345678)]'))
+          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)]'))
+          expect(refchanger.replace_refdef('', '[define, whatever, TEMP(~12345678)]'))
             .to(eq('[define, whatever, TUTU(~12345678)]'))
         end
 
-        it { expect(refchanger.replace_refdef('[define, whatever, TEMP(a)]')).to(eq('[define, whatever, TUTU(a)]')) }
+        it do
+          expect(refchanger.replace_refdef('', '[define, whatever, TEMP(a)]')).to(eq('[define, whatever, TUTU(a)]'))
+        end
       end
 
       context 'when no valid definition' do
         it do
-          expect(refchanger.replace_refdef('[pouet, whatever, TEMP]')).to(eq('[pouet, whatever, TEMP]'))
+          expect(refchanger.replace_refdef('', '[pouet, whatever, TEMP]')).to(eq('[pouet, whatever, TEMP]'))
         end
       end
     end
@@ -57,11 +59,11 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
       end
 
       it do
-        expect(refchanger.replace_refdef('[define, whatever, TEMP]')).to(eq('[define, whatever, TOTO-0124]'))
+        expect(refchanger.replace_refdef('', '[define, whatever, TEMP]')).to(eq('[define, whatever, TOTO-0124]'))
       end
 
       it do
-        refchanger.replace_refdef('[define, whatever, TEMP]')
+        refchanger.replace_refdef('', '[define, whatever, TEMP]')
         expect(refchanger).to(have_attributes(next_ref: 125))
       end
     end
@@ -75,16 +77,18 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
         )
       end
 
-      it { expect(refchanger.replace_refdef('[define, whatever, TOTO-TEMP]')).to(eq('[define, whatever, TOTO-0132]')) }
+      it do
+        expect(refchanger.replace_refdef('', '[define, whatever, TOTO-TEMP]')).to(eq('[define, whatever, TOTO-0132]'))
+      end
 
       it do
-        refchanger.replace_refdef('[define, whatever, TOTO-TEMP]')
-        expect(refchanger.replace_refdef('[define, whatever, TITI-TEMP]')).to(eq('[define, whatever, TITI-0133]'))
+        refchanger.replace_refdef('', '[define, whatever, TOTO-TEMP]')
+        expect(refchanger.replace_refdef('', '[define, whatever, TITI-TEMP]')).to(eq('[define, whatever, TITI-0133]'))
       end
 
       it do
-        refchanger.replace_refdef('[define, whatever, TOTO-TEMP1]')
-        refchanger.replace_refdef('[define, whatever, TITI-TEMP2]')
+        refchanger.replace_refdef('', '[define, whatever, TOTO-TEMP1]')
+        refchanger.replace_refdef('', '[define, whatever, TITI-TEMP2]')
         expect(refchanger).to(have_attributes(changes: [%w[TOTO-TEMP1 TOTO-0132], %w[TITI-TEMP2 TITI-0133]]))
       end
     end
@@ -93,10 +97,10 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
       subject(:refchanger) { described_class.new(from_regexp: 'TEMP', to_template: 'TUTU') }
 
       before do
-        refchanger.replace_refdef('....')
+        refchanger.replace_refdef('', '....')
       end
 
-      it { expect(refchanger.replace_refdef('[define, whatever, TEMP]')).to(eq('[define, whatever, TEMP]')) }
+      it { expect(refchanger.replace_refdef('', '[define, whatever, TEMP]')).to(eq('[define, whatever, TEMP]')) }
     end
 
     context 'when definition is after literal block' do
@@ -105,27 +109,27 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
       end
 
       before do
-        refchanger.replace_refdef("....\n")
-        refchanger.replace_refdef('[define, whatever, TEMP]')
-        refchanger.replace_refdef("....\n")
+        refchanger.replace_refdef('', "....\n")
+        refchanger.replace_refdef('', '[define, whatever, TEMP]')
+        refchanger.replace_refdef('', "....\n")
       end
 
-      it { expect(refchanger.replace_refdef('[define, whatever, TEMP]')).to(eq('[define, whatever, TUTU]')) }
+      it { expect(refchanger.replace_refdef('', '[define, whatever, TEMP]')).to(eq('[define, whatever, TUTU]')) }
     end
 
     context 'when definition do no fit with a definition\'s type value' do
       subject(:refchanger) { described_class.new(def_type: 'req', from_regexp: 'TEMP', to_template: 'TUTU') }
 
-      it { expect(refchanger.replace_refdef('[define, whatever, TEMP]')).to(eq('[define, whatever, TEMP]')) }
-      it { expect(refchanger.replace_refdef('[define, req, TEMP]')).to(eq('[define, req, TUTU]')) }
+      it { expect(refchanger.replace_refdef('', '[define, whatever, TEMP]')).to(eq('[define, whatever, TEMP]')) }
+      it { expect(refchanger.replace_refdef('', '[define, req, TEMP]')).to(eq('[define, req, TUTU]')) }
     end
 
     context 'when definition do no fit with a definition\'s type list' do
       subject(:refchanger) { described_class.new(def_type: %w[req pouet], from_regexp: 'TEMP', to_template: 'TUTU') }
 
-      it { expect(refchanger.replace_refdef('[define, whatever, TEMP]')).to(eq('[define, whatever, TEMP]')) }
-      it { expect(refchanger.replace_refdef('[define, req, TEMP]')).to(eq('[define, req, TUTU]')) }
-      it { expect(refchanger.replace_refdef('[define, pouet, TEMP]')).to(eq('[define, pouet, TUTU]')) }
+      it { expect(refchanger.replace_refdef('', '[define, whatever, TEMP]')).to(eq('[define, whatever, TEMP]')) }
+      it { expect(refchanger.replace_refdef('', '[define, req, TEMP]')).to(eq('[define, req, TUTU]')) }
+      it { expect(refchanger.replace_refdef('', '[define, pouet, TEMP]')).to(eq('[define, pouet, TUTU]')) }
     end
   end
 
@@ -139,26 +143,22 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
     end
 
     before do
-      refchanger.replace_refdef('[define, whatever, TOTO-TEMP123]')
-      refchanger.replace_refdef('[define, whatever, TITI-TEMP421]')
+      refchanger.replace_refdef('', '[define, whatever, TOTO-TEMP123]')
+      refchanger.replace_refdef('', '[define, whatever, TITI-TEMP421]')
     end
 
-    it { expect(refchanger.replace_irefs('defs:iref[TOTO-TEMP1234]')).to(eq('defs:iref[TOTO-TEMP1234]')) }
-    it { expect(refchanger.replace_irefs('defs:iref[TOTO-TEMP123]')).to(eq('defs:iref[TOTO-0132]')) }
+    it { expect(refchanger.replace_irefs('', 'defs:iref[TOTO-TEMP1234]')).to(eq('defs:iref[TOTO-TEMP1234]')) }
+    it { expect(refchanger.replace_irefs('', 'defs:iref[TOTO-TEMP123]')).to(eq('defs:iref[TOTO-0132]')) }
 
     it do
       expect(
-        refchanger.replace_irefs(
-          'defs:iref[TOTO-TEMP123] defs:iref[TITI-TEMP421] bla'
-        )
+        refchanger.replace_irefs('', 'defs:iref[TOTO-TEMP123] defs:iref[TITI-TEMP421] bla')
       ).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'
-        )
+        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
@@ -173,12 +173,12 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
     end
 
     before do
-      refchanger.replace_refdef('[define, whatever, TOTO-TEMP123]')
-      refchanger.replace_refdef('[define, whatever, TITI-TEMP421]')
+      refchanger.replace_refdef('', '[define, whatever, TOTO-TEMP123]')
+      refchanger.replace_refdef('', '[define, whatever, TITI-TEMP421]')
     end
 
     it do
-      expect(refchanger.replace_irefs('include::target[tags=TOTO-TEMP1234]'))
+      expect(refchanger.replace_irefs('', 'include::target[tags=TOTO-TEMP1234]'))
         .to(eq('include::target[tags=TOTO-TEMP1234]'))
     end
 
@@ -191,7 +191,9 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
       ['tag=!TITI-TEMP421;TOTO-TEMP123', 'tag=!TITI-0133;TOTO-0132']
     ].each do |from, to|
       it do
-        expect(refchanger.replace_include_tags("include::path/target[#{from}]")).to(eq("include::path/target[#{to}]"))
+        expect(
+          refchanger.replace_include_tags('', "include::path/target[#{from}]")
+        ).to(eq("include::path/target[#{to}]"))
       end
     end
 
@@ -201,7 +203,7 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
       'include:target[tag=TITI-TEMP421]',
       '# include::target[tag=TITI-TEMP421]'
     ].each do |unchanged|
-      it { expect(refchanger.replace_include_tags(unchanged)).to(eq(unchanged)) }
+      it { expect(refchanger.replace_include_tags('', unchanged)).to(eq(unchanged)) }
     end
   end
 
@@ -247,28 +249,32 @@ MIF
     end
 
     before do
-      refchanger.replace_refdef('[define, whatever, TOTO-TEMP123]')
-      refchanger.replace_refdef('[define, whatever, TITI-TEMP421]')
+      refchanger.replace_refdef('', '[define, whatever, TOTO-TEMP123]')
+      refchanger.replace_refdef('', '[define, whatever, TITI-TEMP421]')
 
-      allow(File).to(receive(:readlines)).with('target').and_return(['# tag::TOTO-TEMP123'])
-      allow(File).to(receive(:readlines)).with('path/target').and_return(original_included_file.split)
+      allow(File).to(receive(:readlines)).with('sub/target').and_return(['whatever'])
+      allow(File).to(receive(:readlines)).with('sub/path/target').and_return(original_included_file.split)
+      allow(File).to(receive(:readlines)).with('./path/target').and_return(['whatever'])
+      allow(File).to(receive(:readlines)).with('./target').and_return(['whatever'])
 
       allow(File).to(receive(:writelines))
 
-      refchanger.replace_tags_in_included_files('include::path/target[]')
-      refchanger.replace_tags_in_included_files('includ::otherpath/othertarget[]')
+      refchanger.replace_tags_in_included_files('sub/one_file.adoc', 'include::path/target[]')
+      refchanger.replace_tags_in_included_files('', 'includ::otherpath/othertarget[]')
     end
 
-    it { expect(File).to(have_received(:readlines).with('path/target')) }
+    it { expect(File).to(have_received(:readlines).with('sub/path/target')) }
 
     it do
-      expect(File).to(have_received(:writelines).with('path/target', mofified_included_file.split))
+      expect(File).to(have_received(:writelines).with('sub/path/target', mofified_included_file.split))
     end
 
     it { expect(File).not_to(have_received(:readlines).with('otherpath/othertarget')) }
 
-    it { expect(refchanger.replace_tags_in_included_files('include::target[]')).to(eq('include::target[]')) }
+    it { expect(refchanger.replace_tags_in_included_files('', 'include::target[]')).to(eq('include::target[]')) }
 
-    it { expect(refchanger.replace_tags_in_included_files('include::path/target[]')).to(eq('include::path/target[]')) }
+    it do
+      expect(refchanger.replace_tags_in_included_files('', 'include::path/target[]')).to(eq('include::path/target[]'))
+    end
   end
 end

data/spec/unit/defmastership/modifier/modifier_common_spec.rb

@@ -32,13 +32,13 @@ class DummyClass < DummyClassParent
   end
 
   # This method smells of :reek:UtilityFunction
-  def replace_pouet_by_foo(line)
-    line.gsub('pouet', 'foo')
+  def replace_pouet_by_foo(filename, line)
+    line.gsub('pouet', "foo(#{filename})")
   end
 
   # This method smells of :reek:UtilityFunction
-  def replace_foo_by_zoo(line)
-    line.gsub('foo', 'zoo')
+  def replace_foo_by_zoo(filename, line)
+    line.gsub('foo', "zoo(#{filename})")
   end
 end
 
@@ -70,7 +70,7 @@ RSpec.describe(Defmastership::Modifier::ModifierCommon) do
       adoc_sources = { first: "pouet\ntoto\npouet", second: "toto\npouet\ntoto" }
 
       expect(modifier.do_modifications(adoc_sources))
-        .to(eq({ first: "zoo\ntoto\nzoo", second: "toto\nzoo\ntoto" }))
+        .to(eq({ first: "zoo(first)(first)\ntoto\nzoo(first)(first)", second: "toto\nzoo(second)(second)\ntoto" }))
     end
   end
 end