defmastership 1.0.17 → 1.0.19

data/lib/defmastership/update_def_checksum_line_modifier.rb

@@ -1,38 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-module DefMastership
-  # modify one line after another
-  class UpdateDefChecksumLineModifier < LineModifierBase
-    attr_accessor :document
-
-    def self.from_config(hash)
-      new.from_config(hash)
-    end
-
-    def initialize
-      super
-      @config = {
-        def_type: ''
-      }
-    end
-
-    def replace(line)
-      match = matched?(line)
-
-      return line unless match
-      return line unless match[:type] == def_type
-
-      line.gsub(Regexp.new("#{match[:reference]}#{DMRegexp::DEF_VERSION_AND_CHECKSUM}")) do
-        "#{match[:reference]}(#{match[:explicit_version]}#{@document.ref_to_def(match[:reference]).sha256})"
-      end
-    end
-
-    def matched?(line)
-      return if line.commented?
-      return unless line =~ DMRegexp::DEFINITION
-
-      Regexp.last_match
-    end
-  end
-end

data/lib/defmastership/update_def_version_line_modifier.rb

@@ -1,58 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-module DefMastership
-  # modify one line after another
-  class UpdateDefVersionLineModifier < LineModifierBase
-    attr_accessor :document, :ref_document
-
-    def self.from_config(hash)
-      new.from_config(hash)
-    end
-
-    def initialize
-      super
-      @config = {
-        def_type: '',
-        ref_document: '',
-        first_version: ''
-      }
-    end
-
-    def replace(line)
-      match = matched?(line)
-
-      return line unless match
-      return line unless match[:type] == def_type
-
-      version_and_checksum = ''
-      if match[:explicit_checksum] || version_string(match)
-        version_and_checksum = "(#{version_string(match)}#{match[:explicit_checksum]})"
-      end
-
-      line.gsub(Regexp.new("#{match[:reference]}#{DMRegexp::DEF_VERSION_AND_CHECKSUM}")) do
-        "#{match[:reference]}#{version_and_checksum}"
-      end
-    end
-
-    private
-
-    def matched?(line)
-      return if line.commented?
-      return unless line =~ DMRegexp::DEFINITION
-
-      Regexp.last_match
-    end
-
-    def version_string(match)
-      ref_definition = @ref_document.ref_to_def(match[:reference])
-      definition = @document.ref_to_def(match[:reference])
-
-      return if ref_definition.nil?
-      return ref_definition.explicit_version if definition.sha256 == ref_definition.sha256
-
-      ref_version = @ref_document.ref_to_def(match[:reference]).explicit_version
-      ref_version.nil? ? @config[:first_version] : ref_version.next
-    end
-  end
-end

data/spec/unit/def_mastership/change_ref_line_modifier_spec.rb

@@ -1,250 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require('defmastership')
-
-RSpec.describe(DefMastership::ChangeRefLineModifier) do
-  subject(:refchanger) { described_class.new }
-
-  describe '.new' do
-    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(next_ref:    0)) }
-    it { is_expected.to(have_attributes(changes:     [])) }
-
-    it do
-      expect { refchanger.user_defined_attribute }
-        .to(raise_error(NoMethodError))
-    end
-  end
-
-  describe '.from_config' do
-    subject(:refchanger) do
-      described_class.from_config(
-        from_regexp: 'Whatever.+',
-        to_template: 'Whatever',
-        next_ref: 17
-      )
-    end
-
-    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')) }
-    it { is_expected.to(have_attributes(next_ref:    17)) }
-  end
-
-  describe '#from_config' do
-    before do
-      refchanger.from_config(
-        from_regexp: 'Whatever.+',
-        to_template: 'Whatever',
-        next_ref: 17,
-        user_defined_attribute: 'Tadaam'
-      )
-    end
-
-    it { is_expected.to(have_attributes(from_regexp: 'Whatever.+')) }
-    it { is_expected.to(have_attributes(to_template: 'Whatever')) }
-    it { is_expected.to(have_attributes(next_ref:    17)) }
-    it { is_expected.to(have_attributes(user_defined_attribute: 'Tadaam')) }
-  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
-
-    context 'when initalized with additionnal keys' do
-      before do
-        refchanger.from_config(
-          next_ref: 1256,
-          user_defined_attribute: 'Tadaam'
-        )
-      end
-
-      it { expect(refchanger.config).to(include(from_regexp: '')) }
-      it { expect(refchanger.config).to(include(to_template: '')) }
-      it { expect(refchanger.config).to(include(next_ref: 1256)) }
-      it { expect(refchanger.config).to(include(user_defined_attribute: 'Tadaam')) }
-    end
-  end
-
-  describe '#replace_def' do
-    context 'when really simple rule' do
-      before do
-        refchanger.from_config(
-          from_regexp: 'TEMP',
-          to_template: 'TUTU'
-        )
-      end
-
-      context 'when valid definition' do
-        it do
-          expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-            .to(eq('[define, whatever, TUTU]'))
-        end
-      end
-
-      context 'when no valid definition' do
-        it do
-          expect(refchanger.replace_refdef('[pouet, whatever, TEMP]'))
-            .to(eq('[pouet, whatever, TEMP]'))
-        end
-      end
-    end
-
-    context 'when template is variable' do
-      before do
-        refchanger.from_config(
-          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]'))
-      end
-
-      it do
-        refchanger.replace_refdef('[define, whatever, TEMP]')
-        expect(refchanger).to(have_attributes(next_ref: 125))
-      end
-    end
-
-    context 'when capture group in regexp' do
-      before do
-        refchanger.from_config(
-          from_regexp: '(?<cg>TOTO|TITI)-TEMP[\d]*',
-          to_template: '%<cg>s-%<next_ref>04d',
-          next_ref: 132
-        )
-      end
-
-      it do
-        expect(refchanger.replace_refdef('[define, whatever, TOTO-TEMP]'))
-          .to(eq('[define, whatever, TOTO-0132]'))
-      end
-
-      it do
-        refchanger.replace_refdef('[define, whatever, TOTO-TEMP]')
-        expect(refchanger.replace_refdef('[define, whatever, TITI-TEMP]'))
-          .to(eq('[define, whatever, TITI-0133]'))
-      end
-
-      it do
-        refchanger.replace_refdef('[define, whatever, TOTO-TEMP1]')
-        refchanger.replace_refdef('[define, whatever, TITI-TEMP2]')
-        expect(refchanger).to(have_attributes(changes: [%w[TOTO-TEMP1 TOTO-0132], %w[TITI-TEMP2 TITI-0133]]))
-      end
-    end
-
-    context 'when definition is in literal block' do
-      before do
-        refchanger.from_config(
-          from_regexp: 'TEMP',
-          to_template: 'TUTU'
-        )
-        refchanger.replace_refdef('....')
-      end
-
-      it do
-        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-          .to(eq('[define, whatever, TEMP]'))
-      end
-    end
-
-    context 'when defintion is after literal block' do
-      before do
-        refchanger.from_config(
-          from_regexp: 'TEMP',
-          to_template: 'TUTU'
-        )
-        refchanger.replace_refdef("....\n")
-        refchanger.replace_refdef('[define, whatever, TEMP]')
-        refchanger.replace_refdef("....\n")
-      end
-
-      it do
-        expect(refchanger.replace_refdef('[define, whatever, TEMP]'))
-          .to(eq('[define, whatever, TUTU]'))
-      end
-    end
-  end
-
-  describe '#replace_irefs' do
-    before do
-      refchanger.from_config(
-        from_regexp: '(?<cg>TOTO|TITI)-TEMP[\d]*',
-        to_template: '%<cg>s-%<next_ref>04d',
-        next_ref: 132
-      )
-      refchanger.replace_refdef('[define, whatever, TOTO-TEMP123]')
-      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 do
-      expect(
-        refchanger.replace_irefs(
-          'defs:iref[TOTO-TEMP123] defs:iref[TITI-TEMP421] bla'
-        )
-      ).to(eq('defs:iref[TOTO-0132] defs:iref[TITI-0133] bla'))
-    end
-  end
-
-  describe '#replace' do
-    before do
-      refchanger.from_config(
-        from_regexp: 'TEMP',
-        to_template: 'TUTU'
-      )
-    end
-
-    it do
-      expect(refchanger.replace(:refdef, '[define, whatever, TEMP]'))
-        .to(eq('[define, whatever, TUTU]'))
-    end
-
-    it do
-      expect(refchanger.replace(:refdef, '[define, whatever, TEMP(a~12345678)]'))
-        .to(eq('[define, whatever, TUTU(a~12345678)]'))
-    end
-
-    it do
-      expect(refchanger.replace(:refdef, '[define, whatever, TEMP(~12345678)]'))
-        .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 do
-      refchanger.replace(:refdef, '[define, whatever, TEMP]')
-      expect(refchanger.replace(:irefs, 'defs:iref[TEMP]'))
-        .to(eq('defs:iref[TUTU]'))
-    end
-
-    it do
-      expect { refchanger.replace(:pouet, 'whatever') }
-        .to(raise_error(NoMethodError))
-    end
-  end
-end

data/spec/unit/def_mastership/rename_included_files_line_modifier_spec.rb

@@ -1,207 +0,0 @@
-# Copyright (c) 2021 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require('defmastership')
-
-RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
-  subject(:includeschanger) { described_class.new }
-
-  describe '.new' do
-    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 do
-      expect { includeschanger.user_defined_attribute }
-        .to(raise_error(NoMethodError))
-    end
-  end
-
-  describe '.from_config' do
-    subject(:includeschanger) do
-      described_class.from_config(
-        from_regexp: 'Whatever.+',
-        to_template: 'Whatever'
-      )
-    end
-
-    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
-
-  describe '#replace' do
-    context 'when NOT valid include' do
-      before do
-        includeschanger.from_config(
-          from_regexp: 'orig',
-          cancel_if_match: 'REF',
-          to_template: 'dest'
-        )
-        allow(File).to(receive(:rename))
-      end
-
-      context 'when the include statement do not match' do
-        before do
-          ['[define,requirement,REFERENCE]', '--'].each do |line|
-            includeschanger.replace(line)
-          end
-        end
-
-        it do
-          expect(includeschanger.replace('badinclude::orig[]'))
-            .to(eq('badinclude::orig[]'))
-        end
-
-        it do
-          includeschanger.replace('badinclude::orig[]')
-          expect(includeschanger).to(have_attributes(changes: []))
-        end
-      end
-
-      context 'when the include is not in a definition' do
-        before do
-          ['[define,requirement,REFERENCE]', '--', 'text', '--'].each do |line|
-            includeschanger.replace(line)
-          end
-        end
-
-        it do
-          expect(includeschanger.replace('include::orig[]'))
-            .to(eq('include::orig[]'))
-        end
-
-        it do
-          includeschanger.replace('include::orig[]')
-          expect(includeschanger).to(have_attributes(changes: []))
-        end
-      end
-
-      context 'when the cancel regexp is met' do
-        before do
-          ['[define,requirement,REFERENCE]', '--'].each do |line|
-            includeschanger.replace(line)
-          end
-        end
-
-        it do
-          expect(includeschanger.replace('include::REFERENCE_orig[]'))
-            .to(eq('include::REFERENCE_orig[]'))
-        end
-
-        it do
-          includeschanger.replace('include::REFERENCE_orig[]')
-          expect(includeschanger).to(have_attributes(changes: []))
-        end
-      end
-    end
-
-    context 'when valid include' do
-      before do
-        allow(File).to(receive(:rename))
-      end
-
-      context 'when really simple rule' do
-        before do
-          includeschanger.from_config(
-            from_regexp: 'orig',
-            cancel_if_match: 'REF',
-            to_template: 'dest'
-          )
-          includeschanger.replace('[define,requirement,REFERENCE]')
-          includeschanger.replace('--')
-        end
-
-        it do
-          expect(includeschanger.replace("include::orig[]\n"))
-            .to(eq("include::dest[]\n"))
-        end
-
-        it do
-          includeschanger.replace("include::orig[]\n")
-          expect(File).to(have_received(:rename).with('orig', 'dest'))
-        end
-
-        it do
-          includeschanger.replace("include::orig[]\n")
-          expect(includeschanger).to(have_attributes(changes: [%w[orig dest]]))
-        end
-
-        it do
-          expect(includeschanger.replace("include::toto/orig[]\n"))
-            .to(eq("include::toto/dest[]\n"))
-        end
-
-        it do
-          includeschanger.replace("include::toto/orig[]\n")
-          expect(File).to(have_received(:rename).with('toto/orig', 'toto/dest'))
-        end
-
-        it do
-          includeschanger.replace("include::toto/orig[]\n")
-          expect(includeschanger).to(have_attributes(changes: [%w[toto/orig toto/dest]]))
-        end
-      end
-
-      context 'when complex from_regexp' do
-        before do
-          includeschanger.from_config(
-            from_regexp: '(?<origin>.*\.extension)',
-            to_template: '%<reference>s_%<origin>s'
-          )
-          includeschanger.replace('[define,requirement,REF]')
-        end
-
-        it do
-          expect(includeschanger.replace('include::any_path/one_file.extension[]'))
-            .to(eq('include::any_path/REF_one_file.extension[]'))
-        end
-
-        it do
-          includeschanger.replace('include::any_path/one_file.extension[]')
-          expect(File).to(have_received(:rename).with('any_path/one_file.extension', 'any_path/REF_one_file.extension'))
-        end
-
-        it do
-          changes = [%w[any_path/one_file.extension any_path/REF_one_file.extension]]
-          includeschanger.replace('include::any_path/one_file.extension[]')
-          expect(includeschanger).to(have_attributes(changes: changes))
-        end
-      end
-
-      context 'when path with variable' do
-        before do
-          includeschanger.from_config(
-            from_regexp: 'orig',
-            to_template: 'dest'
-          )
-          includeschanger.replace(':any: one')
-          includeschanger.replace(':path: two')
-          includeschanger.replace('[define,requirement,REFERENCE]')
-          includeschanger.replace('--')
-        end
-
-        it do
-          expect(includeschanger.replace('include::{any}/orig[]'))
-            .to(eq('include::{any}/dest[]'))
-        end
-
-        it do
-          includeschanger.replace('include::{any}/orig[]')
-          expect(File).to(have_received(:rename).with('one/orig', 'one/dest'))
-        end
-
-        it do
-          includeschanger.replace('include::{any}_{path}/orig[]')
-          expect(File).to(have_received(:rename).with('one_two/orig', 'one_two/dest'))
-        end
-
-        it do
-          includeschanger.replace('include::{any}_{path}/orig[]')
-          expect(includeschanger).to(have_attributes(changes: [%w[one_two/orig one_two/dest]]))
-        end
-      end
-    end
-  end
-end

data/spec/unit/def_mastership/update_def_checksum_line_modifier_spec.rb

@@ -1,82 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require('defmastership')
-
-RSpec.describe(DefMastership::UpdateDefChecksumLineModifier) do
-  subject(:linemodifier) { described_class.new }
-
-  describe '.new' do
-    it { is_expected.not_to(be_nil) }
-    it { is_expected.to(have_attributes(def_type: '')) }
-    it { is_expected.to(have_attributes(changes:  [])) }
-
-    it do
-      expect { linemodifier.user_defined_attribute }
-        .to(raise_error(NoMethodError))
-    end
-  end
-
-  describe '.from_config' do
-    subject(:linemodifier) do
-      described_class.from_config(
-        def_type: 'requirement'
-      )
-    end
-
-    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
-
-  describe '#replace' do
-    subject(:linemodifier) do
-      described_class.from_config(
-        def_type: 'requirement'
-      )
-    end
-
-    let(:definition)  { instance_double(DefMastership::Definition, 'definition') }
-    let(:document)    { instance_double(DefMastership::Document, 'document')     }
-    let(:definitions) { { 'REFERENCE' => definition }                            }
-
-    before do
-      linemodifier.document = document
-      allow(File).to(receive(:rename))
-    end
-
-    context 'when definition has not the good type' do
-      it do
-        expect(linemodifier.replace('[define,req,REFERENCE]'))
-          .to(eq('[define,req,REFERENCE]'))
-      end
-    end
-
-    context 'when definition has the good type' do
-      before do
-        allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
-        allow(definition).to(receive(:sha256).and_return('~abcd1234'))
-      end
-
-      it do
-        expect(linemodifier.replace('[define,requirement,REFERENCE]'))
-          .to(eq('[define,requirement,REFERENCE(~abcd1234)]'))
-      end
-
-      it do
-        expect(linemodifier.replace('[define,requirement,REFERENCE(~bad)]'))
-          .to(eq('[define,requirement,REFERENCE(~abcd1234)]'))
-      end
-
-      it do
-        expect(linemodifier.replace('[define,requirement,REFERENCE(toto~bad)]'))
-          .to(eq('[define,requirement,REFERENCE(toto~abcd1234)]'))
-      end
-
-      it do
-        expect(linemodifier.replace('[define,requirement,REFERENCE(toto)]'))
-          .to(eq('[define,requirement,REFERENCE(toto~abcd1234)]'))
-      end
-    end
-  end
-end