defmastership 1.0.2 → 1.0.7

data/spec/unit/defmastership/comment_filter_spec.rb

@@ -1,3 +1,4 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
 require('defmastership')
@@ -74,8 +75,10 @@ RSpec.describe(DefMastership::CommentFilter) do
     end
 
     before do
-      allow(DefMastership).to(receive(:comment_filter)
-        .and_return(comment_filter))
+      allow(DefMastership).to(
+        receive(:comment_filter)
+          .and_return(comment_filter)
+      )
     end
 
     context 'when not .commented?' do
@@ -93,8 +96,10 @@ RSpec.describe(DefMastership::CommentFilter) do
 
     context 'when .commented?' do
       before do
-        allow(comment_filter).to(receive(:accept?)
-          .with('blabla').and_return(false))
+        allow(comment_filter).to(
+          receive(:accept?)
+            .with('blabla').and_return(false)
+        )
       end
 
       it do

data/spec/unit/defmastership/csv_formatter_body_spec.rb

@@ -1,3 +1,4 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
 require('defmastership')
@@ -12,12 +13,13 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     it { is_expected.not_to(be(nil)) }
   end
 
-  describe '#fixed_body' do
+  describe '#fixed' do
     before do
       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.fixed_body(definition)
+      allow(definition).to(receive(:sha256).with(no_args).and_return('d'))
+      formatter.fixed(definition)
     end
 
     it { expect(definition).to(have_received(:type).with(no_args)) }
@@ -26,19 +28,43 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
 
     it { expect(definition).to(have_received(:value).with(no_args)) }
 
-    it { expect(formatter.fixed_body(definition)).to(eq(%w[a b c])) }
+    it { expect(definition).to(have_received(:sha256).with(no_args)) }
+
+    it { expect(formatter.fixed(definition)).to(eq(%w[a b c d])) }
+  end
+
+  describe '#wrong_explicit_checksum' do
+    context 'when no wrong_explicit checksum' do
+      before do
+        allow(definition).to(receive(:wrong_explicit_checksum).with(no_args).and_return(nil))
+        formatter.wrong_explicit_checksum(definition)
+      end
+
+      it { expect(definition).to(have_received(:wrong_explicit_checksum).with(no_args)) }
+
+      it { expect(formatter.wrong_explicit_checksum(definition)).to(eq([''])) }
+    end
+
+    context 'when explicit checksum' do
+      before do
+        allow(definition).to(receive(:wrong_explicit_checksum).with(no_args).and_return('ab12'))
+        formatter.wrong_explicit_checksum(definition)
+      end
+
+      it { expect(formatter.wrong_explicit_checksum(definition)).to(eq(['ab12'])) }
+    end
   end
 
-  describe '#labels_body' do
+  describe '#labels' do
     context 'when no labels on document' do
       before do
         allow(document).to(receive(:labels).with(no_args).and_return([]))
-        formatter.labels_body(definition)
+        formatter.labels(definition)
       end
 
       it { expect(document).to(have_received(:labels).once.with(no_args)) }
 
-      it { expect(formatter.labels_body(definition)).to(eq([])) }
+      it { expect(formatter.labels(definition)).to(eq([])) }
     end
 
     context 'when labels on document' do
@@ -47,66 +73,66 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       context 'when no labels on definition' do
         before do
           allow(definition).to(receive(:labels).with(no_args).and_return([]))
-          formatter.labels_body(definition)
+          formatter.labels(definition)
         end
 
         it { expect(definition).to(have_received(:labels).once.with(no_args)) }
 
-        it { expect(formatter.labels_body(definition)).to(eq([''])) }
+        it { expect(formatter.labels(definition)).to(eq([''])) }
       end
 
       context 'when labels on definition' do
         before do
           allow(definition).to(receive(:labels).with(no_args).and_return(%w[toto tutu]))
-          formatter.labels_body(definition)
+          formatter.labels(definition)
         end
 
         it { expect(definition).to(have_received(:labels).once.with(no_args)) }
 
-        it { expect(formatter.labels_body(definition)).to(eq(["toto\ntutu"])) }
+        it { expect(formatter.labels(definition)).to(eq(["toto\ntutu"])) }
       end
     end
   end
 
-  describe '#eref_body' do
+  describe '#eref' do
     context 'when no eref on the document' do
       before do
         allow(document).to(receive(:eref).with(no_args).and_return({}))
-        formatter.eref_body(definition)
+        formatter.eref(definition)
       end
 
       it { expect(document).to(have_received(:eref).with(no_args)) }
 
-      it { expect(formatter.eref_body(nil)).to(eq([])) }
+      it { expect(formatter.eref(nil)).to(eq([])) }
     end
 
     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_body(definition)
+        formatter.eref(definition)
       end
 
       it { expect(definition).to(have_received(:eref).exactly(3).times.with(no_args)) }
 
-      it { expect(formatter.eref_body(definition)).to(eq(["A\nB", '', 'C'])) }
+      it { expect(formatter.eref(definition)).to(eq(["A\nB", '', 'C'])) }
     end
   end
 
-  describe '#iref_body' do
+  describe '#iref' do
     context 'when no iref on the document' do
       before do
         allow(document).to(receive(:iref).with(no_args).and_return(false))
-        formatter.iref_body(definition)
+        formatter.iref(definition)
       end
 
       it { expect(document).to(have_received(:iref).with(no_args)) }
 
-      it { expect(formatter.iref_body(definition)).to(eq([])) }
+      it { expect(formatter.iref(definition)).to(eq([])) }
     end
 
     context 'when iref on the document' do
@@ -115,53 +141,52 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       context 'when no iref on the definition' do
         before do
           allow(definition).to(receive(:iref).with(no_args).and_return([]))
-          formatter.iref_body(definition)
+          formatter.iref(definition)
         end
 
         it { expect(definition).to(have_received(:iref).with(no_args)) }
 
-        it { expect(formatter.iref_body(definition)).to(eq([''])) }
+        it { expect(formatter.iref(definition)).to(eq([''])) }
       end
 
       context 'when iref on the definition' do
         before do
           allow(definition).to(receive(:iref).with(no_args).and_return(%w[A B]))
-          formatter.iref_body(definition)
+          formatter.iref(definition)
         end
 
         it { expect(definition).to(have_received(:iref).with(no_args)) }
 
-        it { expect(formatter.iref_body(definition)).to(eq(["A\nB"])) }
+        it { expect(formatter.iref(definition)).to(eq(["A\nB"])) }
       end
     end
   end
 
-  describe '#attributes_body' do
+  describe '#attributes' do
     context 'when no attributes on the document' do
       before do
         allow(document).to(receive(:attributes).with(no_args).and_return({}))
-        formatter.attributes_body(definition)
+        formatter.attributes(definition)
       end
 
       it { expect(document).to(have_received(:attributes).with(no_args)) }
 
-      it { expect(formatter.attributes_body(nil)).to(eq([])) }
+      it { expect(formatter.attributes(nil)).to(eq([])) }
     end
 
     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_body(definition)
+        formatter.attributes(definition)
       end
 
       it { expect(definition).to(have_received(:attributes).exactly(3).times) }
 
-      it { expect(formatter.attributes_body(definition)).to(eq(['X', '', 'Y'])) }
+      it { expect(formatter.attributes(definition)).to(eq(['X', '', 'Y'])) }
     end
   end
 end

data/spec/unit/defmastership/csv_formatter_header_spec.rb

@@ -1,3 +1,4 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
 require('defmastership')
@@ -12,88 +13,112 @@ RSpec.describe(DefMastership::CSVFormatterHeader) do
   end
 
   describe '#header' do
-    describe '#fixed_header' do
-      it { expect(formatter.fixed_header).to(eq(%w[Type Reference Value])) }
+    describe '#fixed' do
+      it { expect(formatter.fixed).to(eq(%w[Type Reference Value sha256])) }
     end
 
-    describe '#labels_header' do
+    describe '#wrong_explicit_checksum' do
+      context 'when no wrong explicit checksum' do
+        before do
+          allow(document).to(receive(:wrong_explicit_checksum?).and_return(false))
+          formatter.wrong_explicit_checksum
+        end
+
+        it { expect(document).to(have_received(:wrong_explicit_checksum?)) }
+
+        it { expect(formatter.wrong_explicit_checksum).to(eq([])) }
+      end
+
+      context 'when wrong explicit checksum' do
+        before do
+          allow(document).to(receive(:wrong_explicit_checksum?).and_return(true))
+          formatter.wrong_explicit_checksum
+        end
+
+        it { expect(formatter.wrong_explicit_checksum).to(eq(['Wrong explicit checksum'])) }
+      end
+    end
+
+    describe '#labels' do
       context 'when no labels' do
         before do
           allow(document).to(receive(:labels).and_return([]))
-          formatter.labels_header
+          formatter.labels
         end
 
         it { expect(document).to(have_received(:labels)) }
 
-        it { expect(formatter.labels_header).to(eq([])) }
+        it { expect(formatter.labels).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'])) }
+        it { expect(formatter.labels).to(eq(['Labels'])) }
       end
     end
 
-    describe '#eref_header' do
+    describe '#eref' do
       context 'when no eref' do
         before do
           allow(document).to(receive(:eref).and_return({}))
-          formatter.eref_header
+          formatter.eref
         end
 
         it { expect(document).to(have_received(:eref)) }
 
-        it { expect(formatter.eref_header).to(eq([])) }
+        it { expect(formatter.eref).to(eq([])) }
       end
 
       context 'when eref' do
         before do
-          allow(document).to(receive(:eref).and_return(
-                               whatever: { prefix: 'A' },
-                               other: { prefix: 'C', url: 'D' }
-                             ))
+          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'])) }
+        it { expect(formatter.eref).to(eq(%w[A C])) }
       end
     end
 
-    describe '#iref_header' do
+    describe '#iref' do
       context 'when no iref' do
         before do
           allow(document).to(receive(:iref).and_return(false))
-          formatter.iref_header
+          formatter.iref
         end
 
         it { expect(document).to(have_received(:iref)) }
 
-        it { expect(formatter.iref_header).to(eq([])) }
+        it { expect(formatter.iref).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'])) }
+        it { expect(formatter.iref).to(eq(['Internal links'])) }
       end
     end
 
-    describe '#attributes_header' do
+    describe '#attributes' do
       context 'when no attributes' do
         before do
           allow(document).to(receive(:attributes).and_return({}))
-          formatter.attributes_header
+          formatter.attributes
         end
 
         it { expect(document).to(have_received(:attributes)) }
 
-        it { expect(formatter.attributes_header).to(eq([])) }
+        it { expect(formatter.attributes).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])) }
+        it { expect(formatter.attributes).to(eq(%w[A B])) }
       end
     end
   end

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,130 +14,93 @@ RSpec.describe(DefMastership::CSVFormatter) do
     it { is_expected.not_to(be(nil)) }
   end
 
-  describe '#header' do
-    context 'when minimal' do
+  describe '#export_to' do
+    context 'when wrong explicit checksum' do
+      let(:header) { instance_double(DefMastership::CSVFormatterHeader, 'header') }
+      let(:body) { instance_double(DefMastership::CSVFormatterBody, 'body') }
+      let(:csv)  { instance_double(CSV, 'csv')                              }
+
+      methods1 = %i[fixed wrong_explicit_checksum labels eref iref attributes]
       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
+        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(true))
+        methods1.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
 
-      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)) }
+      methods1.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])) }
-    end
+      it do
+        expect(csv).to(have_received(:<<).with(methods1.map { |method| "#{method} header" }))
+      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'))
+      it do
+        expect(csv).to(have_received(:<<).with(methods1.map { |method| "#{method} def1 body" }))
       end
 
       it do
-        expect(formatter.header).to(eq(%w[Type Reference Value Labels] +
-                                     ['A', 'C D', 'Internal links'] +
-                                     %w[E F]))
+        expect(csv).to(have_received(:<<).with(methods1.map { |method| "#{method} def2 body" }))
       end
     end
-  end
 
-  describe '#body' do
-    let(:definition) { instance_double(DefMastership::Definition, 'definition') }
+    context 'when no wrong explicit checksum' do
+      let(:header) { instance_double(DefMastership::CSVFormatterHeader, 'header') }
+      let(:body) { instance_double(DefMastership::CSVFormatterBody, 'body') }
+      let(:csv)  { instance_double(CSV, 'csv')                              }
 
-    context 'when minimal' do
+      methods2 = %i[fixed labels eref iref attributes]
       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)
+        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))
+        methods2.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
 
-      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)
+      methods2.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(: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 do
+        expect(csv).to(have_received(:<<).with(methods2.map { |method| "#{method} header" }))
+      end
 
-      it { expect(definition).to(have_received(:attributes).exactly(3).times.with(no_args)) }
+      it do
+        expect(csv).to(have_received(:<<).with(methods2.map { |method| "#{method} def1 body" }))
+      end
 
       it do
-        expect(formatter.body(definition)).to(eq(%w[a b c] + ["toto\ntutu"] +
-                                                 ["A\nB", '', 'C'] +
-                                                 ["E\nF"] +
-                                                 ['X', '', 'Y']))
+        expect(csv).to(have_received(:<<).with(methods2.map { |method| "#{method} def2 body" }))
       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')
+          OpenStruct.new(type: 'a', reference: 'b', value: 'c', sha256: 'd'),
+          OpenStruct.new(type: 'd', reference: 'e', value: 'f', sha256: 'g')
         ]
       end
 
@@ -146,24 +111,21 @@ RSpec.describe(DefMastership::CSVFormatter) do
         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))
+        allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(false))
         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
+          Type;Reference;Value;sha256
+          a;b;c;d
+          d;e;f;g
         CSV_FILE
       end
     end