defmastership 1.0.16 → 1.0.18

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

@@ -1,13 +1,13 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/document')
 
 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)) }
@@ -15,16 +15,32 @@ RSpec.describe(DefMastership::Document) do
     it { is_expected.to(have_attributes(variables: {})) }
   end
 
+  describe '.method_missing' do
+    it do
+      expect { document.not_implemented_random_method }
+        .to(raise_error(NoMethodError))
+    end
+  end
+
+  describe '.respond_to_missing?' do
+    it { expect(document.respond_to?(:add_new_definition)).to(be(true)) }
+    it { expect(document.respond_to?(:not_implemented_random_method)).to(be(false)) }
+  end
+
   describe '#parse' do
     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))
+        allow(definition).to(
+          receive_messages(
+            labels: Set.new,
+            '<<': definition,
+            add_eref: definition,
+            add_iref: definition
+          )
+        )
       end
 
       context 'when simple definition line' do
@@ -323,7 +339,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
@@ -365,7 +381,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
 
@@ -401,8 +417,12 @@ RSpec.describe(DefMastership::Document) do
 
       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_messages(
+            labels: Set.new,
+            '<<': definition
+          )
+        )
         document.parse(input_lines)
       end
 
@@ -431,6 +451,18 @@ RSpec.describe(DefMastership::Document) do
         it { expect(definition).to(have_received(:<<).with('bef {variable} aft')) }
       end
 
+      context 'when badly defined variable' do
+        let(:input_lines) do
+          [
+            ':variable:one value',
+            '[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
           [
@@ -503,8 +535,12 @@ RSpec.describe(DefMastership::Document) do
       allow(adoc_doc).to(receive(:reader).and_return(adoc_reader))
       allow(adoc_reader).to(receive(:read_lines).and_return(input_lines))
       allow(DefMastership::Definition).to(receive(:new).and_return(definition))
-      allow(definition).to(receive(:<<).and_return(definition))
-      allow(definition).to(receive(:labels).and_return(Set.new))
+      allow(definition).to(
+        receive_messages(
+          '<<': definition,
+          labels: Set.new
+        )
+      )
       document.parse_file_with_preprocessor('the_file.adoc')
     end
 
@@ -522,8 +558,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]',
@@ -535,41 +575,44 @@ 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.first, defs[1]))
+      defs.each do |definition|
+        allow(definition).to(receive(:labels)).and_return([])
+        allow(definition).to(receive(:<<)).and_return(definition)
+      end
     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)
+        defs.each { |definition| allow(definition).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.first).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.first).to(receive(:wrong_explicit_checksum)).and_return('toto')
+        allow(defs[1]).to(receive(:wrong_explicit_checksum)).and_return(nil)
         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]',
@@ -581,41 +624,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.first, defs[1]))
+      allow(defs.first).to(receive(:labels)).and_return([])
+      allow(defs[1]).to(receive(:labels)).and_return([])
+      allow(defs.first).to(receive(:<<).and_return(defs.first))
+      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.first).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.first).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.first).to(receive(:explicit_version)).and_return('toto')
+        allow(defs[1]).to(receive(:explicit_version)).and_return(nil)
         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(:definitions) do
+      [
+        instance_double(DefMastership::Definition, 'def1'),
+        instance_double(DefMastership::Definition, 'def2')
+      ]
+    end
     let(:input_lines) do
       [
         '[define, requirement, TOTO-0001]',
@@ -627,17 +674,25 @@ 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(definitions.first, definitions[1]))
+      allow(definitions.first).to(
+        receive_messages(
+          labels: [],
+          '<<': definitions.first,
+          reference: 'TOTO-0001'
+        )
+      )
+      allow(definitions[1]).to(
+        receive_messages(
+          labels: [],
+          '<<': definitions[1],
+          reference: 'TOTO-0002'
+        )
+      )
       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(definitions.first)) }
+    it { expect(document.ref_to_def('TOTO-0002')).to(eq(definitions[1])) }
   end
 end

data/spec/unit/def_mastership/matching_line_spec.rb

@@ -0,0 +1,37 @@
+# Copyright (c) 2024 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/matching_line')
+
+RSpec.describe(DefMastership::MatchingLine) do
+  describe '.new' do
+    subject(:matching_line) do
+      described_class.new(:a_match, :a_line)
+    end
+
+    it { is_expected.not_to(be_nil) }
+    it { is_expected.to(have_attributes(match: :a_match)) }
+    it { is_expected.to(have_attributes(line: :a_line)) }
+  end
+
+  describe '#[]' do
+    subject(:matching_line) do
+      described_class.new(match, :a_line)
+    end
+
+    let(:match) { instance_double(Hash, 'match') }
+
+    before do
+      allow(match).to(receive(:[]).with(:whatever).and_return('Whatever'))
+      allow(match).to(receive(:[]).with(:line).and_return(nil))
+    end
+
+    it do
+      matching_line[:whatever]
+      expect(match).to(have_received(:[]).with(:whatever))
+    end
+
+    it { expect(matching_line[:whatever]).to(eq('Whatever')) }
+    it { expect(matching_line[:line]).to(eq(:a_line)) }
+  end
+end

data/spec/unit/def_mastership/modifier_factory_spec.rb

@@ -0,0 +1,37 @@
+# Copyright (c) 2023 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/modifier_factory')
+
+module DefMastership
+  class TotoModifier
+    include Modifier
+  end
+end
+
+RSpec.describe(DefMastership::ModifierFactory) do
+  describe('.from_config') do
+    let(:toto)        { instance_double(DefMastership::TotoModifier, 'toto') }
+    let(:toto_config) { { type: 'toto', config: { p: 'whatever' } }          }
+    let(:tutu)        { instance_double(DefMastership::TotoModifier, 'tutu') }
+    let(:tutu_config) { { type: 'tu_tu', config: { p: 'whatever' } }         }
+
+    before do
+      allow(DefMastership::TotoModifier).to(receive(:new).with(toto_config[:config]).and_return(toto))
+      allow(DefMastership::TuTuModifier).to(receive(:new).with(tutu_config[:config]).and_return(tutu))
+    end
+
+    it { expect(described_class.from_config(toto_config)).to(be(toto)) }
+    it { expect(described_class.from_config(tutu_config)).to(be(tutu)) }
+
+    it do
+      described_class.from_config(toto_config)
+      expect(DefMastership::TotoModifier).to(have_received(:new).with(toto_config[:config]))
+    end
+
+    it do
+      described_class.from_config(tutu_config)
+      expect(DefMastership::TuTuModifier).to(have_received(:new).with(tutu_config[:config]))
+    end
+  end
+end

data/spec/unit/def_mastership/modifier_spec.rb

@@ -0,0 +1,83 @@
+# Copyright (c) 2023 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/modifier')
+
+class DummyclassParrent
+  def respond_to_missing?(method_name, *_)
+    return true if method_name == :ploup
+
+    false
+  end
+end
+
+class DummyClass < DummyclassParrent
+  include DefMastership::Modifier
+
+  def self.replacement_methods
+    %i[replace_pouet_by_foo replace_foo_by_zoo]
+  end
+
+  def self.default_config
+    { something: :default }
+  end
+
+  def initialize(config)
+    setup_modifier_module(config)
+    super()
+  end
+
+  def replace_pouet_by_foo(line)
+    line.gsub('pouet', 'foo')
+  end
+
+  def replace_foo_by_zoo(line)
+    line.gsub('foo', 'zoo')
+  end
+end
+
+class BadDummyClass < DummyclassParrent
+  include DefMastership::Modifier
+end
+
+RSpec.describe(DefMastership::Modifier) do
+  subject(:modifier) { DummyClass.new({}) }
+
+  describe '.new' do
+    it { is_expected.not_to(be_nil) }
+    it { is_expected.to(have_attributes(config: { something: :default })) }
+    it { is_expected.to(have_attributes(changes: [])) }
+  end
+
+  context 'when want to use config smoothly' do
+    subject(:modifier) { DummyClass.new(plop: 'Whatever', something: :not_default) }
+
+    it { is_expected.to(have_attributes(config: { plop: 'Whatever', something: :not_default })) }
+    it { is_expected.to(have_attributes(plop: 'Whatever')) }
+    it { is_expected.not_to(respond_to(:pleeep)) }
+    it { is_expected.to(respond_to(:ploup)) }
+
+    it do
+      expect { modifier.plooooop }
+        .to(raise_error(NoMethodError))
+    end
+  end
+
+  describe '#apply_to_all' do
+    it do
+      texts = { first: "pouet\ntoto\npouet", second: "toto\npouet\ntoto" }
+
+      expect(modifier.apply_to_all(texts, :replace_pouet_by_foo))
+        .to(eq({ first: "foo\ntoto\nfoo", second: "toto\nfoo\ntoto" }))
+    end
+  end
+
+  describe '#do_modifications' do
+    it do
+      adoc_sources = { first: "pouet\ntoto\npouet", second: "toto\npouet\ntoto" }
+
+      expect(modifier.do_modifications(adoc_sources))
+        .to(eq({ first: "zoo\ntoto\nzoo", second: "toto\nzoo\ntoto" }))
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/parsing_state')
 
 RSpec.describe(DefMastership::ParsingState) do
   subject(:parsing_state) do
@@ -9,29 +9,29 @@ RSpec.describe(DefMastership::ParsingState) do
   end
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    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(eq(false)) }
+      it { expect(parsing_state.enabled?("//whatever\n")).to(be(false)) }
     end
 
     context 'when starting' do
-      it { expect(parsing_state.enabled?("whatever\n")).to(eq(true)) }
-      it { expect(parsing_state.enabled?("----\n")).to(eq(false)) }
-      it { expect(parsing_state.enabled?("....\n")).to(eq(false)) }
-      it { expect(parsing_state.enabled?("////\n")).to(eq(false)) }
-      it { expect(parsing_state.enabled?('....')).to(eq(false)) }
+      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(eq(false)) }
-      it { expect(parsing_state.enabled?("----\n")).to(eq(true)) }
-      it { expect(parsing_state.enabled?("....\n")).to(eq(false)) }
-      it { expect(parsing_state.enabled?("////\n")).to(eq(false)) }
+      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
@@ -39,8 +39,8 @@ RSpec.describe(DefMastership::ParsingState) do
         ["....\n", "----\n", "whatever\n"].each { |line| parsing_state.enabled?(line) }
       end
 
-      it { expect(parsing_state.enabled?("----\n")).to(eq(false)) }
-      it { expect(parsing_state.enabled?("....\n")).to(eq(true)) }
+      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
@@ -48,7 +48,7 @@ RSpec.describe(DefMastership::ParsingState) do
         ["....\n", "----\n", "whatever\n"].each { |line| parsing_state.enabled?(line) }
       end
 
-      it { expect(parsing_state.enabled?("....\n")).to(eq(true)) }
+      it { expect(parsing_state.enabled?("....\n")).to(be(true)) }
     end
 
     context 'with intricated disables starting with "////"' do
@@ -56,7 +56,7 @@ RSpec.describe(DefMastership::ParsingState) do
         ["////\n", "----\n", "whatever\n"].each { |line| parsing_state.enabled?(line) }
       end
 
-      it { expect(parsing_state.enabled?("////\n")).to(eq(true)) }
+      it { expect(parsing_state.enabled?("////\n")).to(be(true)) }
     end
   end
 end