regexp_parser 2.0.0 → 2.1.1

data/spec/expression/free_space_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe(Regexp::Expression::FreeSpace) do
     space = root[0]
 
     expect(space).to be_instance_of(FreeSpace::WhiteSpace)
-    expect { space.quantify(:dummy, '#') }.to raise_error(RuntimeError)
+    expect { space.quantify(:dummy, '#') }.to raise_error(Regexp::Parser::Error)
   end
 
   specify('comment quantify raises error') do
@@ -22,6 +22,6 @@ RSpec.describe(Regexp::Expression::FreeSpace) do
     comment = root[3]
 
     expect(comment).to be_instance_of(FreeSpace::Comment)
-    expect { comment.quantify(:dummy, '#') }.to raise_error(RuntimeError)
+    expect { comment.quantify(:dummy, '#') }.to raise_error(Regexp::Parser::Error)
   end
 end

data/spec/expression/methods/match_length_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-RSpec.describe(Regexp::MatchLength) do
-  ML = described_class
+ML = Regexp::MatchLength
 
+RSpec.describe(Regexp::MatchLength) do
   specify('literal') { expect(ML.of(/a/).minmax).to eq [1, 1] }
   specify('literal sequence') { expect(ML.of(/abc/).minmax).to eq [3, 3] }
   specify('dot') { expect(ML.of(/./).minmax).to eq [1, 1] }

data/spec/expression/subexpression_spec.rb

@@ -32,7 +32,7 @@ RSpec.describe(Regexp::Expression::Subexpression) do
     }
 
     root.each_expression do |exp|
-      next unless expected_nesting_level = tests.delete(exp.to_s)
+      next unless (expected_nesting_level = tests.delete(exp.to_s))
       expect(expected_nesting_level).to eq exp.nesting_level
     end
 

data/spec/expression/to_s_spec.rb

@@ -1,58 +1,50 @@
 require 'spec_helper'
 
 RSpec.describe('Expression#to_s') do
-  specify('literal alternation') do
-    pattern = 'abcd|ghij|klmn|pqur'
+  def parse_frozen(pattern, ruby_version = nil)
+    IceNine.deep_freeze(RP.parse(pattern, *ruby_version))
+  end
 
-    expect(RP.parse(pattern).to_s).to eq pattern
+  def expect_round_trip(pattern, ruby_version = nil)
+    parsed = parse_frozen(pattern, ruby_version)
+
+    expect(parsed.to_s).to eql(pattern)
   end
 
-  specify('quantified alternations') do
-    pattern = '(?:a?[b]+(c){2}|d+[e]*(f)?)|(?:g+[h]?(i){2,3}|j*[k]{3,5}(l)?)'
+  specify('literal alternation') do
+    expect_round_trip('abcd|ghij|klmn|pqur')
+  end
 
-    expect(RP.parse(pattern).to_s).to eq pattern
+  specify('quantified alternations') do
+    expect_round_trip('(?:a?[b]+(c){2}|d+[e]*(f)?)|(?:g+[h]?(i){2,3}|j*[k]{3,5}(l)?)')
   end
 
   specify('quantified sets') do
-    pattern = '[abc]+|[^def]{3,6}'
-
-    expect(RP.parse(pattern).to_s).to eq pattern
+    expect_round_trip('[abc]+|[^def]{3,6}')
   end
 
   specify('property sets') do
-    pattern = '[\\a\\b\\p{Lu}\\P{Z}\\c\\d]+'
-
-    expect(RP.parse(pattern, 'ruby/1.9').to_s).to eq pattern
+    expect_round_trip('[\\a\\b\\p{Lu}\\P{Z}\\c\\d]+', 'ruby/1.9')
   end
 
   specify('groups') do
-    pattern = "(a(?>b(?:c(?<n>d(?'N'e)??f)+g)*+h)*i)++"
-
-    expect(RP.parse(pattern, 'ruby/1.9').to_s).to eq pattern
+    expect_round_trip("(a(?>b(?:c(?<n>d(?'N'e)??f)+g)*+h)*i)++", 'ruby/1.9')
   end
 
   specify('assertions') do
-    pattern = '(a+(?=b+(?!c+(?<=d+(?<!e+)?f+)?g+)?h+)?i+)?'
-
-    expect(RP.parse(pattern, 'ruby/1.9').to_s).to eq pattern
+    expect_round_trip('(a+(?=b+(?!c+(?<=d+(?<!e+)?f+)?g+)?h+)?i+)?', 'ruby/1.9')
   end
 
   specify('comments') do
-    pattern = '(?#start)a(?#middle)b(?#end)'
-
-    expect(RP.parse(pattern).to_s).to eq pattern
+    expect_round_trip('(?#start)a(?#middle)b(?#end)')
   end
 
   specify('options') do
-    pattern = '(?mix:start)a(?-mix:middle)b(?i-mx:end)'
-
-    expect(RP.parse(pattern).to_s).to eq pattern
+    expect_round_trip('(?mix:start)a(?-mix:middle)b(?i-mx:end)')
   end
 
   specify('url') do
-    pattern = ('(^$)|(^(http|https):\\/\\/[a-z0-9]+([\\-\\.]{1}[a-z0-9]+)*' + '\\.[a-z]{2,5}(([0-9]{1,5})?\\/.*)?$)')
-
-    expect(RP.parse(pattern).to_s).to eq pattern
+    expect_round_trip('(^$)|(^(http|https):\\/\\/[a-z0-9]+([\\-\\.]{1}[a-z0-9]+)*' + '\\.[a-z]{2,5}(([0-9]{1,5})?\\/.*)?$)')
   end
 
   specify('multiline source') do
@@ -64,7 +56,7 @@ RSpec.describe('Expression#to_s') do
           \z
         /x
 
-    expect(RP.parse(multiline).to_s).to eq multiline.source
+    expect(parse_frozen(multiline).to_s).to eql(multiline.source)
   end
 
   specify('multiline #to_s') do
@@ -76,7 +68,7 @@ RSpec.describe('Expression#to_s') do
           \z
         /x
 
-    expect(RP.parse(multiline.to_s).to_s).to eq multiline.to_s
+    expect_round_trip(multiline.to_s)
   end
 
   # Free spacing expressions that use spaces between quantifiers and their
@@ -93,24 +85,24 @@ RSpec.describe('Expression#to_s') do
         /x
 
     str = 'bbbcged'
-    root = RP.parse(multiline)
+    root = parse_frozen(multiline)
 
-    expect(Regexp.new(root.to_s, Regexp::EXTENDED).match(str)[0]).to eq multiline.match(str)[0]
+    expect(Regexp.new(root.to_s, Regexp::EXTENDED).match(str)[0]).to eql(multiline.match(str)[0])
   end
 
   # special case: implicit groups used for chained quantifiers produce no parens
   specify 'chained quantifiers #to_s' do
     pattern = /a+{1}{2}/
-    root = RP.parse(pattern)
-    expect(root.to_s).to eq 'a+{1}{2}'
+    root = parse_frozen(pattern)
+    expect(root.to_s).to eql('a+{1}{2}')
   end
 
   # regression test for https://github.com/ammar/regexp_parser/issues/74
   specify('non-ascii comment') do
     pattern = '(?x) 😋 # 😋'
     root = RP.parse(pattern)
-    expect(root.last).to be_a Regexp::Expression::Comment
-    expect(root.last.to_s).to eq '# 😋'
-    expect(root.to_s).to eq pattern
+    expect(root.last).to be_a(Regexp::Expression::Comment)
+    expect(root.last.to_s).to eql('# 😋')
+    expect(root.to_s).to eql(pattern)
   end
 end

data/spec/lexer/refcalls_spec.rb

@@ -32,6 +32,11 @@ RSpec.describe('RefCall lexing') do
   include_examples 'lex', "(abc)\\g'1'",
     3 => [:backref, :number_call,           "\\g'1'",     5, 10, 0, 0, 0]
 
+  include_examples 'lex', '\g<0>',
+    0 => [:backref, :number_call,           '\g<0>',      0,  5, 0, 0, 0]
+  include_examples 'lex', "\\g'0'",
+    0 => [:backref, :number_call,           "\\g'0'",     0,  5, 0, 0, 0]
+
   include_examples 'lex', '(abc)\g<-1>',
     3 => [:backref, :number_rel_call,       '\g<-1>',     5, 11, 0, 0, 0]
   include_examples 'lex', "(abc)\\g'-1'",

data/spec/parser/all_spec.rb

@@ -34,10 +34,10 @@ RSpec.describe(Regexp::Parser) do
   end
 
   specify('parse no quantifier target raises error') do
-    expect { RP.parse('?abc') }.to raise_error(ArgumentError)
+    expect { RP.parse('?abc') }.to raise_error(Regexp::Parser::Error)
   end
 
   specify('parse sequence no quantifier target raises error') do
-    expect { RP.parse('abc|?def') }.to raise_error(ArgumentError)
+    expect { RP.parse('abc|?def') }.to raise_error(Regexp::Parser::Error)
   end
 end

data/spec/parser/errors_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe('Parsing errors') do
       .to raise_error(Regexp::Parser::UnknownTokenTypeError)
   end
 
-  RSpec.shared_examples 'UnknownTokenError' do |type, token|
+  RSpec.shared_examples 'UnknownTokenError' do |type|
     it "raises for unkown tokens of type #{type}" do
       expect { parser.send(:parse_token, Regexp::Token.new(type, :foo)) }
         .to raise_error(Regexp::Parser::UnknownTokenError)

data/spec/parser/quantifiers_spec.rb

@@ -11,6 +11,7 @@ RSpec.describe('Quantifier parsing') do
       expect(exp.quantifier.min).to eq min
       expect(exp.quantifier.max).to eq max
       expect(exp.quantifier.mode).to eq mode
+      expect(exp.quantifier.text).to eq text
     end
   end
 

data/spec/parser/refcalls_spec.rb

@@ -29,6 +29,11 @@ RSpec.describe('Refcall parsing') do
   include_examples 'parse', /(abc)\g'1'/,
     1 => [:backref, :number_call, Backreference::NumberCall, number: 1]
 
+  include_examples 'parse', '\g<0>',
+    0 => [:backref, :number_call, Backreference::NumberCall, number: 0]
+  include_examples 'parse', "\\g'0'",
+    0 => [:backref, :number_call, Backreference::NumberCall, number: 0]
+
   include_examples 'parse', /(abc)\g<-1>/,
     1 => [:backref, :number_rel_call, Backreference::NumberCallRelative, number: -1]
   include_examples 'parse', /(abc)\g'-1'/,

data/spec/scanner/escapes_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe('Escape scanning') do
   include_examples 'scan', /c\at/,            1 => [:escape,  :bell,             '\a',             1,  3]
 
   # not an escape outside a character set
-  include_examples 'scan', /c\bt/,            1 => [:anchor,  :word_boundary,    '\b',             1, 3]
+  include_examples 'scan', /c\bt/,            1 => [:anchor,  :word_boundary,    '\b',             1,  3]
 
   include_examples 'scan', /c\ft/,            1 => [:escape,  :form_feed,        '\f',             1,  3]
   include_examples 'scan', /c\nt/,            1 => [:escape,  :newline,          '\n',             1,  3]
@@ -27,6 +27,7 @@ RSpec.describe('Escape scanning') do
   include_examples 'scan', 'a\0124',          1 => [:escape,  :octal,            '\012',           1,  5]
   include_examples 'scan', '\712+7',          0 => [:escape,  :octal,            '\712',           0,  4]
 
+  include_examples 'scan', 'a\xA',            1 => [:escape,  :hex,              '\xA',            1,  4]
   include_examples 'scan', 'a\x24c',          1 => [:escape,  :hex,              '\x24',           1,  5]
   include_examples 'scan', 'a\x0640c',        1 => [:escape,  :hex,              '\x06',           1,  5]
 

data/spec/scanner/groups_spec.rb

@@ -5,11 +5,20 @@ RSpec.describe('Group scanning') do
   include_examples 'scan', '(?>abc)',         0 => [:group,     :atomic,         '(?>',        0, 3]
   include_examples 'scan', '(abc)',           0 => [:group,     :capture,        '(',          0, 1]
 
+  # Named groups
+  # only names that start with a hyphen or digit (ascii or other) are invalid
   include_examples 'scan', '(?<name>abc)',    0 => [:group,     :named_ab,       '(?<name>',   0, 8]
   include_examples 'scan', "(?'name'abc)",    0 => [:group,     :named_sq,       "(?'name'",   0, 8]
-
   include_examples 'scan', '(?<name_1>abc)',  0 => [:group,     :named_ab,       '(?<name_1>', 0,10]
   include_examples 'scan', "(?'name_1'abc)",  0 => [:group,     :named_sq,       "(?'name_1'", 0,10]
+  include_examples 'scan', '(?<name-1>abc)',  0 => [:group,     :named_ab,       '(?<name-1>', 0,10]
+  include_examples 'scan', "(?'name-1'abc)",  0 => [:group,     :named_sq,       "(?'name-1'", 0,10]
+  include_examples 'scan', "(?<name'1>abc)",  0 => [:group,     :named_ab,       "(?<name'1>", 0,10]
+  include_examples 'scan', "(?'name>1'abc)",  0 => [:group,     :named_sq,       "(?'name>1'", 0,10]
+  include_examples 'scan', '(?<üüuuüü>abc)',  0 => [:group,     :named_ab,       '(?<üüuuüü>', 0,10]
+  include_examples 'scan', "(?'üüuuüü'abc)",  0 => [:group,     :named_sq,       "(?'üüuuüü'", 0,10]
+  include_examples 'scan', "(?<😋1234😋>abc)",  0 => [:group,     :named_ab,       "(?<😋1234😋>", 0,10]
+  include_examples 'scan', "(?'😋1234😋'abc)",  0 => [:group,     :named_sq,       "(?'😋1234😋'", 0,10]
 
   include_examples 'scan', '(?:abc)',         0 => [:group,     :passive,        '(?:',        0, 3]
   include_examples 'scan', '(?:)',            0 => [:group,     :passive,        '(?:',        0, 3]

data/spec/scanner/refcalls_spec.rb

@@ -5,9 +5,19 @@ RSpec.describe('RefCall scanning') do
   include_examples 'scan', '(abc)\1' ,          3 => [:backref, :number,                  '\1',         5, 7]
 
   # Group back-references, named, numbered, and relative
+  #
+  # NOTE: only \g supports forward-looking references using '+', e.g. \g<+1>
+  # refers to the next group, but \k<+1> refers to a group named '+1'.
+  # Inversely, only \k supports addition or substraction of a recursion level.
+  # E.g. \k<x+0> refers to a group named 'x' at the current recursion level,
+  # but \g<x+0> refers to a a group named 'x+0'.
+  #
   include_examples 'scan', '(?<X>abc)\k<X>',    3 => [:backref, :name_ref_ab,             '\k<X>',      9, 14]
   include_examples 'scan', "(?<X>abc)\\k'X'",   3 => [:backref, :name_ref_sq,             "\\k'X'",     9, 14]
 
+  include_examples 'scan', '(?<+1>abc)\k<+1>',  3 => [:backref, :name_ref_ab,             '\k<+1>',    10, 16]
+  include_examples 'scan', "(?<+1>abc)\\k'+1'", 3 => [:backref, :name_ref_sq,             "\\k'+1'",   10, 16]
+
   include_examples 'scan', '(abc)\k<1>',        3 => [:backref, :number_ref_ab,           '\k<1>',      5, 10]
   include_examples 'scan', "(abc)\\k'1'",       3 => [:backref, :number_ref_sq,           "\\k'1'",     5, 10]
 
@@ -18,9 +28,15 @@ RSpec.describe('RefCall scanning') do
   include_examples 'scan', '(?<X>abc)\g<X>',    3 => [:backref, :name_call_ab,            '\g<X>',      9, 14]
   include_examples 'scan', "(?<X>abc)\\g'X'",   3 => [:backref, :name_call_sq,            "\\g'X'",     9, 14]
 
+  include_examples 'scan', '(?<X>abc)\g<X-1>',  3 => [:backref, :name_call_ab,            '\g<X-1>',    9, 16]
+  include_examples 'scan', "(?<X>abc)\\g'X-1'", 3 => [:backref, :name_call_sq,            "\\g'X-1'",   9, 16]
+
   include_examples 'scan', '(abc)\g<1>',        3 => [:backref, :number_call_ab,          '\g<1>',      5, 10]
   include_examples 'scan', "(abc)\\g'1'",       3 => [:backref, :number_call_sq,          "\\g'1'",     5, 10]
 
+  include_examples 'scan', 'a(b|\g<0>)',        4 => [:backref, :number_call_ab,          '\g<0>',      4, 9]
+  include_examples 'scan', "a(b|\\g'0')",       4 => [:backref, :number_call_sq,          "\\g'0'",     4, 9]
+
   include_examples 'scan', '(abc)\g<-1>',       3 => [:backref, :number_rel_call_ab,      '\g<-1>',     5, 11]
   include_examples 'scan', "(abc)\\g'-1'",      3 => [:backref, :number_rel_call_sq,      "\\g'-1'",    5, 11]
 
@@ -33,4 +49,7 @@ RSpec.describe('RefCall scanning') do
 
   include_examples 'scan', '(abc)\k<1-0>',      3 => [:backref, :number_recursion_ref_ab, '\k<1-0>',    5, 12]
   include_examples 'scan', "(abc)\\k'1-0'",     3 => [:backref, :number_recursion_ref_sq, "\\k'1-0'",   5, 12]
+
+  include_examples 'scan', '(abc)\k<+1-0>',     3 => [:backref, :name_recursion_ref_ab,   '\k<+1-0>',   5, 13]
+  include_examples 'scan', "(abc)\\k'+1-0'",    3 => [:backref, :name_recursion_ref_sq,   "\\k'+1-0'",  5, 13]
 end

data/spec/scanner/sets_spec.rb

@@ -6,8 +6,18 @@ RSpec.describe('Set scanning') do
   include_examples 'scan', /[^n]/,                  1 => [:set,    :negate,          '^',          1, 2]
 
   include_examples 'scan', /[c]/,                   1 => [:literal, :literal,        'c',          1, 2]
-  include_examples 'scan', /[\b]/,                  1 => [:escape,  :backspace,      '\b',         1, 3]
-  include_examples 'scan', /[A\bX]/,                2 => [:escape,  :backspace,      '\b',         2, 4]
+  include_examples 'scan', /[^d]/,                  2 => [:literal, :literal,        'd',          2, 3]
+
+  include_examples 'scan', /[\b]/,                  1 => [:escape, :backspace,       '\b',         1, 3]
+  include_examples 'scan', /[A\bX]/,                2 => [:escape, :backspace,       '\b',         2, 4]
+
+  include_examples 'scan', /[\a]/,                  1 => [:escape, :bell,            '\a',         1, 3]
+  include_examples 'scan', /[\e]/,                  1 => [:escape, :escape,          '\e',         1, 3]
+  include_examples 'scan', /[\f]/,                  1 => [:escape, :form_feed,       '\f',         1, 3]
+  include_examples 'scan', /[\n]/,                  1 => [:escape, :newline,         '\n',         1, 3]
+  include_examples 'scan', /[\r]/,                  1 => [:escape, :carriage,        '\r',         1, 3]
+  include_examples 'scan', /[\t]/,                  1 => [:escape, :tab,             '\t',         1, 3]
+  include_examples 'scan', /[\v]/,                  1 => [:escape, :vertical_tab,    '\v',         1, 3]
 
   include_examples 'scan', /[.]/,                   1 => [:literal, :literal,        '.',          1, 2]
   include_examples 'scan', /[?]/,                   1 => [:literal, :literal,        '?',          1, 2]
@@ -18,22 +28,36 @@ RSpec.describe('Set scanning') do
   include_examples 'scan', /[<]/,                   1 => [:literal, :literal,        '<',          1, 2]
   include_examples 'scan', /[>]/,                   1 => [:literal, :literal,        '>',          1, 2]
 
-  include_examples 'scan', /[\x20]/,                1 => [:escape, :hex,             '\x20',       1, 5]
-
-  include_examples 'scan', '[\.]',                  1 => [:escape, :dot,             '\.',         1, 3]
+  include_examples 'scan', '[\\\\]',                1 => [:escape, :backslash,       '\\\\',       1, 3]
+  include_examples 'scan', '[\u0040]',              1 => [:escape, :codepoint,       '\u0040',     1, 7]
+  include_examples 'scan', '[\u{40}]',              1 => [:escape, :codepoint_list,  '\u{40}',     1, 7]
+  include_examples 'scan', '[\c2]',                 1 => [:escape, :control,         '\c2',        1, 4]
+  include_examples 'scan', '[\C-C]',                1 => [:escape, :control,         '\C-C',       1, 5]
+  include_examples 'scan', '[\x20]',                1 => [:escape, :hex,             '\x20',       1, 5]
+  include_examples 'scan', '[\M-Z]',                1 => [:escape, :meta_sequence,   '\M-Z',       1, 5]
+  include_examples 'scan', '[\M-\C-X]',             1 => [:escape, :meta_sequence,   '\M-\C-X',    1, 8]
+  include_examples 'scan', '[\\[]',                 1 => [:escape, :set_open,        '\[',         1, 3]
+  include_examples 'scan', '[\\]]',                 1 => [:escape, :set_close,       '\]',         1, 3]
+  include_examples 'scan', '[a\-]',                 2 => [:escape, :literal,         '\-',         2, 4]
+  include_examples 'scan', '[\-c]',                 1 => [:escape, :literal,         '\-',         1, 3]
+  include_examples 'scan', '[\.]',                  1 => [:escape, :literal,         '\.',         1, 3]
+  include_examples 'scan', '[\?]',                  1 => [:escape, :literal,         '\?',         1, 3]
+  include_examples 'scan', '[\*]',                  1 => [:escape, :literal,         '\*',         1, 3]
+  include_examples 'scan', '[\+]',                  1 => [:escape, :literal,         '\+',         1, 3]
+  include_examples 'scan', '[\|]',                  1 => [:escape, :literal,         '\|',         1, 3]
+  include_examples 'scan', '[\{]',                  1 => [:escape, :literal,         '\{',         1, 3]
+  include_examples 'scan', '[\}]',                  1 => [:escape, :literal,         '\}',         1, 3]
+  include_examples 'scan', '[\(]',                  1 => [:escape, :literal,         '\(',         1, 3]
+  include_examples 'scan', '[\)]',                  1 => [:escape, :literal,         '\)',         1, 3]
   include_examples 'scan', '[\!]',                  1 => [:escape, :literal,         '\!',         1, 3]
   include_examples 'scan', '[\#]',                  1 => [:escape, :literal,         '\#',         1, 3]
-  include_examples 'scan', '[\\]]',                 1 => [:escape, :set_close,       '\]',         1, 3]
-  include_examples 'scan', '[\\\\]',                1 => [:escape, :backslash,       '\\\\',       1, 3]
   include_examples 'scan', '[\A]',                  1 => [:escape, :literal,         '\A',         1, 3]
   include_examples 'scan', '[\z]',                  1 => [:escape, :literal,         '\z',         1, 3]
   include_examples 'scan', '[\g]',                  1 => [:escape, :literal,         '\g',         1, 3]
   include_examples 'scan', '[\K]',                  1 => [:escape, :literal,         '\K',         1, 3]
   include_examples 'scan', '[\R]',                  1 => [:escape, :literal,         '\R',         1, 3]
   include_examples 'scan', '[\X]',                  1 => [:escape, :literal,         '\X',         1, 3]
-  include_examples 'scan', '[\c2]',                 1 => [:escape, :literal,         '\c',         1, 3]
   include_examples 'scan', '[\B]',                  1 => [:escape, :literal,         '\B',         1, 3]
-  include_examples 'scan', '[a\-c]',                2 => [:escape, :literal,         '\-',         2, 4]
 
   include_examples 'scan', /[\d]/,                  1 => [:type,   :digit,           '\d',         1, 3]
   include_examples 'scan', /[\da-z]/,               1 => [:type,   :digit,           '\d',         1, 3]
@@ -54,19 +78,23 @@ RSpec.describe('Set scanning') do
   include_examples 'scan', /[a-b-]/,                4 => [:literal, :literal,        '-',          4, 5]
   include_examples 'scan', /[-a]/,                  1 => [:literal, :literal,        '-',          1, 2]
   include_examples 'scan', /[a-c^]/,                4 => [:literal, :literal,        '^',          4, 5]
-  include_examples 'scan', /[a-bd-f]/,              2 => [:set,    :range,           '-',          2, 3]
-  include_examples 'scan', /[a-cd-f]/,              5 => [:set,    :range,           '-',          5, 6]
+  include_examples 'scan', /[a-bd-f]/,              2 => [:set,     :range,          '-',          2, 3]
+  include_examples 'scan', /[a-cd-f]/,              5 => [:set,     :range,          '-',          5, 6]
+  # this is a buggy range, it matches only `c`, but not `a`, `b` or `-`
+  include_examples 'scan', /[a-[c]]/,               2 => [:set,     :range,          '-',          2, 3]
+  # these are not ranges, they match `a`, `c` and `-` (or non-`-` if negated)
+  include_examples 'scan', /[[a]-[c]]/,             4 => [:literal, :literal,        '-',          4, 5]
+  include_examples 'scan', /[[a]-c]/,               4 => [:literal, :literal,        '-',          4, 5]
+  include_examples 'scan', /[^-c]/,                 2 => [:literal, :literal,        '-',          2, 3]
 
   include_examples 'scan', /[a[:digit:]c]/,         2 => [:posixclass,    :digit,    '[:digit:]',  2, 11]
   include_examples 'scan', /[[:digit:][:space:]]/,  2 => [:posixclass,    :space,    '[:space:]', 10, 19]
   include_examples 'scan', /[[:^digit:]]/,          1 => [:nonposixclass, :digit,    '[:^digit:]', 1, 11]
 
-  include_examples 'scan', /[a[.a-b.]c]/,           2 => [:set,    :collation,       '[.a-b.]',    2,  9]
-  include_examples 'scan', /[a[=e=]c]/,             2 => [:set,    :equivalent,      '[=e=]',      2,  7]
-
   include_examples 'scan', /[a-d&&g-h]/,            4 => [:set,    :intersection,    '&&',         4, 6]
   include_examples 'scan', /[a&&]/,                 2 => [:set,    :intersection,    '&&',         2, 4]
   include_examples 'scan', /[&&z]/,                 1 => [:set,    :intersection,    '&&',         1, 3]
+  include_examples 'scan', /[&&]/,                  1 => [:set,    :intersection,    '&&',         1, 3]
 
   include_examples 'scan', /[a\p{digit}c]/,         2 => [:property,    :digit,      '\p{digit}',  2, 11]
   include_examples 'scan', /[a\P{digit}c]/,         2 => [:nonproperty, :digit,      '\P{digit}',  2, 11]
@@ -88,6 +116,21 @@ RSpec.describe('Set scanning') do
     8 => [:set,    :range,           '-',          9, 10],
     10=> [:set,    :close,           ']',          11, 12]
 
+  # Collations/collating sequences and character equivalents are not enabled
+  # in Ruby at the moment. If they ever are, enable them in the scanner,
+  # add them to a new syntax version, and handle them in the parser. Until then,
+  # expect them to be scanned as regular subsets containing literals.
+  # include_examples 'scan', /[a[.a-b.]c]/,           2 => [:set,    :collation,       '[.a-b.]',    2,  9]
+  # include_examples 'scan', /[a[=e=]c]/,             2 => [:set,    :equivalent,      '[=e=]',      2,  7]
+  include_examples 'scan', '[a[.a-b.]c]',
+    2 => [:set,     :open,           '[',          2,  3],
+    3 => [:literal, :literal,        '.',          3,  4],
+    4 => [:literal, :literal,        'a',          4,  5]
+  include_examples 'scan', '[a[=e=]c]',
+    2 => [:set,     :open,           '[',          2,  3],
+    3 => [:literal, :literal,        '=',          3,  4],
+    4 => [:literal, :literal,        'e',          4,  5]
+
   # multi-byte characters should not affect indices
   include_examples 'scan', /[れます]/,
     0 => [:set,     :open,           '[',          0, 1],

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+require 'ice_nine'
 require 'regexp_parser'
 require 'regexp_property_values'
 require_relative 'support/shared_examples'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexp_parser
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Ammar Ali
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-25 00:00:00.000000000 Z
+date: 2021-02-23 00:00:00.000000000 Z
 dependencies: []
 description: A library for tokenizing, lexing, and parsing Ruby regular expressions.
 email:
@@ -23,6 +23,7 @@ files:
 - README.md
 - Rakefile
 - lib/regexp_parser.rb
+- lib/regexp_parser/error.rb
 - lib/regexp_parser/expression.rb
 - lib/regexp_parser/expression/classes/alternation.rb
 - lib/regexp_parser/expression/classes/anchor.rb
@@ -183,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.0.rc.1
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Scanner, lexer, parser for ruby's regular expressions