defmastership 1.0.3 → 1.0.8

data/spec/unit/defmastership/csv_formatter_spec.rb

@@ -1,10 +1,12 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
 require('defmastership')
 require('ostruct')
+require('csv')
 
 RSpec.describe(DefMastership::CSVFormatter) do
-  subject(:formatter) { described_class.new(document) }
+  subject(:formatter) { described_class.new(document, ';') }
 
   let(:document) { instance_double(DefMastership::Document, 'document') }
 
@@ -12,160 +14,257 @@ RSpec.describe(DefMastership::CSVFormatter) do
     it { is_expected.not_to(be(nil)) }
   end
 
-  describe '#header' do
-    context 'when minimal' do
+  describe '#export_to' do
+    let(:header) { instance_double(DefMastership::CSVFormatterHeader, 'header') }
+    let(:body) { instance_double(DefMastership::CSVFormatterBody, 'body') }
+    let(:csv)  { instance_double(CSV, 'csv')                              }
+
+    before do
+      allow(CSV).to(receive(:open).and_yield(csv))
+      allow(csv).to(receive(:<<))
+      allow(DefMastership::CSVFormatterHeader).to(receive(:new).with(document).and_return(header))
+      allow(DefMastership::CSVFormatterBody).to(receive(:new).with(document).and_return(body))
+      allow(document).to(receive(:definitions).and_return(%i[def1 def2]))
+      allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(false))
+      allow(document).to(receive(:explicit_version?).with(no_args).and_return(false))
+      allow(document).to(receive(:labels).with(no_args).and_return([]))
+      allow(document).to(receive(:eref).with(no_args).and_return([]))
+      allow(document).to(receive(:iref).with(no_args).and_return(false))
+      allow(document).to(receive(:attributes).with(no_args).and_return([]))
+    end
+
+    context 'when no variable columns' do
+      methods = %i[fixed]
+
       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
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        formatter.export_to('whatever')
+      end
+
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
       end
 
-      it { expect(document).to(have_received(:labels).with(no_args)) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
+    end
 
-      it { expect(document).to(have_received(:eref).with(no_args)) }
+    context 'when wrong_explicit_checksum' do
+      methods = %i[fixed wrong_explicit_checksum]
 
-      it { expect(document).to(have_received(:iref).with(no_args)) }
+      before do
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(true))
+        formatter.export_to('whatever')
+      end
 
-      it { expect(document).to(have_received(:attributes).with(no_args)) }
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
+      end
 
-      it { expect(formatter.header).to(eq(%w[Type Reference Value])) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
 
-    context 'when has everything' do
+    context 'when explicit_version' do
+      methods = %i[fixed explicit_version]
+
       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'))
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        allow(document).to(receive(:explicit_version?).with(no_args).and_return(true))
+        formatter.export_to('whatever')
       end
 
-      it do
-        expect(formatter.header).to(eq(%w[Type Reference Value Labels] +
-                                     ['A', 'C D', 'Internal links'] +
-                                     %w[E F]))
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
       end
+
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
-  end
 
-  describe '#body' do
-    let(:definition) { instance_double(DefMastership::Definition, 'definition') }
+    context 'when labels' do
+      methods = %i[fixed labels]
 
-    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)
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        allow(document).to(receive(:labels).with(no_args).and_return([:whatever]))
+        formatter.export_to('whatever')
       end
 
-      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)) }
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
+      end
 
-      it { expect(document).to(have_received(:attributes).with(no_args)) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
+    end
 
-      it { expect(definition).to(have_received(:type).with(no_args)) }
+    context 'when eref' do
+      methods = %i[fixed eref]
 
-      it { expect(definition).to(have_received(:reference).with(no_args)) }
+      before do
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        allow(document).to(receive(:eref).with(no_args).and_return([:whatever]))
+        formatter.export_to('whatever')
+      end
 
-      it { expect(definition).to(have_received(:value).with(no_args)) }
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
+      end
 
-      it { expect(formatter.body(definition)).to(eq(%w[a b c])) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
 
-    context 'when has everything' do
+    context 'when iref' do
+      methods = %i[fixed iref]
+
       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'
-                           ))
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
         allow(document).to(receive(:iref).with(no_args).and_return(true))
-        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)
+        formatter.export_to('whatever')
       end
 
-      it { expect(definition).to(have_received(:labels).with(no_args)) }
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
+      end
 
-      it { expect(definition).to(have_received(:eref).exactly(3).times.with(no_args)) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
+    end
 
-      it { expect(definition).to(have_received(:iref).with(no_args)) }
+    context 'when attributes' do
+      methods = %i[fixed attributes]
 
-      it { expect(definition).to(have_received(:attributes).exactly(3).times.with(no_args)) }
+      before do
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        allow(document).to(receive(:attributes).with(no_args).and_return([:whatever]))
+        formatter.export_to('whatever')
+      end
 
-      it do
-        expect(formatter.body(definition)).to(eq(%w[a b c] + ["toto\ntutu"] +
-                                                 ["A\nB", '', 'C'] +
-                                                 ["E\nF"] +
-                                                 ['X', '', 'Y']))
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
       end
+
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
-  end
 
-  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
+    context 'when every colums' do
+      methods = %i[fixed wrong_explicit_checksum explicit_version labels eref iref attributes]
 
       before do
-        setup_aruba
-        allow(document).to(receive(:labels).exactly(3).times.with(no_args).and_return([]))
-        allow(document).to(receive(:eref).exactly(3).times.with(no_args).and_return({}))
-        allow(document).to(receive(:iref).exactly(3).times.with(no_args).and_return(false))
-        allow(document).to(receive(:attributes).exactly(3).times.with(no_args).and_return({}))
-        allow(document).to(receive(:definitions).with(no_args).and_return(definitions))
-        formatter.export_to("#{aruba.current_directory}/#{target_file}")
+        methods.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
+          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+        end
+        allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(true))
+        allow(document).to(receive(:explicit_version?).with(no_args).and_return(true))
+        allow(document).to(receive(:labels).with(no_args).and_return([:whatever]))
+        allow(document).to(receive(:eref).with(no_args).and_return([:whatever]))
+        allow(document).to(receive(:iref).with(no_args).and_return(true))
+        allow(document).to(receive(:attributes).with(no_args).and_return([:whatever]))
+        formatter.export_to('whatever')
       end
 
-      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)) }
+      methods.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+        it { expect(body).to(have_received(method).with(:def1)) }
+        it { expect(body).to(have_received(method).with(:def2)) }
+      end
 
-      it { expect(document).to(have_received(:iref).exactly(3).times.with(no_args)) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
+    end
+  end
 
-      it { expect(document).to(have_received(:attributes).exactly(3).times.with(no_args)) }
+  context 'when #export_to csv file' do
+    let(:target_file) { 'export.csv' }
+    let(:definitions) do
+      [
+        OpenStruct.new(type: 'a', reference: 'b', value: 'c', sha256: 'd'),
+        OpenStruct.new(type: 'd', reference: 'e', value: 'f', sha256: 'g')
+      ]
+    end
 
-      it { expect(document).to(have_received(:definitions).with(no_args)) }
+    before do
+      setup_aruba
+      allow(document).to(receive(:labels).with(no_args).and_return([]))
+      allow(document).to(receive(:eref).with(no_args).and_return({}))
+      allow(document).to(receive(:iref).with(no_args).and_return(false))
+      allow(document).to(receive(:attributes).with(no_args).and_return({}))
+      allow(document).to(receive(:definitions).with(no_args).and_return(definitions))
+      allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(false))
+      allow(document).to(receive(:explicit_version?).with(no_args).and_return(false))
+      formatter.export_to("#{aruba.current_directory}/#{target_file}")
+    end
 
-      it do
-        expect(target_file).to(have_file_content(<<~CSV_FILE))
-          Type,Reference,Value
-          a,b,c
-          d,e,f
-        CSV_FILE
-      end
+    it { expect(document).to(have_received(:labels).with(no_args)) }
+    it { expect(document).to(have_received(:eref).with(no_args)) }
+    it { expect(document).to(have_received(:iref).with(no_args)) }
+    it { expect(document).to(have_received(:attributes).with(no_args)) }
+    it { expect(document).to(have_received(:definitions).with(no_args)) }
+    it { expect(document).to(have_received(:wrong_explicit_checksum?).with(no_args)) }
+    it { expect(document).to(have_received(:explicit_version?).with(no_args)) }
+
+    it do
+      expect(target_file).to(have_file_content(<<~CSV_FILE))
+        Type;Reference;Value;Checksum
+        a;b;c;d
+        d;e;f;g
+      CSV_FILE
     end
   end
 end

data/spec/unit/defmastership/definition_parser_spec.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::DefinitionParser) do
+  subject(:parser) { described_class.new(callback_object) }
+
+  let(:callback_object) { instance_double('callback_object') }
+
+  before do
+    allow(callback_object).to(receive(:add_new_definition).with(any_args))
+    allow(callback_object).to(receive(:add_line).with(any_args))
+  end
+
+  describe 'transitions' do
+    it { is_expected.to(have_state(:idle)) }
+
+    it { is_expected.to(transition_from(:idle).to(:wait_content).on_event(:new_definition, :whatever)) }
+
+    it { is_expected.to(transition_from(:wait_content).to(:in_block).on_event(:block_delimiter, :whatever)) }
+    it { is_expected.to(transition_from(:in_block).to(:idle).on_event(:block_delimiter, :whatever)) }
+    it { is_expected.to(transition_from(:idle).to(:idle).on_event(:block_delimiter, :whatever)) }
+    it { is_expected.to(transition_from(:single_para).to(:idle).on_event(:block_delimiter, :whatever)) }
+
+    it { is_expected.to(transition_from(:wait_content).to(:single_para).on_event(:new_line, :whatever)) }
+    it { is_expected.to(transition_from(:single_para).to(:single_para).on_event(:new_line, :whatever)) }
+    it { is_expected.to(transition_from(:in_block).to(:in_block).on_event(:new_line, :whatever)) }
+    it { is_expected.to(transition_from(:idle).to(:idle).on_event(:new_line, :whatever)) }
+
+    it { is_expected.to(transition_from(:wait_content).to(:idle).on_event(:empty_line, :whatever)) }
+    it { is_expected.to(transition_from(:single_para).to(:idle).on_event(:empty_line, :whatever)) }
+    it { is_expected.to(transition_from(:idle).to(:idle).on_event(:empty_line, :whatever)) }
+    it { is_expected.to(transition_from(:in_block).to(:in_block).on_event(:empty_line, :whatever)) }
+  end
+
+  describe 'actions' do
+    it do
+      parser.new_definition(:whatever)
+      expect(callback_object).to(have_received(:add_new_definition).with(:whatever))
+    end
+
+    it do
+      parser.new_definition(:whatever)
+      parser.new_line(:other_whatever)
+      expect(callback_object).to(have_received(:add_line).with(:other_whatever))
+    end
+
+    it do
+      parser.new_definition(:whatever)
+      parser.new_line(:other_whatever)
+      parser.new_line(:other_whatever2)
+      expect(callback_object).to(have_received(:add_line).with(:other_whatever2))
+    end
+
+    it do
+      parser.new_definition(:whatever)
+      parser.block_delimiter(:other_whatever)
+      parser.new_line(:other_whatever2)
+      expect(callback_object).to(have_received(:add_line).with(:other_whatever2))
+    end
+  end
+end

data/spec/unit/defmastership/definition_spec.rb

@@ -1,10 +1,11 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
 require('defmastership')
 
 RSpec.describe(DefMastership::Definition) do
   describe '.new' do
-    context 'without labels' do
+    context 'when minimal' do
       subject do
         described_class.new(
           type: 'req',
@@ -21,12 +22,14 @@ RSpec.describe(DefMastership::Definition) do
       it { is_expected.to(have_attributes(iref:       [])) }
       it { is_expected.to(have_attributes(attributes: {})) }
       it { is_expected.to(have_attributes(labels:     Set.new)) }
+      it { is_expected.to(have_attributes(wrong_explicit_checksum: nil)) }
+      it { is_expected.to(have_attributes(explicit_version: nil)) }
     end
 
     context 'with labels' do
       subject do
         described_class.new(
-          gtype: 'req',
+          type: 'req',
           reference: 'TUTU-001',
           labels: 'something'
         )
@@ -34,6 +37,40 @@ RSpec.describe(DefMastership::Definition) do
 
       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
+
+      it do
+        definition << 'def value with a checksum != ~8cc259e6'
+        expect(definition).to(have_attributes(wrong_explicit_checksum: '~8cc259e6'))
+      end
+
+      it do
+        definition << 'def value with a good checksum'
+        expect(definition).to(have_attributes(wrong_explicit_checksum: nil))
+      end
+    end
+
+    context 'with explicit_version' do
+      subject(:definition) do
+        described_class.new(
+          type: 'req',
+          reference: 'TUTU-001',
+          explicit_version: 'pouet'
+        )
+      end
+
+      it do
+        expect(definition).to(have_attributes(explicit_version: 'pouet'))
+      end
+    end
   end
 
   describe '#<<' do
@@ -49,7 +86,7 @@ RSpec.describe(DefMastership::Definition) do
       expect(definition.value).to(eq('first line'))
     end
 
-    it 'store line when added' do
+    it 'stores line when added' do
       definition << 'first line'
       expect(definition.lines).to(eq(['first line']))
     end
@@ -59,10 +96,15 @@ RSpec.describe(DefMastership::Definition) do
       expect(definition.value).to(eq("first line\nsecond line"))
     end
 
-    it 'store each line when added' do
+    it 'stores each line when added' do
       definition << 'first line' << 'second line'
       expect(definition.lines).to(eq(['first line', 'second line']))
     end
+
+    it 'calculates sha256 of value' do
+      definition << 'first line' << 'second line'
+      expect(definition.sha256).to(eq('~beb0535a'))
+    end
   end
 
   describe '#add_eref' do