defmastership 1.3.2 → 1.3.4

data/spec/unit/defmastership/app_spec.rb

@@ -19,7 +19,7 @@ RSpec.describe(Defmastership::App) do
     context('when "--version" option') do
       it {
         expect { described_class.run(['--version']) }
-          .to(output(/version/).to_stdout)
+          .to(output(/version/).to_stdout_from_any_process)
       }
     end
 
@@ -28,10 +28,12 @@ RSpec.describe(Defmastership::App) do
 
       [
         /Export\s+the\s+definition\s+database\s+in\s+CSV$/,
-        /\bexport\b.*\basciidoctor_file\b$/,
+        /\bexport\b.*\basciidoctor_file\b\s+\[asciidoctor_file\]\.\.\.$/,
         /--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
+           case\s+of\s+wrong\s+explicit\s+checksum$/mx,
+        /--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']) }
@@ -40,22 +42,6 @@ RSpec.describe(Defmastership::App) do
       end
     end
 
-    context('when "export" with more than one argument') do
-      it { expect(described_class.run(%w[export arg1 arg2])).to(be(64)) }
-
-      it do
-        expect { described_class.run(%w[export arg1 arg2]) }
-          .to(output(/error: export expected only 1 arguments, but received 2/).to_stderr_from_any_process)
-      end
-
-      it { expect(described_class.run(['export'])).to(be(64)) }
-
-      it do
-        expect { described_class.run(['export']) }
-          .to(output(/error: export expected at least 1 arguments, but was given only 0/).to_stderr_from_any_process)
-      end
-    end
-
     context('when "export toto.adoc" subcommand') do
       let(:document)  { instance_double(Defmastership::Document, 'document')                     }
       let(:formatter) { instance_double(Defmastership::Export::CSV::Formatter, 'formatter')      }
@@ -91,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?)) }
 
@@ -115,6 +101,57 @@ 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')      }
+      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::CSV::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', '--output-file=pouet.csv', 'toto.adoc', 'tutu.adoc'])
+      end
+
+      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, 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
+
     context('when "modify --help" subcommand') do
       it { expect(described_class.run(['modify', '--help'])).to(be(0)) }
 

data/spec/unit/defmastership/batch_modifier_spec.rb

@@ -4,14 +4,16 @@
 require('defmastership/batch_modifier')
 
 module Defmastership
-  # Modifier example
-  class Toto
-    include Modifier
-  end
+  module Modifier
+    # Modifier example
+    class Toto
+      include ModifierCommon
+    end
 
-  # Modifier example
-  class TuTu
-    include Modifier
+    # Modifier example
+    class TuTu
+      include ModifierCommon
+    end
   end
 end
 

data/spec/unit/defmastership/def_type_list_spec.rb

@@ -0,0 +1,22 @@
+# Copyright (c) 2025 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/def_type_list')
+
+RSpec.describe(Defmastership::DefTypeList) do
+  subject(:def_type_list) { described_class.new('') }
+
+  describe '.new' do
+    it { is_expected.not_to(be_nil) }
+  end
+
+  describe '#include?' do
+    it { expect(described_class.new('').include?('whatever')).to(be(true)) }
+    it { expect(described_class.new('all').include?('whatever')).to(be(true)) }
+    it { expect(described_class.new('one_type').include?('whatever')).to(be(false)) }
+    it { expect(described_class.new('one_type').include?('one_type')).to(be(true)) }
+    it { expect(described_class.new('one_type_more').include?('one_type')).to(be(false)) }
+    it { expect(described_class.new(%w[one_type another_type]).include?('one_type')).to(be(true)) }
+    it { expect(described_class.new(%w[one_type another_type]).include?('whatever')).to(be(false)) }
+  end
+end

data/spec/unit/defmastership/definition_spec.rb

@@ -6,12 +6,7 @@ require('defmastership/definition')
 RSpec.describe(Defmastership::Definition) do
   describe '.new' do
     context 'when minimal' do
-      subject do
-        described_class.new(
-          type: 'req',
-          reference: 'TUTU-001'
-        )
-      end
+      subject { described_class.new(type: 'req', reference: 'TUTU-001') }
 
       it { is_expected.not_to(be_nil) }
       it { is_expected.to(have_attributes(type:       'req')) }
@@ -27,25 +22,13 @@ RSpec.describe(Defmastership::Definition) do
     end
 
     context 'with labels' do
-      subject do
-        described_class.new(
-          type: 'req',
-          reference: 'TUTU-001',
-          labels: 'something'
-        )
-      end
+      subject { described_class.new(type: 'req', reference: 'TUTU-001', labels: 'something') }
 
       it { is_expected.to(have_attributes(labels: Set['something'])) }
     end
 
     context 'with explicit_checksum' do
-      subject(:definition) do
-        described_class.new(
-          type: 'req',
-          reference: 'TUTU-001',
-          explicit_checksum: '~8cc259e6'
-        )
-      end
+      subject(:definition) { described_class.new(type: 'req', reference: 'TUTU-001', explicit_checksum: '~8cc259e6') }
 
       it do
         definition << 'def value with a checksum != ~8cc259e6'
@@ -59,13 +42,7 @@ RSpec.describe(Defmastership::Definition) do
     end
 
     context 'with explicit_version' do
-      subject(:definition) do
-        described_class.new(
-          type: 'req',
-          reference: 'TUTU-001',
-          explicit_version: 'pouet'
-        )
-      end
+      subject(:definition) { described_class.new(type: 'req', reference: 'TUTU-001', explicit_version: 'pouet') }
 
       it do
         expect(definition).to(have_attributes(explicit_version: 'pouet'))
@@ -74,12 +51,7 @@ RSpec.describe(Defmastership::Definition) do
   end
 
   describe '#<<' do
-    subject(:definition) do
-      described_class.new(
-        type: 'req',
-        reference: 'TUTU-001'
-      )
-    end
+    subject(:definition) { described_class.new(type: 'req', reference: 'TUTU-001') }
 
     it 'has value when one line is added' do
       definition << 'first line'
@@ -133,12 +105,7 @@ RSpec.describe(Defmastership::Definition) do
   end
 
   describe '#add_eref' do
-    subject(:definition) do
-      described_class.new(
-        type: 'req',
-        reference: 'TUTU-001'
-      )
-    end
+    subject(:definition) { described_class.new(type: 'req', reference: 'TUTU-001') }
 
     [
       'tutu,titi,pouet',
@@ -152,12 +119,7 @@ RSpec.describe(Defmastership::Definition) do
   end
 
   describe '#add_iref' do
-    subject(:definition) do
-      described_class.new(
-        type: 'req',
-        reference: 'TUTU-001'
-      )
-    end
+    subject(:definition) { described_class.new(type: 'req', reference: 'TUTU-001') }
 
     it 'shall accept to add multiple iref' do
       definition.add_iref('toto')
@@ -167,12 +129,7 @@ RSpec.describe(Defmastership::Definition) do
   end
 
   describe '#set_attribute' do
-    subject(:definition) do
-      described_class.new(
-        type: 'req',
-        reference: 'TUTU-001'
-      )
-    end
+    subject(:definition) { described_class.new(type: 'req', reference: 'TUTU-001') }
 
     it 'shall accept to set attribute' do
       definition.set_attribute(:whatever, 'value')

data/spec/unit/defmastership/document_spec.rb

@@ -297,8 +297,7 @@ RSpec.describe(Defmastership::Document) do
 
         it do
           document.__send__(:do_parse, input_lines)
-          expect(document.eref[:implements])
-            .to(eq(prefix: 'Participate to:'))
+          expect(document.eref[:implements]).to(eq(prefix: 'Participate to:'))
         end
       end
 
@@ -326,7 +325,8 @@ RSpec.describe(Defmastership::Document) do
         let(:input_lines) do
           [
             '[define, requirement, TOTO-0001]',
-            'defs:iref[toto] defs:iref[tutu]',
+            'defs:iref[toto] defs:iref[tutu(a)]',
+            'defs:iref[titi(a)], defs:iref[tata(a~12345678)]',
             'defs:iref[pouet]'
           ]
         end
@@ -337,7 +337,9 @@ RSpec.describe(Defmastership::Document) do
         end
 
         it { expect(definition).to(have_received(:add_iref).with('toto')) }
-        it { expect(definition).to(have_received(:add_iref).with('tutu')) }
+        it { expect(definition).to(have_received(:add_iref).with('tutu(a)')) }
+        it { expect(definition).to(have_received(:add_iref).with('titi(a)')) }
+        it { expect(definition).to(have_received(:add_iref).with('tata(a~12345678)')) }
         it { expect(definition).to(have_received(:add_iref).with('pouet')) }
         it { expect(document.iref).to(be(true)) }
       end
@@ -417,12 +419,7 @@ RSpec.describe(Defmastership::Document) do
 
       before do
         allow(Defmastership::Definition).to(receive(:new).and_return(definition))
-        allow(definition).to(
-          receive_messages(
-            labels: Set.new,
-            '<<': definition
-          )
-        )
+        allow(definition).to(receive_messages(labels: Set.new, '<<': definition))
         document.__send__(:do_parse, input_lines)
       end
 
@@ -522,9 +519,7 @@ RSpec.describe(Defmastership::Document) do
         end
 
         before do
-          allow(Defmastership::Definition).to(
-            receive(:new).and_raise('not a valide definition')
-          )
+          allow(Defmastership::Definition).to(receive(:new).and_raise('not a valide definition'))
         end
 
         it do
@@ -543,9 +538,7 @@ RSpec.describe(Defmastership::Document) do
         end
 
         before do
-          allow(Defmastership::Definition).to(
-            receive(:new).and_raise('not a valide definition')
-          )
+          allow(Defmastership::Definition).to(receive(:new).and_raise('not a valide definition'))
         end
 
         it do
@@ -569,12 +562,7 @@ RSpec.describe(Defmastership::Document) do
       allow(adoc_doc).to(receive(:reader).and_return(adoc_reader))
       allow(adoc_reader).to(receive(:read_lines).and_return(input_lines))
       allow(Defmastership::Definition).to(receive(:new).and_return(definition))
-      allow(definition).to(
-        receive_messages(
-          '<<': definition,
-          labels: Set.new
-        )
-      )
+      allow(definition).to(receive_messages('<<': definition, labels: Set.new))
       document.parse_file_with_preprocessor('the_file.adoc')
     end
 
@@ -758,20 +746,8 @@ RSpec.describe(Defmastership::Document) do
 
     before do
       allow(Defmastership::Definition).to(receive(:new).twice.and_return(definitions.first, definitions[1]))
-      allow(definitions.first).to(
-        receive_messages(
-          labels: [],
-          '<<': definitions.first,
-          reference: 'TOTO-0001'
-        )
-      )
-      allow(definitions[1]).to(
-        receive_messages(
-          labels: [],
-          '<<': definitions[1],
-          reference: 'TOTO-0002'
-        )
-      )
+      allow(definitions.first).to(receive_messages(labels: [], '<<': definitions.first, reference: 'TOTO-0001'))
+      allow(definitions[1]).to(receive_messages(labels: [], '<<': definitions[1], reference: 'TOTO-0002'))
       document.__send__(:do_parse, input_lines)
     end
 

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

@@ -1,6 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require('defmastership/document')
 require('defmastership/export/body_formatter')
 
 RSpec.describe(Defmastership::Export::BodyFormatter) do
@@ -142,11 +143,7 @@ RSpec.describe(Defmastership::Export::BodyFormatter) do
 
     context 'when eref on the document' do
       before do
-        allow(document).to(
-          receive(:eref).with(no_args).and_return(
-            a: 'whatever', b: 'whatever', c: 'whatever'
-          )
-        )
+        allow(document).to(receive(:eref).with(no_args).and_return(a: 'whatever', b: 'whatever', c: 'whatever'))
         allow(definition).to(receive(:eref).with(no_args).and_return(a: %w[A B], b: [], c: ['C']))
         formatter.eref
       end
@@ -157,11 +154,7 @@ RSpec.describe(Defmastership::Export::BodyFormatter) do
 
     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(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
@@ -208,10 +201,7 @@ RSpec.describe(Defmastership::Export::BodyFormatter) do
 
     context 'when attributes on the document' do
       before do
-        allow(document).to(
-          receive(:attributes).with(no_args)
-            .and_return(a: 'whatever', b: 'whatever', c: 'whatever')
-        )
+        allow(document).to(receive(:attributes).with(no_args).and_return(a: 'whatever', b: 'whatever', c: 'whatever'))
         allow(definition).to(receive(:attributes).and_return(a: 'X', b: '', c: 'Y'))
         formatter.attributes
       end
@@ -222,10 +212,7 @@ RSpec.describe(Defmastership::Export::BodyFormatter) do
 
     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(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