defmastership 1.0.1

data/spec/unit/defmastership/csv_formatter_header_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::CSVFormatterHeader) 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 '#header' do
+    describe '#fixed_header' do
+      it { expect(formatter.fixed_header).to(eq(%w[Type Reference Value])) }
+    end
+
+    describe '#labels_header' do
+      context 'when no labels' do
+        before do
+          allow(document).to(receive(:labels).and_return([]))
+          formatter.labels_header
+        end
+
+        it { expect(document).to(have_received(:labels)) }
+
+        it { expect(formatter.labels_header).to(eq([])) }
+      end
+
+      context 'when there is labels' do
+        before { allow(document).to(receive(:labels).and_return(['Whatever'])) }
+
+        it { expect(formatter.labels_header).to(eq(['Labels'])) }
+      end
+    end
+
+    describe '#eref_header' do
+      context 'when no eref' do
+        before do
+          allow(document).to(receive(:eref).and_return({}))
+          formatter.eref_header
+        end
+
+        it { expect(document).to(have_received(:eref)) }
+
+        it { expect(formatter.eref_header).to(eq([])) }
+      end
+
+      context 'when eref' do
+        before do
+          allow(document).to(receive(:eref).and_return(
+                               whatever: { prefix: 'A' },
+                               other: { prefix: 'C', url: 'D' }
+                             ))
+        end
+
+        it { expect(formatter.eref_header).to(eq(['A', 'C D'])) }
+      end
+    end
+
+    describe '#iref_header' do
+      context 'when no iref' do
+        before do
+          allow(document).to(receive(:iref).and_return(false))
+          formatter.iref_header
+        end
+
+        it { expect(document).to(have_received(:iref)) }
+
+        it { expect(formatter.iref_header).to(eq([])) }
+      end
+
+      context 'when iref' do
+        before { allow(document).to(receive(:iref).and_return(true)) }
+
+        it { expect(formatter.iref_header).to(eq(['Internal links'])) }
+      end
+    end
+
+    describe '#attributes_header' do
+      context 'when no attributes' do
+        before do
+          allow(document).to(receive(:attributes).and_return({}))
+          formatter.attributes_header
+        end
+
+        it { expect(document).to(have_received(:attributes)) }
+
+        it { expect(formatter.attributes_header).to(eq([])) }
+      end
+
+      context 'when attributes' do
+        before { allow(document).to(receive(:attributes).and_return(whatever: 'A', other: 'B')) }
+
+        it { expect(formatter.attributes_header).to(eq(%w[A B])) }
+      end
+    end
+  end
+end

data/spec/unit/defmastership/csv_formatter_spec.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require('defmastership')
+require('ostruct')
+
+RSpec.describe(DefMastership::CSVFormatter) 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 '#header' do
+    context 'when minimal' do
+      before do
+        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({}))
+        formatter.header
+      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(formatter.header).to(eq(%w[Type Reference Value])) }
+    end
+
+    context 'when has everything' do
+      before do
+        allow(document).to(receive(:labels)
+          .with(no_args)
+          .and_return(['Whatever']))
+        allow(document).to(receive(:eref)
+          .with(no_args)
+          .and_return(whatever: { prefix: 'A' },
+                      other: { prefix: 'C', url: 'D' }))
+        allow(document).to(receive(:iref).with(no_args).and_return(true))
+        allow(document).to(receive(:attributes)
+          .with(no_args)
+          .and_return(whatever: 'E', other: 'F'))
+      end
+
+      it do
+        expect(formatter.header).to(eq(%w[Type Reference Value Labels] +
+                                     ['A', 'C D', 'Internal links'] +
+                                     %w[E F]))
+      end
+    end
+  end
+
+  describe '#body' do
+    let(:definition) { instance_double(DefMastership::Definition, 'definition') }
+
+    context 'when minimal' do
+      before do
+        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(definition).to(receive(:type).with(no_args).and_return('a'))
+        allow(definition).to(receive(:reference).with(no_args).and_return('b'))
+        allow(definition).to(receive(:value).with(no_args).and_return('c'))
+        formatter.body(definition)
+      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(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(formatter.body(definition)).to(eq(%w[a b c])) }
+    end
+
+    context 'when has everything' do
+      before do
+        allow(document).to(receive(:labels).with(no_args).and_return(['Whatever']))
+        allow(document).to(receive(:eref).with(no_args).and_return(
+                             a: 'whatever',
+                             b: 'whatever',
+                             c: 'whatever'
+                           ))
+        allow(document).to(receive(:iref).with(no_args).and_return(true))
+        allow(document).to(receive(:attributes).with(no_args).and_return(
+                             a: 'whatever',
+                             b: 'whatever',
+                             c: 'whatever'
+                           ))
+        allow(definition).to(receive(:type).with(no_args).and_return('a'))
+        allow(definition).to(receive(:reference).with(no_args).and_return('b'))
+        allow(definition).to(receive(:value).with(no_args).and_return('c'))
+        allow(definition).to(receive(:labels).with(no_args).and_return(%w[toto tutu]))
+        allow(definition).to(receive(:eref).with(no_args).and_return(a: %w[A B], b: [], c: ['C']))
+        allow(definition).to(receive(:iref).with(no_args).and_return(%w[E F]))
+        allow(definition).to(receive(:attributes).with(no_args).and_return(a: 'X', b: '', c: 'Y'))
+        formatter.body(definition)
+      end
+
+      it { expect(definition).to(have_received(:labels).with(no_args)) }
+
+      it { expect(definition).to(have_received(:eref).exactly(3).times.with(no_args)) }
+
+      it { expect(definition).to(have_received(:iref).with(no_args)) }
+
+      it { expect(definition).to(have_received(:attributes).exactly(3).times.with(no_args)) }
+
+      it do
+        expect(formatter.body(definition)).to(eq(%w[a b c] + ["toto\ntutu"] +
+                                                 ["A\nB", '', 'C'] +
+                                                 ["E\nF"] +
+                                                 ['X', '', 'Y']))
+      end
+    end
+  end
+
+  describe '#export_to' do
+    context 'when #export_to csv file' do
+      let(:target_file) { 'export.csv' }
+      let(:definitions) do
+        [
+          OpenStruct.new(type: 'a', reference: 'b', value: 'c'),
+          OpenStruct.new(type: 'd', reference: 'e', value: 'f')
+        ]
+      end
+
+      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))
+        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
+          a,b,c
+          d,e,f
+        CSV_FILE
+      end
+    end
+  end
+end

data/spec/unit/defmastership/definition_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::Definition) do
+  describe '.new' do
+    context 'without labels' do
+      subject do
+        described_class.new(
+          type: 'req',
+          reference: 'TUTU-001'
+        )
+      end
+
+      it { is_expected.not_to(be(nil)) }
+      it { is_expected.to(have_attributes(type:       'req')) }
+      it { is_expected.to(have_attributes(reference:  'TUTU-001')) }
+      it { is_expected.to(have_attributes(lines:      [])) }
+      it { is_expected.to(have_attributes(value:      '')) }
+      it { is_expected.to(have_attributes(eref:       {})) }
+      it { is_expected.to(have_attributes(iref:       [])) }
+      it { is_expected.to(have_attributes(attributes: {})) }
+      it { is_expected.to(have_attributes(labels:     Set.new)) }
+    end
+
+    context 'with labels' do
+      subject do
+        described_class.new(
+          gtype: 'req',
+          reference: 'TUTU-001',
+          labels: 'something'
+        )
+      end
+
+      it { is_expected.to(have_attributes(labels: Set['something'])) }
+    end
+  end
+
+  describe '#<<' do
+    subject(:definition) do
+      described_class.new(
+        type: 'req',
+        reference: 'TUTU-001'
+      )
+    end
+
+    it 'has value when one line is added' do
+      definition << 'first line'
+      expect(definition.value).to(eq('first line'))
+    end
+
+    it 'store line when added' do
+      definition << 'first line'
+      expect(definition.lines).to(eq(['first line']))
+    end
+
+    it 'has multiline value when multiple lines are added' do
+      definition << 'first line' << 'second line'
+      expect(definition.value).to(eq("first line\nsecond line"))
+    end
+
+    it 'store each line when added' do
+      definition << 'first line' << 'second line'
+      expect(definition.lines).to(eq(['first line', 'second line']))
+    end
+  end
+
+  describe '#add_eref' do
+    subject(:definition) do
+      described_class.new(
+        type: 'req',
+        reference: 'TUTU-001'
+      )
+    end
+
+    it 'shall accept to add one eref' do
+      definition.add_eref(:foo, '   tutu, titi  ,   pouet')
+      expect(definition.eref[:foo]).to(eq(%w[tutu titi pouet]))
+    end
+  end
+
+  describe '#add_iref' do
+    subject(:definition) do
+      described_class.new(
+        type: 'req',
+        reference: 'TUTU-001'
+      )
+    end
+
+    it 'shall accept to add multiple iref' do
+      definition.add_iref('toto')
+      definition.add_iref('tutu')
+      expect(definition.iref).to(eq(%w[toto tutu]))
+    end
+  end
+
+  describe '#set_attribute' do
+    subject(:definition) do
+      described_class.new(
+        type: 'req',
+        reference: 'TUTU-001'
+      )
+    end
+
+    it 'shall accept to set attribute' do
+      definition.set_attribute(:whatever, 'value')
+      expect(definition.attributes[:whatever]).to(eq('value'))
+    end
+  end
+end

data/spec/unit/defmastership/document_spec.rb

@@ -0,0 +1,398 @@
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::Document) do
+  describe '.new' do
+    it { is_expected.not_to(be(nil)) }
+    it { is_expected.to(have_attributes(definitions: [])) }
+    it { is_expected.to(have_attributes(eref: {})) }
+    it { is_expected.to(have_attributes(iref: false)) }
+    it { is_expected.to(have_attributes(attributes: {})) }
+    it { is_expected.to(have_attributes(variables: {})) }
+  end
+
+  describe '#parse' do
+    subject(:document) { described_class.new }
+
+    context 'with valid definitions' do
+      let(:definition) { instance_double(DefMastership::Definition, 'definition') }
+
+      before do
+        allow(DefMastership::Definition).to(receive(:new).and_return(definition))
+        allow(definition).to(receive(:labels).and_return(Set.new))
+        allow(definition).to(receive(:<<).and_return(definition))
+        allow(definition).to(receive(:add_eref).and_return(definition))
+        allow(definition).to(receive(:add_iref).and_return(definition))
+      end
+
+      context 'when simple definition line' do
+        let(:input_lines) { ['[define, requirement, TOTO-0001]'] }
+
+        before do
+          allow(DefMastership::Definition).to(receive(:new).with(
+            matchdata_including(
+              type: 'requirement',
+              reference: 'TOTO-0001'
+            )
+          ).and_return(definition))
+          document.parse(input_lines)
+        end
+
+        it do
+          expect(DefMastership::Definition).to(have_received(:new).with(
+                                                 matchdata_including(type: 'requirement', reference: 'TOTO-0001')
+                                               ))
+        end
+
+        it { expect(document).to(have_attributes(definitions: [definition])) }
+      end
+
+      context 'when complete definition with content' do
+        let(:input_lines) do
+          [
+            '[define, requirement, TOTO-0001]',
+            '--',
+            'a',
+            'b',
+            '--',
+            'not included'
+          ]
+        end
+
+        before do
+          allow(definition).to(receive(:<<).and_return(definition))
+          document.parse(input_lines)
+        end
+
+        it { expect(definition).to(have_received(:<<).with('a')) }
+
+        it { expect(definition).to(have_received(:<<).with('b')) }
+      end
+
+      context 'when definition with one paragraph' do
+        let(:input_lines) do
+          [
+            '[define, requirement, TOTO-0001]',
+            'one line',
+            'another line',
+            '',
+            'not included'
+          ]
+        end
+
+        before do
+          allow(definition).to(receive(:<<).and_return(definition))
+          document.parse(input_lines)
+        end
+
+        it { expect(definition).to(have_received(:<<).with('one line')) }
+
+        it { expect(definition).to(have_received(:<<).with('another line')) }
+      end
+
+      context 'when definition with one paragraph followed by a block' do
+        let(:input_lines) do
+          [
+            '[define, requirement, TOTO-0001]',
+            'one line',
+            'another line',
+            '--',
+            'not included',
+            '--'
+          ]
+        end
+
+        before { document.parse(input_lines) }
+
+        it { expect(definition).not_to(have_received(:<<).with('not included')) }
+      end
+
+      context 'when block without definition' do
+        let(:input_lines) { ['--', 'first line', '--'] }
+
+        it do
+          document.parse(input_lines)
+          expect(document.definitions).to(eq([]))
+        end
+      end
+
+      context 'when definition with labels' do
+        let(:input_lines) do
+          [
+            '[define, requirement, TOTO-0001, [label1, label2]]',
+            'one line',
+            'not included'
+          ]
+        end
+
+        before do
+          allow(definition).to(receive(:labels).and_return(Set['bla1', 'bla2']))
+          document.parse(input_lines)
+        end
+
+        it do
+          expect(DefMastership::Definition).to(have_received(:new).with(matchdata_including(
+                                                                          type: 'requirement',
+                                                                          reference: 'TOTO-0001',
+                                                                          labels: 'label1, label2'
+                                                                        )))
+        end
+
+        it { expect(document.labels).to(eq(Set['bla1', 'bla2'])) }
+      end
+
+      context 'when definition with labels without spaces' do
+        let(:input_lines) do
+          [
+            '[define,requirement,TOTO-0001,[label1,label2]]',
+            'one line',
+            'not included'
+          ]
+        end
+
+        before do
+          allow(definition).to(receive(:labels).and_return(Set['bla1', 'bla2']))
+          document.parse(input_lines)
+        end
+
+        it do
+          expect(DefMastership::Definition).to(have_received(:new).with(matchdata_including(
+                                                                          type: 'requirement',
+                                                                          reference: 'TOTO-0001',
+                                                                          labels: 'label1,label2'
+                                                                        )))
+        end
+
+        it { expect(document.labels).to(eq(Set['bla1', 'bla2'])) }
+      end
+
+      context 'when setup external links' do
+        let(:input_lines) do
+          [
+            ':eref-implements-prefix: Participate to:',
+            ':eref-implements-url:    ./other_document.html',
+            'one line',
+            'not included'
+          ]
+        end
+
+        before { document.parse(input_lines) }
+
+        it { expect(document.eref[:implements]).to(eq(prefix: 'Participate to:', url: './other_document.html')) }
+      end
+
+      context 'when setup external links without url' do
+        let(:input_lines) do
+          [
+            ':eref-implements-prefix: Participate to:',
+            'one line',
+            'not included'
+          ]
+        end
+
+        it do
+          document.parse(input_lines)
+          expect(document.eref[:implements])
+            .to(eq(prefix: 'Participate to:'))
+        end
+      end
+
+      context 'when define external links' do
+        let(:input_lines) do
+          [
+            '[define, requirement, TOTO-0001]',
+            'one line',
+            'defs:eref[implements, [SYSTEM-0012, SYSTEM-0014]]'
+          ]
+        end
+
+        before do
+          allow(definition).to(receive(:add_eref).with(:implements, 'SYSTEM-0012, SYSTEM-0014')
+                                 .and_return(definition))
+          document.parse(input_lines)
+        end
+
+        it { expect(definition).to(have_received(:add_eref).with(:implements, 'SYSTEM-0012, SYSTEM-0014')) }
+      end
+
+      context 'when define internal links' do
+        let(:input_lines) do
+          [
+            '[define, requirement, TOTO-0001]',
+            'defs:iref[toto] defs:iref[tutu]',
+            'defs:iref[pouet]'
+          ]
+        end
+
+        before do
+          allow(definition).to(receive(:add_iref))
+          document.parse(input_lines)
+        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('pouet')) }
+        it { expect(document.iref).to(eq(true)) }
+      end
+
+      context 'when configure attributes' do
+        let(:input_lines) do
+          [
+            ':attr-myattribute-prefix: My attribute:',
+            ':attr-myotherone-prefix: My other attribute:'
+          ]
+        end
+
+        before { document.parse(input_lines) }
+
+        it { expect(document.attributes).to(eq(myattribute: 'My attribute:', myotherone: 'My other attribute:')) }
+      end
+
+      context 'when setup attributes value' do
+        let(:input_lines) do
+          [
+            '[define, requirement, TOTO-0001]',
+            'defs:attribute[myattribute, My value]'
+          ]
+        end
+
+        before do
+          allow(definition).to(receive(:set_attribute).with(:myattribute, 'My value'))
+          document.parse(input_lines)
+        end
+
+        it { expect(definition).to(have_received(:set_attribute).with(:myattribute, 'My value')) }
+      end
+
+      context 'when putting comments' do
+        let(:input_lines) do
+          [
+            '[define, requirement, TOTO-0001]',
+            '// defs:iref[toto] defs:iref[tutu]'
+          ]
+        end
+
+        it do
+          document.parse(input_lines)
+          expect(document.iref).to(eq(false))
+        end
+      end
+
+      context 'when definition in wrong literal block' do
+        let(:input_lines) do
+          [
+            '1234',
+            '[define, requirement, TOTO-0001]'
+          ]
+        end
+
+        before do
+          allow(DefMastership::Definition).to(receive(:new).with(matchdata_including(
+                                                                   type: 'requirement',
+                                                                   reference: 'TOTO-0001'
+                                                                 )).and_return(definition))
+          document.parse(input_lines)
+        end
+
+        it do
+          expect(DefMastership::Definition).to(have_received(:new).with(matchdata_including(
+                                                                          type: 'requirement',
+                                                                          reference: 'TOTO-0001'
+                                                                        )))
+        end
+      end
+    end
+
+    context 'when variables replacement' do
+      let(:definition) { instance_double(DefMastership::Definition, 'definition') }
+
+      before do
+        allow(DefMastership::Definition).to(receive(:new).and_return(definition))
+        allow(definition).to(receive(:labels).and_return(Set.new))
+        allow(definition).to(receive(:<<).and_return(definition))
+        document.parse(input_lines)
+      end
+
+      context 'when defined variable' do
+        let(:input_lines) do
+          [
+            ':variable: one value',
+            '[define, requirement, TOTO-0001]',
+            'bef {variable} aft'
+          ]
+        end
+
+        it { expect(document).to(have_attributes(variables: { variable: 'one value' })) }
+
+        it { expect(definition).to(have_received(:<<).with('bef one value aft')) }
+      end
+
+      context 'when not defined variable' do
+        let(:input_lines) do
+          [
+            '[define, requirement, TOTO-0001]',
+            'bef {variable} aft'
+          ]
+        end
+
+        it { expect(definition).to(have_received(:<<).with('bef {variable} aft')) }
+      end
+
+      context 'when multiple defined variables' do
+        let(:input_lines) do
+          [
+            ':variable: one',
+            ':variable2: two',
+            '[define, requirement, TOTO-0001]',
+            'bef {variable} {variable2} aft'
+          ]
+        end
+
+        it { expect(definition).to(have_received(:<<).with('bef one two aft')) }
+      end
+    end
+
+    context 'with invalid definitions' do
+      context 'when definition in literal block' do
+        let(:input_lines) do
+          [
+            '....',
+            '[define, requirement, TOTO-0001]',
+            '....'
+          ]
+        end
+
+        before do
+          allow(DefMastership::Definition).to(receive(:new)
+            .and_raise('not a valide definition'))
+        end
+
+        it do
+          document.parse(input_lines)
+          expect(document).to(have_attributes(definitions: []))
+        end
+      end
+
+      context 'when definition in comment block' do
+        let(:input_lines) do
+          [
+            '////',
+            '[define, requirement, TOTO-0001]',
+            '////'
+          ]
+        end
+
+        before do
+          allow(DefMastership::Definition).to(receive(:new)
+            .and_raise('not a valide definition'))
+        end
+
+        it do
+          document.parse(input_lines)
+          expect(document).to(have_attributes(definitions: []))
+        end
+      end
+    end
+  end
+end