defmastership-core 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f53b9cafb00c67beb3c5412e3668d5e72683db35a0d6d7a6449aafa5adf22494
-  data.tar.gz: f7e347edb42e478b6103d09d74079c79571b9914fabceee5b7d27934a8dbaf7a
+  metadata.gz: b6b48fcdac016b1032cf07bb002e0c2672a8849af943e6394d5190bb2a3945e9
+  data.tar.gz: ac0c88a4f42312c140edd29f0395ea76774921799e2f4915a31c85dc51cd5fdb
 SHA512:
-  metadata.gz: 5b95b3e3915b799e9025f741a201ad806e23b5048a2c7ef3438a48e73b21ac0e40012c9519a4d481fad38554f7b94869b59d6c8d54a8cfd7a09df14e2c3d44c1
-  data.tar.gz: 06d4d2f26ec9a37a1756046c02b48c9e6921182d3861e27aa0b9518f9894fac39e57d1d2323eea7980a248180fdcc0e0d34f2b78b982ed4aa653707f80d88710
+  metadata.gz: 33adb210da4e371ba6b94ff7c5de5980b0d74cb8d31f0939f1adfe41f846970fa042ea08c449de038a21b1eb857f9a5852a278832e0af07c261ff3fd0f1dfcbd
+  data.tar.gz: 9e67eb21f21bb5d30faf71697f5865bbd5c98ba536e6af9a622f064ba44e274afcf5dfd0a354145e661e645b1ad5f6a86f2e77fae753553beca30a65887867aa

data/.gitlab-ci.yml

@@ -1,5 +1,5 @@
 default:
-  image: ruby:3.3
+  image: ruby:3.4
   before_script:
     - apt-get update
     - ruby -v
@@ -54,6 +54,11 @@ unit tests ruby3.2:
   script:
     - bundle exec rake test:spec
 
+unit tests ruby3.3:
+  image: ruby:3.3
+  script:
+    - bundle exec rake test:spec
+
 pages:
   stage: deploy
   script:

data/Gemfile

@@ -10,27 +10,27 @@ ruby RUBY_VERSION
 # rubocop:disable Metrics/BlockLength
 group :development do
   # needed by yard to render documentation
-  gem 'asciidoctor',           '~> 2'
+  gem 'asciidoctor',           '~> 2.0'
   # cucumber steps for command line tests
-  gem 'aruba',                 '~> 2'
+  gem 'aruba',                 '~> 2.2'
   # bdd
-  gem 'cucumber',              '~> 9'
+  gem 'cucumber',              '~> 9.2'
 
   # code duplication
-  gem 'flay',                  '~> 2'
+  gem 'flay',                  '~> 2.13'
 
   # automatic test run
-  gem 'guard',                 '~> 2'
+  gem 'guard',                 '~> 2.19'
   # automatic update invocation
-  gem 'guard-bundler',         '~> 3'
+  gem 'guard-bundler',         '~> 3.0'
   if RUBY_VERSION >= '3.0'
     # automatic style check
     gem 'guard-reek', '~> 1.2'
   end
   # automatic tdd
-  gem 'guard-rspec',           '~> 4'
+  gem 'guard-rspec',           '~> 4.7'
   # automatic style check
-  gem 'guard-rubocop',         '~> 1'
+  gem 'guard-rubocop',         '~> 1.5'
 
   # if RUBY_VERSION >= '3.0'
   #   # mutation testing
@@ -44,45 +44,45 @@ group :development do
   #   gem 'mutant-rspec', '~> 0'
   # end
   # to parse and execute Rakefile
-  gem 'rake', '~> 13'
+  gem 'rake', '~> 13.2'
 
   if RUBY_VERSION >= '3.0'
     # needed by yard to render documentation
-    gem 'rdoc', '~> 6'
+    gem 'rdoc', '~> 6.1O'
   end
   # tdd
-  gem 'rspec',                 '~> 3'
+  gem 'rspec',                 '~> 3.13'
   # # to test performances
   # gem 'rspec-benchmark',       '~> 0'
   # code needs to be clean
-  gem 'rubocop',               '1.68'
+  gem 'rubocop',               '1.69'
   # code needs to be clean
-  gem 'rubocop-performance',   '~> 1'
+  gem 'rubocop-performance',   '~> 1.23'
   # test code needs to be clean
-  gem 'rubocop-rspec',         '~> 3'
+  gem 'rubocop-rspec',         '~> 3.3'
   # Rakefiles need to be clean
-  gem 'rubocop-rake',          '~> 0'
+  gem 'rubocop-rake',          '~> 0.6'
 
   if RUBY_VERSION >= '3.0'
     # detect selling code
-    gem 'reek', '~> 6'
+    gem 'reek', '~> 6.3'
     # my code needs to be critiqued
-    gem 'rubycritic', '~> 4'
+    gem 'rubycritic', '~> 4.9'
     # Doc need to be clean
-    gem 'rubocop-yard', '~> 0'
+    gem 'rubocop-yard', '~> 0.10'
   end
 
   # What is tdd without code coverage ?
-  gem 'simplecov', '~> 0'
+  gem 'simplecov', '~> 0.22'
 
   if RUBY_VERSION >= '3.0'
     # to document code
-    gem 'yard', '~> 0'
+    gem 'yard', '~> 0.9'
   end
 end
 # rubocop:enable Metrics/BlockLength
 
 group :debugging do
   # Sometimes, we need to debug
-  gem 'pry', '~> 0'
+  gem 'pry', '~> 0.15'
 end

data/lib/defmastership/core/constants.rb

@@ -7,60 +7,108 @@ module Defmastership
     # set of regexp of added asciidoctor constructions
     # This module smells of :reek:TooManyConstants
     module DMRegexp
+      # generic regexp pattern for ids
+      #
+      # @param backref_name [String] set the name of the id's backref
+      def self.an_id(backref_name)
+        "(?<#{backref_name}>[\\w-]+)"
+      end
+
       # [Regexp] to match a single line comment
       SINGLE_LINE_COMMENT = %r{^//[^/]}.freeze
       public_constant :SINGLE_LINE_COMMENT
 
+      # [Regexp] match the definition keyword
+      DEF_KEYWORD = '\s*define\s*'
+      public_constant :DEF_KEYWORD
+
+      # [Regexp] match a definition type
+      DEF_TYPE = ",\\s*#{an_id('type')}\\s*"
+      public_constant :DEF_TYPE
+
       # [Regexp] match all text before the definition's reference
-      DEF_BEFORE_REF = <<~'BEF'
-        ^\s*
-        \[\s*define\s*,
-        \s*(?<type>[\w:_-]+)\s*,
-        \s*
+      DEF_BEFORE_REF = <<~"BEF"
+        ^
+        \\s*
+        \\[
+        #{DEF_KEYWORD}
+        #{DEF_TYPE}
+        ,
+        \\s*
       BEF
       public_constant :DEF_BEFORE_REF
 
-      # [Regexp] match all text after the definition's reference
-      DEF_AFTER_REF = <<~'AFT'
-        \s*
-        (,\s*\[\s*(?<labels>.*?)\s*\])?\s*\]
-      AFT
-      public_constant :DEF_AFTER_REF
-
       # [Regexp] match optional explicit version and explicit checksum
       DEF_VERSION_AND_CHECKSUM = '(?<version_and_checksum>' \
-                                 '\((?<explicit_version>[^~]+)?(?<explicit_checksum>~[[:alnum:]]+)?\)' \
+                                 '\((?<explicit_version>[^~]+)?(?<explicit_checksum>~\h+)?\)' \
                                  ')?'
       public_constant :DEF_VERSION_AND_CHECKSUM
 
       # [Regexp] match reference
-      REFERENCE = '(?<reference>[\\w:_-]+)'
+      REFERENCE = an_id('reference').freeze
       public_constant :REFERENCE
 
+      # [Regexp] match defintion summary
+      DEF_SUMMARY = <<~'SUM'
+        \s*
+        (,\s*
+        ((?<summary>[^\s,\[\]][^,\[\]]*?)|("(?<summary>[^""]*)"))
+        \s*)?
+      SUM
+      public_constant :DEF_SUMMARY
+
+      # [Regexp] match definition labels
+      DEF_LABELS = '(,\s*\[\s*(?<labels>.*\b)\s*\])?'
+      public_constant :DEF_LABELS
+
+      # [Regexp] match all text after the definition's reference
+      DEF_AFTER_REF = <<~"AFT"
+        \\s*
+        #{DEF_SUMMARY}
+        #{DEF_LABELS}
+        \\s*
+        \\]
+      AFT
+      public_constant :DEF_AFTER_REF
+
       # [Regexp] match a definition line
-      DEFINITION = Regexp.new(
-        "#{DEF_BEFORE_REF}#{REFERENCE}#{DEF_VERSION_AND_CHECKSUM}#{DEF_AFTER_REF}",
-        Regexp::EXTENDED
-      )
+      definition_re_string = <<~"DEF"
+        ^
+        \\s*
+        \\[
+        #{DEF_KEYWORD}
+        #{DEF_TYPE}
+        ,
+        \\s*
+        #{REFERENCE}
+        #{DEF_VERSION_AND_CHECKSUM}
+        \\s*
+        #{DEF_SUMMARY}
+        #{DEF_LABELS}
+        \\s*
+        \\]
+      DEF
+      # [Regexp] match a definition line
+      DEFINITION = Regexp.new(definition_re_string, Regexp::EXTENDED)
       public_constant :DEFINITION
 
       # [Regexp] match a asciidcotor attribute definition
-      VARIABLE_DEF = /^\s*:(?<varname>[\w:_-]+):\s+
+      VARIABLE_DEF = /^\s*:#{an_id('varname')}:\s+
                    (?<value>\S.*\S)\s*$/x.freeze
       public_constant :VARIABLE_DEF
 
       # [Regexp] match a asciidcotor attribute use
-      VARIABLE_USE = /{(?<varname>[\w:_-]+)}/x.freeze
+      VARIABLE_USE = /{#{an_id('varname')}}/x.freeze
       public_constant :VARIABLE_USE
 
       # [Regexp] match an external cross reference type configuration
-      EREF_CONFIG = /^\s*:eref-(?<reference>[\w:_-]+)-(?<symb>prefix|url):\s*
+      EREF_CONFIG = /^\s*:eref-#{an_id('reference')}-(?<symb>prefix|url):\s*
                    \s*(?<value>\S.*\S)\s*/x.freeze
       public_constant :EREF_CONFIG
       # [Regexp] match an external cross reference use
       EREF_DEF = /^\s*
                defs:eref\[
-               \s*(?<reference>[\w:_-]+)\s*,
+               \s*#{an_id('reference')}\s*,
                \s*\[\s*(?<extrefs>[^\]]+?)\s*\]\s*\]/x.freeze
       public_constant :EREF_DEF
 
@@ -76,19 +124,19 @@ module Defmastership
       public_constant :IREF_DEF_AFT
       # [Regexp] match an internal cross reference
       IREF_DEF = Regexp.new(
-        "#{IREF_DEF_BEF}(?<intref>[\\w:_-]+)#{IREF_DEF_AFT}",
+        "#{IREF_DEF_BEF}#{an_id('intref')}#{IREF_DEF_AFT}",
         Regexp::EXTENDED
       )
       public_constant :IREF_DEF
 
       # [Regexp] match an attribute configuration
-      ATTR_CONFIG = /\s*:attr-(?<attr>[\w:_-]+)-prefix:
+      ATTR_CONFIG = /\s*:attr-#{an_id('attr')}-prefix:
                       \s+(?<prefix>.+?)\s*$/x.freeze
       public_constant :ATTR_CONFIG
       # [Regexp] match an attribute use
       ATTR_SET = /\s*
                 defs:attribute\[
-                \s*(?<attr>[\w:_-]+)\s*,
+                \s*#{an_id('attr')}\s*,
                 \s*(?<value>.+?)\s*\]/x.freeze
       public_constant :ATTR_SET
 
@@ -101,13 +149,13 @@ module Defmastership
       public_constant :WHATEVER
 
       # [Regexp] match asciidoc include statement keyword
-      INCLUDE_KEYWORD = '\binclude::'
+      INCLUDE_KEYWORD = '^\s*include::'
       public_constant :INCLUDE_KEYWORD
       # [Regexp] match asciidoc include statement path
       INCLUDE_PATH = '(?<path>.*/)?'
       public_constant :INCLUDE_PATH
       # [Regexp] match asciidoc include statement filename
-      INCLUDE_FILENAME = '(?<filename>[^\\/]+)'
+      INCLUDE_FILENAME = '(?<filename>[^\\\/]+)'
       public_constant :INCLUDE_FILENAME
       # [Regexp] match asciidoc include statement options
       INCLUDE_OPTIONS = '\[(?<options>[^\]]*)\]'

data/lib/defmastership/core/version.rb

@@ -5,7 +5,7 @@ module Defmastership
   # Common to defmastership and asciidoctor-defmastership
   module Core
     # [String] Gem version
-    VERSION = '1.2.0'
+    VERSION = '1.4.0'
     public_constant :VERSION
   end
 end

data/spec/unit/defmastership/core/dm_regexp_spec.rb

@@ -0,0 +1,665 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/core/constants')
+
+RSpec.describe(Defmastership::Core::DMRegexp) do
+  describe '#an id' do
+    subject(:regexp) { Regexp.new("^#{described_class.an_id('backref')}$", Regexp::EXTENDED) }
+
+    context 'when valid id' do
+      [
+        'abc',
+        'abc_efg',
+        '_abc_efg_',
+        'abc-efg',
+        '-abc-efg-',
+        '67abc123-efg12',
+        'REFERENCE-0001'
+      ].each do |line|
+        it { is_expected.to(match(line)) }
+      end
+
+      it { expect(regexp.match('67abc123-efg12')[:backref]).to(eq('67abc123-efg12')) }
+
+      context 'when not valid id' do
+        [
+          '&abcg',
+          'ab@cg',
+          'abc12:3-efg'
+        ].each do |line|
+          it { is_expected.not_to(match(line)) }
+        end
+      end
+    end
+  end
+
+  describe 'SINGLE_LINE_COMMENT' do
+    subject { described_class::SINGLE_LINE_COMMENT }
+
+    context 'when the string is a single line comment' do
+      [
+        '// This is a comment',
+        '// This is a // comment'
+      ].each do |the_line|
+        it { is_expected.to(match(the_line)) }
+      end
+    end
+
+    context 'when the string is not a single line comment' do
+      [
+        'This is not a comment',
+        ' // This is not a comment'
+      ].each do |the_bad_line|
+        it { is_expected.not_to(match(the_bad_line)) }
+      end
+    end
+  end
+
+  describe 'DEF_KEYWORD' do
+    subject(:regexp) { Regexp.new("^#{described_class::DEF_KEYWORD}$", Regexp::EXTENDED) }
+
+    context 'with valid definition keyword' do
+      [
+        'define',
+        ' define',
+        ' define '
+      ].each do |line|
+        it { is_expected.to(match(line)) }
+      end
+    end
+
+    context 'with invalid definition keyword' do
+      it { is_expected.not_to(match('defoune')) }
+    end
+  end
+
+  describe 'DEF_TYPE' do
+    subject(:regexp) { Regexp.new("^#{described_class::DEF_TYPE}$", Regexp::EXTENDED) }
+
+    context 'with valid definition type' do
+      [
+        ', a_type',
+        ', a-type',
+        ', a-type  '
+      ].each do |line|
+        it { is_expected.to(match(line)) }
+      end
+
+      it { expect(regexp.match(', a-type  ')[:type]).to(eq('a-type')) }
+    end
+
+    context 'with invalid definition type' do
+      it { is_expected.not_to(match(' , a_type')) }
+      it { is_expected.not_to(match(', a type with blank ')) }
+    end
+  end
+
+  describe 'DEF_BEFORE_REF' do
+    subject(:regexp) { Regexp.new("#{described_class::DEF_BEFORE_REF}$", Regexp::EXTENDED) }
+
+    context 'when valid definitions beginning' do
+      [
+        '[define,def_type,',
+        '  [define,def_type,',
+        '  [   define,def_type,',
+        '  [   define,   def_type,',
+        '  [   define,   def_type,   '
+      ].each do |def_beg|
+        it { is_expected.to(match(def_beg)) }
+        it { expect(regexp.match(def_beg)[:type]).to(eq('def_type')) }
+      end
+    end
+
+    context 'when does not match invalid definitions beginning' do
+      [
+        'define def_type,',
+        '[define def_type,',
+        '[define, def_type',
+        'something [define, def_type'
+      ].each do |bad_def_beg|
+        it { is_expected.not_to(match(bad_def_beg)) }
+      end
+    end
+  end
+
+  describe 'DEF_AFTER_REF' do
+    subject(:regexp) { Regexp.new("^#{described_class::DEF_AFTER_REF}$", Regexp::EXTENDED) }
+
+    context 'when valid definitions end' do
+      [
+        ']',
+        ',[label1]]',
+        ', a nice summary,[label1]]',
+        ', a nice summary]',
+        ', "a nice summary, with comma"]'
+      ].each do |def_end|
+        it { is_expected.to(match(def_end)) }
+      end
+
+      it { expect(regexp.match('   ,[   label1    ,    label2    ]     ]')[:labels]).to(eq('label1    ,    label2')) }
+      it { expect(regexp.match('   ,[   label1    ,    label2    ]     ]')[:summary]).to(be_nil) }
+      it { expect(regexp.match(', a summary ]')[:summary]).to(eq('a summary')) }
+      it { expect(regexp.match(', a summary ]')[:labels]).to(be_nil) }
+      it { expect(regexp.match(', "a, summary" ]')[:summary]).to(eq('a, summary')) }
+    end
+
+    context 'when invalid definitions end' do
+      it { is_expected.not_to(match('whatever')) }
+      it { is_expected.not_to(match(',[label1]')) }
+      it { is_expected.not_to(match('[label1]]')) }
+      it { is_expected.not_to(match(',label1,label2]]')) }
+    end
+  end
+
+  describe 'DEF_VERSION_AND_CHECKSUM' do
+    subject(:regexp) { Regexp.new("^#{described_class::DEF_VERSION_AND_CHECKSUM}$", Regexp::EXTENDED) }
+
+    context 'when valid input' do
+      context 'when version without checksum' do
+        it { is_expected.to(match('(abc)')) }
+        it { expect(regexp.match('(abc)')[:version_and_checksum]).to(eq('(abc)')) }
+        it { expect(regexp.match('(abc)')[:explicit_version]).to(eq('abc')) }
+        it { expect(regexp.match('(abc)')[:explicit_checksum]).to(be_nil) }
+      end
+
+      context 'when checksum without version' do
+        it { is_expected.to(match('(~abcd1234)')) }
+        it { expect(regexp.match('(~abcd1234)')[:version_and_checksum]).to(eq('(~abcd1234)')) }
+        it { expect(regexp.match('(~abcd1234)')[:explicit_version]).to(be_nil) }
+        it { expect(regexp.match('(~abcd1234)')[:explicit_checksum]).to(eq('~abcd1234')) }
+        it { expect(regexp.match('(~ABCD1234)')[:explicit_checksum]).to(eq('~ABCD1234')) }
+      end
+
+      context 'when version and checksum' do
+        it { is_expected.to(match('(abc~abcd1234)')) }
+        it { expect(regexp.match('(abc~abcd1234)')[:version_and_checksum]).to(eq('(abc~abcd1234)')) }
+        it { expect(regexp.match('(abc~abcd1234)')[:explicit_version]).to(eq('abc')) }
+        it { expect(regexp.match('(abc~abcd1234)')[:explicit_checksum]).to(eq('~abcd1234')) }
+      end
+    end
+
+    context 'when invalid input' do
+      it { is_expected.not_to(match('whatever')) }
+      it { is_expected.not_to(match('(abc~ghij1234)')) }
+    end
+  end
+
+  describe 'REFERENCE' do
+    subject(:regexp) { Regexp.new("^#{described_class::REFERENCE}$", Regexp::EXTENDED) }
+
+    context 'when valid definition reference' do
+      [
+        'abc',
+        'abc_efg',
+        '_abc_efg_',
+        'abc-efg',
+        '-abc-efg-',
+        '67abc123-efg12',
+        'REFERENCE-0001'
+      ].each do |line|
+        it { is_expected.to(match(line)) }
+      end
+
+      it { expect(regexp.match('67abc123-efg12')[:reference]).to(eq('67abc123-efg12')) }
+    end
+
+    context 'when not valid definition reference' do
+      [
+        '&abcg',
+        'ab@cg',
+        'abc12:3-efg'
+      ].each do |line|
+        it { is_expected.not_to(match(line)) }
+      end
+    end
+  end
+
+  describe 'DEF_SUMMARY' do
+    subject(:regexp) { Regexp.new("^#{described_class::DEF_SUMMARY}$", Regexp::EXTENDED) }
+
+    context 'with valid definition summary' do
+      [
+        '',
+        ', bla bla bli',
+        ', bla bla bli   ',
+        '   , bla bla bli   ',
+        ', bla: bla bli',
+        ', "bla bla, bli"',
+        ', "  bla bla  , bli   "'
+      ].each do |line|
+        it { is_expected.to(match(line)) }
+      end
+
+      it { expect(regexp.match('')[:summary]).to(be_nil) }
+      it { expect(regexp.match(', bla: bla bli   ')[:summary]).to(eq('bla: bla bli')) }
+      it { expect(regexp.match(', " bla bla , bli "')[:summary]).to(eq(' bla bla , bli ')) }
+    end
+
+    context 'with invalid definition summary' do
+      it { is_expected.not_to(match('blabla without coma')) }
+      it { is_expected.not_to(match(', [bla bla bli')) }
+      it { is_expected.not_to(match(', bla bla bli]')) }
+      it { is_expected.not_to(match(', "bla bla bli]')) }
+      it { is_expected.not_to(match(', bla bla bli"]')) }
+      it { is_expected.not_to(match(', ""bla bla bli]')) }
+      it { is_expected.not_to(match(',')) }
+      it { is_expected.not_to(match(',   ')) }
+      it { is_expected.not_to(match(',,')) }
+    end
+  end
+
+  describe 'DEF_LABELS' do
+    subject(:regexp) { Regexp.new("^#{described_class::DEF_LABELS}$", Regexp::EXTENDED) }
+
+    context 'with valid definition labels' do
+      [
+        '',
+        ', [ label1 ]',
+        ', [ label1, label2 ]',
+        ', [ label1 , label2 ]',
+        ', [ label with blank ]'
+      ].each do |line|
+        it { is_expected.to(match(line)) }
+      end
+
+      it { expect(regexp.match('')[:labels]).to(be_nil) }
+      it { expect(regexp.match(', [ label1 , label2 ]')[:labels]).to(eq('label1 , label2')) }
+    end
+
+    context 'with invalid definition summary' do
+      it { is_expected.not_to(match(' , [ label1 , label2 ]')) }
+      it { is_expected.not_to(match(', [ label1 , label2 ] ')) }
+      it { is_expected.not_to(match(', label1 , label2 ')) }
+    end
+  end
+
+  describe 'DEFINITION' do
+    subject(:regexp) { described_class::DEFINITION }
+
+    context 'with valid definition lines' do
+      [
+        '[ define, definition_type, REFERENCE_0001(abcd~abcdef) ]',
+        '[define , definition_type, REFERENCE-0001]',
+        '[ define,def-type , 001-REFERENCE, [ label1, label2 ] ]   ',
+        '[ define, def-type , REFERENCE-001 ,    [ label1, label2 ] ]',
+        '[ define, def-type , REFERENCE-001 , a summary, [ label1, label2 ] ]',
+        '[ define, def-type , REFERENCE-001 , "a, summary, comma", [ label1, label2 ] ]'
+      ].each do |line|
+        it { is_expected.to(match(line)) }
+      end
+
+      let(:one_match) { regexp.match('[define,type,REF_01(a~1234),a summary,[a,b]]') }
+
+      it { expect(one_match[:type]).to(eq('type')) }
+      it { expect(one_match[:reference]).to(eq('REF_01')) }
+      it { expect(one_match[:explicit_version]).to(eq('a')) }
+      it { expect(one_match[:explicit_checksum]).to(eq('~1234')) }
+      it { expect(one_match[:summary]).to(eq('a summary')) }
+      it { expect(one_match[:labels]).to(eq('a,b')) }
+
+      it { expect(regexp.match('[define,t,R," a , comma "]')[:summary]).to(eq(' a , comma ')) }
+    end
+
+    context 'with invalid definition lines' do
+      [
+        'define, type, ref',
+        '[define type , ref]',
+        '[defineeee, type , ref]',
+        '[defineeee, type , ref, pouet, [tagada, tsointsoin]]',
+        '[defineeee, type , ref, [tagada, tsointsoin], pouet]'
+      ].each do |line|
+        it { is_expected.not_to(match(line)) }
+      end
+    end
+  end
+
+  describe 'VARIABLE_DEF' do
+    subject(:regexp) { described_class::VARIABLE_DEF }
+
+    context 'with valid variable definitions' do
+      [
+        ':my_var: value',
+        '    :my_var: value',
+        ':var_with_underscores: another_value',
+        ':var-with_dash: another_value',
+        ':var_with_leading_space:      value',
+        ':var_with_trailing_space: value    '
+      ].each do |line|
+        it { is_expected.to(match(line)) }
+      end
+
+      let(:one_match) { regexp.match(':my_nice-var:       nice    value    ') }
+
+      it { expect(one_match[:varname]).to(eq('my_nice-var')) }
+      it { expect(one_match[:value]).to(eq('nice    value')) }
+    end
+
+    context 'with invalid variable definitions' do
+      [
+        ':var_@: value',
+        ':var space: value',
+        ':var_space : value',
+        ':var_with:: value'
+      ].each do |line|
+        it { is_expected.not_to(match(line)) }
+      end
+    end
+  end
+
+  describe 'VARIABLE_USE' do
+    subject(:regexp) { described_class::VARIABLE_USE }
+
+    context 'with valid variable utilization' do
+      [
+        '{my_var}',
+        '    {my_var}   ',
+        '{var-with_dash}',
+        '[define, requirement, TOTO-0001, A nice {a_variable}]'
+      ].each do |line|
+        it { is_expected.to(match(line)) }
+      end
+
+      let(:one_match) { regexp.match('  {my_nice-var} ') }
+
+      it { expect(one_match[:varname]).to(eq('my_nice-var')) }
+    end
+
+    context 'with invalid variable definitions' do
+      [
+        '{var_@}',
+        '{var space}',
+        '{var_space }',
+        '{var_with:}'
+      ].each do |line|
+        it { is_expected.not_to(match(line)) }
+      end
+    end
+  end
+
+  describe 'EREF_CONFIG' do
+    subject(:regexp) { described_class::EREF_CONFIG }
+
+    context 'with valid external ref configuration' do
+      let(:one_match_prefix) { regexp.match('  :eref-something-prefix:  a_prefix       ') }
+      let(:one_match_url) { regexp.match(':eref-something-url:        an url   ') }
+
+      [
+        ':eref-something-prefix: a_prefix',
+        ':eref-something-url: a_url',
+        '    :eref-something-url: a_url'
+      ].each do |line|
+        it { is_expected.to(match(line)) }
+      end
+
+      it { expect(one_match_prefix[:reference]).to(eq('something')) }
+      it { expect(one_match_prefix[:symb]).to(eq('prefix')) }
+      it { expect(one_match_prefix[:value]).to(eq('a_prefix')) }
+
+      it { expect(one_match_url[:reference]).to(eq('something')) }
+      it { expect(one_match_url[:symb]).to(eq('url')) }
+      it { expect(one_match_url[:value]).to(eq('an url')) }
+    end
+
+    context 'with invalid ref configuration' do
+      [
+        ':eref-something-plop: a_prefix',
+        ':  eref-something-prefix: a_prefix',
+        ':eref-something-prefix  : a_prefix',
+        ':eref- something-prefix: a_prefix',
+        ':eref-something -prefix: a_prefix',
+        ':eref-something- prefix: a_prefix'
+      ].each do |line|
+        it { is_expected.not_to(match(line)) }
+      end
+    end
+  end
+
+  describe 'EREF_DEF' do
+    subject(:regexp) { described_class::EREF_DEF }
+
+    let(:one_match) { regexp.match('defs:eref[abcdef, [ABC, EDF]]') }
+
+    context 'with valid external ref' do
+      [
+        'defs:eref[abcdef, [ABC, EDF]]',
+        '   defs:eref[abcdef, [ABC, EDF]]',
+        'defs:eref[    abcdef, [ABC, EDF]]',
+        'defs:eref[abcdef,[ABC,EDF]]',
+        'defs:eref[abcdef, [ABC, EDF]   ]',
+        'defs:eref[abcdef, [ABC, EDF   ]]',
+        'defs:eref[abcdef, [ABC]]'
+      ].each do |line|
+        it { is_expected.to(match(line)) }
+      end
+
+      it { expect(one_match[:reference]).to(eq('abcdef')) }
+      it { expect(one_match[:extrefs]).to(eq('ABC, EDF')) }
+    end
+
+    context 'with invalid external ref' do
+      [
+        'defs   :eref[abcdef, [ABC, EDF]]',
+        'defs:   eref[abcdef, [ABC, EDF]]',
+        'defs:eref   [abcdef, [ABC, EDF]]'
+      ].each do |line|
+        it { is_expected.not_to(match(line)) }
+      end
+    end
+  end
+
+  describe 'BLOCK' do
+    subject(:regexp) { described_class::BLOCK }
+
+    context 'with valid block delimiter' do
+      it { is_expected.to(match('--')) }
+      it { is_expected.to(match('--    ')) }
+    end
+
+    context 'with invalid block delimiter' do
+      it { is_expected.not_to(match('  --')) }
+      it { is_expected.not_to(match('--    qsdqsd')) }
+    end
+  end
+
+  describe 'IREF_DEF_BEF' do
+    subject(:regexp) { Regexp.new("^#{described_class::IREF_DEF_BEF}$") }
+
+    context 'with valid IREF_DEF_BEF' do
+      it { is_expected.to(match('defs:iref[')) }
+      it { is_expected.to(match('defs:iref[    ')) }
+    end
+
+    context 'with invalid IREF_DEF_BEF' do
+      it { is_expected.not_to(match('  defs:iref[')) }
+      it { is_expected.not_to(match('defs  :iref[')) }
+      it { is_expected.not_to(match('defs:  iref[')) }
+      it { is_expected.not_to(match('defs:iref  [')) }
+      it { is_expected.not_to(match('defs:iref[ a')) }
+    end
+  end
+
+  describe 'IREF_DEF_AFT' do
+    subject(:regexp) { Regexp.new("^#{described_class::IREF_DEF_AFT}$") }
+
+    context 'with valid IREF_DEF_AFT' do
+      it { is_expected.to(match(']')) }
+      it { is_expected.to(match('   ]')) }
+    end
+
+    context 'with invalid IREF_DEF_AFT' do
+      it { is_expected.not_to(match('a]')) }
+      it { is_expected.not_to(match('] ')) }
+    end
+  end
+
+  describe 'IREF_DEF' do
+    subject(:regexp) { described_class::IREF_DEF }
+
+    context 'with valid IREF_DEF' do
+      it { is_expected.to(match('defs:iref[blabla]')) }
+      it { is_expected.to(match('defs:iref[bla-bla]')) }
+      it { is_expected.to(match('defs:iref[bla_bla]')) }
+      it { is_expected.to(match('   defs:iref[bla_bla]')) }
+      it { is_expected.to(match('   defs:iref[   bla_bla]')) }
+      it { is_expected.to(match('   defs:iref[   bla_bla   ]')) }
+      it { is_expected.to(match('   defs:iref[   bla_bla   ]   ')) }
+
+      it { expect(regexp.match('   defs:iref[   bla_bla   ]   ')[:intref]).to(eq('bla_bla')) }
+    end
+
+    context 'with invalid IREF_DEF' do
+      it { is_expected.not_to(match('defs :iref[blabla]')) }
+      it { is_expected.not_to(match('defs: iref[blabla]')) }
+      it { is_expected.not_to(match('defs:iref [blabla]')) }
+    end
+  end
+
+  describe 'ATTR_CONFIG' do
+    subject(:regexp) { described_class::ATTR_CONFIG }
+
+    context 'when valid attribute configuration' do
+      it { is_expected.to(match(':attr-my_attribute-prefix: my_prefix')) }
+      it { is_expected.to(match(':attr-my-attribute-prefix: my blala prefix')) }
+      it { expect(regexp.match(':attr-my_attribute-prefix: my_prefix')[:attr]).to(eq('my_attribute')) }
+      it { expect(regexp.match(':attr-my_attribute-prefix: my_prefix')[:prefix]).to(eq('my_prefix')) }
+      it { expect(regexp.match(':attr-my_attribute-prefix:   with blank:  ')[:prefix]).to(eq('with blank:')) }
+    end
+
+    context 'when invalid attribute configuration' do
+      it { is_expected.not_to(match('attr-my_attribute-prefix: my_prefix')) }
+      it { is_expected.not_to(match(':atttr-my_attribute-prefix: my_prefix')) }
+      it { is_expected.not_to(match(':attr-my_attribute-prefixx: my_prefix')) }
+      it { is_expected.not_to(match(':attr-my_attribute-prefix : my_prefix')) }
+      it { is_expected.not_to(match(':attr-my_attribute-prefix: ')) }
+    end
+  end
+
+  describe 'ATTR_SET' do
+    subject(:regexp) { described_class::ATTR_SET }
+
+    context 'when valid attribute setting' do
+      it { is_expected.to(match('defs:attribute[my-attribute, attr value]')) }
+      it { is_expected.to(match('defs:attribute[   my-attribute, attr value]')) }
+      it { is_expected.to(match('defs:attribute[my-attribute   , attr value]')) }
+      it { is_expected.to(match('defs:attribute[my-attribute, attr value   ]')) }
+      it { is_expected.to(match('defs:attribute[   my-attribute   , attr value ]')) }
+      it { expect(regexp.match('defs:attribute[   my-attribute   , attr value ]')[:attr]).to(eq('my-attribute')) }
+      it { expect(regexp.match('defs:attribute[   my-attribute   , attr value ]')[:value]).to(eq('attr value')) }
+    end
+
+    context 'when invalid attribute setting' do
+      it { is_expected.not_to(match('defs :attribute[my-attribute, attr value]')) }
+      it { is_expected.not_to(match('defs: attribute[my-attribute, attr value]')) }
+      it { is_expected.not_to(match('defs:attribute [my-attribute, attr value]')) }
+      it { is_expected.not_to(match('defs:attribute[my@attribute, attr value]')) }
+    end
+  end
+
+  describe 'EMPTY_LINE' do
+    subject(:regexp) { described_class::EMPTY_LINE }
+
+    context 'when valid empty line' do
+      it { is_expected.to(match('')) }
+      it { is_expected.to(match('   ')) }
+      it { is_expected.to(match("   \t   ")) }
+    end
+
+    context 'when invalid empty match' do
+      it { is_expected.not_to(match(' a ')) }
+    end
+  end
+
+  describe 'WHATEVER' do
+    subject(:regexp) { described_class::WHATEVER }
+
+    context 'when matching everything' do
+      it { is_expected.to(match('')) }
+      it { is_expected.to(match('qsdqsd')) }
+      it { is_expected.to(match("   \t qsdqsd \n qsdqsd  ")) }
+    end
+  end
+
+  describe 'INCLUDE_KEYWORD' do
+    subject(:regexp) { Regexp.new("#{described_class::INCLUDE_KEYWORD}$") }
+
+    context 'when matching include keyword' do
+      it { is_expected.to(match('include::')) }
+      it { is_expected.to(match('   include::')) }
+    end
+
+    context 'when not matching bad include keyword' do
+      it { is_expected.not_to(match('   _include::')) }
+      it { is_expected.not_to(match('   a include::')) }
+      it { is_expected.not_to(match('   -include::')) }
+    end
+  end
+
+  describe 'INCLUDE_PATH' do
+    subject(:regexp) { Regexp.new("^#{described_class::INCLUDE_PATH}$") }
+
+    context 'when matching include path' do
+      it { is_expected.to(match('')) }
+      it { is_expected.to(match('bla bla/')) }
+      it { is_expected.to(match('bla //// bla/')) }
+      it { is_expected.to(match('   bla //// bla/')) }
+      it { expect(regexp.match('   bla //// bla/')[:path]).to(eq('   bla //// bla/')) }
+      it { expect(regexp.match('')[:path]).to(be_nil) }
+    end
+
+    context 'when not matching bad include path' do
+      it { is_expected.not_to(match('bla bla')) }
+      it { is_expected.not_to(match('bla bla/ ')) }
+    end
+  end
+
+  describe 'INCLUDE_FILENAME' do
+    subject(:regexp) { Regexp.new("^#{described_class::INCLUDE_FILENAME}$") }
+
+    context 'when matching valid filename' do
+      it { is_expected.to(match('bla bla @ -')) }
+      it { expect(regexp.match('bla bla @ -')[:filename]).to(eq('bla bla @ -')) }
+    end
+
+    context 'when not matching bad filename' do
+      it { is_expected.not_to(match('')) }
+      it { is_expected.not_to(match('bla / bla')) }
+      it { is_expected.not_to(match('bla \ bla ')) }
+    end
+  end
+
+  describe 'INCLUDE_OPTIONS' do
+    subject(:regexp) { Regexp.new("^#{described_class::INCLUDE_OPTIONS}$") }
+
+    context 'when matching include options' do
+      it { is_expected.to(match('[]')) }
+      it { is_expected.to(match('[whatever qsddl qmlsdkml qsdl]')) }
+      it { expect(regexp.match('[]')[:options]).to(eq('')) }
+      it { expect(regexp.match('[whatever blabla ]')[:options]).to(eq('whatever blabla ')) }
+    end
+
+    context 'when not matching bad include options' do
+      it { is_expected.not_to(match('[whatever]]')) }
+      it { is_expected.not_to(match('[whate]ver]')) }
+    end
+  end
+
+  describe 'INCLUDE' do
+    subject(:regexp) { described_class::INCLUDE }
+
+    context 'when matching include statement' do
+      let(:line) { 'include::my path/my filename[my options]' }
+
+      it { is_expected.to(match(line)) }
+      it { expect(regexp.match(line)[:path]).to(eq('my path/')) }
+      it { expect(regexp.match(line)[:filename]).to(eq('my filename')) }
+      it { expect(regexp.match(line)[:options]).to(eq('my options')) }
+    end
+
+    context 'when not matching bad include statement' do
+      it { is_expected.not_to(match('a include::my path/my filename[my options]')) }
+      it { is_expected.not_to(match('include::my path/my\ filename[my options]')) }
+      it { is_expected.not_to(match('include::my path/[my options]')) }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: defmastership-core
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Jérôme Arbez-Gindre
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-16 00:00:00.000000000 Z
+date: 2025-01-04 00:00:00.000000000 Z
 dependencies: []
 description:
 email: jeromearbezgindre@gmail.com
@@ -32,6 +32,7 @@ files:
 - lib/defmastership/core/parsing_state.rb
 - lib/defmastership/core/version.rb
 - spec/spec_helper.rb
+- spec/unit/defmastership/core/dm_regexp_spec.rb
 - spec/unit/defmastership/core/parsing_state_spec.rb
 - spec/unit/defmastership/core_spec.rb
 - tasks/code_quality.rake