regexp_parser 1.5.0 → 1.8.0

data/spec/parser/groups_spec.rb

@@ -1,267 +1,108 @@
 require 'spec_helper'
 
 RSpec.describe('Group parsing') do
-  specify('parse root options mi') do
-    t = RP.parse(/[abc]/mi, 'ruby/1.8')
-
-    expect(t.m?).to be true
-    expect(t.i?).to be true
-    expect(t.x?).to be false
-  end
-
-  specify('parse option group') do
-    t = RP.parse(/(?m:a)/, 'ruby/1.8')
-
-    expect(t[0]).to be_instance_of(Group::Options)
-    expect(t[0].token).to eq :options
-
-    expect(t[0].m?).to be true
-    expect(t[0].i?).to be false
-    expect(t[0].x?).to be false
-
-    expect(t[0].option_changes[:m]).to be true
-    expect(t[0].option_changes[:i]).to be_nil
-  end
-
-  specify('parse self defeating option group') do
-    t = RP.parse(/(?m-m:a)/, 'ruby/1.8')
-
-    expect(t[0].m?).to be false
-    expect(t[0].i?).to be false
-    expect(t[0].x?).to be false
-
-    expect(t[0].option_changes[:m]).to be false
-    expect(t[0].option_changes[:i]).to be_nil
-  end
-
-  specify('parse nested options activate one') do
-    t = RP.parse(/(?x-mi:a(?m:b))/, 'ruby/1.8')
-
-    expect(t[0].m?).to be false
-    expect(t[0].i?).to be false
-    expect(t[0].x?).to be true
-
-    expect(t[0][1].m?).to be true
-    expect(t[0][1].i?).to be false
-    expect(t[0][1].x?).to be true
-
-    expect(t[0][1].option_changes[:m]).to be true
-    expect(t[0][1].option_changes[:i]).to be_nil
-    expect(t[0][1].option_changes[:x]).to be_nil
-  end
-
-  specify('parse nested options deactivate one') do
-    t = RP.parse(/(?ix-m:a(?-i:b))/, 'ruby/1.8')
-
-    expect(t[0].m?).to be false
-    expect(t[0].i?).to be true
-    expect(t[0].x?).to be true
-
-    expect(t[0][1].m?).to be false
-    expect(t[0][1].i?).to be false
-    expect(t[0][1].x?).to be true
-
-    expect(t[0][1].option_changes[:i]).to be false
-    expect(t[0][1].option_changes[:m]).to be_nil
-    expect(t[0][1].option_changes[:x]).to be_nil
-  end
-
-  specify('parse nested options invert all') do
-    t = RP.parse('(?xi-m:a(?m-ix:b))', 'ruby/1.8')
-
-    expect(t[0].m?).to be false
-    expect(t[0].i?).to be true
-    expect(t[0].x?).to be true
-
-    expect(t[0][1].m?).to be true
-    expect(t[0][1].i?).to be false
-    expect(t[0][1].x?).to be false
-
-    expect(t[0][1].option_changes[:m]).to be true
-    expect(t[0][1].option_changes[:i]).to be false
-    expect(t[0][1].option_changes[:x]).to be false
-  end
-
-  specify('parse nested options affect literal subexpressions') do
-    t = RP.parse(/(?x-mi:a(?m:b))/, 'ruby/1.8')
-
-    expect(t[0][0].m?).to be false
-    expect(t[0][0].i?).to be false
-    expect(t[0][0].x?).to be true
-
-    expect(t[0][1][0].m?).to be true
-    expect(t[0][1][0].i?).to be false
-    expect(t[0][1][0].x?).to be true
-  end
-
-  specify('parse option switch group') do
-    t = RP.parse(/a(?i-m)b/m, 'ruby/1.8')
-
-    expect(t[1]).to be_instance_of(Group::Options)
-    expect(t[1].token).to eq :options_switch
-
-    expect(t[1].m?).to be false
-    expect(t[1].i?).to be true
-    expect(t[1].x?).to be false
-
-    expect(t[1].option_changes[:i]).to be true
-    expect(t[1].option_changes[:m]).to be false
-    expect(t[1].option_changes[:x]).to be_nil
-  end
-
-  specify('parse option switch affects following expressions') do
-    t = RP.parse(/a(?i-m)b/m, 'ruby/1.8')
-
-    expect(t[0].m?).to be true
-    expect(t[0].i?).to be false
-    expect(t[0].x?).to be false
-
-    expect(t[2].m?).to be false
-    expect(t[2].i?).to be true
-    expect(t[2].x?).to be false
-  end
-
-  specify('parse option switch in group') do
-    t = RP.parse(/(a(?i-m)b)c/m, 'ruby/1.8')
-
-    group1 = t[0]
-
-    expect(group1.m?).to be true
-    expect(group1.i?).to be false
-    expect(group1.x?).to be false
-
-    expect(group1[0].m?).to be true
-    expect(group1[0].i?).to be false
-    expect(group1[0].x?).to be false
-
-    expect(group1[1].m?).to be false
-    expect(group1[1].i?).to be true
-    expect(group1[1].x?).to be false
-
-    expect(group1[2].m?).to be false
-    expect(group1[2].i?).to be true
-    expect(group1[2].x?).to be false
-
-    expect(t[1].m?).to be true
-    expect(t[1].i?).to be false
-    expect(t[1].x?).to be false
-  end
-
-  specify('parse nested option switch in group') do
-    t = RP.parse(/((?i-m)(a(?-i)b))/m, 'ruby/1.8')
-
-    group2 = t[0][1]
-
-    expect(group2.m?).to be false
-    expect(group2.i?).to be true
-    expect(group2.x?).to be false
-
-    expect(group2[0].m?).to be false
-    expect(group2[0].i?).to be true
-    expect(group2[0].x?).to be false
-
-    expect(group2[1].m?).to be false
-    expect(group2[1].i?).to be false
-    expect(group2[1].x?).to be false
-
-    expect(group2[2].m?).to be false
-    expect(group2[2].i?).to be false
-    expect(group2[2].x?).to be false
-  end
-
-  specify('parse options dau') do
-    t = RP.parse('(?dua:abc)')
-
-    expect(t[0].d?).to be false
-    expect(t[0].a?).to be true
-    expect(t[0].u?).to be false
-  end
-
-  specify('parse nested options dau') do
-    t = RP.parse('(?u:a(?d:b))')
-
-    expect(t[0].u?).to be true
-    expect(t[0].d?).to be false
-    expect(t[0].a?).to be false
-
-    expect(t[0][1].d?).to be true
-    expect(t[0][1].a?).to be false
-    expect(t[0][1].u?).to be false
-  end
-
-  specify('parse nested options da') do
-    t = RP.parse('(?di-xm:a(?da-x:b))')
-
-    expect(t[0].d?).to be true
-    expect(t[0].i?).to be true
-    expect(t[0].m?).to be false
-    expect(t[0].x?).to be false
-    expect(t[0].a?).to be false
-    expect(t[0].u?).to be false
-
-    expect(t[0][1].d?).to be false
-    expect(t[0][1].a?).to be true
-    expect(t[0][1].u?).to be false
-    expect(t[0][1].x?).to be false
-    expect(t[0][1].m?).to be false
-    expect(t[0][1].i?).to be true
-  end
-
-  specify('parse lookahead') do
-    t = RP.parse('(?=abc)(?!def)', 'ruby/1.8')
-
-    expect(t[0]).to be_a(Assertion::Lookahead)
-
-    expect(t[1]).to be_a(Assertion::NegativeLookahead)
-  end
-
-  specify('parse lookbehind') do
-    t = RP.parse('(?<=abc)(?<!def)', 'ruby/1.9')
-
-    expect(t[0]).to be_a(Assertion::Lookbehind)
-
-    expect(t[1]).to be_a(Assertion::NegativeLookbehind)
-  end
-
-  specify('parse comment') do
-    t = RP.parse('a(?# is for apple)b(?# for boy)c(?# cat)')
-
-    [1, 3, 5].each do |i|
-      expect(t[i]).to be_a(Group::Comment)
-
-      expect(t[i].type).to eq :group
-      expect(t[i].token).to eq :comment
-    end
-  end
-
-  specify('parse absence group', if: ruby_version_at_least('2.4.1')) do
-    t = RP.parse('a(?~b)c(?~d)e')
-
-    [1, 3].each do |i|
-      expect(t[i]).to be_a(Group::Absence)
-
-      expect(t[i].type).to eq :group
-      expect(t[i].token).to eq :absence
-    end
-  end
+  include_examples 'parse', /(?=abc)(?!def)/,
+    0 => [:assertion, :lookahead,   Assertion::Lookahead],
+    1 => [:assertion, :nlookahead,  Assertion::NegativeLookahead]
+
+  include_examples 'parse', /(?<=abc)(?<!def)/,
+    0 => [:assertion, :lookbehind,  Assertion::Lookbehind],
+    1 => [:assertion, :nlookbehind, Assertion::NegativeLookbehind]
+
+  include_examples 'parse', /a(?# is for apple)b(?# for boy)c(?# cat)/,
+    1 => [:group, :comment, Group::Comment],
+    3 => [:group, :comment, Group::Comment],
+    5 => [:group, :comment, Group::Comment]
+
+  if ruby_version_at_least('2.4.1')
+    include_examples 'parse', 'a(?~b)c(?~d)e',
+      1 => [:group, :absence, Group::Absence],
+      3 => [:group, :absence, Group::Absence]
+  end
+
+  include_examples 'parse', /(?m:a)/,
+    0 => [:group, :options, Group::Options, options: { m: true }, option_changes: { m: true }]
+
+  # self-defeating group option
+  include_examples 'parse', /(?m-m:a)/,
+    0 => [:group, :options, Group::Options, options: {}, option_changes: { m: false }]
+
+  # activate one option in nested group
+  include_examples 'parse', /(?x-mi:a(?m:b))/,
+    0      => [:group, :options, Group::Options, options: { x: true }, option_changes: { i: false, m: false, x: true }],
+    [0, 1] => [:group, :options, Group::Options, options: { m: true, x: true }, option_changes: { m: true }]
+
+  # deactivate one option in nested group
+  include_examples 'parse', /(?ix-m:a(?-i:b))/,
+    0      => [:group, :options, Group::Options, options: { i: true, x: true }, option_changes: { i: true, m: false, x: true }],
+    [0, 1] => [:group, :options, Group::Options, options: { x: true }, option_changes: { i: false }]
+
+  # invert all options in nested group
+  include_examples 'parse', /(?xi-m:a(?m-ix:b))/,
+    0      => [:group, :options, Group::Options, options: { i: true, x: true }, option_changes: { i: true, m: false, x: true }],
+    [0, 1] => [:group, :options, Group::Options, options: { m: true }, option_changes: { i: false, m: true, x: false }]
+
+  # nested options affect literal subexpressions
+  include_examples 'parse', /(?x-mi:a(?m:b))/,
+    [0, 0]    => [:literal, :literal, Literal, text: 'a', options: { x: true }],
+    [0, 1, 0] => [:literal, :literal, Literal, text: 'b', options: { m: true, x: true }]
+
+  # option switching group
+  include_examples 'parse', /a(?i-m)b/m,
+    0 => [:literal, :literal,         Literal,        text: 'a', options: { m: true }],
+    1 => [:group,   :options_switch,  Group::Options, options: { i: true }, option_changes: { i: true, m: false }],
+    2 => [:literal, :literal,         Literal,        text: 'b', options: { i: true }]
+
+  # option switch in group
+  include_examples 'parse', /(a(?i-m)b)c/m,
+    0      => [:group,   :capture,        Group::Capture, options: { m: true }],
+    [0, 0] => [:literal, :literal,        Literal,        text: 'a', options: { m: true }],
+    [0, 1] => [:group,   :options_switch, Group::Options, options: { i: true }, option_changes: { i: true, m: false }],
+    [0, 2] => [:literal, :literal,        Literal,        text: 'b', options: { i: true }],
+    1      => [:literal, :literal,        Literal,        text: 'c', options: { m: true }]
+
+  # nested option switch in group
+  include_examples 'parse', /((?i-m)(a(?-i)b))/m,
+    [0, 1]    => [:group,   :capture,        Group::Capture, options: { i: true }],
+    [0, 1, 0] => [:literal, :literal,        Literal,        text: 'a', options: { i: true }],
+    [0, 1, 1] => [:group,   :options_switch, Group::Options, options: {}, option_changes: { i: false }],
+    [0, 1, 2] => [:literal, :literal,        Literal,        text: 'b', options: {}]
+
+  # options dau
+  include_examples 'parse', /(?dua:abc)/,
+    0 => [:group, :options, Group::Options, options: { a: true }, option_changes: { a: true }]
+
+  # nested options dau
+  include_examples 'parse', /(?u:a(?d:b))/,
+    0         => [:group,   :options, Group::Options, options: { u: true }, option_changes: { u: true }],
+    [0, 1]    => [:group,   :options, Group::Options, options: { d: true }, option_changes: { d: true, u: false }],
+    [0, 1, 0] => [:literal, :literal, Literal,        text: 'b', options: { d: true }]
+
+  # nested options da
+  include_examples 'parse', /(?di-xm:a(?da-x:b))/,
+    0         => [:group,   :options, Group::Options, options: { d: true, i:true }],
+    [0, 1]    => [:group,   :options, Group::Options, options: { a: true, i: true }, option_changes: { a: true, d: false, x: false}],
+    [0, 1, 0] => [:literal, :literal, Literal,        text: 'b', options: { a: true, i: true }]
 
   specify('parse group number') do
-    t = RP.parse('(a)(?=b)((?:c)(d|(e)))')
-    expect(t[0].number).to eq 1
-    expect(t[1]).not_to respond_to(:number)
-    expect(t[2].number).to eq 2
-    expect(t[2][0]).not_to respond_to(:number)
-    expect(t[2][1].number).to eq 3
-    expect(t[2][1][0][1][0].number).to eq 4
+    root = RP.parse(/(a)(?=b)((?:c)(d|(e)))/)
+
+    expect(root[0].number).to eq 1
+    expect(root[1]).not_to respond_to(:number)
+    expect(root[2].number).to eq 2
+    expect(root[2][0]).not_to respond_to(:number)
+    expect(root[2][1].number).to eq 3
+    expect(root[2][1][0][1][0].number).to eq 4
   end
 
   specify('parse group number at level') do
-    t = RP.parse('(a)(?=b)((?:c)(d|(e)))')
-    expect(t[0].number_at_level).to eq 1
-    expect(t[1]).not_to respond_to(:number_at_level)
-    expect(t[2].number_at_level).to eq 2
-    expect(t[2][0]).not_to respond_to(:number_at_level)
-    expect(t[2][1].number_at_level).to eq 1
-    expect(t[2][1][0][1][0].number_at_level).to eq 1
+    root = RP.parse(/(a)(?=b)((?:c)(d|(e)))/)
+
+    expect(root[0].number_at_level).to eq 1
+    expect(root[1]).not_to respond_to(:number_at_level)
+    expect(root[2].number_at_level).to eq 2
+    expect(root[2][0]).not_to respond_to(:number_at_level)
+    expect(root[2][1].number_at_level).to eq 1
+    expect(root[2][1][0][1][0].number_at_level).to eq 1
   end
 end

data/spec/parser/keep_spec.rb

@@ -1,19 +1,6 @@
 require 'spec_helper'
 
 RSpec.describe('Keep parsing') do
-  specify('parse keep') do
-    regexp = /ab\Kcd/
-    root = RP.parse(regexp)
-
-    expect(root[1]).to be_instance_of(Keep::Mark)
-    expect(root[1].text).to eq '\\K'
-  end
-
-  specify('parse keep nested') do
-    regexp = /(a\\\Kb)/
-    root = RP.parse(regexp)
-
-    expect(root[0][2]).to be_instance_of(Keep::Mark)
-    expect(root[0][2].text).to eq '\\K'
-  end
+  include_examples 'parse', /ab\Kcd/, 1      => [:keep, :mark, Keep::Mark, text: '\K']
+  include_examples 'parse', /(a\K)/,  [0, 1] => [:keep, :mark, Keep::Mark, text: '\K']
 end

data/spec/parser/options_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+RSpec.describe('passing options to parse') do
+  it 'raises if if parsing from a Regexp and options are passed' do
+    expect { RP.parse(/a+/, options: ::Regexp::EXTENDED) }.to raise_error(
+      ArgumentError,
+      'options cannot be supplied unless parsing a String'
+    )
+  end
+
+  it 'sets options if parsing from a String' do
+    root = RP.parse('a+', options: ::Regexp::MULTILINE | ::Regexp::EXTENDED)
+
+    expect(root.options).to eq(m: true, x: true)
+  end
+
+  it 'allows options to not be supplied when parsing from a Regexp' do
+    root = RP.parse(/a+/ix)
+
+    expect(root.options).to eq(i: true, x: true)
+  end
+
+  it 'has an empty option-hash when parsing from a String and passing no options' do
+    root = RP.parse('a+')
+
+    expect(root.options).to be_empty
+  end
+end

data/spec/parser/posix_classes_spec.rb

@@ -1,27 +1,8 @@
 require 'spec_helper'
 
-RSpec.describe('PosixClasse parsing') do
-  specify('parse posix class') do
-    root = RP.parse('[[:word:]]')
-    exp = root[0][0]
-
-    expect(exp).to be_instance_of(PosixClass)
-    expect(exp.type).to eq :posixclass
-    expect(exp.token).to eq :word
-    expect(exp.name).to eq 'word'
-    expect(exp.text).to eq '[:word:]'
-    expect(exp).not_to be_negative
-  end
-
-  specify('parse negative posix class') do
-    root = RP.parse('[[:^word:]]')
-    exp = root[0][0]
-
-    expect(exp).to be_instance_of(PosixClass)
-    expect(exp.type).to eq :nonposixclass
-    expect(exp.token).to eq :word
-    expect(exp.name).to eq 'word'
-    expect(exp.text).to eq '[:^word:]'
-    expect(exp).to be_negative
-  end
+RSpec.describe('PosixClass parsing') do
+  include_examples 'parse', /[[:word:]]/,  [0, 0] => [:posixclass,    :word, PosixClass,
+                                           name: 'word', text: '[:word:]', negative?: false]
+  include_examples 'parse', /[[:^word:]]/, [0, 0] => [:nonposixclass, :word, PosixClass,
+                                           name: 'word', text: '[:^word:]', negative?: true]
 end

data/spec/parser/properties_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 RSpec.describe('Property parsing') do
-  modes = %w[p P]
   example_props = [
     'Alnum',
     'Any',
@@ -20,108 +19,97 @@ RSpec.describe('Property parsing') do
     'InChessSymbols'
   ]
 
-  modes.each do |mode|
-    token_type = mode == 'p' ? :property : :nonproperty
+  example_props.each do |name|
+    it("parses property #{name}") do
+      exp = RP.parse("ab\\p{#{name}}", '*').last
 
-    example_props.each do |property|
-      specify("parse_#{token_type}_#{property}") do
-        t = RP.parse("ab\\#{mode}{#{property}}", '*')
+      expect(exp).to be_a(UnicodeProperty::Base)
+      expect(exp.type).to eq :property
+      expect(exp.name).to eq name
+    end
 
-        expect(t.expressions.last).to be_a(UnicodeProperty::Base)
+    it("parses nonproperty #{name}") do
+      exp = RP.parse("ab\\P{#{name}}", '*').last
 
-        expect(t.expressions.last.type).to eq token_type
-        expect(t.expressions.last.name).to eq property
-      end
+      expect(exp).to be_a(UnicodeProperty::Base)
+      expect(exp.type).to eq :nonproperty
+      expect(exp.name).to eq name
     end
   end
 
   specify('parse all properties of current ruby') do
     unsupported = RegexpPropertyValues.all_for_current_ruby.reject do |prop|
-      begin
-        RP.parse("\\p{#{prop}}")
-      rescue SyntaxError, StandardError
-        nil
-      end
+      RP.parse("\\p{#{prop}}") rescue false
     end
     expect(unsupported).to be_empty
   end
 
   specify('parse property negative') do
-    t = RP.parse('ab\\p{L}cd', 'ruby/1.9')
-
-    expect(t[1]).not_to be_negative
+    root = RP.parse('ab\p{L}cd', 'ruby/1.9')
+    expect(root[1]).not_to be_negative
   end
 
   specify('parse nonproperty negative') do
-    t = RP.parse('ab\\P{L}cd', 'ruby/1.9')
-
-    expect(t[1]).to be_negative
+    root = RP.parse('ab\P{L}cd', 'ruby/1.9')
+    expect(root[1]).to be_negative
   end
 
   specify('parse caret nonproperty negative') do
-    t = RP.parse('ab\\p{^L}cd', 'ruby/1.9')
-
-    expect(t[1]).to be_negative
+    root = RP.parse('ab\p{^L}cd', 'ruby/1.9')
+    expect(root[1]).to be_negative
   end
 
   specify('parse double negated property negative') do
-    t = RP.parse('ab\\P{^L}cd', 'ruby/1.9')
-
-    expect(t[1]).not_to be_negative
+    root = RP.parse('ab\P{^L}cd', 'ruby/1.9')
+    expect(root[1]).not_to be_negative
   end
 
   specify('parse property shortcut') do
-    expect(RP.parse('\\p{mark}')[0].shortcut).to eq 'm'
-    expect(RP.parse('\\p{sc}')[0].shortcut).to eq 'sc'
-    expect(RP.parse('\\p{in_bengali}')[0].shortcut).to be_nil
+    expect(RP.parse('\p{lowercase_letter}')[0].shortcut).to eq 'll'
+    expect(RP.parse('\p{sc}')[0].shortcut).to eq 'sc'
+    expect(RP.parse('\p{in_bengali}')[0].shortcut).to be_nil
   end
 
   specify('parse property age') do
-    t = RP.parse('ab\\p{age=5.2}cd', 'ruby/1.9')
-
-    expect(t[1]).to be_a(UnicodeProperty::Age)
+    root = RP.parse('ab\p{age=5.2}cd', 'ruby/1.9')
+    expect(root[1]).to be_a(UnicodeProperty::Age)
   end
 
   specify('parse property derived') do
-    t = RP.parse('ab\\p{Math}cd', 'ruby/1.9')
-
-    expect(t[1]).to be_a(UnicodeProperty::Derived)
+    root = RP.parse('ab\p{Math}cd', 'ruby/1.9')
+    expect(root[1]).to be_a(UnicodeProperty::Derived)
   end
 
   specify('parse property script') do
-    t = RP.parse('ab\\p{Hiragana}cd', 'ruby/1.9')
-
-    expect(t[1]).to be_a(UnicodeProperty::Script)
+    root = RP.parse('ab\p{Hiragana}cd', 'ruby/1.9')
+    expect(root[1]).to be_a(UnicodeProperty::Script)
   end
 
   specify('parse property script V1 9 3') do
-    t = RP.parse('ab\\p{Brahmi}cd', 'ruby/1.9.3')
-
-    expect(t[1]).to be_a(UnicodeProperty::Script)
+    root = RP.parse('ab\p{Brahmi}cd', 'ruby/1.9.3')
+    expect(root[1]).to be_a(UnicodeProperty::Script)
   end
 
   specify('parse property script V2 2 0') do
-    t = RP.parse('ab\\p{Caucasian_Albanian}cd', 'ruby/2.2')
-
-    expect(t[1]).to be_a(UnicodeProperty::Script)
+    root = RP.parse('ab\p{Caucasian_Albanian}cd', 'ruby/2.2')
+    expect(root[1]).to be_a(UnicodeProperty::Script)
   end
 
   specify('parse property block') do
-    t = RP.parse('ab\\p{InArmenian}cd', 'ruby/1.9')
-
-    expect(t[1]).to be_a(UnicodeProperty::Block)
+    root = RP.parse('ab\p{InArmenian}cd', 'ruby/1.9')
+    expect(root[1]).to be_a(UnicodeProperty::Block)
   end
 
   specify('parse property following literal') do
-    t = RP.parse('ab\\p{Lu}cd', 'ruby/1.9')
-
-    expect(t[2]).to be_a(Literal)
+    root = RP.parse('ab\p{Lu}cd', 'ruby/1.9')
+    expect(root[2]).to be_a(Literal)
   end
 
   specify('parse abandoned newline property') do
-    t = RP.parse('\\p{newline}', 'ruby/1.9')
-    expect(t.expressions.last).to be_a(UnicodeProperty::Base)
+    root = RP.parse('\p{newline}', 'ruby/1.9')
+    expect(root.expressions.last).to be_a(UnicodeProperty::Base)
 
-    expect { RP.parse('\\p{newline}', 'ruby/2.0') }.to raise_error(Regexp::Syntax::NotImplementedError)
+    expect { RP.parse('\p{newline}', 'ruby/2.0') }
+      .to raise_error(Regexp::Syntax::NotImplementedError)
   end
 end