defmastership-core 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e02b53e306be26b56798011f57225ffce2c03d247faab3846375b2279e87c2fa
-  data.tar.gz: 5c236cdea358de4137c53667dd9a4c42ae3fcdffde9298977a5b56f14dd36b07
+  metadata.gz: '034357962fd2a1625b213b5ed29b83bd7cc9a659c24b1b0a8f5b202dea47113a'
+  data.tar.gz: d32796f5f8cb5eef96568e35011a09033badccb5d7708c3077ccd9519df71228
 SHA512:
-  metadata.gz: 479cfc833f1a4e2364e5f620cfee9b66dc5847636182aefcdc779a4c8a465a9eb0335e740fe3eff5d148fb96b8b38401d80617b02462cd4bd882387645f8a3a6
-  data.tar.gz: 5e498d2697e36fc40ee377308611c44b4323230082d0e071f05d604b398042cbd5eb0e87d1663a619441e2077d851fdcbf3a120b1648eab2e0cc00b63e196c63
+  metadata.gz: 04b9343450b59869b5100144cbf1ec8388ff72cfba713be83be2292b81a6f55e20e087fec8b91f3b49a63df88a2312cc9bdffca4f415c401581167021b60738a
+  data.tar.gz: 979b8eed01f02b85ff4d2b314779c4210cd8372e6f901335662163d72c2135d480e3af501702de4a5ed88ab29410e3aa7cc58598133cdd2204e61ad83fc41c71

data/lib/defmastership/core/constants.rb

@@ -7,60 +7,102 @@ 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 = '\s*(,\s*(?<summary>[^\s,\[\]][^,\[\]]*?)\s*)?'
+      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
+      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 +118,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 +143,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/parsing_state.rb

@@ -1,6 +1,9 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require('defmastership/core/constants')
+require('defmastership/core/parsing_state')
+
 module Defmastership
   module Core
     # Allow to know if we need to parse the line or simply ignore it

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

data/spec/spec_helper.rb

@@ -25,5 +25,3 @@ RSpec::Matchers.define(:matchdata_including) do |h|
     end
   end
 end
-
-require('defmastership')

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

@@ -0,0 +1,652 @@
+# 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]'
+      ].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) }
+    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   '
+      ].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')) }
+    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(',')) }
+      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 ] ]'
+      ].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')) }
+    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}'
+      ].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.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Jérôme Arbez-Gindre
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-16 00:00:00.000000000 Z
+date: 2024-12-22 00:00:00.000000000 Z
 dependencies: []
 description:
 email: jeromearbezgindre@gmail.com
@@ -28,11 +28,11 @@ files:
 - config/rspec
 - config/rubocop.yml
 - defmastership-core.gemspec
-- lib/defmastership.rb
 - lib/defmastership/core/constants.rb
 - 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
@@ -61,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: Handling of references and definitions with asciidoctor - common code

data/lib/defmastership.rb

@@ -1,9 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require('defmastership/core/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/core/constants')
-require('defmastership/core/parsing_state')