mutant 0.8.10 → 0.8.11

data/spec/unit/mutant/actor/env_spec.rb

@@ -1,6 +1,6 @@
 RSpec.describe Mutant::Actor::Env do
-  let(:thread)      { instance_double(Thread)                 }
-  let(:thread_root) { instance_double(Thread.singleton_class) }
+  let(:thread)      { instance_double(Thread) }
+  let(:thread_root) { class_double(Thread)    }
 
   let(:object) { described_class.new(thread_root) }
 

data/spec/unit/mutant/actor/sender_spec.rb

@@ -1,5 +1,5 @@
 RSpec.describe Mutant::Actor::Sender do
-  let(:object)   { described_class.new(condition_variable, mutex, messages) }
+  let(:object) { described_class.new(condition_variable, mutex, messages) }
 
   let(:condition_variable) { instance_double(ConditionVariable) }
   let(:mutex)              { instance_double(Mutex)             }

data/spec/unit/mutant/ast/meta/send_spec.rb

@@ -23,7 +23,7 @@ RSpec.describe Mutant::AST::Meta::Send do
     ].map do |values|
       new(Hash[anima.attribute_names.zip(values)])
     end.freeze
-  end
+  end # Expectation
 
   # Rspec should have a build in for this kind of "n-dimensional assertion with context"
   (Expectation.anima.attribute_names - %i[name]).each do |name|

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

@@ -8,6 +8,14 @@ RSpec.describe Mutant::AST::NamedChildren do
       end
     end
 
+    def publish
+      klass.class_eval do
+        public :foo, :bar
+
+        public :remaining_children, :remaining_children_indices, :remaining_children_with_index
+      end
+    end
+
     let(:instance) { klass.new(node) }
 
     let(:node_foo) { s(:foo) }
@@ -17,26 +25,42 @@ RSpec.describe Mutant::AST::NamedChildren do
     let(:node) { s(:node, node_foo, node_bar, node_baz) }
 
     describe 'generated methods' do
+      specify 'are private by default' do
+        %i[
+          foo
+          bar
+          remaining_children
+          remaining_children_indices
+          remaining_children_with_index
+        ].each do |name|
+          expect(klass.private_instance_methods.include?(name)).to be(true)
+        end
+      end
+
       describe '#remaining_children' do
         it 'returns remaining unnamed children' do
+          publish
           expect(instance.remaining_children).to eql([node_baz])
         end
       end
 
       describe '#remaining_children_indices' do
         it 'returns remaining unnamed children indices' do
+          publish
           expect(instance.remaining_children_indices).to eql([2])
         end
       end
 
       describe '#remaining_children_with_index' do
         it 'returns remaining unnamed children indices' do
+          publish
           expect(instance.remaining_children_with_index).to eql([[node_baz, 2]])
         end
       end
 
       describe '#foo' do
         it 'returns named child foo' do
+          publish
           expect(instance.foo).to be(node_foo)
         end
       end
@@ -44,6 +68,7 @@ RSpec.describe Mutant::AST::NamedChildren do
       describe '#bar' do
         context 'when node is present' do
           it 'returns named child bar' do
+            publish
             expect(instance.bar).to be(node_bar)
           end
         end
@@ -52,6 +77,7 @@ RSpec.describe Mutant::AST::NamedChildren do
           let(:node) { s(:node, node_foo) }
 
           it 'returns nil' do
+            publish
             expect(instance.bar).to be(nil)
           end
         end

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

@@ -0,0 +1,7 @@
+RSpec.describe Mutant::AST::Regexp, '.parse' do
+  before { stub_const('RUBY_VERSION', '2.3.9') }
+
+  it 'parses using minor ruby version' do
+    expect(described_class.parse(/foo/).to_re).to eql(/foo/)
+  end
+end

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

@@ -0,0 +1,14 @@
+RSpec.describe Mutant::AST::Regexp, '.supported?' do
+  subject { described_class.supported?(expression) }
+
+  let(:expression) { described_class.parse(regexp) }
+  let(:regexp)     { /foo/                         }
+
+  it { should be(true) }
+
+  context 'conditional regular expressions' do
+    let(:regexp) { /((?(1)(foo)(bar)))/ }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,617 @@
+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'
+
+        return if regexp.encoding.name.eql?('ASCII-8BIT')
+
+        include_context 'regexp round trip'
+      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(/\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, 'a', 'b')))
+end
+
+RegexpSpec.expect_mapping(/[ab]/, :regexp_character_set) do
+  s(:regexp_root_expression,
+    s(:regexp_character_set, 'a', 'b'))
+end
+
+RegexpSpec.expect_mapping(/[a-j]/, :regexp_character_set) do
+  s(:regexp_root_expression,
+    s(:regexp_character_set, 'a-j'))
+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, {
+        m: false,
+        i: false,
+        x: true,
+        d: false,
+        a: false,
+        u: false
+      },
+      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, 'a', '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(/\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_hex_type) do
+  s(:regexp_root_expression,
+    s(:regexp_nonhex_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_any_property) do
+  s(:regexp_root_expression,
+    s(:regexp_letter_any_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>)/, :regexp_named_group) do
+  s(:regexp_root_expression,
+    s(:regexp_named_group, '(?<foo>'))
+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,
+        {
+          m: false,
+          i: true,
+          x: false,
+          d: false,
+          a: false,
+          u: false
+        },
+        s(:regexp_literal_literal, 'a'))))
+end
+
+RegexpSpec.expect_mapping(/(?x-: #{"\n"} )/, :regexp_whitespace_free_space) do
+  s(:regexp_root_expression,
+    s(:regexp_options_group,
+      {
+        m: false,
+        i: false,
+        x: true,
+        d: false,
+        a: false,
+        u: false
+      },
+      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(/.{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_script_arabic_property) do
+  s(:regexp_root_expression,
+    s(:regexp_script_arabic_property))
+end
+
+RegexpSpec.expect_mapping(/\p{Han}/, :regexp_script_han_property) do
+  s(:regexp_root_expression,
+    s(:regexp_script_han_property))
+end
+
+RegexpSpec.expect_mapping(/\p{Hangul}/, :regexp_script_hangul_property) do
+  s(:regexp_root_expression,
+    s(:regexp_script_hangul_property))
+end
+
+RegexpSpec.expect_mapping(/\p{Hiragana}/, :regexp_script_hiragana_property) do
+  s(:regexp_root_expression,
+    s(:regexp_script_hiragana_property))
+end
+
+RegexpSpec.expect_mapping(/\p{Katakana}/, :regexp_script_katakana_property) do
+  s(:regexp_root_expression,
+    s(:regexp_script_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(/\*/, :regexp_zero_or_more_escape) do
+  s(:regexp_root_expression,
+    s(:regexp_zero_or_more_escape))
+end