regexp_parser 1.4.0 → 1.7.1

data/lib/regexp_parser/syntax/tokens.rb

@@ -39,15 +39,7 @@ require 'regexp_parser/syntax/tokens/unicode_property'
 # into the All and Types constants.
 module Regexp::Syntax
   module Token
-    if RUBY_VERSION >= '1.9'
-      All = Map.map {|k,v| v}.flatten.uniq.sort
-    else
-      All = Map.map {|k,v| v}.flatten.uniq
-    end
-
-    Types = Map.keys
-
-    All.freeze
-    Types.freeze
+    All   = Map.values.flatten.uniq.sort.freeze
+    Types = Map.keys.freeze
   end
 end

data/lib/regexp_parser/syntax/tokens/unicode_property.rb

@@ -53,6 +53,10 @@ module Regexp::Syntax
 
       Age_V2_6_0 = [:'age=11.0']
 
+      Age_V2_6_2 = [:'age=12.0']
+
+      Age_V2_6_3 = [:'age=12.1']
+
       Age = all[:Age_V]
 
       Derived_V1_9_0 = [
@@ -297,6 +301,18 @@ module Regexp::Syntax
         :sogdian,
       ]
 
+      Script_V2_6_2 = [
+        :egyptian_hieroglyph_format_controls,
+        :elymaic,
+        :nandinagari,
+        :nyiakeng_puachue_hmong,
+        :ottoman_siyaq_numbers,
+        :small_kana_extension,
+        :symbols_and_pictographs_extended_a,
+        :tamil_supplement,
+        :wancho,
+      ]
+
       Script = all[:Script_V]
 
       UnicodeBlock_V1_9_0 = [
@@ -612,6 +628,18 @@ module Regexp::Syntax
         :in_sogdian,
       ]
 
+      UnicodeBlock_V2_6_2 = [
+        :in_egyptian_hieroglyph_format_controls,
+        :in_elymaic,
+        :in_nandinagari,
+        :in_nyiakeng_puachue_hmong,
+        :in_ottoman_siyaq_numbers,
+        :in_small_kana_extension,
+        :in_symbols_and_pictographs_extended_a,
+        :in_tamil_supplement,
+        :in_wancho,
+      ]
+
       UnicodeBlock = all[:UnicodeBlock_V]
 
       Emoji_V2_5_0 = [
@@ -632,6 +660,8 @@ module Regexp::Syntax
       V2_4_0 = all[:V2_4_0]
       V2_5_0 = all[:V2_5_0]
       V2_6_0 = all[:V2_6_0]
+      V2_6_2 = all[:V2_6_2]
+      V2_6_3 = all[:V2_6_3]
 
       All = all[/^V\d+_\d+_\d+$/]
 

data/lib/regexp_parser/syntax/versions/2.6.2.rb

@@ -0,0 +1,10 @@
+module Regexp::Syntax
+  class V2_6_2 < Regexp::Syntax::V2_6_0
+    def initialize
+      super
+
+      implements :property,    UnicodeProperty::V2_6_2
+      implements :nonproperty, UnicodeProperty::V2_6_2
+    end
+  end
+end

data/lib/regexp_parser/syntax/versions/2.6.3.rb

@@ -0,0 +1,10 @@
+module Regexp::Syntax
+  class V2_6_3 < Regexp::Syntax::V2_6_2
+    def initialize
+      super
+
+      implements :property,    UnicodeProperty::V2_6_3
+      implements :nonproperty, UnicodeProperty::V2_6_3
+    end
+  end
+end

data/lib/regexp_parser/version.rb

@@ -1,5 +1,5 @@
 class Regexp
   class Parser
-    VERSION = '1.4.0'
+    VERSION = '1.7.1'
   end
 end

data/regexp_parser.gemspec

@@ -21,12 +21,12 @@ Gem::Specification.new do |gem|
 
   gem.require_paths = ['lib']
 
-  gem.files         = Dir.glob('{lib,test}/**/*.rb') +
+  gem.files         = Dir.glob('{lib,spec}/**/*.rb') +
                       Dir.glob('lib/**/*.rl') +
                       Dir.glob('lib/**/*.yml') +
                       %w(Gemfile Rakefile LICENSE README.md CHANGELOG.md regexp_parser.gemspec)
 
-  gem.test_files    = Dir.glob('test/**/*.rb')
+  gem.test_files    = Dir.glob('spec/**/*.rb')
 
   gem.rdoc_options  = ["--inline-source", "--charset=UTF-8"]
 

data/spec/expression/base_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Expression::Base) do
+  specify('#to_re') do
+    re_text = '^a*(b([cde]+))+f?$'
+
+    re = RP.parse(re_text).to_re
+
+    expect(re).to be_a(::Regexp)
+    expect(re_text).to eq re.source
+  end
+
+  specify('#level') do
+    regexp = /^a(b(c(d)))e$/
+    root = RP.parse(regexp)
+
+    ['^', 'a', '(b(c(d)))', 'e', '$'].each_with_index do |t, i|
+      expect(root[i].to_s).to eq t
+      expect(root[i].level).to eq 0
+    end
+
+    expect(root[2][0].to_s).to eq 'b'
+    expect(root[2][0].level).to eq 1
+
+    expect(root[2][1][0].to_s).to eq 'c'
+    expect(root[2][1][0].level).to eq 2
+
+    expect(root[2][1][1][0].to_s).to eq 'd'
+    expect(root[2][1][1][0].level).to eq 3
+  end
+
+  specify('#terminal?') do
+    root = RP.parse('^a([b]+)c$')
+
+    expect(root).not_to be_terminal
+
+    expect(root[0]).to be_terminal
+    expect(root[1]).to be_terminal
+    expect(root[2]).not_to be_terminal
+    expect(root[2][0]).not_to be_terminal
+    expect(root[2][0][0]).to be_terminal
+    expect(root[3]).to be_terminal
+    expect(root[4]).to be_terminal
+  end
+
+  specify('alt #terminal?') do
+    root = RP.parse('^(ab|cd)$')
+
+    expect(root).not_to be_terminal
+
+    expect(root[0]).to be_terminal
+    expect(root[1]).not_to be_terminal
+    expect(root[1][0]).not_to be_terminal
+    expect(root[1][0][0]).not_to be_terminal
+    expect(root[1][0][0][0]).to be_terminal
+    expect(root[1][0][1]).not_to be_terminal
+    expect(root[1][0][1][0]).to be_terminal
+  end
+
+  specify('#coded_offset') do
+    root = RP.parse('^a*(b+(c?))$')
+
+    expect(root.coded_offset).to eq '@0+12'
+
+    [
+      ['@0+1', '^'],
+      ['@1+2', 'a*'],
+      ['@3+8', '(b+(c?))'],
+      ['@11+1', '$'],
+    ].each_with_index do |check, i|
+      against = [root[i].coded_offset, root[i].to_s]
+
+      expect(against).to eq check
+    end
+
+    expect([root[2][0].coded_offset, root[2][0].to_s]).to eq ['@4+2', 'b+']
+    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/clone_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+RSpec.describe('Expression#clone') do
+  specify('Base#clone') do
+    root = RP.parse(/^(?i:a)b+$/i)
+    copy = root.clone
+
+    expect(copy.to_s).to eq root.to_s
+
+    expect(root.object_id).not_to eq copy.object_id
+    expect(root.text).to eq copy.text
+    expect(root.text.object_id).not_to eq copy.text.object_id
+
+    root_1 = root[1]
+    copy_1 = copy[1]
+
+    expect(root_1.options).to eq copy_1.options
+    expect(root_1.options.object_id).not_to eq copy_1.options.object_id
+
+    root_2 = root[2]
+    copy_2 = copy[2]
+
+    expect(root_2).to be_quantified
+    expect(copy_2).to be_quantified
+    expect(root_2.quantifier.text).to eq copy_2.quantifier.text
+    expect(root_2.quantifier.text.object_id).not_to eq copy_2.quantifier.text.object_id
+    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 }
+  end
+
+  specify('Subexpression#clone') do
+    root = RP.parse(/^a(b([cde])f)g$/)
+    copy = root.clone
+
+    expect(copy.to_s).to eq root.to_s
+
+    expect(root).to respond_to(:expressions)
+    expect(copy).to respond_to(:expressions)
+    expect(root.expressions.object_id).not_to eq copy.expressions.object_id
+    copy.expressions.each_with_index do |exp, index|
+      expect(root[index].object_id).not_to eq exp.object_id
+    end
+    copy[2].each_with_index do |exp, index|
+      expect(root[2][index].object_id).not_to eq exp.object_id
+    end
+
+    # regression test
+    expect { root.clone }.not_to change { root.expressions.object_id }
+  end
+
+  specify('Group::Named#clone') do
+    root = RP.parse('^(?<somename>a)+bc$')
+    copy = root.clone
+
+    expect(copy.to_s).to eq root.to_s
+
+    root_1 = root[1]
+    copy_1 = copy[1]
+
+    expect(root_1.name).to eq copy_1.name
+    expect(root_1.name.object_id).not_to eq copy_1.name.object_id
+    expect(root_1.text).to eq copy_1.text
+    expect(root_1.expressions.object_id).not_to eq copy_1.expressions.object_id
+    copy_1.expressions.each_with_index do |exp, index|
+      expect(root_1[index].object_id).not_to eq exp.object_id
+    end
+
+    # regression test
+    expect { root_1.clone }.not_to change { root_1.name.object_id }
+  end
+
+  specify('Sequence#clone') do
+    root = RP.parse(/(a|b)/)
+    copy = root.clone
+
+    # regression test
+    expect(copy.to_s).to eq root.to_s
+
+    root_seq_op = root[0][0]
+    copy_seq_op = copy[0][0]
+    root_seq_1 = root[0][0][0]
+    copy_seq_1 = copy[0][0][0]
+
+    expect(root_seq_op.object_id).not_to eq copy_seq_op.object_id
+    expect(root_seq_1.object_id).not_to eq copy_seq_1.object_id
+    copy_seq_1.expressions.each_with_index do |exp, index|
+      expect(root_seq_1[index].object_id).not_to eq exp.object_id
+    end
+  end
+
+  describe('Base#unquantified_clone') do
+    it 'produces a clone' do
+      root = RP.parse(/^a(b([cde])f)g$/)
+      copy = root.unquantified_clone
+
+      expect(copy.to_s).to eq root.to_s
+
+      expect(copy.object_id).not_to eq root.object_id
+    end
+
+    it 'does not carry over the callee quantifier' do
+      expect(RP.parse(/a{3}/)[0]).to be_quantified
+      expect(RP.parse(/a{3}/)[0].unquantified_clone).not_to be_quantified
+
+      expect(RP.parse(/[a]{3}/)[0]).to be_quantified
+      expect(RP.parse(/[a]{3}/)[0].unquantified_clone).not_to be_quantified
+
+      expect(RP.parse(/(a|b){3}/)[0]).to be_quantified
+      expect(RP.parse(/(a|b){3}/)[0].unquantified_clone).not_to be_quantified
+    end
+
+    it 'keeps quantifiers of callee children' do
+      expect(RP.parse(/(a{3}){3}/)[0][0]).to be_quantified
+      expect(RP.parse(/(a{3}){3}/)[0].unquantified_clone[0]).to be_quantified
+    end
+  end
+end

data/spec/expression/conditional_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Expression::Conditional) do
+  let(:root)   { RP.parse('^(a(b))(b(?(1)c|(?(2)d|(?(3)e|f)))g)$') }
+  let(:cond_1) { root[2][1] }
+  let(:cond_2) { root[2][1][2][0] }
+  let(:cond_3) { root[2][1][2][0][2][0] }
+
+  specify('root level') do
+    [
+      '^',
+      '(a(b))',
+      '(b(?(1)c|(?(2)d|(?(3)e|f)))g)',
+      '$'
+    ].each_with_index do |t, i|
+      expect(root[i].conditional_level).to eq 0
+      expect(root[i].to_s).to eq t
+    end
+
+    expect(root[2][0].to_s).to eq 'b'
+    expect(root[2][0].conditional_level).to eq 0
+  end
+
+  specify('level one') do
+    condition = cond_1.condition
+    branch_1 = cond_1.branches.first
+
+    expect(condition).to be_a Conditional::Condition
+    expect(condition.to_s).to eq '(1)'
+    expect(condition.conditional_level).to eq 1
+
+    expect(branch_1).to be_a Conditional::Branch
+    expect(branch_1.to_s).to eq 'c'
+    expect(branch_1.conditional_level).to eq 1
+
+    expect(branch_1.first.to_s).to eq 'c'
+    expect(branch_1.first.conditional_level).to eq 1
+  end
+
+  specify('level two') do
+    condition = cond_2.condition
+    branch_1 = cond_2.branches.first
+    branch_2 = cond_2.branches.last
+
+    expect(cond_2.to_s).to start_with '(?'
+    expect(cond_2.conditional_level).to eq 1
+
+    expect(condition).to be_a Conditional::Condition
+    expect(condition.to_s).to eq '(2)'
+    expect(condition.conditional_level).to eq 2
+
+    expect(branch_1).to be_a Conditional::Branch
+    expect(branch_1.to_s).to eq 'd'
+    expect(branch_1.conditional_level).to eq 2
+
+    expect(branch_1.first.to_s).to eq 'd'
+    expect(branch_1.first.conditional_level).to eq 2
+
+    expect(branch_2.first.to_s).to start_with '(?'
+    expect(branch_2.first.conditional_level).to eq 2
+  end
+
+  specify('level three') do
+    condition = cond_3.condition
+    branch_1 = cond_3.branches.first
+    branch_2 = cond_3.branches.last
+
+    expect(condition).to be_a Conditional::Condition
+    expect(condition.to_s).to eq '(3)'
+    expect(condition.conditional_level).to eq 3
+
+    expect(cond_3.to_s).to eq '(?(3)e|f)'
+    expect(cond_3.conditional_level).to eq 2
+
+    expect(branch_1).to be_a Conditional::Branch
+    expect(branch_1.to_s).to eq 'e'
+    expect(branch_1.conditional_level).to eq 3
+
+    expect(branch_1.first.to_s).to eq 'e'
+    expect(branch_1.first.conditional_level).to eq 3
+
+    expect(branch_2).to be_a Conditional::Branch
+    expect(branch_2.to_s).to eq 'f'
+    expect(branch_2.conditional_level).to eq 3
+
+    expect(branch_2.first.to_s).to eq 'f'
+    expect(branch_2.first.conditional_level).to eq 3
+  end
+end

data/spec/expression/free_space_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Expression::FreeSpace) do
+  specify('white space quantify raises error') do
+    regexp = /
+      a # Comment
+    /x
+
+    root = RP.parse(regexp)
+    space = root[0]
+
+    expect(space).to be_instance_of(FreeSpace::WhiteSpace)
+    expect { space.quantify(:dummy, '#') }.to raise_error(RuntimeError)
+  end
+
+  specify('comment quantify raises error') do
+    regexp = /
+      a # Comment
+    /x
+
+    root = RP.parse(regexp)
+    comment = root[3]
+
+    expect(comment).to be_instance_of(FreeSpace::Comment)
+    expect { comment.quantify(:dummy, '#') }.to raise_error(RuntimeError)
+  end
+end