defmastership 1.3.2 → 1.3.3

data/spec/unit/defmastership/modifier/change_ref_spec.rb

@@ -12,6 +12,7 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
     it { is_expected.to(have_attributes(from_regexp: '')) }
     it { is_expected.to(have_attributes(to_template: '')) }
     it { is_expected.to(have_attributes(next_ref:    0)) }
+    it { is_expected.to(have_attributes(config: { def_type: '', from_regexp: '', to_template: '', next_ref: 0 })) }
   end
 
   describe '.replacement_methods' do
@@ -21,29 +22,13 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
     end
   end
 
-  describe '#config' do
-    context 'when not initalized' do
-      it do
-        expect(refchanger.config).to(
-          include(from_regexp: '', to_template: '', next_ref: 0)
-        )
-      end
-    end
-  end
-
   describe '#replace_refdef' do
     context 'when really simple rule' do
-      subject(:refchanger) do
-        described_class.new(
-          from_regexp: 'TEMP',
-          to_template: 'TUTU'
-        )
-      end
+      subject(:refchanger) { described_class.new(from_regexp: 'TEMP', to_template: 'TUTU') }
 
       context 'when valid definition' do
         it do
-          expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-            .to(eq('[define, whatever, TUTU]'))
+          expect(refchanger.replace_refdef('[define, whatever, TEMP]')).to(eq('[define, whatever, TUTU]'))
         end
 
         it do
@@ -56,32 +41,23 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
             .to(eq('[define, whatever, TUTU(~12345678)]'))
         end
 
-        it do
-          expect(refchanger.replace_refdef('[define, whatever, TEMP(a)]'))
-            .to(eq('[define, whatever, TUTU(a)]'))
-        end
+        it { expect(refchanger.replace_refdef('[define, whatever, TEMP(a)]')).to(eq('[define, whatever, TUTU(a)]')) }
       end
 
       context 'when no valid definition' do
         it do
-          expect(refchanger.replace_refdef('[pouet, whatever, TEMP]'))
-            .to(eq('[pouet, whatever, TEMP]'))
+          expect(refchanger.replace_refdef('[pouet, whatever, TEMP]')).to(eq('[pouet, whatever, TEMP]'))
         end
       end
     end
 
     context 'when template is variable' do
       subject(:refchanger) do
-        described_class.new(
-          from_regexp: 'TEMP',
-          to_template: 'TOTO-%<next_ref>04d',
-          next_ref: 124
-        )
+        described_class.new(from_regexp: 'TEMP', to_template: 'TOTO-%<next_ref>04d', next_ref: 124)
       end
 
       it do
-        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-          .to(eq('[define, whatever, TOTO-0124]'))
+        expect(refchanger.replace_refdef('[define, whatever, TEMP]')).to(eq('[define, whatever, TOTO-0124]'))
       end
 
       it do
@@ -99,15 +75,11 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
         )
       end
 
-      it do
-        expect(refchanger.replace_refdef('[define, whatever, TOTO-TEMP]'))
-          .to(eq('[define, whatever, TOTO-0132]'))
-      end
+      it { expect(refchanger.replace_refdef('[define, whatever, TOTO-TEMP]')).to(eq('[define, whatever, TOTO-0132]')) }
 
       it do
         refchanger.replace_refdef('[define, whatever, TOTO-TEMP]')
-        expect(refchanger.replace_refdef('[define, whatever, TITI-TEMP]'))
-          .to(eq('[define, whatever, TITI-0133]'))
+        expect(refchanger.replace_refdef('[define, whatever, TITI-TEMP]')).to(eq('[define, whatever, TITI-0133]'))
       end
 
       it do
@@ -118,29 +90,18 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
     end
 
     context 'when definition is in literal block' do
-      subject(:refchanger) do
-        described_class.new(
-          from_regexp: 'TEMP',
-          to_template: 'TUTU'
-        )
-      end
+      subject(:refchanger) { described_class.new(from_regexp: 'TEMP', to_template: 'TUTU') }
 
       before do
         refchanger.replace_refdef('....')
       end
 
-      it do
-        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-          .to(eq('[define, whatever, TEMP]'))
-      end
+      it { expect(refchanger.replace_refdef('[define, whatever, TEMP]')).to(eq('[define, whatever, TEMP]')) }
     end
 
-    context 'when defintion is after literal block' do
+    context 'when definition is after literal block' do
       subject(:refchanger) do
-        described_class.new(
-          from_regexp: 'TEMP',
-          to_template: 'TUTU'
-        )
+        described_class.new(from_regexp: 'TEMP', to_template: 'TUTU')
       end
 
       before do
@@ -149,10 +110,22 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
         refchanger.replace_refdef("....\n")
       end
 
-      it do
-        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-          .to(eq('[define, whatever, TUTU]'))
-      end
+      it { expect(refchanger.replace_refdef('[define, whatever, TEMP]')).to(eq('[define, whatever, TUTU]')) }
+    end
+
+    context 'when definition do no fit with a definition\'s type value' do
+      subject(:refchanger) { described_class.new(def_type: 'req', from_regexp: 'TEMP', to_template: 'TUTU') }
+
+      it { expect(refchanger.replace_refdef('[define, whatever, TEMP]')).to(eq('[define, whatever, TEMP]')) }
+      it { expect(refchanger.replace_refdef('[define, req, TEMP]')).to(eq('[define, req, TUTU]')) }
+    end
+
+    context 'when definition do no fit with a definition\'s type list' do
+      subject(:refchanger) { described_class.new(def_type: %w[req pouet], from_regexp: 'TEMP', to_template: 'TUTU') }
+
+      it { expect(refchanger.replace_refdef('[define, whatever, TEMP]')).to(eq('[define, whatever, TEMP]')) }
+      it { expect(refchanger.replace_refdef('[define, req, TEMP]')).to(eq('[define, req, TUTU]')) }
+      it { expect(refchanger.replace_refdef('[define, pouet, TEMP]')).to(eq('[define, pouet, TUTU]')) }
     end
   end
 
@@ -170,15 +143,8 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
       refchanger.replace_refdef('[define, whatever, TITI-TEMP421]')
     end
 
-    it do
-      expect(refchanger.replace_irefs('defs:iref[TOTO-TEMP1234]'))
-        .to(eq('defs:iref[TOTO-TEMP1234]'))
-    end
-
-    it do
-      expect(refchanger.replace_irefs('defs:iref[TOTO-TEMP123]'))
-        .to(eq('defs:iref[TOTO-0132]'))
-    end
+    it { expect(refchanger.replace_irefs('defs:iref[TOTO-TEMP1234]')).to(eq('defs:iref[TOTO-TEMP1234]')) }
+    it { expect(refchanger.replace_irefs('defs:iref[TOTO-TEMP123]')).to(eq('defs:iref[TOTO-0132]')) }
 
     it do
       expect(
@@ -225,8 +191,7 @@ RSpec.describe(Defmastership::Modifier::ChangeRef) do
       ['tag=!TITI-TEMP421;TOTO-TEMP123', 'tag=!TITI-0133;TOTO-0132']
     ].each do |from, to|
       it do
-        expect(refchanger.replace_include_tags("include::path/target[#{from}]"))
-          .to(eq("include::path/target[#{to}]"))
+        expect(refchanger.replace_include_tags("include::path/target[#{from}]")).to(eq("include::path/target[#{to}]"))
       end
     end
 
@@ -297,9 +262,7 @@ MIF
     it { expect(File).to(have_received(:readlines).with('path/target')) }
 
     it do
-      expect(File).to(
-        have_received(:writelines).with('path/target', mofified_included_file.split)
-      )
+      expect(File).to(have_received(:writelines).with('path/target', mofified_included_file.split))
     end
 
     it { expect(File).not_to(have_received(:readlines).with('otherpath/othertarget')) }

data/spec/unit/defmastership/modifier/factory_spec.rb

@@ -14,32 +14,55 @@ module Defmastership
     class TuTu
       include ModifierCommon
     end
+
+    # Modifier example
+    class Nono
+      include ModifierCommon
+    end
   end
 end
 
 RSpec.describe(Defmastership::Modifier::Factory) do
   describe('.from_config') do
-    let(:toto)        { instance_double(Defmastership::Modifier::Toto, 'toto') }
-    let(:toto_config) { { type: 'toto', config: { p: 'whatever' } }            }
-    let(:tutu)        { instance_double(Defmastership::Modifier::TuTu, 'tutu') }
-    let(:tutu_config) { { type: 'tu_tu', config: { p: 'whatever' } }           }
-
-    before do
-      allow(Defmastership::Modifier::Toto).to(receive(:new).with(toto_config[:config]).and_return(toto))
-      allow(Defmastership::Modifier::TuTu).to(receive(:new).with(tutu_config[:config]).and_return(tutu))
-    end
+    context 'when :config is not empty' do
+      let(:toto)        { instance_double(Defmastership::Modifier::Toto, 'toto') }
+      let(:toto_config) { { type: 'toto', config: { p: 'whatever' } }            }
+      let(:tutu)        { instance_double(Defmastership::Modifier::TuTu, 'tutu') }
+      let(:tutu_config) { { type: 'tu_tu', config: { p: 'whatever' } }           }
 
-    it { expect(described_class.from_config(toto_config)).to(be(toto)) }
-    it { expect(described_class.from_config(tutu_config)).to(be(tutu)) }
+      before do
+        allow(Defmastership::Modifier::Toto).to(receive(:new).and_return(toto))
+        allow(Defmastership::Modifier::TuTu).to(receive(:new).and_return(tutu))
+      end
 
-    it do
-      described_class.from_config(toto_config)
-      expect(Defmastership::Modifier::Toto).to(have_received(:new).with(toto_config[:config]))
+      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::Modifier::Toto).to(have_received(:new).with(toto_config[:config]))
+      end
+
+      it do
+        described_class.from_config(tutu_config)
+        expect(Defmastership::Modifier::TuTu).to(have_received(:new).with(tutu_config[:config]))
+      end
     end
 
-    it do
-      described_class.from_config(tutu_config)
-      expect(Defmastership::Modifier::TuTu).to(have_received(:new).with(tutu_config[:config]))
+    context 'when :config is empty' do
+      let(:nono)        { instance_double(Defmastership::Modifier::Nono, 'nono') }
+      let(:nono_config) { { type: 'nono' }                                       }
+
+      before do
+        allow(Defmastership::Modifier::Nono).to(receive(:new).and_return(nono))
+      end
+
+      it { expect(described_class.from_config(nono_config)).to(be(nono)) }
+
+      it do
+        described_class.from_config(nono_config)
+        expect(Defmastership::Modifier::Nono).to(have_received(:new).with({}))
+      end
     end
   end
 end

data/spec/unit/defmastership/modifier/modifier_common_spec.rb

@@ -1,6 +1,8 @@
 # Copyright (c) 2023 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require('defmastership/modifier/modifier_common')
+
 # just a class for test
 class DummyClassParent
   # This method smells of :reek:ControlParameter

data/spec/unit/defmastership/modifier/rename_included_files_spec.rb

@@ -24,12 +24,7 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
 
   describe '#replace' do
     context 'when NOT valid include' do
-      subject(:includeschanger) do
-        described_class.new(
-          from_regexp: 'orig',
-          to_template: 'dest'
-        )
-      end
+      subject(:includeschanger) { described_class.new(from_regexp: 'orig', to_template: 'dest') }
 
       before do
         allow(File).to(receive(:rename))
@@ -42,10 +37,7 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
           end
         end
 
-        it do
-          expect(includeschanger.replace('badinclude::orig[]'))
-            .to(eq('badinclude::orig[]'))
-        end
+        it { expect(includeschanger.replace('badinclude::orig[]')).to(eq('badinclude::orig[]')) }
 
         it do
           includeschanger.replace('badinclude::orig[]')
@@ -60,10 +52,7 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
           end
         end
 
-        it do
-          expect(includeschanger.replace('include::orig[]'))
-            .to(eq('include::orig[]'))
-        end
+        it { expect(includeschanger.replace('include::orig[]')).to(eq('include::orig[]')) }
 
         it do
           includeschanger.replace('include::orig[]')
@@ -77,19 +66,12 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
           includeschanger.replace('--')
         end
 
-        it do
-          expect(includeschanger.replace('// include::orig[]'))
-            .to(eq('// include::orig[]'))
-        end
+        it { expect(includeschanger.replace('// include::orig[]')).to(eq('// include::orig[]')) }
       end
 
       context 'when the cancel regexp is met' do
         subject(:includeschanger) do
-          described_class.new(
-            from_regexp: 'orig',
-            cancel_if_match: 'orig',
-            to_template: 'dest'
-          )
+          described_class.new(from_regexp: 'orig', cancel_if_match: 'orig', to_template: 'dest')
         end
 
         before do
@@ -97,10 +79,7 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
           includeschanger.replace('--')
         end
 
-        it do
-          expect(includeschanger.replace("include::orig[]\n"))
-            .to(eq("include::orig[]\n"))
-        end
+        it { expect(includeschanger.replace("include::orig[]\n")).to(eq("include::orig[]\n")) }
       end
     end
 
@@ -111,11 +90,7 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
 
       context 'when really simple rule' do
         subject(:includeschanger) do
-          described_class.new(
-            from_regexp: 'orig',
-            cancel_if_match: '_no_cancel_',
-            to_template: 'dest'
-          )
+          described_class.new(from_regexp: 'orig', cancel_if_match: '_no_cancel_', to_template: 'dest')
         end
 
         before do
@@ -166,10 +141,7 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
 
       context 'when complex from_regexp' do
         subject(:includeschanger) do
-          described_class.new(
-            from_regexp: '(?<origin>.*\.extension)',
-            to_template: '%<reference>s_%<origin>s'
-          )
+          described_class.new(from_regexp: '(?<origin>.*\.extension)', to_template: '%<reference>s_%<origin>s')
         end
 
         before do
@@ -194,12 +166,7 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
       end
 
       context 'when path with variable' do
-        subject(:includeschanger) do
-          described_class.new(
-            from_regexp: 'orig',
-            to_template: 'dest'
-          )
-        end
+        subject(:includeschanger) { described_class.new(from_regexp: 'orig', to_template: 'dest') }
 
         before do
           includeschanger.replace(':any: one')
@@ -209,10 +176,7 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
           includeschanger.replace('--')
         end
 
-        it do
-          expect(includeschanger.replace('include::{any}/orig[]'))
-            .to(eq('include::{any}/dest[]'))
-        end
+        it { expect(includeschanger.replace('include::{any}/orig[]')).to(eq('include::{any}/dest[]')) }
 
         it do
           includeschanger.replace('include::{any}{var}/orig[]')
@@ -234,6 +198,58 @@ RSpec.describe(Defmastership::Modifier::RenameIncludedFiles) do
           expect(includeschanger).to(have_attributes(changes: [%w[one_two/orig one_two/dest]]))
         end
       end
+
+      context 'when definition\'s type does not fit a value' do
+        subject(:includeschanger) do
+          described_class.new(def_type: 'requirement', from_regexp: 'orig', to_template: 'dest')
+        end
+
+        it do
+          includeschanger.replace('[define,whatever,REFERENCE]')
+          includeschanger.replace('--')
+          expect(includeschanger.replace("include::orig[]\n"))
+            .to(eq("include::orig[]\n"))
+        end
+
+        it do
+          includeschanger.replace('[define,requirement,REFERENCE]')
+          includeschanger.replace('--')
+          expect(includeschanger.replace("include::orig[]\n"))
+            .to(eq("include::dest[]\n"))
+        end
+      end
+
+      context 'when definition\'s type is not included in a list' do
+        subject(:includeschanger) do
+          described_class.new(def_type: %w[requirement pouet], from_regexp: 'orig', to_template: 'dest')
+        end
+
+        it do
+          expect(includeschanger.replace("include::orig[]\n"))
+            .to(eq("include::orig[]\n"))
+        end
+
+        it do
+          includeschanger.replace('[define,whatever,REFERENCE]')
+          includeschanger.replace('--')
+          expect(includeschanger.replace("include::orig[]\n"))
+            .to(eq("include::orig[]\n"))
+        end
+
+        it do
+          includeschanger.replace('[define,requirement,REFERENCE]')
+          includeschanger.replace('--')
+          expect(includeschanger.replace("include::orig[]\n"))
+            .to(eq("include::dest[]\n"))
+        end
+
+        it do
+          includeschanger.replace('[define,pouet,REFERENCE]')
+          includeschanger.replace('--')
+          expect(includeschanger.replace("include::orig[]\n"))
+            .to(eq("include::dest[]\n"))
+        end
+      end
     end
   end
 end

data/spec/unit/defmastership/modifier/update_def_checksum_spec.rb

@@ -55,11 +55,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefChecksum) do
   end
 
   describe '#replace' do
-    subject(:modifier) do
-      described_class.new(
-        def_type: 'requirement'
-      )
-    end
+    subject(:modifier) { described_class.new(def_type: 'requirement') }
 
     let(:definition)  { instance_double(Defmastership::Definition, 'definition') }
     let(:document)    { instance_double(Defmastership::Document, 'document')     }
@@ -70,10 +66,7 @@ RSpec.describe(Defmastership::Modifier::UpdateDefChecksum) do
     end
 
     context 'when definition has not the good type' do
-      it do
-        expect(modifier.replace_reference('[define,req,REFERENCE]'))
-          .to(eq('[define,req,REFERENCE]'))
-      end
+      it { expect(modifier.replace_reference('[define,req,REFERENCE]')).to(eq('[define,req,REFERENCE]')) }
     end
 
     context 'when definition has the good type' do

data/spec/unit/defmastership/modifier/update_def_spec.rb

@@ -1,6 +1,8 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require('defmastership/modifier/update_def')
+
 module Defmastership
   module Modifier
     # Just a class for tests
@@ -60,19 +62,10 @@ RSpec.describe(Defmastership::Modifier::UpdateDef) do
       )
     end
 
-    it do
-      expect(modifier.do_modifications(adoc_sources).fetch('file1.adoc'))
-        .to(include('REFERENCE_something_'))
-    end
+    it { expect(modifier.do_modifications(adoc_sources).fetch('file1.adoc')).to(include('REFERENCE_something_')) }
   end
 
   describe '#replace_reference' do
-    subject(:modifier) do
-      Defmastership::Modifier::ConcreteRef.new(
-        def_type: 'requirement'
-      )
-    end
-
     let(:definition)  { instance_double(Defmastership::Definition, 'definition') }
     let(:document)    { instance_double(Defmastership::Document, 'document')     }
     let(:definitions) { { 'REFERENCE' => definition }                            }
@@ -81,21 +74,45 @@ RSpec.describe(Defmastership::Modifier::UpdateDef) do
       allow(File).to(receive(:rename))
     end
 
-    context 'when line do not match' do
+    context 'when def_type is not specified' do
+      subject(:modifier) do
+        Defmastership::Modifier::ConcreteRef.new(def_type: '')
+      end
+
+      before do
+        allow(Defmastership::Document).to(receive(:new).and_return(document))
+        allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+        allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+      end
+
       it do
-        expect(modifier.replace_reference('[define---,req,REFERENCE(abcd)]'))
-          .to(eq('[define---,req,REFERENCE(abcd)]'))
+        expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd)]'))
+          .to(eq('[define,requirement,REFERENCE_something_abcd]'))
       end
     end
 
-    context 'when definition has not the good type' do
+    context 'when def_type is \'all\'' do
+      subject(:modifier) do
+        Defmastership::Modifier::ConcreteRef.new(def_type: 'all')
+      end
+
+      before do
+        allow(Defmastership::Document).to(receive(:new).and_return(document))
+        allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+        allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+      end
+
       it do
-        expect(modifier.replace_reference('[define,req,REFERENCE(abcd)]'))
-          .to(eq('[define,req,REFERENCE(abcd)]'))
+        expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd)]'))
+          .to(eq('[define,requirement,REFERENCE_something_abcd]'))
       end
     end
 
-    context 'when definition has the good type' do
+    context 'when def_type is a list' do
+      subject(:modifier) do
+        Defmastership::Modifier::ConcreteRef.new(def_type: %w[requirement pouet])
+      end
+
       before do
         allow(Defmastership::Document).to(receive(:new).and_return(document))
         allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
@@ -108,13 +125,51 @@ RSpec.describe(Defmastership::Modifier::UpdateDef) do
       end
 
       it do
-        expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd~bad)]'))
-          .to(eq('[define,requirement,REFERENCE_something_abcd]'))
+        expect(modifier.replace_reference('[define,pouet,REFERENCE(abcd)]'))
+          .to(eq('[define,pouet,REFERENCE_something_abcd]'))
       end
 
       it do
-        expect(modifier.replace_reference('// [define,requirement,REFERENCE(abcd~bad)]'))
-          .to(eq('// [define,requirement,REFERENCE(abcd~bad)]'))
+        expect(modifier.replace_reference('[define,whatever,REFERENCE(abcd)]'))
+          .to(eq('[define,whatever,REFERENCE(abcd)]'))
+      end
+    end
+
+    context 'when modifier is specific' do
+      subject(:modifier) { Defmastership::Modifier::ConcreteRef.new(def_type: 'requirement') }
+
+      context 'when line do not match' do
+        it do
+          expect(modifier.replace_reference('[define---,req,REFERENCE(abcd)]'))
+            .to(eq('[define---,req,REFERENCE(abcd)]'))
+        end
+      end
+
+      context 'when definition has not the good type' do
+        it { expect(modifier.replace_reference('[define,req,REFERENCE(abcd)]')).to(eq('[define,req,REFERENCE(abcd)]')) }
+      end
+
+      context 'when definition has the good type' do
+        before do
+          allow(Defmastership::Document).to(receive(:new).and_return(document))
+          allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+          allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+        end
+
+        it do
+          expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd)]'))
+            .to(eq('[define,requirement,REFERENCE_something_abcd]'))
+        end
+
+        it do
+          expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd~bad)]'))
+            .to(eq('[define,requirement,REFERENCE_something_abcd]'))
+        end
+
+        it do
+          expect(modifier.replace_reference('// [define,requirement,REFERENCE(abcd~bad)]'))
+            .to(eq('// [define,requirement,REFERENCE(abcd~bad)]'))
+        end
       end
     end
   end