defmastership 1.0.9 → 1.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9dd61d32bacab380bbfc110df15fd6617b38540aa5bc8eb14bd5b2736e657b7c
-  data.tar.gz: 1ec7bc921411173863b71ba0c3f4164829ac2efbe0689c321830f632a3333f64
+  metadata.gz: 942362543576801349518b2d73e49abb5cfb076b246df05a7e28fe86814b506e
+  data.tar.gz: 1a351eadc8b3583df8f31b590225a4b8e5207d7db089b3a62ac644f03fa02c08
 SHA512:
-  metadata.gz: e8dcebcb309fd755a339ab702f7c07c65387e5a961400518661d70e9421911630652855a10ad647ac6155b9686665927fde8315a8efb71e3a2913a8db32fbcd5
-  data.tar.gz: 83e28e54b372de48cc554b8f532e659817453e905f3c6634071b3e280f23fba2431119353af9bdd6b23b97a6d6bf8a2b9a261b39e70591f27be45a3b04dce19b
+  metadata.gz: 6151951967b1d4b0e2108b2b11f101045780d6ec3f8ba4505078dbb1c240f2795bd56cce0f177187c58b2d8dacd3d63c1cfce6ca8969cb5f54d972d32d61e42b
+  data.tar.gz: 6836a23ffae998a9a1b54716941b0e9bb661e81f18a4422ad984af1ee41218b685ba937c108298f8a02cf348af434ddd1138f81c5644017193c5d72d6ad2cbdd

data/.rubocop.yml

@@ -62,3 +62,7 @@ RSpec/FilePath :
 
 RSpec/NestedGroups:
   Max: 4
+
+Layout/RedundantLineBreak:
+  Enabled: false
+  

data/defmastership.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('rake', '~> 13')
   s.add_development_dependency('rdoc', '~> 6')
   s.add_development_dependency('rspec', '~> 3')
-  s.add_development_dependency('rubocop', '~> 1.3')
+  s.add_development_dependency('rubocop', '1.13')
   s.add_development_dependency('rubocop-rake', '~> 0.5')
   s.add_development_dependency('rubocop-rspec', '~> 2.0')
   s.add_development_dependency('simplecov', '~> 0')

data/features/changeref.feature

@@ -36,6 +36,39 @@ Feature: The changeref command
     [define, requirement, TOTO-0123]
     """
 
+  Scenario: Change a definition with explicit checksum and version
+    Given a file named "modifications.yml" with:
+    """
+    ---
+    :toto:
+      :type: change_ref
+      :config:
+        :from_regexp: TOTO-TEMP-[X\d]{4}
+        :to_template: TOTO-%<next_ref>04d
+        :next_ref: 123
+    """
+    And a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-TEMP-XXX1(a~12345678)]
+    """
+    When I successfully run `defmastership modify --modifications toto thedoc.adoc`
+    Then the stdout should not contain anything
+    And the stderr should not contain anything
+    And the file "modifications.yml" should contain:
+    """
+    ---
+    :toto:
+      :type: change_ref
+      :config:
+        :from_regexp: TOTO-TEMP-[X\d]{4}
+        :to_template: TOTO-%<next_ref>04d
+        :next_ref: 124
+    """
+    And the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0123(a~12345678)]
+    """
+
   Scenario: Change two definitions
     Given a file named "modifications.yml" with:
     """

data/features/definition_version.feature

@@ -22,3 +22,183 @@ Feature: definitions version
     And the stdout should not contain anything
     And the stderr should not contain anything
 
+  Scenario: Set initial explicit version when definition has changed 
+    Given a file named "ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    initial text.
+    --
+    """
+    Given a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(whatever)]
+    --
+    modified text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :first_version: a
+        :ref_document: ./ref_doc.adoc
+    """
+    When I successfully run `defmastership modify --modifications update_requirement_version thedoc.adoc`
+    And the stdout should not contain anything
+    And the stderr should not contain anything
+    Then the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0001(a)]
+    --
+    modified text.
+    --
+    """
+
+  Scenario: Do not set initial explicit version when definition has NOT changed 
+    Given a file named "ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    initial text.
+    --
+    """
+    Given a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(whatever)]
+    --
+    initial text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :first_version: a
+        :ref_document: ./ref_doc.adoc
+    """
+    When I successfully run `defmastership modify --modifications update_requirement_version thedoc.adoc`
+    And the stdout should not contain anything
+    And the stderr should not contain anything
+    Then the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    initial text.
+    --
+    """
+
+  Scenario: Set initial explicit version when definition has changed and ref is not an initial version
+    Given a file named "ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(3)]
+    --
+    initial text.
+    --
+    """
+    Given a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(whatever)]
+    --
+    modified text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :first_version: 1
+        :ref_document: ./ref_doc.adoc
+    """
+    When I successfully run `defmastership modify --modifications update_requirement_version thedoc.adoc`
+    And the stdout should not contain anything
+    And the stderr should not contain anything
+    Then the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0001(4)]
+    --
+    modified text.
+    --
+    """
+
+  Scenario: No initial explicit version when definition is new
+    Given a file named "ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0002]
+    --
+    initial text.
+    --
+    """
+    Given a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(whatever)]
+    --
+    modified text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :first_version: 1
+        :ref_document: ./ref_doc.adoc
+    """
+    When I successfully run `defmastership modify --modifications update_requirement_version thedoc.adoc`
+    And the stdout should not contain anything
+    And the stderr should not contain anything
+    Then the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    modified text.
+    --
+    """
+
+  Scenario: update explicit version whith explicit checksum
+    Given a file named "ref_doc.adoc" with:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    initial text.
+    --
+    """
+    Given a file named "thedoc.adoc" with:
+    """
+    [define, requirement, TOTO-0001(whatever~abcd1234)]
+    --
+    modified text.
+    --
+    """
+    And a file named "modifications.yml" with:
+    """
+    ---
+    :update_requirement_version:
+      :type: update_def_version
+      :config:
+        :def_type: requirement
+        :first_version: a
+        :ref_document: ./ref_doc.adoc
+    """
+    When I successfully run `defmastership modify --modifications update_requirement_version thedoc.adoc`
+    And the stdout should not contain anything
+    And the stderr should not contain anything
+    Then the file "thedoc.adoc" should contain:
+    """
+    [define, requirement, TOTO-0001(a~abcd1234)]
+    --
+    modified text.
+    --
+    """
+

data/features/export.feature

@@ -116,6 +116,27 @@ Feature: The extract command
     And the stdout should not contain anything
     And the stderr should not contain anything
 
+  Scenario: Ignore definitions in example block
+    Given a file named "toto.adoc" with:
+    """
+    [define, requirement, TOTO-0001]
+    --
+    Exemple of multiline requirement.
+    Second line.
+    --
+    ----
+    [define, something_else, TOTO-0003]
+    only one line
+    ----
+    """
+    When I successfully run `defmastership export toto.adoc`
+    Then the file "toto.csv" should not contain:
+    """
+    something_else
+    """
+    And the stdout should not contain anything
+    And the stderr should not contain anything
+
   Scenario: Ignore definitions in commment block
     Given a file named "toto.adoc" with:
     """

data/features/rename_included_files.feature

@@ -73,7 +73,9 @@ Feature: The rename_included_files command
     :any: one
     :path: two
     [define, requirement, TOTO-WHATEVER-123]
+    --
     include::{any}_{path}/one_file.png[]
+    --
     """
     And a directory named "one_two"
     And an empty file named "one_two/one_file.png"
@@ -85,7 +87,9 @@ Feature: The rename_included_files command
     :any: one
     :path: two
     [define, requirement, TOTO-WHATEVER-123]
+    --
     include::{any}_{path}/TOTO-WHATEVER-123_one_file.png[]
+    --
     """
     And the file "one_two/one_file.png" should not exist
     And the file "one_two/TOTO-WHATEVER-123_one_file.png" should exist

data/lib/defmastership.rb

@@ -6,6 +6,7 @@ require('defmastership/version')
 # Add requires for other files you add to your project here, so
 # you just need to require this one file in your bin file
 require('defmastership/constants')
+require('defmastership/parsing_state')
 require('defmastership/definition')
 require('defmastership/definition_parser')
 require('defmastership/filters')
@@ -25,3 +26,6 @@ require('defmastership/rename_included_files_line_modifier')
 
 require('defmastership/update_def_checksum_modifier')
 require('defmastership/update_def_checksum_line_modifier')
+
+require('defmastership/update_def_version_modifier')
+require('defmastership/update_def_version_line_modifier')

data/lib/defmastership/change_ref_line_modifier.rb

@@ -28,7 +28,7 @@ module DefMastership
         to_template: '',
         next_ref: 0
       }
-      @in_literal = false
+      @parsing_state = ParsingState.new
     end
 
     def replace(method, line)
@@ -36,10 +36,10 @@ module DefMastership
     end
 
     def replace_refdef(line)
-      if in_literal(line)
-        line
-      else
+      if @parsing_state.enabled?(line)
         do_replace_refdef(line)
+      else
+        line
       end
     end
 
@@ -66,21 +66,17 @@ module DefMastership
       regexp_str =
         "(?<before>#{REGEXP_FROM[const][:before]})" \
         "(?<from>#{from})" \
+        "#{DMRegexp::DEF_VERSION_AND_CHECKSUM}" \
         "(?<after>#{REGEXP_FROM[const][:after]})"
       Regexp.new(regexp_str, Regexp::EXTENDED)
     end
 
     def text_with(match, replacement)
-      match[:before] + replacement + match[:after]
+      match[:before] + replacement + (match[:version_and_checksum] || '') + match[:after]
     end
 
     def hmerge(match)
       @config.merge(match.names.map(&:to_sym).zip(match.captures).to_h)
     end
-
-    def in_literal(line)
-      @in_literal ^= true if line.chomp == '....'
-      @in_literal
-    end
   end
 end

data/lib/defmastership/comment_filter.rb

@@ -1,43 +1,10 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-# Add a class to handled asciidoctor comments
-module DefMastership
-  attr_reader :comment_filter
-
-  # Kind of proxy that Filters comments fome Asciidoctor document
-  class CommentFilter
-    def initialize
-      @in_multiline_comment = false
-    end
-
-    def accept?(line)
-      case line
-      when DMRegexp::SINGLE_LINE_COMMENT then false
-      when DMRegexp::MULTI_LINE_COMMENT_DELIM
-        @in_multiline_comment ^= true
-        false
-      else !@in_multiline_comment
-      end
-    end
-  end
-
-  @comment_filter = CommentFilter.new
-
-  def self.reset_comments
-    @comment_filter = CommentFilter.new
-    nil
-  end
-
-  def self.comment_filter
-    @comment_filter
-  end
-end
-
 # adding a method to string to figure out if a string is commented or
 # not.
 class String
   def commented?
-    !DefMastership.comment_filter.accept?(self)
+    !match(DefMastership::DMRegexp::SINGLE_LINE_COMMENT).nil?
   end
 end

data/lib/defmastership/constants.rb

@@ -6,8 +6,6 @@ module DefMastership
   module DMRegexp
     SINGLE_LINE_COMMENT = %r{^//[^/]}.freeze
 
-    MULTI_LINE_COMMENT_DELIM = %r{^////\s*$}.freeze
-
     DEF_BEFORE_REF = <<~'BEF'
       ^\s*
       \[\s*define\s*,
@@ -20,7 +18,9 @@ module DefMastership
       (,\s*\[\s*(?<labels>.*?)\s*\])?\s*\]
     AFT
 
-    DEF_VERSION_AND_CHECKSUM = '(\((?<explicit_version>[^~]+)?(?<explicit_checksum>~[[:alnum:]]+)?\))?'
+    DEF_VERSION_AND_CHECKSUM = '(?<version_and_checksum>' \
+                               '\((?<explicit_version>[^~]+)?(?<explicit_checksum>~[[:alnum:]]+)?\)' \
+                               ')?'
 
     DEFINITION = Regexp.new(
       "#{DEF_BEFORE_REF}(?<reference>[\\w:_-]+)#{DEF_VERSION_AND_CHECKSUM}#{DEF_AFTER_REF}",
@@ -39,7 +39,6 @@ module DefMastership
                \s*(?<refname>[\w:_-]+)\s*,
                \s*\[(?<extrefs>[^\]]+)\]\s*\]/x.freeze
     BLOCK = /^--\s*$/.freeze
-    LITERAL_BLOCK = /^\.\.\.\.\s*$/.freeze
 
     IREF_DEF_BEF = 'defs:iref\[\s*'
     IREF_DEF_AFT = '\s*\]'
@@ -70,7 +69,6 @@ module DefMastership
     )
 
     public_constant :SINGLE_LINE_COMMENT,
-                    :MULTI_LINE_COMMENT_DELIM,
                     :DEF_BEFORE_REF,
                     :DEF_AFTER_REF,
                     :DEFINITION,
@@ -79,7 +77,6 @@ module DefMastership
                     :EREF_CONFIG,
                     :EREF_DEF,
                     :BLOCK,
-                    :LITERAL_BLOCK,
                     :IREF_DEF_BEF,
                     :IREF_DEF_AFT,
                     :IREF_DEF,

data/lib/defmastership/definition.rb

@@ -31,7 +31,7 @@ module DefMastership
     end
 
     def sha256
-      "~#{Digest::SHA2.new(256).hexdigest(value).split(//).last(8).join}"
+      "~#{Digest::SHA2.new(256).hexdigest(value).chars.last(8).join}"
     end
 
     def wrong_explicit_checksum

data/lib/defmastership/document.rb

@@ -16,14 +16,16 @@ module DefMastership
       @eref          = {}
       @iref          = false
       @attributes    = {}
-      @in_literal    = true
       @variables     = {}
+      @parsing_state = ParsingState.new
       @definition_parser = DefinitionParser.new(self)
     end
 
     def parse(lines)
       lines.reject(&:commented?).each do |line|
-        (@in_literal ? FILTERS : FILTERS_IN_LITERAL).each do |filter|
+        next unless @parsing_state.enabled?(line)
+
+        FILTERS.each do |filter|
           next unless line.match(filter.regexp)
 
           line = generate_event(filter.event, Regexp.last_match, line)
@@ -49,11 +51,6 @@ module DefMastership
       end
     end
 
-    def code_block_delimiter(_match, line)
-      @in_literal ^= true
-      line
-    end
-
     def add_new_definition(match, line)
       definition = Definition.new(match)
       @labels.merge(definition.labels)

data/lib/defmastership/filters.rb

@@ -6,12 +6,6 @@ module DefMastership
   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),
@@ -22,7 +16,6 @@ module DefMastership
     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

data/lib/defmastership/parsing_state.rb

@@ -0,0 +1,23 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Allow to know if we need to parse the line or simply ignore it
+  class ParsingState
+    def initialize
+      @last_disabling_line = nil
+    end
+
+    def enabled?(line)
+      line = line.dup.chomp
+      if ['....', '----', '////'].include?(line)
+        if @last_disabling_line == line
+          @last_disabling_line = nil
+        elsif @last_disabling_line.nil?
+          @last_disabling_line = line
+        end
+      end
+      @last_disabling_line.nil?
+    end
+  end
+end

data/lib/defmastership/rename_included_files_line_modifier.rb

@@ -96,7 +96,7 @@ module DefMastership
 
         filename.gsub!("{#{varname}}", @variables[varname.to_sym])
       end
-      filename
+      filename.chomp
     end
 
     def complete_regexp_from(from)

data/lib/defmastership/update_def_checksum_modifier.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 module DefMastership
-  # Update definition checksum wih calculated one
+  # Update definition checksum with calculated one
   class UpdateDefChecksumModifier < ModifierBase
     def replacements
       %i[replace]

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.9'
+  VERSION = '1.0.14'
   public_constant :VERSION
 end

data/spec/unit/defmastership/change_ref_line_modifier_spec.rb

@@ -217,6 +217,21 @@ RSpec.describe(DefMastership::ChangeRefLineModifier) do
         .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]'))

data/spec/unit/defmastership/comment_filter_spec.rb

@@ -3,124 +3,10 @@
 
 require('defmastership')
 
-RSpec.describe(DefMastership::CommentFilter) do
-  describe '.new' do
-    it { is_expected.not_to(be(nil)) }
-  end
-
-  describe '#accept?' do
-    subject(:comment_filter) { described_class.new }
-
-    context 'when no comment' do
-      it do
-        expect(comment_filter.accept?('whatever')).to(be(true))
-      end
-    end
-
-    context 'when single line comment' do
-      it do
-        expect(comment_filter.accept?('// whatever')).to(be(false))
-      end
-    end
-
-    context 'when bat formated single line comment' do
-      it do
-        expect(comment_filter.accept?('///')).to(be(true))
-      end
-    end
-
-    context 'when starting multiline comment' do
-      it do
-        expect(comment_filter.accept?('////')).to(be(false))
-      end
-    end
-
-    context 'when multiline comment' do
-      before do
-        comment_filter.accept?('////')
-      end
-
-      it do
-        expect(comment_filter.accept?('whatever')).to(be(false))
-      end
-    end
-
-    context 'when exiting multiline comment' do
-      before do
-        comment_filter.accept?('////')
-        comment_filter.accept?('something')
-      end
-
-      it do
-        expect(comment_filter.accept?('////')).to(be(false))
-      end
-    end
-
-    context 'when end of multiline comment' do
-      before do
-        comment_filter.accept?('////')
-        comment_filter.accept?('something')
-        comment_filter.accept?('////')
-      end
-
-      it do
-        expect(comment_filter.accept?('whatever')).to(be(true))
-      end
-    end
-  end
-
-  describe 'String .commented?' do
-    let(:comment_filter) do
-      instance_double(described_class, 'comment_filter')
-    end
-
-    before do
-      allow(DefMastership).to(
-        receive(:comment_filter)
-          .and_return(comment_filter)
-      )
-    end
-
-    context 'when not .commented?' do
-      before do
-        allow(comment_filter).to(receive(:accept?).with('blabla').and_return(true))
-        'blabla'.commented?
-      end
-
-      it { expect(DefMastership).to(have_received(:comment_filter)) }
-
-      it { expect(comment_filter).to(have_received(:accept?).with('blabla')) }
-
-      it { expect('blabla'.commented?).to(be(false)) }
-    end
-
-    context 'when .commented?' do
-      before do
-        allow(comment_filter).to(
-          receive(:accept?)
-            .with('blabla').and_return(false)
-        )
-      end
-
-      it do
-        expect('blabla'.commented?).to(be(true))
-      end
-    end
-  end
-
-  describe '#reset_comments' do
-    before do
-      '////'.commented?
-    end
-
-    it do
-      expect('whatever'.commented?).to(be(true))
-    end
-
-    it do
-      '////'.commented?
-      DefMastership.reset_comments
-      expect('whatever'.commented?).to(be(false))
-    end
+RSpec.describe(String) do
+  context 'when .commented?' do
+    it { expect('blabla'.commented?).to(be(false)) }
+    it { expect('//blabla'.commented?).to(be(true)) }
+    it { expect('///blabla'.commented?).to(be(false)) }
   end
 end

data/spec/unit/defmastership/parsing_state_spec.rb

@@ -0,0 +1,58 @@
+# 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 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)) }
+    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)) }
+    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(eq(false)) }
+      it { expect(parsing_state.enabled?("....\n")).to(eq(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(eq(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(eq(true)) }
+    end
+  end
+end

data/spec/unit/defmastership/rename_included_files_line_modifier_spec.rb

@@ -110,32 +110,32 @@ RSpec.describe(DefMastership::RenameIncludedFilesLineModifier) do
         end
 
         it do
-          expect(includeschanger.replace('include::orig[]'))
-            .to(eq('include::dest[]'))
+          expect(includeschanger.replace("include::orig[]\n"))
+            .to(eq("include::dest[]\n"))
         end
 
         it do
-          includeschanger.replace('include::orig[]')
+          includeschanger.replace("include::orig[]\n")
           expect(File).to(have_received(:rename).with('orig', 'dest'))
         end
 
         it do
-          includeschanger.replace('include::orig[]')
+          includeschanger.replace("include::orig[]\n")
           expect(includeschanger).to(have_attributes(changes: [%w[orig dest]]))
         end
 
         it do
-          expect(includeschanger.replace('include::toto/orig[]'))
-            .to(eq('include::toto/dest[]'))
+          expect(includeschanger.replace("include::toto/orig[]\n"))
+            .to(eq("include::toto/dest[]\n"))
         end
 
         it do
-          includeschanger.replace('include::toto/orig[]')
+          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[]')
+          includeschanger.replace("include::toto/orig[]\n")
           expect(includeschanger).to(have_attributes(changes: [%w[toto/orig toto/dest]]))
         end
       end

data/spec/unit/defmastership/update_def_version_line_modifier_spec.rb

@@ -0,0 +1,127 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::UpdateDefVersionLineModifier) 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 { expect { linemodifier.user_defined_attribute }.to(raise_error(NoMethodError)) }
+  end
+
+  describe '.from_config' do
+    subject(:linemodifier) do
+      described_class.from_config(
+        def_type: 'requirement',
+        first_version: 'a'
+      )
+    end
+
+    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)) }
+    it { is_expected.to(have_attributes(ref_document: nil)) }
+  end
+
+  describe '#replace' do
+    subject(:linemodifier) do
+      described_class.from_config(
+        def_type: 'requirement',
+        first_version: 'a'
+      )
+    end
+
+    let(:document)       { instance_double(DefMastership::Document, 'document')          }
+    let(:ref_document)   { instance_double(DefMastership::Document, 'ref_document')      }
+    let(:definition)     { instance_double(DefMastership::Definition, 'definition')      }
+    let(:ref_definition) { instance_double(DefMastership::Definition, 'ref_definitions') }
+
+    before do
+      linemodifier.document = document
+      linemodifier.ref_document = ref_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
+
+      context 'when definition has NOT changed' do
+        before do
+          allow(ref_document).to(receive(:ref_to_def).with('REFERENCE').and_return(ref_definition))
+          allow(ref_definition).to(receive(:sha256).and_return('~abcd1234'))
+        end
+
+        it do
+          allow(ref_definition).to(receive(:explicit_version).and_return(nil))
+          expect(linemodifier.replace('[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE]'))
+        end
+
+        it do
+          allow(ref_definition).to(receive(:explicit_version).and_return('c'))
+          expect(linemodifier.replace('[define,requirement,REFERENCE]'))
+            .to(eq('[define,requirement,REFERENCE(c)]'))
+        end
+
+        it do
+          allow(ref_definition).to(receive(:explicit_version).and_return('c'))
+          expect(linemodifier.replace('[define,requirement,REFERENCE(tyty~1234)]'))
+            .to(eq('[define,requirement,REFERENCE(c~1234)]'))
+        end
+      end
+
+      context 'when definition has changed' do
+        before do
+          allow(ref_document).to(receive(:ref_to_def).with('REFERENCE').and_return(ref_definition))
+          allow(ref_definition).to(receive(:sha256).and_return('~4321aaaa'))
+        end
+
+        [
+          [nil,    '',            '(a)'],
+          ['c',    '',            '(d)'],
+          ['c',    '(tyty~1234)', '(d~1234)'],
+          ['2',    '',            '(3)'],
+          ['1222', '',            '(1223)'],
+          ['abb',  '',            '(abc)']
+        ].each do |ref, from, to|
+          it do
+            allow(ref_definition).to(receive(:explicit_version).and_return(ref))
+            expect(linemodifier.replace("[define,requirement,REFERENCE#{from}]"))
+              .to(eq("[define,requirement,REFERENCE#{to}]"))
+          end
+        end
+      end
+
+      context 'when definition is new' do
+        before do
+          allow(ref_document).to(receive(:ref_to_def).with('REFERENCE').and_return(nil))
+        end
+
+        it do
+          expect(linemodifier.replace('[define,requirement,REFERENCE(whatever)]'))
+            .to(eq('[define,requirement,REFERENCE]'))
+        end
+
+        it do
+          expect(linemodifier.replace('[define,requirement,REFERENCE(~1234)]'))
+            .to(eq('[define,requirement,REFERENCE(~1234)]'))
+        end
+      end
+    end
+  end
+end

data/spec/unit/defmastership/update_def_version_modifier_spec.rb

@@ -0,0 +1,80 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::UpdateDefVersionModifier) do
+  subject(:modifier) do
+    described_class.new(
+      ref_document: 'ref.adoc'
+    )
+  end
+
+  let(:adoc_texts) do
+    {
+      'file1.adoc' => "file1 line1\nfile1 line2",
+      'file2.adoc' => "file2 line1\nfile2 line2"
+    }
+  end
+
+  describe '.new' do
+    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
+
+  describe '#do_modifications' do
+    let(:line_modifier) { instance_double(DefMastership::UpdateDefVersionLineModifier, 'lineModifier') }
+    let(:document)      { instance_double(DefMastership::Document, 'document')                         }
+    let(:ref_document)  { instance_double(DefMastership::Document, 'ref_document')                     }
+
+    before do
+      allow(DefMastership::UpdateDefVersionLineModifier).to(
+        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))
+      allow(ref_document).to(receive(:parse_file_with_preprocessor))
+      allow(line_modifier).to(receive(:'document=').with(document))
+      allow(line_modifier).to(receive(:'ref_document=').with(ref_document))
+      allow(line_modifier).to(receive(:replace).with("file1 line1\n").and_return("new file1 line1\n"))
+      allow(line_modifier).to(receive(:replace).with('file1 line2').and_return('new file1 line2'))
+      allow(line_modifier).to(receive(:replace).with("file2 line1\n").and_return("new file2 line1\n"))
+      allow(line_modifier).to(receive(:replace).with('file2 line2').and_return('new file2 line2'))
+      allow(line_modifier).to(receive(:config).and_return(ref_document: 'ref.adoc'))
+      allow(line_modifier).to(receive(:changes).and_return([%w[from1 to1], %w[from2 to2]]))
+    end
+
+    context 'when detailed expectations' do
+      before { modifier.do_modifications(adoc_texts) }
+
+      it do
+        expect(DefMastership::UpdateDefVersionLineModifier).to(
+          have_received(:from_config).with(ref_document: 'ref.adoc')
+        )
+      end
+
+      it { expect(document).to(have_received(:parse_file_with_preprocessor).with('file1.adoc')) }
+      it { expect(document).to(have_received(:parse_file_with_preprocessor).with('file2.adoc')) }
+      it { expect(ref_document).to(have_received(:parse_file_with_preprocessor).with('ref.adoc')) }
+      it { expect(line_modifier).to(have_received(:'document=').with(document)) }
+      it { expect(line_modifier).to(have_received(:'ref_document=').with(ref_document)) }
+      it { expect(line_modifier).to(have_received(:replace).with("file1 line1\n")) }
+      it { expect(line_modifier).to(have_received(:replace).with('file1 line2')) }
+      it { expect(line_modifier).to(have_received(:replace).with("file2 line1\n")) }
+      it { expect(line_modifier).to(have_received(:replace).with('file2 line2')) }
+      it { expect(line_modifier).to(have_received(:config)) }
+      it { expect(line_modifier).to(have_received(:changes)) }
+      it { is_expected.to(have_attributes(config: { ref_document: 'ref.adoc' })) }
+      it { is_expected.to(have_attributes(changes: [%w[from1 to1], %w[from2 to2]])) }
+    end
+
+    it do
+      expected_adoc = {
+        'file1.adoc' => "new file1 line1\nnew file1 line2",
+        'file2.adoc' => "new file2 line1\nnew file2 line2"
+      }
+      expect(modifier.do_modifications(adoc_texts)).to(eq(expected_adoc))
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: defmastership
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.0.14
 platform: ruby
 authors:
 - Jérôme Arbez-Gindre
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-24 00:00:00.000000000 Z
+date: 2021-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aruba
@@ -70,16 +70,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.13'
 - !ruby/object:Gem::Dependency
   name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement
@@ -216,10 +216,13 @@ files:
 - lib/defmastership/filters.rb
 - lib/defmastership/line_modifier_base.rb
 - lib/defmastership/modifier_base.rb
+- lib/defmastership/parsing_state.rb
 - lib/defmastership/rename_included_files_line_modifier.rb
 - lib/defmastership/rename_included_files_modifier.rb
 - lib/defmastership/update_def_checksum_line_modifier.rb
 - lib/defmastership/update_def_checksum_modifier.rb
+- lib/defmastership/update_def_version_line_modifier.rb
+- lib/defmastership/update_def_version_modifier.rb
 - lib/defmastership/version.rb
 - spec/spec_helper.rb
 - spec/unit/defmastership/batch_modifier_spec.rb
@@ -232,10 +235,13 @@ files:
 - spec/unit/defmastership/definition_parser_spec.rb
 - spec/unit/defmastership/definition_spec.rb
 - spec/unit/defmastership/document_spec.rb
+- spec/unit/defmastership/parsing_state_spec.rb
 - spec/unit/defmastership/rename_included_files_line_modifier_spec.rb
 - spec/unit/defmastership/rename_included_files_modifier_spec.rb
 - spec/unit/defmastership/update_def_checksum_line_modifier_spec.rb
 - spec/unit/defmastership/update_def_checksum_modifier_spec.rb
+- spec/unit/defmastership/update_def_version_line_modifier_spec.rb
+- spec/unit/defmastership/update_def_version_modifier_spec.rb
 - spec/unit/defmastership_spec.rb
 homepage: https://gitlab.com/jjag/defmastership/
 licenses: