mutant 0.8.24 → 0.9.0

data/spec/unit/mutant/ast/regexp/parse_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::AST::Regexp, '.parse' do
-  def apply(input)
-    described_class.parse(input)
-  end
-
-  context 'on regexp regexp_parser does accept' do
-    it 'parses using minor ruby version' do
-      expect(apply(/foo/).to_re).to eql(/foo/)
-    end
-  end
-
-  context 'on regexp regexp_parser does not accept' do
-    it 'returns nil' do
-      expect(apply(/u{/)).to be(nil)
-    end
-  end
-end

data/spec/unit/mutant/ast/regexp/transformer/lookup_table/table_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::AST::Regexp::Transformer::LookupTable::Table do
-  subject { table.lookup(:regexp_fake_thing) }
-
-  let(:expression_class) { class_double(Regexp::Expression) }
-
-  let(:table) do
-    described_class.create(
-      [:regexp_fake_thing, %i[thing fake], expression_class]
-    )
-  end
-
-  its(:token) { should eql(Regexp::Token.new(:thing, :fake)) }
-
-  its(:regexp_class) { should be(expression_class) }
-
-  it 'exposes list of types' do
-    expect(table.types).to eql([:regexp_fake_thing])
-  end
-end

data/spec/unit/mutant/ast/regexp/transformer/lookup_table_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::AST::Regexp::Transformer::LookupTable do
-  subject(:pair) { mapper.new(s(:regexp_fake)).pair }
-
-  let(:table) { instance_double(described_class::Table) }
-  let(:token) { ::Regexp::Token.new  }
-  let(:klass) { ::Regexp::Expression }
-
-  let(:mapping) do
-    described_class::Mapping.new(token, klass)
-  end
-
-  let(:mapper) do
-    fake_table = table
-
-    Class.new do
-      include Concord.new(:node), Mutant::AST::Regexp::Transformer::LookupTable
-
-      const_set(:TABLE, fake_table)
-
-      def pair
-        [expression_token, expression_class]
-      end
-    end
-  end
-
-  before do
-    allow(table).to receive(:lookup).with(:regexp_fake).and_return(mapping)
-  end
-
-  it 'constructs regexp lookup table' do
-    expect(pair).to eql([token, klass])
-  end
-end

data/spec/unit/mutant/ast/regexp/transformer_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::AST::Regexp::Transformer do
-  before do
-    stub_const("#{described_class}::REGISTRY", Mutant::Registry.new)
-  end
-
-  it 'registers types to a given class' do
-    klass = Class.new(described_class) { register(:regexp_bos_anchor) }
-
-    expect(described_class.lookup(:regexp_bos_anchor)).to be(klass)
-  end
-
-  it 'rejects duplicate registrations' do
-    Class.new(described_class) { register(:regexp_bos_anchor) }
-
-    expect { Class.new(described_class) { register(:regexp_bos_anchor) } }
-      .to raise_error(Mutant::Registry::RegistryError)
-      .with_message('Duplicate type registration: :regexp_bos_anchor')
-  end
-end

data/spec/unit/mutant/ast/regexp_spec.rb

@@ -1,704 +0,0 @@
-# frozen_string_literal: true
-
-module RegexpSpec
-  class Expression < SimpleDelegator
-    NO_EXPRESSIONS = Object.new.freeze
-
-    include Equalizer.new(:type, :token, :text, :quantifier, :expressions)
-
-    def quantifier
-      return Quantifier::NONE unless quantified?
-
-      Quantifier.new(super())
-    end
-
-    def expressions
-      return NO_EXPRESSIONS if terminal?
-
-      super().map(&self.class.public_method(:new))
-    end
-
-    class Quantifier < SimpleDelegator
-      NONE = Object.new.freeze
-
-      include Equalizer.new(:token, :text, :mode, :min, :max)
-    end # Quantifier
-  end # Expression
-
-  RSpec.shared_context 'regexp transformation' do
-    let(:parsed)     { Mutant::AST::Regexp.parse(regexp)      }
-    let(:ast)        { Mutant::AST::Regexp.to_ast(parsed)     }
-    let(:expression) { Mutant::AST::Regexp.to_expression(ast) }
-
-    def expect_frozen_expression(expression, root = expression)
-      expect(expression.frozen?).to(
-        be(true),
-        "Expected #{root} to be deep frozen"
-      )
-
-      return if expression.terminal?
-
-      expression.expressions.each do |subexpression|
-        expect_frozen_expression(subexpression, root)
-      end
-    end
-
-    it 'transforms into ast' do
-      expect(ast).to eql(expected)
-    end
-
-    it 'deep freezes expression mapping' do
-      expect_frozen_expression(expression)
-    end
-
-    it 'transforms ast back to expression' do
-      expect(Expression.new(expression)).to eql(Expression.new(parsed))
-    end
-  end
-
-  RSpec.shared_context 'regexp round trip' do
-    let(:round_trip) { expression.to_re }
-
-    it 'round trips Regexp' do
-      expect(round_trip).to eql(regexp)
-    end
-  end
-
-  def self.expect_mapping(regexp, type, &block)
-    RSpec.describe Mutant::AST::Regexp::Transformer.lookup(type) do
-      context "when mapping #{regexp.inspect}" do
-        let(:regexp) { regexp }
-        let(:expected, &block)
-
-        include_context 'regexp transformation'
-
-        unless regexp.encoding.name.eql?('ASCII-8BIT')
-          include_context 'regexp round trip'
-        end
-      end
-    end
-  end
-end # RegexpSpec
-
-RegexpSpec.expect_mapping(/A/, :regexp_root_expression) do
-  s(:regexp_root_expression,
-    s(:regexp_literal_literal, 'A'))
-end
-
-RegexpSpec.expect_mapping(/\p{Alpha}/, :regexp_alpha_property) do
-  s(:regexp_root_expression,
-    s(:regexp_alpha_property))
-end
-
-RegexpSpec.expect_mapping(/foo|bar/, :regexp_alternation_meta) do
-  s(:regexp_root_expression,
-    s(:regexp_alternation_meta,
-      s(:regexp_sequence_expression,
-        s(:regexp_literal_literal, 'foo')),
-      s(:regexp_sequence_expression,
-        s(:regexp_literal_literal, 'bar'))))
-end
-
-RegexpSpec.expect_mapping(/(?>a)/, :regexp_atomic_group) do
-  s(:regexp_root_expression,
-    s(:regexp_atomic_group,
-      s(:regexp_literal_literal, 'a')))
-end
-
-RegexpSpec.expect_mapping(/\\/, :regexp_backslash_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_backslash_escape, '\\\\'))
-end
-
-RegexpSpec.expect_mapping(/^/, :regexp_bol_anchor) do
-  s(:regexp_root_expression,
-    s(:regexp_bol_anchor))
-end
-
-RegexpSpec.expect_mapping(/\^/, :regexp_bol_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_bol_escape))
-end
-
-RegexpSpec.expect_mapping(/\A/, :regexp_bos_anchor) do
-  s(:regexp_root_expression,
-    s(:regexp_bos_anchor))
-end
-
-RegexpSpec.expect_mapping(/(foo)/, :regexp_capture_group) do
-  s(:regexp_root_expression,
-    s(:regexp_capture_group,
-      s(:regexp_literal_literal, 'foo')))
-end
-
-RegexpSpec.expect_mapping(/()\1/, :regexp_number_backref) do
-  s(:regexp_root_expression,
-    s(:regexp_capture_group),
-    s(:regexp_number_backref, '\\1'))
-end
-
-RegexpSpec.expect_mapping(/(a)*/, :regexp_capture_group) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_zero_or_more, 0, -1,
-      s(:regexp_capture_group,
-        s(:regexp_literal_literal, 'a'))))
-end
-
-RegexpSpec.expect_mapping(/\r/, :regexp_carriage_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_carriage_escape))
-end
-
-RegexpSpec.expect_mapping(/\a/, :regexp_bell_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_bell_escape))
-end
-
-RegexpSpec.expect_mapping(/\?/, :regexp_zero_or_one_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_zero_or_one_escape))
-end
-
-RegexpSpec.expect_mapping(/\|/, :regexp_alternation_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_alternation_escape))
-end
-
-RegexpSpec.expect_mapping(/\c2/, :regexp_control_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_control_escape, '\\c2'))
-end
-
-RegexpSpec.expect_mapping(/\M-B/n, :regexp_meta_sequence_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_meta_sequence_escape, '\M-B'))
-end
-
-RegexpSpec.expect_mapping(/\K/, :regexp_mark_keep) do
-  s(:regexp_root_expression,
-    s(:regexp_mark_keep))
-end
-
-RegexpSpec.expect_mapping(/\e/, :regexp_escape_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_escape_escape))
-end
-
-RegexpSpec.expect_mapping(/\f/, :regexp_form_feed_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_form_feed_escape))
-end
-
-RegexpSpec.expect_mapping(/\v/, :regexp_vertical_tab_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_vertical_tab_escape))
-end
-
-RegexpSpec.expect_mapping(/\e/, :regexp_escape_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_escape_escape))
-end
-
-RegexpSpec.expect_mapping(/[ab]+/, :regexp_character_set) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_one_or_more, 1, -1,
-      s(:regexp_character_set,
-        s(:regexp_literal_literal, 'a'),
-        s(:regexp_literal_literal, 'b'))))
-end
-
-RegexpSpec.expect_mapping(/[ab]/, :regexp_character_set) do
-  s(:regexp_root_expression,
-    s(:regexp_character_set,
-      s(:regexp_literal_literal, 'a'),
-      s(:regexp_literal_literal, 'b')))
-end
-
-RegexpSpec.expect_mapping(/[a-j]/, :regexp_character_set) do
-  s(:regexp_root_expression,
-    s(:regexp_character_set,
-      s(:regexp_range_set,
-        s(:regexp_literal_literal, 'a'),
-        s(:regexp_literal_literal, 'j'))))
-end
-
-RegexpSpec.expect_mapping(/[\b]/, :regexp_backspace_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_character_set,
-      s(:regexp_backspace_escape)))
-end
-
-RegexpSpec.expect_mapping(/()(?(1)a|b)/, :regexp_open_conditional) do
-  s(:regexp_root_expression,
-    s(:regexp_capture_group),
-    s(:regexp_open_conditional,
-      s(:regexp_condition_conditional, '(1)'),
-      s(:regexp_sequence_expression,
-        s(:regexp_literal_literal, 'a')),
-      s(:regexp_sequence_expression,
-        s(:regexp_literal_literal, 'b'))))
-end
-
-RegexpSpec.expect_mapping(/[ab&&bc]/, :regexp_intersection_set) do
-  s(:regexp_root_expression,
-    s(:regexp_character_set,
-      s(:regexp_intersection_set,
-        s(:regexp_sequence_expression,
-          s(:regexp_literal_literal, 'a'),
-          s(:regexp_literal_literal, 'b')),
-        s(:regexp_sequence_expression,
-          s(:regexp_literal_literal, 'b'),
-          s(:regexp_literal_literal, 'c')))))
-end
-
-RegexpSpec.expect_mapping(/\u{9879}/, :regexp_codepoint_list_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_codepoint_list_escape, '\\u{9879}'))
-end
-
-RegexpSpec.expect_mapping(/(?#foo)/, :regexp_comment_group) do
-  s(:regexp_root_expression,
-    s(:regexp_comment_group, '(?#foo)'))
-end
-
-RegexpSpec.expect_mapping(/(?x: # comment
-)/, :regexp_comment_free_space) do
-  s(:regexp_root_expression,
-    s(:regexp_options_group, {
-        x: true
-      },
-      s(:regexp_whitespace_free_space, ' '),
-      s(:regexp_comment_free_space, "# comment\n")))
-end
-
-RegexpSpec.expect_mapping(/\d/, :regexp_digit_type) do
-  s(:regexp_root_expression,
-    s(:regexp_digit_type))
-end
-
-RegexpSpec.expect_mapping(/\./, :regexp_dot_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_dot_escape))
-end
-
-RegexpSpec.expect_mapping(/.+/, :regexp_dot_meta) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_one_or_more, 1, -1,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/$/, :regexp_eol_anchor) do
-  s(:regexp_root_expression,
-    s(:regexp_eol_anchor))
-end
-
-RegexpSpec.expect_mapping(/\$/, :regexp_eol_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_eol_escape))
-end
-
-RegexpSpec.expect_mapping(/\z/, :regexp_eos_anchor) do
-  s(:regexp_root_expression,
-    s(:regexp_eos_anchor))
-end
-
-RegexpSpec.expect_mapping(/\Z/, :regexp_eos_ob_eol_anchor) do
-  s(:regexp_root_expression,
-    s(:regexp_eos_ob_eol_anchor))
-end
-
-RegexpSpec.expect_mapping(/a{1,}/, :regexp_greedy_interval) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_interval, 1, -1,
-      s(:regexp_literal_literal, 'a')))
-end
-
-RegexpSpec.expect_mapping(/.{2}/, :regexp_greedy_interval) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_interval, 2, 2,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/.{3,5}/, :regexp_greedy_interval) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_interval, 3, 5,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/.{,3}/, :regexp_greedy_interval) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_interval, 0, 3,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/.+/, :regexp_greedy_one_or_more) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_one_or_more, 1, -1,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/[ab]+/, :regexp_greedy_one_or_more) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_one_or_more, 1, -1,
-      s(:regexp_character_set,
-        s(:regexp_literal_literal, 'a'),
-        s(:regexp_literal_literal, 'b'))))
-end
-
-RegexpSpec.expect_mapping(/(a)*/, :regexp_greedy_zero_or_more) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_zero_or_more, 0, -1,
-      s(:regexp_capture_group,
-        s(:regexp_literal_literal, 'a'))))
-end
-
-RegexpSpec.expect_mapping(/.*/, :regexp_greedy_zero_or_more) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_zero_or_more, 0, -1,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/.?/, :regexp_greedy_zero_or_one) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_zero_or_one, 0, 1,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/\)/, :regexp_group_close_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_group_close_escape))
-end
-
-RegexpSpec.expect_mapping(/\(/, :regexp_group_open_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_group_open_escape))
-end
-
-RegexpSpec.expect_mapping(/\101/, :regexp_octal_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_octal_escape, '\\101'))
-end
-
-RegexpSpec.expect_mapping(/\xFF/n, :regexp_hex_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_hex_escape, '\\xFF'))
-end
-
-RegexpSpec.expect_mapping(/\h/, :regexp_hex_type) do
-  s(:regexp_root_expression,
-    s(:regexp_hex_type))
-end
-
-RegexpSpec.expect_mapping(/\H/, :regexp_nonhex_type) do
-  s(:regexp_root_expression,
-    s(:regexp_nonhex_type))
-end
-
-RegexpSpec.expect_mapping(/\R/, :regexp_linebreak_type) do
-  s(:regexp_root_expression,
-    s(:regexp_linebreak_type))
-end
-
-RegexpSpec.expect_mapping(/\X/, :regexp_xgrapheme_type) do
-  s(:regexp_root_expression,
-    s(:regexp_xgrapheme_type))
-end
-
-RegexpSpec.expect_mapping(/\}/, :regexp_interval_close_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_interval_close_escape))
-end
-
-RegexpSpec.expect_mapping(/\{/, :regexp_interval_open_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_interval_open_escape))
-end
-
-RegexpSpec.expect_mapping(/\p{L}/, :regexp_letter_property) do
-  s(:regexp_root_expression,
-    s(:regexp_letter_property))
-end
-
-RegexpSpec.expect_mapping(/\-/, :regexp_literal_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_literal_escape, '\\-'))
-end
-
-RegexpSpec.expect_mapping(/\ /, :regexp_literal_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_literal_escape, '\\ '))
-end
-
-RegexpSpec.expect_mapping(/\#/, :regexp_literal_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_literal_escape, '\\#'))
-end
-
-RegexpSpec.expect_mapping(/\:/, :regexp_literal_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_literal_escape, '\\:'))
-end
-
-RegexpSpec.expect_mapping(/\</, :regexp_literal_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_literal_escape, '\\<'))
-end
-
-RegexpSpec.expect_mapping(/foo/, :regexp_literal_literal) do
-  s(:regexp_root_expression,
-    s(:regexp_literal_literal, 'foo'))
-end
-
-RegexpSpec.expect_mapping(/a+/, :regexp_literal_literal) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_one_or_more, 1, -1,
-      s(:regexp_literal_literal, 'a')))
-end
-
-RegexpSpec.expect_mapping(/(?=a)/, :regexp_lookahead_assertion) do
-  s(:regexp_root_expression,
-    s(:regexp_lookahead_assertion,
-      s(:regexp_literal_literal, 'a')))
-end
-
-RegexpSpec.expect_mapping(/(?<=a)/, :regexp_lookbehind_assertion) do
-  s(:regexp_root_expression,
-    s(:regexp_lookbehind_assertion,
-      s(:regexp_literal_literal, 'a')))
-end
-
-RegexpSpec.expect_mapping(/\G/, :regexp_match_start_anchor) do
-  s(:regexp_root_expression,
-    s(:regexp_match_start_anchor))
-end
-
-RegexpSpec.expect_mapping(/(?<foo>a)+/, :regexp_named_group) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_one_or_more, 1, -1,
-      s(:regexp_named_group, 'foo',
-        s(:regexp_literal_literal, 'a'))))
-end
-
-RegexpSpec.expect_mapping(/(?<a>)\g<a>/, :regexp_name_call_backref) do
-  s(:regexp_root_expression,
-    s(:regexp_named_group, 'a'),
-    s(:regexp_name_call_backref, '\\g<a>'))
-end
-
-RegexpSpec.expect_mapping(/\n/, :regexp_newline_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_newline_escape))
-end
-
-RegexpSpec.expect_mapping(/(?!a)/, :regexp_nlookahead_assertion) do
-  s(:regexp_root_expression,
-    s(:regexp_nlookahead_assertion,
-      s(:regexp_literal_literal, 'a')))
-end
-
-RegexpSpec.expect_mapping(/(?<!a)/, :regexp_nlookbehind_assertion) do
-  s(:regexp_root_expression,
-    s(:regexp_nlookbehind_assertion,
-      s(:regexp_literal_literal, 'a')))
-end
-
-RegexpSpec.expect_mapping(/\D/, :regexp_nondigit_type) do
-  s(:regexp_root_expression,
-    s(:regexp_nondigit_type))
-end
-
-RegexpSpec.expect_mapping(/\S/, :regexp_nonspace_type) do
-  s(:regexp_root_expression,
-    s(:regexp_nonspace_type))
-end
-
-RegexpSpec.expect_mapping(/\B/, :regexp_nonword_boundary_anchor) do
-  s(:regexp_root_expression,
-    s(:regexp_nonword_boundary_anchor))
-end
-
-RegexpSpec.expect_mapping(/\W/, :regexp_nonword_type) do
-  s(:regexp_root_expression,
-    s(:regexp_nonword_type))
-end
-
-RegexpSpec.expect_mapping(/\+/, :regexp_one_or_more_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_one_or_more_escape))
-end
-
-RegexpSpec.expect_mapping(/(?i:a)+/, :regexp_options_group) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_one_or_more, 1, -1,
-      s(:regexp_options_group,
-        {
-          i: true
-        },
-        s(:regexp_literal_literal, 'a'))))
-end
-
-RegexpSpec.expect_mapping(/(?i-x:a)+/, :regexp_options_group) do
-  s(:regexp_root_expression,
-    s(:regexp_greedy_one_or_more, 1, -1,
-      s(:regexp_options_group,
-        {
-          i: true,
-          x: false
-        },
-        s(:regexp_literal_literal, 'a'))))
-end
-
-RegexpSpec.expect_mapping(/a(?i)b/, :regexp_options_switch_group) do
-  s(:regexp_root_expression,
-    s(:regexp_literal_literal, 'a'),
-    s(:regexp_options_switch_group, i: true),
-    s(:regexp_literal_literal, 'b'))
-end
-
-RegexpSpec.expect_mapping(/(?x: #{"\n"} )/, :regexp_whitespace_free_space) do
-  s(:regexp_root_expression,
-    s(:regexp_options_group,
-      {
-        x: true
-      },
-      s(:regexp_whitespace_free_space, " \n ")))
-end
-
-RegexpSpec.expect_mapping(/(?:a)/, :regexp_passive_group) do
-  s(:regexp_root_expression,
-    s(:regexp_passive_group,
-      s(:regexp_literal_literal, 'a')))
-end
-
-RegexpSpec.expect_mapping(/.{1,3}+/, :regexp_possessive_interval) do
-  s(:regexp_root_expression,
-    s(:regexp_possessive_interval, 1, 3,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/.++/, :regexp_possessive_one_or_more) do
-  s(:regexp_root_expression,
-    s(:regexp_possessive_one_or_more, 1, -1,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/.*+/, :regexp_possessive_zero_or_more) do
-  s(:regexp_root_expression,
-    s(:regexp_possessive_zero_or_more, 0, -1,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/.?+/, :regexp_possessive_zero_or_one) do
-  s(:regexp_root_expression,
-    s(:regexp_possessive_zero_or_one, 0, 1,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/\P{Print}/, :regexp_print_nonproperty) do
-  s(:regexp_root_expression,
-    s(:regexp_print_nonproperty))
-end
-
-RegexpSpec.expect_mapping(/[[:print:]]/, :regexp_print_posixclass) do
-  s(:regexp_root_expression,
-    s(:regexp_character_set,
-      s(:regexp_print_posixclass)))
-end
-
-RegexpSpec.expect_mapping(/[[:^print:]]/, :regexp_print_nonposixclass) do
-  s(:regexp_root_expression,
-    s(:regexp_character_set,
-      s(:regexp_print_nonposixclass)))
-end
-
-RegexpSpec.expect_mapping(/.{1,3}?/, :regexp_reluctant_interval) do
-  s(:regexp_root_expression,
-    s(:regexp_reluctant_interval, 1, 3,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/.+?/, :regexp_reluctant_one_or_more) do
-  s(:regexp_root_expression,
-    s(:regexp_reluctant_one_or_more, 1, -1,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/.*?/, :regexp_reluctant_zero_or_more) do
-  s(:regexp_root_expression,
-    s(:regexp_reluctant_zero_or_more, 0, -1,
-      s(:regexp_dot_meta)))
-end
-
-RegexpSpec.expect_mapping(/\p{Arabic}/, :regexp_arabic_property) do
-  s(:regexp_root_expression,
-    s(:regexp_arabic_property))
-end
-
-RegexpSpec.expect_mapping(/\p{Han}/, :regexp_han_property) do
-  s(:regexp_root_expression,
-    s(:regexp_han_property))
-end
-
-RegexpSpec.expect_mapping(/\p{Hangul}/, :regexp_hangul_property) do
-  s(:regexp_root_expression,
-    s(:regexp_hangul_property))
-end
-
-RegexpSpec.expect_mapping(/\p{Hiragana}/, :regexp_hiragana_property) do
-  s(:regexp_root_expression,
-    s(:regexp_hiragana_property))
-end
-
-RegexpSpec.expect_mapping(/\p{Katakana}/, :regexp_katakana_property) do
-  s(:regexp_root_expression,
-    s(:regexp_katakana_property))
-end
-
-RegexpSpec.expect_mapping(/foo|bar/, :regexp_sequence_expression) do
-  s(:regexp_root_expression,
-    s(:regexp_alternation_meta,
-      s(:regexp_sequence_expression,
-        s(:regexp_literal_literal, 'foo')),
-      s(:regexp_sequence_expression,
-        s(:regexp_literal_literal, 'bar'))))
-end
-
-RegexpSpec.expect_mapping(/\]/, :regexp_set_close_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_set_close_escape))
-end
-
-RegexpSpec.expect_mapping(/\[/, :regexp_set_open_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_set_open_escape))
-end
-
-RegexpSpec.expect_mapping(/\s/, :regexp_space_type) do
-  s(:regexp_root_expression,
-    s(:regexp_space_type))
-end
-
-RegexpSpec.expect_mapping(/\t/, :regexp_tab_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_tab_escape, '\\t'))
-end
-
-RegexpSpec.expect_mapping(/\b/, :regexp_word_boundary_anchor) do
-  s(:regexp_root_expression,
-    s(:regexp_word_boundary_anchor))
-end
-
-RegexpSpec.expect_mapping(/\w/, :regexp_word_type) do
-  s(:regexp_root_expression,
-    s(:regexp_word_type))
-end
-
-RegexpSpec.expect_mapping(/\h/, :regexp_hex_type) do
-  s(:regexp_root_expression,
-    s(:regexp_hex_type))
-end
-
-RegexpSpec.expect_mapping(/\*/, :regexp_zero_or_more_escape) do
-  s(:regexp_root_expression,
-    s(:regexp_zero_or_more_escape))
-end