regexp_parser 1.5.0 → 1.5.1

data/lib/regexp_parser/version.rb

@@ -1,5 +1,5 @@
 class Regexp
   class Parser
-    VERSION = '1.5.0'
+    VERSION = '1.5.1'
   end
 end

data/spec/expression/base_spec.rb

@@ -77,4 +77,18 @@ RSpec.describe(Regexp::Expression::Base) do
     expect([root[2][1].coded_offset, root[2][1].to_s]).to eq ['@6+4', '(c?)']
     expect([root[2][1][0].coded_offset, root[2][1][0].to_s]).to eq ['@7+2', 'c?']
   end
+
+  specify('#quantity') do
+    expect(RP.parse(/aa/)[0].quantity).to eq [nil, nil]
+    expect(RP.parse(/a?/)[0].quantity).to eq [0, 1]
+    expect(RP.parse(/a*/)[0].quantity).to eq [0, -1]
+    expect(RP.parse(/a+/)[0].quantity).to eq [1, -1]
+  end
+
+  specify('#repetitions') do
+    expect(RP.parse(/aa/)[0].repetitions).to eq 1..1
+    expect(RP.parse(/a?/)[0].repetitions).to eq 0..1
+    expect(RP.parse(/a*/)[0].repetitions).to eq 0..(Float::INFINITY)
+    expect(RP.parse(/a+/)[0].repetitions).to eq 1..(Float::INFINITY)
+  end
 end

data/spec/expression/methods/match_length_spec.rb

@@ -30,6 +30,12 @@ RSpec.describe(Regexp::MatchLength) do
     specify('absence group') { expect(ML.of('(?~abc)').minmax).to eq [0, Float::INFINITY] }
   end
 
+  specify('raises for missing references') do
+    exp = RP.parse(/(a)\1/).last
+    exp.referenced_expression = nil
+    expect { exp.match_length }.to raise_error(ArgumentError)
+  end
+
   describe('::of') do
     it('works with Regexps') { expect(ML.of(/foo/).minmax).to eq [3, 3] }
     it('works with Strings') { expect(ML.of('foo').minmax).to eq [3, 3] }
@@ -138,4 +144,11 @@ RSpec.describe(Regexp::MatchLength) do
       expect(ML.of(/a*/).endless_each.first(3000).size).to eq 3000
     end
   end
+
+  describe('#inspect') do
+    it 'is nice' do
+      result = RP.parse(/a{2,4}/)[0].match_length
+      expect(result.inspect).to eq '#<Regexp::MatchLength<Literal> min=2 max=4>'
+    end
+  end
 end

data/spec/expression/methods/match_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe('Expression#match') do
+  it 'returns the #match result of the respective Regexp' do
+    expect(RP.parse(/a/).match('a')[0]).to eq 'a'
+  end
+
+  it 'can be given an offset, just like Regexp#match' do
+    expect(RP.parse(/./).match('ab', 1)[0]).to eq 'b'
+  end
+
+  it 'works with the #=~ alias' do
+    expect(RP.parse(/a/) =~ 'a').to be_a MatchData
+  end
+end
+
+RSpec.describe('Expression#match?') do
+  it 'returns true if the Respective Regexp matches' do
+    expect(RP.parse(/a/).match?('a')).to be true
+  end
+
+  it 'returns false if the Respective Regexp does not match' do
+    expect(RP.parse(/a/).match?('b')).to be false
+  end
+end

data/spec/expression/methods/tests_spec.rb

@@ -93,5 +93,7 @@ RSpec.describe('ExpressionTests') do
     expect(seq_2.last.one_of?(meta: [:*], anchor: :eos)).to be true
     expect(seq_2.last.one_of?(meta: [:*], anchor: [:bos])).to be false
     expect(seq_2.last.one_of?(meta: [:*], anchor: %i[bos eos])).to be true
+
+    expect { root.one_of?(Object.new) }.to raise_error(ArgumentError)
   end
 end

data/spec/expression/options_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+RSpec.describe('Expression#options') do
+  it 'returns a hash of options/flags that affect the expression' do
+    exp = RP.parse(/a/ix)[0]
+    expect(exp).to be_a Literal
+    expect(exp.options).to eq(i: true, x: true)
+  end
+
+  it 'includes options that are locally enabled via special groups' do
+    exp = RP.parse(/(?x)(?m:a)/i)[1][0]
+    expect(exp).to be_a Literal
+    expect(exp.options).to eq(i: true, m: true, x: true)
+  end
+
+  it 'excludes locally disabled options' do
+    exp = RP.parse(/(?x)(?-im:a)/i)[1][0]
+    expect(exp).to be_a Literal
+    expect(exp.options).to eq(x: true)
+  end
+
+  it 'gives correct precedence to negative options' do
+    # Negative options have precedence. E.g. /(?i-i)a/ is case-sensitive.
+    regexp = /(?i-i:a)/
+    expect(regexp).to match 'a'
+    expect(regexp).not_to match 'A'
+
+    exp = RP.parse(regexp)[0][0]
+    expect(exp).to be_a Literal
+    expect(exp.options).to eq({})
+  end
+
+  it 'correctly handles multiple negative option parts' do
+    regexp = /(?--m--mx--) . /mx
+    expect(regexp).to match ' . '
+    expect(regexp).not_to match '.'
+    expect(regexp).not_to match "\n"
+
+    exp = RP.parse(regexp)[2]
+    expect(exp.options).to eq({})
+  end
+
+  it 'gives correct precedence when encountering multiple encoding flags' do
+    # Any encoding flag overrides all previous encoding flags. If there are
+    # multiple encoding flags in an options string, the last one wins.
+    # E.g. /(?dau)\w/ matches UTF8 chars but /(?dua)\w/ only ASCII chars.
+    regexp1 = /(?dau)\w/
+    regexp2 = /(?dua)\w/
+    expect(regexp1).to match 'ü'
+    expect(regexp2).not_to match 'ü'
+
+    exp1 = RP.parse(regexp1)[1]
+    exp2 = RP.parse(regexp2)[1]
+    expect(exp1.options).to eq(u: true)
+    expect(exp2.options).to eq(a: true)
+  end
+
+  it 'is accessible via shortcuts' do
+    exp = Root.build
+
+    expect { exp.options[:i] = true }
+      .to  change { exp.i? }.from(false).to(true)
+      .and change { exp.ignore_case? }.from(false).to(true)
+      .and change { exp.case_insensitive? }.from(false).to(true)
+
+    expect { exp.options[:m] = true }
+      .to  change { exp.m? }.from(false).to(true)
+      .and change { exp.multiline? }.from(false).to(true)
+
+    expect { exp.options[:x] = true }
+      .to  change { exp.x? }.from(false).to(true)
+      .and change { exp.extended? }.from(false).to(true)
+      .and change { exp.free_spacing? }.from(false).to(true)
+
+    expect { exp.options[:a] = true }
+      .to  change { exp.a? }.from(false).to(true)
+      .and change { exp.ascii_classes? }.from(false).to(true)
+
+    expect { exp.options[:d] = true }
+      .to  change { exp.d? }.from(false).to(true)
+      .and change { exp.default_classes? }.from(false).to(true)
+
+    expect { exp.options[:u] = true }
+      .to  change { exp.u? }.from(false).to(true)
+      .and change { exp.unicode_classes? }.from(false).to(true)
+  end
+
+  RSpec.shared_examples '#options' do |regexp, klass, at: []|
+    it "works for expression class #{klass}" do
+      exp = RP.parse(/#{regexp.source}/i).dig(*at)
+      expect(exp).to be_a(klass)
+      expect(exp).to be_i
+      expect(exp).not_to be_x
+    end
+  end
+
+  include_examples '#options', //, Root
+  include_examples '#options', /a/, Literal, at: [0]
+  include_examples '#options', /\A/, Anchor::Base, at: [0]
+  include_examples '#options', /\d/, CharacterType::Base, at: [0]
+  include_examples '#options', /\n/, EscapeSequence::Base, at: [0]
+  include_examples '#options', /\K/, Keep::Mark, at: [0]
+  include_examples '#options', /./, CharacterType::Any, at: [0]
+  include_examples '#options', /(a)/, Group::Base, at: [0]
+  include_examples '#options', /(a)/, Literal, at: [0, 0]
+  include_examples '#options', /(?=a)/, Assertion::Base, at: [0]
+  include_examples '#options', /(?=a)/, Literal, at: [0, 0]
+  include_examples '#options', /(a|b)/, Group::Base, at: [0]
+  include_examples '#options', /(a|b)/, Alternation, at: [0, 0]
+  include_examples '#options', /(a|b)/, Alternative, at: [0, 0, 0]
+  include_examples '#options', /(a|b)/, Literal, at: [0, 0, 0, 0]
+  include_examples '#options', /(a)\1/, Backreference::Base, at: [1]
+  include_examples '#options', /(a)\k<1>/, Backreference::Number, at: [1]
+  include_examples '#options', /(a)\g<1>/, Backreference::NumberCall, at: [1]
+  include_examples '#options', /[a]/, CharacterSet, at: [0]
+  include_examples '#options', /[a]/, Literal, at: [0, 0]
+  include_examples '#options', /[a-z]/, CharacterSet::Range, at: [0, 0]
+  include_examples '#options', /[a-z]/, Literal, at: [0, 0, 0]
+  include_examples '#options', /[a&&z]/, CharacterSet::Intersection, at: [0, 0]
+  include_examples '#options', /[a&&z]/, CharacterSet::IntersectedSequence, at: [0, 0, 0]
+  include_examples '#options', /[a&&z]/, Literal, at: [0, 0, 0, 0]
+  include_examples '#options', /[[:ascii:]]/, PosixClass, at: [0, 0]
+  include_examples '#options', /\p{word}/, UnicodeProperty::Base, at: [0]
+  include_examples '#options', /(a)(?(1)b|c)/, Conditional::Expression, at: [1]
+  include_examples '#options', /(a)(?(1)b|c)/, Conditional::Condition, at: [1, 0]
+  include_examples '#options', /(a)(?(1)b|c)/, Conditional::Branch, at: [1, 1]
+  include_examples '#options', /(a)(?(1)b|c)/, Literal, at: [1, 1, 0]
+end

data/spec/expression/root_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Expression::Root) do
+  describe('#initialize') do
+    it 'supports the old, nonstandard arity for backwards compatibility' do
+      expect { Root.new }.to output.to_stderr
+    end
+  end
+end

data/spec/expression/sequence_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Expression::Sequence) do
+  describe('#initialize') do
+    it 'supports the old, nonstandard arity for backwards compatibility' do
+      expect { Sequence.new(0, 0, 0) }.to output.to_stderr
+    end
+  end
+end

data/spec/lexer/conditionals_spec.rb

@@ -1,123 +1,53 @@
 require 'spec_helper'
 
 RSpec.describe('Conditional lexing') do
-  # Basic lexer output and nesting tests
-  tests = {
-    '(?<A>a)(?(<A>)b|c)'  => [3, :conditional, :open,       '(?',     7,  9, 0, 0, 0],
-    '(?<B>a)(?(<B>)b|c)'  => [4, :conditional, :condition,  '(<B>)',  9, 14, 0, 0, 1],
-    '(?<C>a)(?(<C>)b|c)'  => [6, :conditional, :separator,  '|',     15, 16, 0, 0, 1],
-    '(?<D>a)(?(<D>)b|c)'  => [8, :conditional, :close,      ')',     17, 18, 0, 0, 0],
-  }
-
-  tests.each_with_index do |(pattern, (index, type, token, text, ts, te, level, set_level, conditional_level)), count|
-    specify("lexer_#{type}_#{token}_#{count}") do
-      tokens = RL.lex(pattern)
-      struct = tokens.at(index)
-
-      expect(struct.type).to eq type
-      expect(struct.token).to eq token
-      expect(struct.text).to eq text
-      expect(struct.ts).to eq ts
-      expect(struct.te).to eq te
-      expect(struct.level).to eq level
-      expect(struct.set_level).to eq set_level
-      expect(struct.conditional_level).to eq conditional_level
-    end
-  end
-
-  specify('lexer conditional mixed nesting') do
-    regexp = '((?<A>a)(?<B>(?(<A>)b|((?(<B>)[e-g]|[h-j])))))'
-    tokens = RL.lex(regexp)
-
-    [
-      [ 0, :group,       :capture,          '(',       0,  1, 0, 0, 0],
-      [ 1, :group,       :named,            '(?<A>',   1,  6, 1, 0, 0],
-
-      [ 5, :conditional, :open,             '(?',     13, 15, 2, 0, 0],
-      [ 6, :conditional, :condition,        '(<A>)',  15, 20, 2, 0, 1],
-      [ 8, :conditional, :separator,        '|',      21, 22, 2, 0, 1],
-
-      [10, :conditional, :open,             '(?',     23, 25, 3, 0, 1],
-      [11, :conditional, :condition,        '(<B>)',  25, 30, 3, 0, 2],
-
-      [12, :set,         :open,             '[',      30, 31, 3, 0, 2],
-      [13, :literal,     :literal,          'e',      31, 32, 3, 1, 2],
-      [14, :set,         :range,            '-',      32, 33, 3, 1, 2],
-      [15, :literal,     :literal,          'g',      33, 34, 3, 1, 2],
-      [16, :set,         :close,            ']',      34, 35, 3, 0, 2],
-
-      [17, :conditional, :separator,        '|',      35, 36, 3, 0, 2],
-      [23, :conditional, :close,            ')',      41, 42, 3, 0, 1],
-      [25, :conditional, :close,            ')',      43, 44, 2, 0, 0],
-
-      [26, :group,       :close,            ')',      44, 45, 1, 0, 0],
-      [27, :group,       :close,            ')',      45, 46, 0, 0, 0]
-    ].each do |index, type, token, text, ts, te, level, set_level, conditional_level|
-      struct = tokens.at(index)
-
-      expect(struct.type).to eq type
-      expect(struct.token).to eq token
-      expect(struct.text).to eq text
-      expect(struct.ts).to eq ts
-      expect(struct.te).to eq te
-      expect(struct.level).to eq level
-      expect(struct.set_level).to eq set_level
-      expect(struct.conditional_level).to eq conditional_level
-    end
-  end
-
-  specify('lexer conditional deep nesting') do
-    regexp = '(a(b(c)))(?(1)(?(2)(?(3)d|e))|(?(3)(?(2)f|g)|(?(1)f|g)))'
-    tokens = RL.lex(regexp)
-
-    [
-      [ 9, :conditional, :open,       '(?',    9, 11, 0, 0, 0],
-      [10, :conditional, :condition,  '(1)',  11, 14, 0, 0, 1],
-
-      [11, :conditional, :open,       '(?',   14, 16, 0, 0, 1],
-      [12, :conditional, :condition,  '(2)',  16, 19, 0, 0, 2],
-
-      [13, :conditional, :open,       '(?',   19, 21, 0, 0, 2],
-      [14, :conditional, :condition,  '(3)',  21, 24, 0, 0, 3],
-
-      [16, :conditional, :separator,  '|',    25, 26, 0, 0, 3],
-
-      [18, :conditional, :close,      ')',    27, 28, 0, 0, 2],
-      [19, :conditional, :close,      ')',    28, 29, 0, 0, 1],
-
-      [20, :conditional, :separator,  '|',    29, 30, 0, 0, 1],
-
-      [21, :conditional, :open,       '(?',   30, 32, 0, 0, 1],
-      [22, :conditional, :condition,  '(3)',  32, 35, 0, 0, 2],
-
-      [23, :conditional, :open,       '(?',   35, 37, 0, 0, 2],
-      [24, :conditional, :condition,  '(2)',  37, 40, 0, 0, 3],
-
-      [26, :conditional, :separator,  '|',    41, 42, 0, 0, 3],
-
-      [28, :conditional, :close,      ')',    43, 44, 0, 0, 2],
-
-      [29, :conditional, :separator,  '|',    44, 45, 0, 0, 2],
-
-      [30, :conditional, :open,       '(?',   45, 47, 0, 0, 2],
-      [31, :conditional, :condition,  '(1)',  47, 50, 0, 0, 3],
-
-      [33, :conditional, :separator,  '|',    51, 52, 0, 0, 3],
-
-      [35, :conditional, :close,      ')',    53, 54, 0, 0, 2],
-      [36, :conditional, :close,      ')',    54, 55, 0, 0, 1],
-      [37, :conditional, :close,      ')',    55, 56, 0, 0, 0]
-    ].each do |index, type, token, text, ts, te, level, set_level, conditional_level|
-      struct = tokens.at(index)
-
-      expect(struct.type).to eq type
-      expect(struct.token).to eq token
-      expect(struct.text).to eq text
-      expect(struct.ts).to eq ts
-      expect(struct.te).to eq te
-      expect(struct.level).to eq level
-      expect(struct.set_level).to eq set_level
-      expect(struct.conditional_level).to eq conditional_level
-    end
-  end
+  include_examples 'lex', /(?<A>a)(?(<A>)b|c)/,
+    3 => [:conditional, :open,       '(?',     7,  9, 0, 0, 0],
+    4 => [:conditional, :condition,  '(<A>)',  9, 14, 0, 0, 1],
+    6 => [:conditional, :separator,  '|',     15, 16, 0, 0, 1],
+    8 => [:conditional, :close,      ')',     17, 18, 0, 0, 0]
+
+  include_examples 'lex', /((?<A>a)(?<B>(?(<A>)b|((?(<B>)[e-g]|[h-j])))))/,
+     0 => [:group,       :capture,     '(',       0,  1, 0, 0, 0],
+     1 => [:group,       :named,       '(?<A>',   1,  6, 1, 0, 0],
+     5 => [:conditional, :open,        '(?',     13, 15, 2, 0, 0],
+     6 => [:conditional, :condition,   '(<A>)',  15, 20, 2, 0, 1],
+     8 => [:conditional, :separator,   '|',      21, 22, 2, 0, 1],
+    10 => [:conditional, :open,        '(?',     23, 25, 3, 0, 1],
+    11 => [:conditional, :condition,   '(<B>)',  25, 30, 3, 0, 2],
+    12 => [:set,         :open,        '[',      30, 31, 3, 0, 2],
+    13 => [:literal,     :literal,     'e',      31, 32, 3, 1, 2],
+    14 => [:set,         :range,       '-',      32, 33, 3, 1, 2],
+    15 => [:literal,     :literal,     'g',      33, 34, 3, 1, 2],
+    16 => [:set,         :close,       ']',      34, 35, 3, 0, 2],
+    17 => [:conditional, :separator,   '|',      35, 36, 3, 0, 2],
+    23 => [:conditional, :close,       ')',      41, 42, 3, 0, 1],
+    25 => [:conditional, :close,       ')',      43, 44, 2, 0, 0],
+    26 => [:group,       :close,       ')',      44, 45, 1, 0, 0],
+    27 => [:group,       :close,       ')',      45, 46, 0, 0, 0]
+
+  include_examples 'lex', /(a(b(c)))(?(1)(?(2)(?(3)d|e))|(?(3)(?(2)f|g)|(?(1)f|g)))/,
+     9 => [:conditional, :open,       '(?',    9, 11, 0, 0, 0],
+    10 => [:conditional, :condition,  '(1)',  11, 14, 0, 0, 1],
+    11 => [:conditional, :open,       '(?',   14, 16, 0, 0, 1],
+    12 => [:conditional, :condition,  '(2)',  16, 19, 0, 0, 2],
+    13 => [:conditional, :open,       '(?',   19, 21, 0, 0, 2],
+    14 => [:conditional, :condition,  '(3)',  21, 24, 0, 0, 3],
+    16 => [:conditional, :separator,  '|',    25, 26, 0, 0, 3],
+    18 => [:conditional, :close,      ')',    27, 28, 0, 0, 2],
+    19 => [:conditional, :close,      ')',    28, 29, 0, 0, 1],
+    20 => [:conditional, :separator,  '|',    29, 30, 0, 0, 1],
+    21 => [:conditional, :open,       '(?',   30, 32, 0, 0, 1],
+    22 => [:conditional, :condition,  '(3)',  32, 35, 0, 0, 2],
+    23 => [:conditional, :open,       '(?',   35, 37, 0, 0, 2],
+    24 => [:conditional, :condition,  '(2)',  37, 40, 0, 0, 3],
+    26 => [:conditional, :separator,  '|',    41, 42, 0, 0, 3],
+    28 => [:conditional, :close,      ')',    43, 44, 0, 0, 2],
+    29 => [:conditional, :separator,  '|',    44, 45, 0, 0, 2],
+    30 => [:conditional, :open,       '(?',   45, 47, 0, 0, 2],
+    31 => [:conditional, :condition,  '(1)',  47, 50, 0, 0, 3],
+    33 => [:conditional, :separator,  '|',    51, 52, 0, 0, 3],
+    35 => [:conditional, :close,      ')',    53, 54, 0, 0, 2],
+    36 => [:conditional, :close,      ')',    54, 55, 0, 0, 1],
+    37 => [:conditional, :close,      ')',    55, 56, 0, 0, 0]
 end

data/spec/lexer/escapes_spec.rb

@@ -1,38 +1,14 @@
 require 'spec_helper'
 
 RSpec.describe('Escape lexing') do
-  tests = {
-    '\u{62}' => {
-      0     => [:escape,     :codepoint_list,   '\u{62}',        0, 6,   0, 0, 0],
-    },
+  include_examples 'lex', '\u{62}',
+    0 => [:escape,  :codepoint_list, '\u{62}',       0, 6,  0, 0, 0]
 
-    '\u{62 63 64}' => {
-      0     => [:escape,     :codepoint_list,   '\u{62 63 64}',  0, 12,  0, 0, 0],
-    },
+  include_examples 'lex', '\u{62 63 64}',
+    0 => [:escape,  :codepoint_list, '\u{62 63 64}', 0, 12, 0, 0, 0]
 
-    '\u{62 63 64}+' => {
-      0     => [:escape,     :codepoint_list,   '\u{62 63}',     0,  9,  0, 0, 0],
-      1     => [:escape,     :codepoint_list,   '\u{64}',        9,  15, 0, 0, 0],
-      2     => [:quantifier, :one_or_more,      '+',             15, 16, 0, 0, 0],
-    },
-  }
-
-  tests.each_with_index do |(pattern, checks), count|
-    specify("lex_escape_runs_#{count}") do
-      tokens = RL.lex(pattern)
-
-      checks.each do |index, (type, token, text, ts, te, level, set_level, conditional_level)|
-        struct = tokens.at(index)
-
-        expect(struct.type).to eq type
-        expect(struct.token).to eq token
-        expect(struct.text).to eq text
-        expect(struct.ts).to eq ts
-        expect(struct.te).to eq te
-        expect(struct.level).to eq level
-        expect(struct.set_level).to eq set_level
-        expect(struct.conditional_level).to eq conditional_level
-      end
-    end
-  end
+  include_examples 'lex', '\u{62 63 64}+',
+    0 => [:escape,     :codepoint_list, '\u{62 63}',  0,  9,  0, 0, 0],
+    1 => [:escape,     :codepoint_list, '\u{64}',     9,  15, 0, 0, 0],
+    2 => [:quantifier, :one_or_more,    '+',          15, 16, 0, 0, 0]
 end