defmastership 1.0.5 → 1.0.10

data/lib/defmastership/filters.rb

@@ -0,0 +1,30 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Contains regexp / action couples
+  Filter = Struct.new(:regexp, :event, :consumed_line)
+  private_constant :Filter
+
+  FILTERS_IN_LITERAL = [
+    Filter.new(DMRegexp::LITERAL_BLOCK, :code_block_delimiter, false),
+    Filter.new(DMRegexp::WHATEVER,      :new_line,             true)
+  ].freeze
+  private_constant :FILTERS_IN_LITERAL
+
+  FILTERS = [
+    Filter.new(DMRegexp::VARIABLE_DEF,  :new_variable_def,     false),
+    Filter.new(DMRegexp::VARIABLE_USE,  :new_variable_use,     false),
+    Filter.new(DMRegexp::DEFINITION,    :new_definition,       true),
+    Filter.new(DMRegexp::EREF_CONFIG,   :new_eref_setup,       true),
+    Filter.new(DMRegexp::EREF_DEF,      :new_eref_def,         false),
+    Filter.new(DMRegexp::IREF_DEF,      :new_iref_def,         false),
+    Filter.new(DMRegexp::ATTR_CONFIG,   :new_attribute_conf,   true),
+    Filter.new(DMRegexp::ATTR_SET,      :new_attribute_value,  false),
+    Filter.new(DMRegexp::BLOCK,         :block_delimiter,      true),
+    Filter.new(DMRegexp::LITERAL_BLOCK, :code_block_delimiter, true),
+    Filter.new(DMRegexp::EMPTY_LINE,    :empty_line,           false),
+    Filter.new(DMRegexp::WHATEVER,      :new_line,             true)
+  ].freeze
+  private_constant :FILTERS
+end

data/lib/defmastership/line_modifier_base.rb

@@ -0,0 +1,29 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Change references from temporary to definitive with multiple RefChangers
+  class LineModifierBase
+    attr_reader :changes, :config
+
+    def initialize
+      @config = {}
+      @changes = []
+    end
+
+    def method_missing(method_name, *args, &block)
+      return @config[method_name] if @config[method_name]
+
+      super
+    end
+
+    def respond_to_missing?(method_name, *args)
+      @config[method_name] || super
+    end
+
+    def from_config(config)
+      @config.merge!(config)
+      self
+    end
+  end
+end

data/lib/defmastership/modifier_base.rb

@@ -0,0 +1,29 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Change references from temporary to definitive with multiple RefChangers
+  class ModifierBase
+    attr_reader :config, :changes
+
+    def initialize(config)
+      @config = config
+      @changes = []
+    end
+
+    def do_modifications(adoc_texts)
+      line_modifier = new_line_modifier(@config, adoc_texts)
+
+      adoc_texts =
+        replacements.reduce(adoc_texts) do |texts, method|
+          texts.transform_values do |text|
+            text.lines.map { |line| line_modifier.public_send(method, line) }.join
+          end
+        end
+
+      @config = line_modifier.config
+      @changes = line_modifier.changes
+      adoc_texts
+    end
+  end
+end

data/lib/defmastership/rename_included_files_line_modifier.rb

@@ -0,0 +1,126 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Change included filenames on one line at a time
+  class RenameIncludedFilesLineModifier < LineModifierBase
+    LOCAL_FILTERS = [
+      Filter.new(DMRegexp::VARIABLE_DEF,  :new_variable_def,     false),
+      Filter.new(DMRegexp::DEFINITION,    :new_definition,       true),
+      Filter.new(DMRegexp::BLOCK,         :block_delimiter,      true),
+      Filter.new(DMRegexp::EMPTY_LINE,    :empty_line,           false),
+      Filter.new(DMRegexp::WHATEVER,      :new_line,             true)
+    ].freeze
+    private_constant :LOCAL_FILTERS
+
+    def self.from_config(config)
+      new.from_config(config)
+    end
+
+    def initialize
+      super
+      @config = {
+        from_regexp: '',
+        to_template: ''
+      }
+      @variables = {}
+      @definition_parser = DefinitionParser.new(self)
+    end
+
+    def replace(line)
+      match = matched?(line)
+
+      return line unless match
+
+      new_line =
+        line.gsub(complete_regexp_from(from_regexp)) do
+          text_with(match, to_template % hmerge(match))
+        end
+
+      rename_file(line, new_line)
+
+      new_line
+    end
+
+    def add_new_definition(match, _line)
+      @config[:reference] = match[:reference]
+    end
+
+    def add_line(_match, _line) end
+
+    def new_variable_def(match, line)
+      @variables[match[:varname].to_sym] = match[:value]
+      line
+    end
+
+    private
+
+    def matched?(line)
+      return if line.commented?
+
+      parse(line)
+
+      return if @definition_parser.idle?
+      return unless line =~ complete_regexp_from(from_regexp)
+
+      match = Regexp.last_match
+
+      return if @config[:cancel_if_match] && match[:filename] =~ Regexp.new(cancel_if_match)
+
+      match
+    end
+
+    def parse(line)
+      LOCAL_FILTERS.each do |filter|
+        next unless line.match(filter.regexp)
+
+        line = generate_event(filter.event, Regexp.last_match, line)
+
+        break if filter.consumed_line
+      end
+    end
+
+    def rename_file(from, to)
+      @changes << [extract_filename(from), extract_filename(to)]
+      File.rename(extract_filename(from), extract_filename(to))
+    end
+
+    def extract_filename(include_statement)
+      filename = include_statement
+                 .gsub(Regexp.new(DMRegexp::INCLUDE_KEYWORD), '')
+                 .gsub(Regexp.new(DMRegexp::INCLUDE_OPTIONS), '')
+
+      filename.dup.scan(DMRegexp::VARIABLE_USE) do |_|
+        varname = Regexp.last_match[:varname]
+        next if @variables[varname.to_sym].nil?
+
+        filename.gsub!("{#{varname}}", @variables[varname.to_sym])
+      end
+      filename
+    end
+
+    def complete_regexp_from(from)
+      Regexp.new(
+        DMRegexp::INCLUDE_KEYWORD + DMRegexp::INCLUDE_PATH +
+        "(?<filename>#{from})" + DMRegexp::INCLUDE_OPTIONS
+      )
+    end
+
+    def text_with(match, to)
+      "include::#{match[:path] || ''}#{to}[#{match[:options]}]"
+    end
+
+    def hmerge(match)
+      @config.merge(match.names.map(&:to_sym).zip(match.captures).to_h)
+    end
+
+    def generate_event(event, match, line)
+      if respond_to?(event)
+        public_send(event, match, line)
+      else
+        @definition_parser.public_send(event, match, line)
+      end
+      line
+    end
+  end
+end

data/lib/defmastership/rename_included_files_modifier.rb

@@ -0,0 +1,15 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Change included filenames
+  class RenameIncludedFilesModifier < ModifierBase
+    def replacements
+      %i[replace]
+    end
+
+    def new_line_modifier(config, _adoc_texts)
+      RenameIncludedFilesLineModifier.from_config(config)
+    end
+  end
+end

data/lib/defmastership/update_def_checksum_line_modifier.rb

@@ -0,0 +1,38 @@
+# 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_checksum_modifier.rb

@@ -0,0 +1,21 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Update definition checksum with calculated one
+  class UpdateDefChecksumModifier < ModifierBase
+    def replacements
+      %i[replace]
+    end
+
+    def new_line_modifier(config, adoc_texts)
+      document = Document.new
+      adoc_texts.each do |adoc_file, _|
+        document.parse_file_with_preprocessor(adoc_file)
+      end
+      line_modifier = UpdateDefChecksumLineModifier.from_config(config)
+      line_modifier.document = document
+      line_modifier
+    end
+  end
+end

data/lib/defmastership/update_def_version_line_modifier.rb

@@ -0,0 +1,58 @@
+# 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/lib/defmastership/update_def_version_modifier.rb

@@ -0,0 +1,25 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Update definition version if the definition has change since
+  # reference document
+  class UpdateDefVersionModifier < ModifierBase
+    def replacements
+      %i[replace]
+    end
+
+    def new_line_modifier(config, adoc_texts)
+      document = Document.new
+      adoc_texts.each do |adoc_file, _|
+        document.parse_file_with_preprocessor(adoc_file)
+      end
+      ref_document = Document.new
+      ref_document.parse_file_with_preprocessor(config[:ref_document])
+      line_modifier = UpdateDefVersionLineModifier.from_config(config)
+      line_modifier.document = document
+      line_modifier.ref_document = ref_document
+      line_modifier
+    end
+  end
+end

data/lib/defmastership/version.rb

@@ -2,6 +2,6 @@
 # frozen_string_literal: true
 
 module DefMastership
-  VERSION = '1.0.5'
+  VERSION = '1.0.10'
   public_constant :VERSION
 end

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@
 
 require('bundler/setup')
 require('aruba/rspec')
+require('aasm/rspec')
 
 # formatter = [SimpleCov::Formatter::HTMLFormatter]
 # SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(formatter)

data/spec/unit/defmastership/batch_modifier_spec.rb

@@ -0,0 +1,123 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership')
+
+module DefMastership
+  class TotoClassModifier < ModifierBase
+  end
+
+  class TutuClassModifier < ModifierBase
+  end
+end
+
+RSpec.describe(DefMastership::BatchModifier) do
+  subject(:batchmodifier) do
+    described_class.new(config, adoc_texts)
+  end
+
+  let(:config) do
+    {
+      modifier1: { type: 'toto_class', config: { p: 1 } },
+      modifier2: { type: 'toto_class', config: { p: 'whatever1' } },
+      modifier3: { type: 'tutu_class', config: { p1: 'whatever2', p2: 'whatever3' } }
+    }
+  end
+  let(:adoc_texts) do
+    {
+      'file1.adoc' => 'some text',
+      'file2.adoc' => 'another text'
+    }
+  end
+
+  describe '.new' do
+    it { is_expected.not_to(be(nil)) }
+    it { is_expected.to(have_attributes(config: config)) }
+
+    it do
+      expect(batchmodifier).to(have_attributes(adoc_texts: adoc_texts))
+    end
+  end
+
+  describe '#apply' do
+    context 'with only one modification' do
+      let(:toto1) { instance_double(DefMastership::TotoClassModifier, 'toto1') }
+      let(:adoc_texts_modified) do
+        {
+          'file1.adoc' => 'some text modified',
+          'file2.adoc' => 'another text'
+        }
+      end
+
+      let(:config_modified) do
+        {
+          modifier1: { type: 'toto_class', config: { p: 'modified_param' } },
+          modifier2: { type: 'toto_class', config: { p: 'whatever1' } },
+          modifier3: { type: 'tutu_class', config: { p1: 'whatever2', p2: 'whatever3' } }
+        }
+      end
+
+      before do
+        allow(DefMastership::TotoClassModifier).to(receive(:new).once.and_return(toto1))
+        allow(toto1).to(receive(:do_modifications).once.and_return(adoc_texts_modified))
+        allow(toto1).to(receive(:config).once.and_return(p: 'modified_param'))
+        allow(toto1).to(receive(:changes).once.and_return([%w[from1 to1], %w[from2 to2]]))
+        batchmodifier.apply('modifier1')
+      end
+
+      it do
+        expect(DefMastership::TotoClassModifier).to(have_received(:new).with(p: 1))
+      end
+
+      it { expect(toto1).to(have_received(:do_modifications).with(adoc_texts)) }
+      it { is_expected.to(have_attributes(adoc_texts: adoc_texts_modified)) }
+      it { expect(toto1).to(have_received(:config).with(no_args)) }
+
+      it { is_expected.to(have_attributes(config: config_modified)) }
+      it { is_expected.to(have_attributes(changes: [%w[modifier1 from1 to1], %w[modifier1 from2 to2]])) }
+    end
+
+    context 'with two modifications' do
+      let(:toto2) { instance_double(DefMastership::TotoClassModifier, 'toto2') }
+      let(:tutu3) { instance_double(DefMastership::TutuClassModifier, 'tutu3') }
+
+      let(:config_modified) do
+        {
+          modifier1: { type: 'toto_class', config: { p: 1 } },
+          modifier2: { type: 'toto_class', config: :whatever },
+          modifier3: { type: 'tutu_class', config: :pouet }
+        }
+      end
+
+      before do
+        allow(DefMastership::TotoClassModifier).to(receive(:new).once.and_return(toto2))
+        allow(toto2).to(receive(:do_modifications).once.and_return(:adoc_texts_modified_mod2))
+        allow(toto2).to(receive(:config).once.and_return(:whatever))
+        allow(DefMastership::TutuClassModifier).to(receive(:new).once.and_return(tutu3))
+        allow(tutu3).to(receive(:do_modifications).once.and_return(:adoc_texts_modified_mod3))
+        allow(tutu3).to(receive(:config).once.and_return(:pouet))
+        allow(toto2).to(receive(:changes).once.and_return([%w[from1 to1]]))
+        allow(tutu3).to(receive(:changes).once.and_return([%w[from2 to2]]))
+        batchmodifier.apply('modifier2, modifier3')
+      end
+
+      it { expect(DefMastership::TotoClassModifier).to(have_received(:new).with(p: 'whatever1')) }
+      it { expect(DefMastership::TutuClassModifier).to(have_received(:new).with(p1: 'whatever2', p2: 'whatever3')) }
+      it { expect(toto2).to(have_received(:do_modifications).with(adoc_texts)) }
+      it { expect(toto2).to(have_received(:config).with(no_args)) }
+      it { expect(tutu3).to(have_received(:do_modifications).with(:adoc_texts_modified_mod2)) }
+      it { expect(tutu3).to(have_received(:config).with(no_args)) }
+      it { is_expected.to(have_attributes(adoc_texts: :adoc_texts_modified_mod3)) }
+      it { is_expected.to(have_attributes(config: config_modified)) }
+      it { is_expected.to(have_attributes(changes: [%w[modifier2 from1 to1], %w[modifier3 from2 to2]])) }
+    end
+
+    context 'with wrong modification' do
+      it do
+        expect { batchmodifier.apply('wrong-modification') }.to(
+          raise_error(ArgumentError, 'wrong-modification is not a known modification')
+        )
+      end
+    end
+  end
+end