regexp_parser 1.8.2 → 2.1.1

data/lib/regexp_parser/syntax/any.rb

@@ -4,12 +4,12 @@ module Regexp::Syntax
   # is useful during development, testing, and should be useful for some types
   # of transformations as well.
   class Any < Base
-    def initialize
+    def initialize # rubocop:disable Lint/MissingSuper
       @implements = { :* => [:*] }
     end
 
-    def implements?(type, token) true end
-    def implements!(type, token) true end
+    def implements?(_type, _token) true end
+    def implements!(_type, _token) true end
   end
 
 end

data/lib/regexp_parser/syntax/base.rb

@@ -1,7 +1,7 @@
 require 'set'
 
 module Regexp::Syntax
-  class NotImplementedError < SyntaxError
+  class NotImplementedError < Regexp::Syntax::SyntaxError
     def initialize(syntax, type, token)
       super "#{syntax.class.name} does not implement: [#{type}:#{token}]"
     end

data/lib/regexp_parser/syntax/version_lookup.rb

@@ -3,13 +3,13 @@ module Regexp::Syntax
   VERSION_REGEXP = /#{VERSION_FORMAT}/
   VERSION_CONST_REGEXP = /\AV\d+_\d+(?:_\d+)?\z/
 
-  class InvalidVersionNameError < SyntaxError
+  class InvalidVersionNameError < Regexp::Syntax::SyntaxError
     def initialize(name)
       super "Invalid version name '#{name}'. Expected format is '#{VERSION_FORMAT}'"
     end
   end
 
-  class UnknownSyntaxNameError < SyntaxError
+  class UnknownSyntaxNameError < Regexp::Syntax::SyntaxError
     def initialize(name)
       super "Unknown syntax name '#{name}'."
     end

data/lib/regexp_parser/syntax.rb

@@ -1,9 +1,11 @@
-require File.expand_path('../syntax/tokens', __FILE__)
-require File.expand_path('../syntax/base', __FILE__)
-require File.expand_path('../syntax/any', __FILE__)
-require File.expand_path('../syntax/version_lookup', __FILE__)
-require File.expand_path('../syntax/versions', __FILE__)
+require 'regexp_parser/error'
 
 module Regexp::Syntax
-  class SyntaxError < StandardError; end
+  class SyntaxError < Regexp::Parser::Error; end
 end
+
+require_relative 'syntax/tokens'
+require_relative 'syntax/base'
+require_relative 'syntax/any'
+require_relative 'syntax/version_lookup'
+require_relative 'syntax/versions'

data/lib/regexp_parser/version.rb

@@ -1,5 +1,5 @@
 class Regexp
   class Parser
-    VERSION = '1.8.2'
+    VERSION = '2.1.1'
   end
 end

data/spec/expression/base_spec.rb

@@ -91,4 +91,14 @@ RSpec.describe(Regexp::Expression::Base) do
     expect(RP.parse(/a*/)[0].repetitions).to eq 0..(Float::INFINITY)
     expect(RP.parse(/a+/)[0].repetitions).to eq 1..(Float::INFINITY)
   end
+
+  specify('#base_length') do
+    expect(RP.parse(/(aa)/)[0].base_length).to eq 4
+    expect(RP.parse(/(aa){42}/)[0].base_length).to eq 4
+  end
+
+  specify('#full_length') do
+    expect(RP.parse(/(aa)/)[0].full_length).to eq 4
+    expect(RP.parse(/(aa){42}/)[0].full_length).to eq 8
+  end
 end

data/spec/expression/clone_spec.rb

@@ -27,8 +27,8 @@ RSpec.describe('Expression#clone') do
     expect(root_2.quantifier.object_id).not_to eq copy_2.quantifier.object_id
 
     # regression test
-    expect { root_2.clone }.not_to change { root_2.quantifier.object_id }
-    expect { root_2.clone }.not_to change { root_2.quantifier.text.object_id }
+    expect { root_2.clone }.not_to(change { root_2.quantifier.object_id })
+    expect { root_2.clone }.not_to(change { root_2.quantifier.text.object_id })
   end
 
   specify('Subexpression#clone') do
@@ -48,7 +48,7 @@ RSpec.describe('Expression#clone') do
     end
 
     # regression test
-    expect { root.clone }.not_to change { root.expressions.object_id }
+    expect { root.clone }.not_to(change { root.expressions.object_id })
   end
 
   specify('Group::Named#clone') do
@@ -69,7 +69,39 @@ RSpec.describe('Expression#clone') do
     end
 
     # regression test
-    expect { root_1.clone }.not_to change { root_1.name.object_id }
+    expect { root_1.clone }.not_to(change { root_1.name.object_id })
+  end
+
+  specify('Group::Options#clone') do
+    root = RP.parse('foo(?i)bar')
+    copy = root.clone
+
+    expect(copy.to_s).to eq root.to_s
+
+    root_1 = root[1]
+    copy_1 = copy[1]
+
+    expect(root_1.option_changes).to eq copy_1.option_changes
+    expect(root_1.option_changes.object_id).not_to eq copy_1.option_changes.object_id
+
+    # regression test
+    expect { root_1.clone }.not_to(change { root_1.option_changes.object_id })
+  end
+
+  specify('Backreference::Base#clone') do
+    root = RP.parse('(foo)\1')
+    copy = root.clone
+
+    expect(copy.to_s).to eq root.to_s
+
+    root_1 = root[1]
+    copy_1 = copy[1]
+
+    expect(root_1.referenced_expression.to_s).to eq copy_1.referenced_expression.to_s
+    expect(root_1.referenced_expression.object_id).not_to eq copy_1.referenced_expression.object_id
+
+    # regression test
+    expect { root_1.clone }.not_to(change { root_1.referenced_expression.object_id })
   end
 
   specify('Sequence#clone') do

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
+
+  def expect_round_trip(pattern, ruby_version = nil)
+    parsed = parse_frozen(pattern, ruby_version)
 
-    expect(RP.parse(pattern).to_s).to eq pattern
+    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,8 +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 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 = parse_frozen(pattern)
+    expect(root.to_s).to eql('a+{1}{2}')
+  end
 
-    expect(Regexp.new(root.to_s, Regexp::EXTENDED).match(str)[0]).to eq multiline.match(str)[0]
+  # 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 eql('# 😋')
+    expect(root.to_s).to eql(pattern)
   end
 end

data/spec/lexer/literals_spec.rb

@@ -10,67 +10,42 @@ RSpec.describe('Literal lexing') do
     1 => [:literal,     :literal,       'b',        1, 2, 0, 0, 0],
     2 => [:quantifier,  :one_or_more,   '+',        2, 3, 0, 0, 0]
 
-  # 2 byte wide characters, Arabic
-  include_examples 'lex', 'ا',
-    0 => [:literal,     :literal,       'ا',        0, 2, 0, 0, 0]
-
-  include_examples 'lex', 'aاbبcت',
-    0 => [:literal,     :literal,       'aاbبcت',   0, 9, 0, 0, 0]
-
-  include_examples 'lex', 'aاbبت?',
-    0 => [:literal,     :literal,       'aاbب',     0, 6, 0, 0, 0],
-    1 => [:literal,     :literal,       'ت',        6, 8, 0, 0, 0],
-    2 => [:quantifier,  :zero_or_one,   '?',        8, 9, 0, 0, 0]
-
-  include_examples 'lex', 'aا?bبcت+',
-    0 => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
-    1 => [:literal,     :literal,       'ا',        1, 3, 0, 0, 0],
-    2 => [:quantifier,  :zero_or_one,   '?',        3, 4, 0, 0, 0],
-    3 => [:literal,     :literal,       'bبc',      4, 8, 0, 0, 0],
-    4 => [:literal,     :literal,       'ت',        8, 10, 0, 0, 0],
-    5 => [:quantifier,  :one_or_more,   '+',        10, 11, 0, 0, 0]
-
-  include_examples 'lex', 'a(اbب+)cت?',
-    0 => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
-    1 => [:group,       :capture,       '(',        1, 2, 0, 0, 0],
-    2 => [:literal,     :literal,       'اb',       2, 5, 1, 0, 0],
-    3 => [:literal,     :literal,       'ب',        5, 7, 1, 0, 0],
-    4 => [:quantifier,  :one_or_more,   '+',        7, 8, 1, 0, 0],
-    5 => [:group,       :close,         ')',        8, 9, 0, 0, 0],
-    6 => [:literal,     :literal,       'c',        9, 10, 0, 0, 0],
-    7 => [:literal,     :literal,       'ت',        10, 12, 0, 0, 0],
-    8 => [:quantifier,  :zero_or_one,   '?',        12, 13, 0, 0, 0]
+  # 2 byte wide characters
+  include_examples 'lex', 'äöü+',
+    0 => [:literal,     :literal,       'äö',       0, 2, 0, 0, 0],
+    1 => [:literal,     :literal,       'ü',        2, 3, 0, 0, 0],
+    2 => [:quantifier,  :one_or_more,   '+',        3, 4, 0, 0, 0]
 
   # 3 byte wide characters, Japanese
   include_examples 'lex', 'ab?れます+cd',
     0 => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
     1 => [:literal,     :literal,       'b',        1, 2, 0, 0, 0],
     2 => [:quantifier,  :zero_or_one,   '?',        2, 3, 0, 0, 0],
-    3 => [:literal,     :literal,       'れま',     3, 9, 0, 0, 0],
-    4 => [:literal,     :literal,       'す',       9, 12, 0, 0, 0],
-    5 => [:quantifier,  :one_or_more,   '+',        12, 13, 0, 0, 0],
-    6 => [:literal,     :literal,       'cd',       13, 15, 0, 0, 0]
+    3 => [:literal,     :literal,       'れま',     3, 5, 0, 0, 0],
+    4 => [:literal,     :literal,       'す',       5, 6, 0, 0, 0],
+    5 => [:quantifier,  :one_or_more,   '+',        6, 7, 0, 0, 0],
+    6 => [:literal,     :literal,       'cd',       7, 9, 0, 0, 0]
 
   # 4 byte wide characters, Osmanya
   include_examples 'lex', '𐒀𐒁?𐒂ab+𐒃',
-    0 => [:literal,     :literal,       '𐒀',        0, 4, 0, 0, 0],
-    1 => [:literal,     :literal,       '𐒁',        4, 8, 0, 0, 0],
-    2 => [:quantifier,  :zero_or_one,   '?',        8, 9, 0, 0, 0],
-    3 => [:literal,     :literal,       '𐒂a',       9, 14, 0, 0, 0],
-    4 => [:literal,     :literal,       'b',        14, 15, 0, 0, 0],
-    5 => [:quantifier,  :one_or_more,   '+',        15, 16, 0, 0, 0],
-    6 => [:literal,     :literal,       '𐒃',        16, 20, 0, 0, 0]
+    0 => [:literal,     :literal,       '𐒀',        0, 1, 0, 0, 0],
+    1 => [:literal,     :literal,       '𐒁',        1, 2, 0, 0, 0],
+    2 => [:quantifier,  :zero_or_one,   '?',        2, 3, 0, 0, 0],
+    3 => [:literal,     :literal,       '𐒂a',       3, 5, 0, 0, 0],
+    4 => [:literal,     :literal,       'b',        5, 6, 0, 0, 0],
+    5 => [:quantifier,  :one_or_more,   '+',        6, 7, 0, 0, 0],
+    6 => [:literal,     :literal,       '𐒃',        7, 8, 0, 0, 0]
 
   include_examples 'lex', 'mu𝄞?si*𝄫c+',
     0 => [:literal,     :literal,       'mu',       0, 2, 0, 0, 0],
-    1 => [:literal,     :literal,       '𝄞',        2, 6, 0, 0, 0],
-    2 => [:quantifier,  :zero_or_one,   '?',        6, 7, 0, 0, 0],
-    3 => [:literal,     :literal,       's',        7, 8, 0, 0, 0],
-    4 => [:literal,     :literal,       'i',        8, 9, 0, 0, 0],
-    5 => [:quantifier,  :zero_or_more,  '*',        9, 10, 0, 0, 0],
-    6 => [:literal,     :literal,       '𝄫',        10, 14, 0, 0, 0],
-    7 => [:literal,     :literal,       'c',        14, 15, 0, 0, 0],
-    8 => [:quantifier,  :one_or_more,   '+',        15, 16, 0, 0, 0]
+    1 => [:literal,     :literal,       '𝄞',        2, 3, 0, 0, 0],
+    2 => [:quantifier,  :zero_or_one,   '?',        3, 4, 0, 0, 0],
+    3 => [:literal,     :literal,       's',        4, 5, 0, 0, 0],
+    4 => [:literal,     :literal,       'i',        5, 6, 0, 0, 0],
+    5 => [:quantifier,  :zero_or_more,  '*',        6, 7, 0, 0, 0],
+    6 => [:literal,     :literal,       '𝄫',        7, 8, 0, 0, 0],
+    7 => [:literal,     :literal,       'c',        8, 9, 0, 0, 0],
+    8 => [:quantifier,  :one_or_more,   '+',        9, 10, 0, 0, 0]
 
   specify('lex single 2 byte char') do
     tokens = RL.lex("\u0627+")

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/escapes_spec.rb

@@ -25,7 +25,7 @@ RSpec.describe('EscapeSequence parsing') do
   include_examples 'parse', /a\u{41 1F60D}/, 1 => [:escape, :codepoint_list,    EscapeSequence::CodepointList]
   include_examples 'parse', /a\u{10FFFF}/,   1 => [:escape, :codepoint_list,    EscapeSequence::CodepointList]
 
-    # hex escapes
+  # hex escapes
   include_examples 'parse', /a\xFF/n,        1 => [:escape, :hex,               EscapeSequence::Hex]
 
   # octal escapes