defmastership 1.0.15 → 1.0.17

data/spec/unit/{defmastership → def_mastership}/csv_formatter_body_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
   let(:definition) { instance_double(DefMastership::Definition, 'definition') }
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
   end
 
   describe '#fixed' do

data/spec/unit/{defmastership → def_mastership}/csv_formatter_header_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe(DefMastership::CSVFormatterHeader) do
   let(:document) { instance_double(DefMastership::Document, 'document') }
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
   end
 
   describe '#header' do

data/spec/unit/{defmastership → def_mastership}/csv_formatter_spec.rb

@@ -1,9 +1,9 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require('csv')
 require('defmastership')
 require('ostruct')
-require('csv')
 
 RSpec.describe(DefMastership::CSVFormatter) do
   subject(:formatter) { described_class.new(document, ';') }
@@ -11,7 +11,7 @@ RSpec.describe(DefMastership::CSVFormatter) do
   let(:document) { instance_double(DefMastership::Document, 'document') }
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
   end
 
   describe '#export_to' do
@@ -232,12 +232,7 @@ RSpec.describe(DefMastership::CSVFormatter) do
 
   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
+    let(:definitions) { [double, double] }
 
     before do
       setup_aruba
@@ -246,6 +241,14 @@ RSpec.describe(DefMastership::CSVFormatter) do
       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(definitions[0]).to(receive(:type).and_return('a'))
+      allow(definitions[0]).to(receive(:reference).and_return('b'))
+      allow(definitions[0]).to(receive(:value).and_return('c'))
+      allow(definitions[0]).to(receive(:sha256).and_return('d'))
+      allow(definitions[1]).to(receive(:type).and_return('d'))
+      allow(definitions[1]).to(receive(:reference).and_return('e'))
+      allow(definitions[1]).to(receive(:value).and_return('f'))
+      allow(definitions[1]).to(receive(:sha256).and_return('g'))
       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}")

data/spec/unit/{defmastership → def_mastership}/definition_parser_spec.rb

@@ -6,7 +6,7 @@ require('defmastership')
 RSpec.describe(DefMastership::DefinitionParser) do
   subject(:parser) { described_class.new(callback_object) }
 
-  let(:callback_object) { instance_double('callback_object') }
+  let(:callback_object) { double }
 
   before do
     allow(callback_object).to(receive(:add_new_definition).with(any_args))

data/spec/unit/{defmastership → def_mastership}/definition_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe(DefMastership::Definition) do
         )
       end
 
-      it { is_expected.not_to(be(nil)) }
+      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:      [])) }

data/spec/unit/{defmastership → def_mastership}/document_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe(DefMastership::Document) do
   subject(:document) { described_class.new }
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    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)) }
@@ -115,6 +115,49 @@ RSpec.describe(DefMastership::Document) do
         it { expect(definition).to(have_received(:<<).with('b')) }
       end
 
+      context 'when complete definition with content including ----' 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(:<<).twice.with('----')) }
+        it { expect(definition).to(have_received(:<<).with('a')) }
+        it { expect(definition).to(have_received(:<<).with('b')) }
+      end
+
+      context 'when complete definition with single line comment' do
+        let(:input_lines) do
+          [
+            '[define, requirement, TOTO-0001]',
+            '--',
+            '// comment',
+            '--',
+            'not included'
+          ]
+        end
+
+        before do
+          allow(definition).to(receive(:<<).and_return(definition))
+          document.parse(input_lines)
+        end
+
+        it { expect(definition).to(have_received(:<<).with('// comment')) }
+      end
+
       context 'when definition with one paragraph' do
         let(:input_lines) do
           [
@@ -280,7 +323,7 @@ RSpec.describe(DefMastership::Document) do
         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)) }
+        it { expect(document.iref).to(be(true)) }
       end
 
       context 'when configure attributes' do
@@ -322,7 +365,7 @@ RSpec.describe(DefMastership::Document) do
 
         it do
           document.parse(input_lines)
-          expect(document.iref).to(eq(false))
+          expect(document.iref).to(be(false))
         end
       end
 
@@ -479,8 +522,12 @@ RSpec.describe(DefMastership::Document) do
   end
 
   describe '#wrong_explicit_checksum?' do
-    let(:def1) { instance_double(DefMastership::Definition, 'definition') }
-    let(:def2) { instance_double(DefMastership::Definition, 'definition') }
+    let(:defs) do
+      [
+        instance_double(DefMastership::Definition, 'definition'),
+        instance_double(DefMastership::Definition, 'definition')
+      ]
+    end
     let(:input_lines) do
       [
         '[define, requirement, TOTO-0001]',
@@ -492,41 +539,45 @@ RSpec.describe(DefMastership::Document) do
     end
 
     before do
-      allow(DefMastership::Definition).to(receive(:new).twice.and_return(def1, def2))
-      allow(def1).to(receive(:labels)).and_return([])
-      allow(def2).to(receive(:labels)).and_return([])
-      allow(def1).to(receive(:<<).and_return(def1))
-      allow(def2).to(receive(:<<).and_return(def2))
+      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs[0], defs[1]))
+      allow(defs[0]).to(receive(:labels)).and_return([])
+      allow(defs[1]).to(receive(:labels)).and_return([])
+      allow(defs[0]).to(receive(:<<).and_return(defs[0]))
+      allow(defs[1]).to(receive(:<<).and_return(defs[1]))
     end
 
     context 'when no wrong explicit checksum' do
       before do
-        allow(def1).to(receive(:wrong_explicit_checksum)).and_return(nil)
-        allow(def2).to(receive(:wrong_explicit_checksum)).and_return(nil)
+        allow(defs[0]).to(receive(:wrong_explicit_checksum)).and_return(nil)
+        allow(defs[1]).to(receive(:wrong_explicit_checksum)).and_return(nil)
         document.parse(input_lines)
         document.wrong_explicit_checksum?
       end
 
-      it { expect(def1).to(have_received(:wrong_explicit_checksum)) }
-      it { expect(def2).to(have_received(:wrong_explicit_checksum)) }
-      it { expect(document.wrong_explicit_checksum?).to(eq(false)) }
+      it { expect(defs[0]).to(have_received(:wrong_explicit_checksum)) }
+      it { expect(defs[1]).to(have_received(:wrong_explicit_checksum)) }
+      it { expect(document.wrong_explicit_checksum?).to(be(false)) }
     end
 
     context 'when one req has wrong explicit checksum' do
       before do
-        allow(def1).to(receive(:wrong_explicit_checksum)).and_return(nil)
-        allow(def2).to(receive(:wrong_explicit_checksum)).and_return('toto')
+        allow(defs[0]).to(receive(:wrong_explicit_checksum)).and_return(nil)
+        allow(defs[1]).to(receive(:wrong_explicit_checksum)).and_return('toto')
         document.parse(input_lines)
         document.wrong_explicit_checksum?
       end
 
-      it { expect(document.wrong_explicit_checksum?).to(eq(true)) }
+      it { expect(document.wrong_explicit_checksum?).to(be(true)) }
     end
   end
 
   describe '#explicit_version?' do
-    let(:def1) { instance_double(DefMastership::Definition, 'definition') }
-    let(:def2) { instance_double(DefMastership::Definition, 'definition') }
+    let(:defs) do
+      [
+        instance_double(DefMastership::Definition, 'definition'),
+        instance_double(DefMastership::Definition, 'definition')
+      ]
+    end
     let(:input_lines) do
       [
         '[define, requirement, TOTO-0001]',
@@ -538,41 +589,45 @@ RSpec.describe(DefMastership::Document) do
     end
 
     before do
-      allow(DefMastership::Definition).to(receive(:new).twice.and_return(def1, def2))
-      allow(def1).to(receive(:labels)).and_return([])
-      allow(def2).to(receive(:labels)).and_return([])
-      allow(def1).to(receive(:<<).and_return(def1))
-      allow(def2).to(receive(:<<).and_return(def2))
+      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs[0], defs[1]))
+      allow(defs[0]).to(receive(:labels)).and_return([])
+      allow(defs[1]).to(receive(:labels)).and_return([])
+      allow(defs[0]).to(receive(:<<).and_return(defs[0]))
+      allow(defs[1]).to(receive(:<<).and_return(defs[1]))
     end
 
     context 'when no explicit version' do
       before do
-        allow(def1).to(receive(:explicit_version)).and_return(nil)
-        allow(def2).to(receive(:explicit_version)).and_return(nil)
+        allow(defs[0]).to(receive(:explicit_version)).and_return(nil)
+        allow(defs[1]).to(receive(:explicit_version)).and_return(nil)
         document.parse(input_lines)
         document.explicit_version?
       end
 
-      it { expect(def1).to(have_received(:explicit_version)) }
-      it { expect(def2).to(have_received(:explicit_version)) }
-      it { expect(document.explicit_version?).to(eq(false)) }
+      it { expect(defs[0]).to(have_received(:explicit_version)) }
+      it { expect(defs[1]).to(have_received(:explicit_version)) }
+      it { expect(document.explicit_version?).to(be(false)) }
     end
 
     context 'when one req has explicit version' do
       before do
-        allow(def1).to(receive(:explicit_version)).and_return(nil)
-        allow(def2).to(receive(:explicit_version)).and_return('toto')
+        allow(defs[0]).to(receive(:explicit_version)).and_return(nil)
+        allow(defs[1]).to(receive(:explicit_version)).and_return('toto')
         document.parse(input_lines)
         document.explicit_version?
       end
 
-      it { expect(document.explicit_version?).to(eq(true)) }
+      it { expect(document.explicit_version?).to(be(true)) }
     end
   end
 
   describe '#ref_to_def?' do
-    let(:def1) { instance_double(DefMastership::Definition, 'definition') }
-    let(:def2) { instance_double(DefMastership::Definition, 'definition') }
+    let(:defs) do
+      [
+        instance_double(DefMastership::Definition, 'definition'),
+        instance_double(DefMastership::Definition, 'definition')
+      ]
+    end
     let(:input_lines) do
       [
         '[define, requirement, TOTO-0001]',
@@ -584,17 +639,17 @@ RSpec.describe(DefMastership::Document) do
     end
 
     before do
-      allow(DefMastership::Definition).to(receive(:new).twice.and_return(def1, def2))
-      allow(def1).to(receive(:labels)).and_return([])
-      allow(def2).to(receive(:labels)).and_return([])
-      allow(def1).to(receive(:<<).and_return(def1))
-      allow(def2).to(receive(:<<).and_return(def2))
-      allow(def1).to(receive(:reference).and_return('TOTO-0001'))
-      allow(def2).to(receive(:reference).and_return('TOTO-0002'))
+      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs[0], defs[1]))
+      allow(defs[0]).to(receive(:labels)).and_return([])
+      allow(defs[1]).to(receive(:labels)).and_return([])
+      allow(defs[0]).to(receive(:<<).and_return(defs[0]))
+      allow(defs[1]).to(receive(:<<).and_return(defs[1]))
+      allow(defs[0]).to(receive(:reference).and_return('TOTO-0001'))
+      allow(defs[1]).to(receive(:reference).and_return('TOTO-0002'))
       document.parse(input_lines)
     end
 
-    it { expect(document.ref_to_def('TOTO-0001')).to(eq(def1)) }
-    it { expect(document.ref_to_def('TOTO-0002')).to(eq(def2)) }
+    it { expect(document.ref_to_def('TOTO-0001')).to(eq(defs[0])) }
+    it { expect(document.ref_to_def('TOTO-0002')).to(eq(defs[1])) }
   end
 end

data/spec/unit/def_mastership/parsing_state_spec.rb

@@ -0,0 +1,62 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::ParsingState) do
+  subject(:parsing_state) do
+    described_class.new
+  end
+
+  describe '.new' do
+    it { is_expected.not_to(be_nil) }
+  end
+
+  describe '#enabled_with?' do
+    context 'when single line commment' do
+      it { expect(parsing_state.enabled?("//whatever\n")).to(be(false)) }
+    end
+
+    context 'when starting' do
+      it { expect(parsing_state.enabled?("whatever\n")).to(be(true)) }
+      it { expect(parsing_state.enabled?("----\n")).to(be(false)) }
+      it { expect(parsing_state.enabled?("....\n")).to(be(false)) }
+      it { expect(parsing_state.enabled?("////\n")).to(be(false)) }
+      it { expect(parsing_state.enabled?('....')).to(be(false)) }
+    end
+
+    context 'when disabled' do
+      before { parsing_state.enabled?("----\n") }
+
+      it { expect(parsing_state.enabled?("whatever\n")).to(be(false)) }
+      it { expect(parsing_state.enabled?("----\n")).to(be(true)) }
+      it { expect(parsing_state.enabled?("....\n")).to(be(false)) }
+      it { expect(parsing_state.enabled?("////\n")).to(be(false)) }
+    end
+
+    context 'with intricated disables starting with "...."' do
+      before do
+        ["....\n", "----\n", "whatever\n"].each { |line| parsing_state.enabled?(line) }
+      end
+
+      it { expect(parsing_state.enabled?("----\n")).to(be(false)) }
+      it { expect(parsing_state.enabled?("....\n")).to(be(true)) }
+    end
+
+    context 'with intricated disables starting with "----"' do
+      before do
+        ["....\n", "----\n", "whatever\n"].each { |line| parsing_state.enabled?(line) }
+      end
+
+      it { expect(parsing_state.enabled?("....\n")).to(be(true)) }
+    end
+
+    context 'with intricated disables starting with "////"' do
+      before do
+        ["////\n", "----\n", "whatever\n"].each { |line| parsing_state.enabled?(line) }
+      end
+
+      it { expect(parsing_state.enabled?("////\n")).to(be(true)) }
+    end
+  end
+end

data/spec/unit/{defmastership → def_mastership}/rename_included_files_line_modifier_spec.rb

@@ -7,11 +7,15 @@ RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
   subject(:includeschanger) { described_class.new }
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
     it { is_expected.to(have_attributes(from_regexp: '')) }
     it { is_expected.to(have_attributes(to_template: '')) }
     it { is_expected.to(have_attributes(changes:     [])) }
-    it { expect { includeschanger.user_defined_attribute }.to(raise_error(NoMethodError)) }
+
+    it do
+      expect { includeschanger.user_defined_attribute }
+        .to(raise_error(NoMethodError))
+    end
   end
 
   describe '.from_config' do
@@ -22,7 +26,7 @@ RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
       )
     end
 
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
     it { is_expected.to(have_attributes(from_regexp: 'Whatever.+')) }
     it { is_expected.to(have_attributes(to_template: 'Whatever')) }
   end

data/spec/unit/{defmastership → def_mastership}/rename_included_files_modifier_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe(DefMastership::RenameIncludedFilesModifier) do
   end
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
     it { is_expected.to(have_attributes(config: 'fake config')) }
     it { is_expected.to(have_attributes(changes: [])) }
   end

data/spec/unit/{defmastership → def_mastership}/update_def_checksum_line_modifier_spec.rb

@@ -7,10 +7,14 @@ RSpec.describe(DefMastership::UpdateDefChecksumLineModifier) do
   subject(:linemodifier) { described_class.new }
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
     it { is_expected.to(have_attributes(def_type: '')) }
     it { is_expected.to(have_attributes(changes:  [])) }
-    it { expect { linemodifier.user_defined_attribute }.to(raise_error(NoMethodError)) }
+
+    it do
+      expect { linemodifier.user_defined_attribute }
+        .to(raise_error(NoMethodError))
+    end
   end
 
   describe '.from_config' do
@@ -20,7 +24,7 @@ RSpec.describe(DefMastership::UpdateDefChecksumLineModifier) do
       )
     end
 
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
     it { is_expected.to(have_attributes(def_type: 'requirement')) }
     it { is_expected.to(have_attributes(document: nil)) }
   end

data/spec/unit/{defmastership → def_mastership}/update_def_checksum_modifier_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe(DefMastership::UpdateDefChecksumModifier) do
   end
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
     it { is_expected.to(have_attributes(config: 'fake config')) }
     it { is_expected.to(have_attributes(changes: [])) }
   end

data/spec/unit/{defmastership → def_mastership}/update_def_version_line_modifier_spec.rb

@@ -7,10 +7,14 @@ RSpec.describe(DefMastership::UpdateDefVersionLineModifier) do
   subject(:linemodifier) { described_class.new }
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
     it { is_expected.to(have_attributes(def_type: '')) }
     it { is_expected.to(have_attributes(changes:  [])) }
-    it { expect { linemodifier.user_defined_attribute }.to(raise_error(NoMethodError)) }
+
+    it do
+      expect { linemodifier.user_defined_attribute }
+        .to(raise_error(NoMethodError))
+    end
   end
 
   describe '.from_config' do
@@ -21,7 +25,7 @@ RSpec.describe(DefMastership::UpdateDefVersionLineModifier) do
       )
     end
 
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
     it { is_expected.to(have_attributes(def_type: 'requirement')) }
     it { is_expected.to(have_attributes(first_version: 'a')) }
     it { is_expected.to(have_attributes(document: nil)) }

data/spec/unit/{defmastership → def_mastership}/update_def_version_modifier_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe(DefMastership::UpdateDefVersionModifier) do
   end
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
     it { is_expected.to(have_attributes(config: { ref_document: 'ref.adoc' })) }
     it { is_expected.to(have_attributes(changes: [])) }
   end
@@ -30,7 +30,7 @@ RSpec.describe(DefMastership::UpdateDefVersionModifier) do
 
     before do
       allow(DefMastership::UpdateDefVersionLineModifier).to(
-        receive(:from_config).with(ref_document: 'ref.adoc').and_return(line_modifier)
+        receive(:from_config).with({ ref_document: 'ref.adoc' }).and_return(line_modifier)
       )
       allow(DefMastership::Document).to(receive(:new).and_return(document, ref_document))
       allow(document).to(receive(:parse_file_with_preprocessor))
@@ -50,7 +50,7 @@ RSpec.describe(DefMastership::UpdateDefVersionModifier) do
 
       it do
         expect(DefMastership::UpdateDefVersionLineModifier).to(
-          have_received(:from_config).with(ref_document: 'ref.adoc')
+          have_received(:from_config).with({ ref_document: 'ref.adoc' })
         )
       end
 

data/spec/unit/{defmastership_spec.rb → def_mastership_spec.rb}

@@ -3,6 +3,6 @@
 
 RSpec.describe(DefMastership) do
   it 'has a version number' do
-    expect(DefMastership::VERSION).not_to(be(nil))
+    expect(DefMastership::VERSION).not_to(be_nil)
   end
 end