mutant 0.8.18 → 0.8.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e671cfb966debd1654091d93bd356505efdd8c30ed8c440c98b141f40f0e375b
-  data.tar.gz: 403a97ad6d13f1fd9809b0acc48fcb8e19289b3a01b0aaccb25bb83ea49bc4a3
+  metadata.gz: dbaeba3292082f39979c87a1918f1a75a681f4cca1299fee251373779c1f381b
+  data.tar.gz: b1e57ca598f25e27d1c74e2b17d2033edb1d3b602742eb0fa62a6a7ac1f1058a
 SHA512:
-  metadata.gz: 892d50fd61d110717f60877f1c1249c92d33179b70f44fdbb725dea7b3b34a82a8f8aa8c9b79329dbc74b12b15006a15d0cc2a118727d4732c65095b19421a64
-  data.tar.gz: 2b2f81d37ba20d4884e168dfe43ad8744e57b9bc0311aeb97f666f0652def83b98df9b71b1855b24070c1cbe16491eecd12f295d65d58bbe6c328041791225e6
+  metadata.gz: 53d8e07cbcfc3ce3c8f1848ae34438f5e31ee3cbb8af8784e02e1f5a4cccc61554ac9f404d07083c0ce1210b4329de873e0ecb3e274260798484a1cabc53f758
+  data.tar.gz: 5ca7d7e28311f4c359d07f823d069b1ace3ed8b408bcb5c9f912d6f106ff469be4d38a4e7ea37afd46083d30eab818039c72f306d323ee4a364e5a6fb3b0beb8

data/{circle.yml → .circleci/config.yml}

@@ -4,20 +4,14 @@ defaults: &defaults
     - checkout
     - run: bundle install
     - run: bundle exec rake ci
-
 version: 2
 jobs:
-  ruby_2_3:
+  ruby_2_5:
     <<: *defaults
     docker:
-      - image: circleci/ruby:2.3.4
-  ruby_2_4:
-    <<: *defaults
-    docker:
-      - image: circleci/ruby:2.4.1
+      - image: circleci/ruby:2.5.3
 workflows:
   version: 2
   test:
     jobs:
-      - ruby_2_3
-      - ruby_2_4
+      - ruby_2_5

data/.rubocop.yml

@@ -4,4 +4,4 @@ AllCops:
     - 'test_app/**/*'
     - 'tmp/**/*'
     - 'vendor/**/*'
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.5

data/Changelog.md

@@ -1,3 +1,8 @@
+# v0.8.19 2018-11-06
+
+* Drop support for Ruby < 2.5
+* Fix bug when mutating a module that includes Memoizable
+
 # v0.8.18 2018-10-24
 
 * Add support for regexp unicode print nodes https://github.com/mbj/mutant/pull/749

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mutant (0.8.16)
+    mutant (0.8.18)
       abstract_type (~> 0.0.7)
       adamantium (~> 0.2.0)
       anima (~> 0.3.0)
@@ -15,10 +15,10 @@ PATH
       parallel (~> 1.3)
       parser (~> 2.5.1)
       procto (~> 0.0.2)
-      regexp_parser (~> 0.4.9)
+      regexp_parser (~> 1.2)
       unparser (~> 0.2.5)
-    mutant-rspec (0.8.16)
-      mutant (~> 0.8.16)
+    mutant-rspec (0.8.18)
+      mutant (~> 0.8.18)
       rspec-core (>= 3.4.0, < 4.0.0)
 
 GEM
@@ -107,7 +107,7 @@ GEM
       kwalify (~> 0.7.0)
       parser (>= 2.5.0.0, < 2.6, != 2.5.1.1)
       rainbow (>= 2.0, < 4.0)
-    regexp_parser (0.4.13)
+    regexp_parser (1.2.0)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
       rspec-expectations (~> 3.8.0)
@@ -170,4 +170,4 @@ DEPENDENCIES
   mutant!
 
 BUNDLED WITH
-   1.16.4
+   1.17.1

data/README.md

@@ -353,7 +353,7 @@ Sorted by recency:
 [sitepoint]: http://www.sitepoint.com/mutation-testing-mutant/
 [arkency1]: http://blog.arkency.com/2015/06/how-good-are-your-ruby-tests-testing-your-tests-with-mutant/
 [arkency2]: http://blog.arkency.com/2015/05/mutation-testing-and-continuous-integration/
-[arkency3]: http://blog.arkency.com/2015/04/why-i-want-to-introduce-mutation-testing-to-the-rails-event-store-gem/  
+[arkency3]: http://blog.arkency.com/2015/04/why-i-want-to-introduce-mutation-testing-to-the-rails-event-store-gem/
 [solnic]: http://solnic.eu/2013/01/23/mutation-testing-with-mutant.html
 
 Support

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 16
-total_score: 1318
+total_score: 1364

data/lib/mutant.rb

@@ -56,13 +56,12 @@ require 'mutant/ast/node_predicates'
 require 'mutant/ast/regexp'
 require 'mutant/ast/regexp/transformer'
 require 'mutant/ast/regexp/transformer/direct'
-require 'mutant/ast/regexp/transformer/text'
-require 'mutant/ast/regexp/transformer/recursive'
-require 'mutant/ast/regexp/transformer/quantifier'
+require 'mutant/ast/regexp/transformer/named_group'
 require 'mutant/ast/regexp/transformer/options_group'
-require 'mutant/ast/regexp/transformer/character_set'
+require 'mutant/ast/regexp/transformer/quantifier'
+require 'mutant/ast/regexp/transformer/recursive'
 require 'mutant/ast/regexp/transformer/root'
-require 'mutant/ast/regexp/transformer/alternative'
+require 'mutant/ast/regexp/transformer/text'
 require 'mutant/ast/meta'
 require 'mutant/ast/meta/send'
 require 'mutant/ast/meta/const'

data/lib/mutant/ast/regexp.rb

@@ -4,10 +4,6 @@ module Mutant
   module AST
     # Regexp source mapper
     module Regexp
-      UNSUPPORTED_EXPRESSION_TYPE = :conditional
-
-      private_constant(*constants(false))
-
       # Parse regex string into expression
       #
       # @param regexp [String]
@@ -17,17 +13,6 @@ module Mutant
         ::Regexp::Parser.parse(regexp)
       end
 
-      # Check if expression is supported by mapper
-      #
-      # @param expression [Regexp::Expression]
-      #
-      # @return [Boolean]
-      def self.supported?(expression)
-        expression.terminal? || expression.all? do |subexp|
-          !subexp.type.equal?(UNSUPPORTED_EXPRESSION_TYPE) && supported?(subexp)
-        end
-      end
-
       # Convert expression into ast node
       #
       # @param expression [Regexp::Expression]

data/lib/mutant/ast/regexp/transformer/direct.rb

@@ -38,53 +38,71 @@ module Mutant
 
             # rubocop:disable LineLength
             TABLE = Table.create(
-              [:regexp_alpha_property,           [:property, :alpha,            '\p{Alpha}'],    ::Regexp::Expression::UnicodeProperty::Alpha],
-              [:regexp_alternation_escape,       [:escape,   :alternation,      '\|'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_bell_escape,              [:escape,   :bell,             '\a'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_bol_anchor,               [:anchor,   :bol,              '^'],            ::Regexp::Expression::Anchor::BeginningOfLine],
-              [:regexp_bol_escape,               [:escape,   :bol,              '\^'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_bos_anchor,               [:anchor,   :bos,              '\\A'],          ::Regexp::Expression::Anchor::BeginningOfString],
-              [:regexp_carriage_escape,          [:escape,   :carriage,         '\r'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_digit_type,               [:type,     :digit,            '\d'],           ::Regexp::Expression::CharacterType::Digit],
-              [:regexp_dot_escape,               [:escape,   :dot,              '\.'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_dot_meta,                 [:meta,     :dot,              '.'],            ::Regexp::Expression::CharacterType::Any],
-              [:regexp_eol_anchor,               [:anchor,   :eol,              '$'],            ::Regexp::Expression::Anchor::EndOfLine],
-              [:regexp_eol_escape,               [:escape,   :eol,              '\$'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_eos_anchor,               [:anchor,   :eos,              '\\z'],          ::Regexp::Expression::Anchor::EndOfString],
-              [:regexp_eos_ob_eol_anchor,        [:anchor,   :eos_ob_eol,       '\\Z'],          ::Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine],
-              [:regexp_escape_escape,            [:escape,   :escape,           '\e'],           ::Regexp::Expression::EscapeSequence::AsciiEscape],
-              [:regexp_form_feed_escape,         [:escape,   :form_feed,        '\f'],           ::Regexp::Expression::EscapeSequence::FormFeed],
-              [:regexp_group_close_escape,       [:escape,   :group_close,      '\)'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_group_open_escape,        [:escape,   :group_open,       '\('],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_hex_type,                 [:type,     :hex,              '\h'],           ::Regexp::Expression::CharacterType::Hex],
-              [:regexp_interval_close_escape,    [:escape,   :interval_close,   '\}'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_interval_open_escape,     [:escape,   :interval_open,    '\{'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_letter_any_property,      [:property, :letter_any,       '\p{L}'],        ::Regexp::Expression::UnicodeProperty::Letter::Any],
-              [:regexp_mark_keep,                [:keep,     :mark,             '\K'],           ::Regexp::Expression::Keep::Mark],
-              [:regexp_match_start_anchor,       [:anchor,   :match_start,      '\\G'],          ::Regexp::Expression::Anchor::MatchStart],
-              [:regexp_newline_escape,           [:escape,   :newline,          '\n'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_nondigit_type,            [:type,     :nondigit,         '\D'],           ::Regexp::Expression::CharacterType::NonDigit],
-              [:regexp_nonhex_type,              [:type,     :nonhex,           '\H'],           ::Regexp::Expression::CharacterType::NonHex],
-              [:regexp_nonspace_type,            [:type,     :nonspace,         '\S'],           ::Regexp::Expression::CharacterType::NonSpace],
-              [:regexp_nonword_boundary_anchor,  [:anchor,   :nonword_boundary, '\\B'],          ::Regexp::Expression::Anchor::NonWordBoundary],
-              [:regexp_nonword_type,             [:type,     :nonword,          '\W'],           ::Regexp::Expression::CharacterType::NonWord],
-              [:regexp_one_or_more_escape,       [:escape,   :one_or_more,      '\+'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_print_nonproperty,        [:property, :nonprint,         '\P{Print}'],    ::Regexp::Expression::UnicodeProperty::Print],
-              [:regexp_print_property,           [:property, :print,            '\p{Print}'],    ::Regexp::Expression::UnicodeProperty::Print],
-              [:regexp_script_arabic_property,   [:property, :script_arabic,    '\p{Arabic}'],   ::Regexp::Expression::UnicodeProperty::Script],
-              [:regexp_script_han_property,      [:property, :script_han,       '\p{Han}'],      ::Regexp::Expression::UnicodeProperty::Script],
-              [:regexp_script_hangul_property,   [:property, :script_hangul,    '\p{Hangul}'],   ::Regexp::Expression::UnicodeProperty::Script],
-              [:regexp_script_hiragana_property, [:property, :script_hiragana,  '\p{Hiragana}'], ::Regexp::Expression::UnicodeProperty::Script],
-              [:regexp_script_katakana_property, [:property, :script_katakana,  '\p{Katakana}'], ::Regexp::Expression::UnicodeProperty::Script],
-              [:regexp_set_close_escape,         [:escape,   :set_close,        '\]'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_set_open_escape,          [:escape,   :set_open,         '\['],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_space_type,               [:type,     :space,            '\s'],           ::Regexp::Expression::CharacterType::Space],
-              [:regexp_vertical_tab_escape,      [:escape,   :vertical_tab,     '\v'],           ::Regexp::Expression::EscapeSequence::VerticalTab],
-              [:regexp_word_boundary_anchor,     [:anchor,   :word_boundary,    '\b'],           ::Regexp::Expression::Anchor::WordBoundary],
-              [:regexp_word_type,                [:type,     :word,             '\w'],           ::Regexp::Expression::CharacterType::Word],
-              [:regexp_xgrapheme_type,           [:type,     :xgrapheme,        '\X'],           ::Regexp::Expression::CharacterType::ExtendedGrapheme],
-              [:regexp_zero_or_more_escape,      [:escape,   :zero_or_more,     '\*'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_zero_or_one_escape,       [:escape,   :zero_or_one,      '\?'],           ::Regexp::Expression::EscapeSequence::Literal]
+              [:regexp_alnum_posixclass,         [:posixclass,    :alnum,            '[:alnum:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_alpha_posixclass,         [:posixclass,    :alpha,            '[:alpha:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_alpha_property,           [:property,      :alpha,            '\p{Alpha}'],    ::Regexp::Expression::UnicodeProperty::Alpha],
+              [:regexp_alternation_escape,       [:escape,        :alternation,      '\|'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_arabic_property,          [:property,      :arabic,           '\p{Arabic}'],   ::Regexp::Expression::UnicodeProperty::Script],
+              [:regexp_ascii_posixclass,         [:posixclass,    :ascii,            '[:ascii:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_backspace_escape,         [:escape,        :backspace,        '\b'],           ::Regexp::Expression::EscapeSequence::Backspace],
+              [:regexp_bell_escape,              [:escape,        :bell,             '\a'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_blank_posixclass,         [:posixclass,    :blank,            '[:blank:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_bol_anchor,               [:anchor,        :bol,              '^'],            ::Regexp::Expression::Anchor::BeginningOfLine],
+              [:regexp_bol_escape,               [:escape,        :bol,              '\^'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_bos_anchor,               [:anchor,        :bos,              '\\A'],          ::Regexp::Expression::Anchor::BeginningOfString],
+              [:regexp_carriage_escape,          [:escape,        :carriage,         '\r'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_cntrl_posixclass,         [:posixclass,    :cntrl,            '[:cntrl:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_digit_posixclass,         [:posixclass,    :digit,            '[:digit:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_digit_type,               [:type,          :digit,            '\d'],           ::Regexp::Expression::CharacterType::Digit],
+              [:regexp_dot_escape,               [:escape,        :dot,              '\.'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_dot_meta,                 [:meta,          :dot,              '.'],            ::Regexp::Expression::CharacterType::Any],
+              [:regexp_eol_anchor,               [:anchor,        :eol,              '$'],            ::Regexp::Expression::Anchor::EndOfLine],
+              [:regexp_eol_escape,               [:escape,        :eol,              '\$'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_eos_anchor,               [:anchor,        :eos,              '\\z'],          ::Regexp::Expression::Anchor::EndOfString],
+              [:regexp_eos_ob_eol_anchor,        [:anchor,        :eos_ob_eol,       '\\Z'],          ::Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine],
+              [:regexp_escape_escape,            [:escape,        :escape,           '\e'],           ::Regexp::Expression::EscapeSequence::AsciiEscape],
+              [:regexp_form_feed_escape,         [:escape,        :form_feed,        '\f'],           ::Regexp::Expression::EscapeSequence::FormFeed],
+              [:regexp_graph_posixclass,         [:posixclass,    :graph,            '[:graph:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_group_close_escape,       [:escape,        :group_close,      '\)'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_group_open_escape,        [:escape,        :group_open,       '\('],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_han_property,             [:property,      :han,              '\p{Han}'],      ::Regexp::Expression::UnicodeProperty::Script],
+              [:regexp_hangul_property,          [:property,      :hangul,           '\p{Hangul}'],   ::Regexp::Expression::UnicodeProperty::Script],
+              [:regexp_hex_type,                 [:type,          :hex,              '\h'],           ::Regexp::Expression::CharacterType::Hex],
+              [:regexp_hiragana_property,        [:property,      :hiragana,         '\p{Hiragana}'], ::Regexp::Expression::UnicodeProperty::Script],
+              [:regexp_interval_close_escape,    [:escape,        :interval_close,   '\}'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_interval_open_escape,     [:escape,        :interval_open,    '\{'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_katakana_property,        [:property,      :katakana,         '\p{Katakana}'], ::Regexp::Expression::UnicodeProperty::Script],
+              [:regexp_letter_property,          [:property,      :letter,           '\p{L}'],        ::Regexp::Expression::UnicodeProperty::Letter::Any],
+              [:regexp_linebreak_type,           [:type,          :linebreak,        '\R'],           ::Regexp::Expression::CharacterType::Linebreak],
+              [:regexp_lower_posixclass,         [:posixclass,    :lower,            '[:lower:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_mark_keep,                [:keep,          :mark,             '\K'],           ::Regexp::Expression::Keep::Mark],
+              [:regexp_match_start_anchor,       [:anchor,        :match_start,      '\\G'],          ::Regexp::Expression::Anchor::MatchStart],
+              [:regexp_newline_escape,           [:escape,        :newline,          '\n'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_nondigit_type,            [:type,          :nondigit,         '\D'],           ::Regexp::Expression::CharacterType::NonDigit],
+              [:regexp_nonhex_type,              [:type,          :nonhex,           '\H'],           ::Regexp::Expression::CharacterType::NonHex],
+              [:regexp_nonspace_type,            [:type,          :nonspace,         '\S'],           ::Regexp::Expression::CharacterType::NonSpace],
+              [:regexp_nonword_boundary_anchor,  [:anchor,        :nonword_boundary, '\\B'],          ::Regexp::Expression::Anchor::NonWordBoundary],
+              [:regexp_nonword_type,             [:type,          :nonword,          '\W'],           ::Regexp::Expression::CharacterType::NonWord],
+              [:regexp_one_or_more_escape,       [:escape,        :one_or_more,      '\+'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_print_nonposixclass,      [:nonposixclass, :print,            '[:^print:]'],   ::Regexp::Expression::PosixClass],
+              [:regexp_print_nonproperty,        [:nonproperty,   :print,            '\P{Print}'],    ::Regexp::Expression::UnicodeProperty::Print],
+              [:regexp_print_posixclass,         [:posixclass,    :print,            '[:print:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_print_posixclass,         [:posixclass,    :print,            '[:print:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_print_property,           [:property,      :print,            '\p{Print}'],    ::Regexp::Expression::UnicodeProperty::Print],
+              [:regexp_punct_posixclass,         [:posixclass,    :punct,            '[:punct:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_set_close_escape,         [:escape,        :set_close,        '\]'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_set_open_escape,          [:escape,        :set_open,         '\['],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_space_posixclass,         [:posixclass,    :space,            '[:space:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_space_type,               [:type,          :space,            '\s'],           ::Regexp::Expression::CharacterType::Space],
+              [:regexp_upper_posixclass,         [:posixclass,    :upper,            '[:upper:]'],    ::Regexp::Expression::PosixClass],
+              [:regexp_vertical_tab_escape,      [:escape,        :vertical_tab,     '\v'],           ::Regexp::Expression::EscapeSequence::VerticalTab],
+              [:regexp_word_boundary_anchor,     [:anchor,        :word_boundary,    '\b'],           ::Regexp::Expression::Anchor::WordBoundary],
+              [:regexp_word_posixclass,          [:posixclass,    :word,             '[:word:]'],     ::Regexp::Expression::PosixClass],
+              [:regexp_word_type,                [:type,          :word,             '\w'],           ::Regexp::Expression::CharacterType::Word],
+              [:regexp_xdigit_posixclass,        [:posixclass,    :xdigit,           '[:xdigit:]'],   ::Regexp::Expression::PosixClass],
+              [:regexp_xgrapheme_type,           [:type,          :xgrapheme,        '\X'],           ::Regexp::Expression::CharacterType::ExtendedGrapheme],
+              [:regexp_zero_or_more_escape,      [:escape,        :zero_or_more,     '\*'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_zero_or_one_escape,       [:escape,        :zero_or_one,      '\?'],           ::Regexp::Expression::EscapeSequence::Literal]
             )
 
           private

data/lib/mutant/ast/regexp/transformer/named_group.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    module Regexp
+      class Transformer
+        # Transformer for named groups
+        class NamedGroup < self
+          register :regexp_named_group
+
+          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
+          class ExpressionToAST < Transformer::ExpressionToAST
+
+            # Transform named group into node
+            #
+            # @return [Parser::AST::Node]
+            def call
+              quantify(ast(expression.name, *children))
+            end
+          end # ExpressionToAST
+
+          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
+          class ASTToExpression < Transformer::ASTToExpression
+            include NamedChildren
+
+            children :name
+
+          private
+
+            # Convert node into expression
+            #
+            # @return [Regexp::Expression::Group::Named]
+            def transform
+              named_group.tap do |expression|
+                expression.expressions = subexpressions
+              end
+            end
+
+            # Recursive mapping of children
+            #
+            # @return [Array<Regexp::Expression>]
+            def subexpressions
+              remaining_children.map(&Regexp.public_method(:to_expression))
+            end
+
+            # Named group instance constructed using name
+            #
+            # @return [Regexp::Expression::Group::Named]
+            def named_group
+              ::Regexp::Expression::Group::Named.new(
+                ::Regexp::Token.new(:group, :named, "(?<#{name}>")
+              )
+            end
+          end # ASTToExpression
+        end # NamedGroup
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant

data/lib/mutant/ast/regexp/transformer/options_group.rb

@@ -7,6 +7,7 @@ module Mutant
         # Transformer for option groups
         class OptionsGroup < self
           register :regexp_options_group
+          register :regexp_options_switch_group
 
           # Mapper from `Regexp::Expression` to `Parser::AST::Node`
           class ExpressionToAST < Transformer::ExpressionToAST
@@ -15,7 +16,7 @@ module Mutant
             #
             # @return [Parser::AST::Node]
             def call
-              quantify(ast(expression.options, *children))
+              quantify(ast(expression.option_changes, *children))
             end
           end # ExpressionToAST
 
@@ -23,11 +24,11 @@ module Mutant
           class ASTToExpression < Transformer::ASTToExpression
             include NamedChildren
 
-            children :options
+            children :option_changes
 
           private
 
-            # Covnert node into expression
+            # Convert node into expression
             #
             # @return [Regexp::Expression::Group::Options]
             def transform
@@ -48,17 +49,31 @@ module Mutant
             # @return [Regexp::Expression::Group::Options]
             def options_group
               ::Regexp::Expression::Group::Options.new(
-                ::Regexp::Token.new(:group, :options, text)
+                ::Regexp::Token.new(:group, type, text)
               )
             end
 
-            # Flag text constructed from enabled options
+            # Options group type derived from node type
+            #
+            # @return [Symbol]
+            def type
+              {
+                regexp_options_group:        :options,
+                regexp_options_switch_group: :options_switch
+              }.fetch(node.type)
+            end
+
+            # Flag text constructed from enabled and disabled options
             #
             # @return [String]
             def text
-              flags = options.map { |key, value| key if value }.join
+              pos, neg = option_changes.partition { |_opt, val| val }.map do |arr|
+                arr.map(&:first).join
+              end
+              neg_opt_sep = '-' unless neg.empty?
+              content_sep = ':' unless type.equal?(:options_switch)
 
-              "(?#{flags}-:"
+              "(?#{pos}#{neg_opt_sep}#{neg}#{content_sep}"
             end
           end # ASTToExpression
         end # OptionsGroup

data/lib/mutant/ast/regexp/transformer/recursive.rb

@@ -21,15 +21,21 @@ module Mutant
             include LookupTable
 
             # rubocop:disable LineLength
+            # Expression::Sequence represents conditional branches, alternation branches, and intersection branches
             TABLE = Table.create(
-              [:regexp_alternation_meta,      [:meta,      :alternation, '|'],    ::Regexp::Expression::Alternation],
-              [:regexp_nlookahead_assertion,  [:assertion, :nlookahead,  '(?!'],  ::Regexp::Expression::Assertion::NegativeLookahead],
-              [:regexp_passive_group,         [:group,     :passive,     '(?:'],  ::Regexp::Expression::Group::Passive],
-              [:regexp_nlookbehind_assertion, [:assertion, :nlookbehind, '(?<!'], ::Regexp::Expression::Assertion::NegativeLookbehind],
-              [:regexp_lookbehind_assertion,  [:assertion, :lookbehind,  '(?<='], ::Regexp::Expression::Assertion::Lookbehind],
-              [:regexp_lookahead_assertion,   [:assertion, :lookahead,   '(?='],  ::Regexp::Expression::Assertion::Lookahead],
-              [:regexp_atomic_group,          [:group,     :atomic,      '(?>'],  ::Regexp::Expression::Group::Atomic],
-              [:regexp_capture_group,         [:group,     :capture,     '('],    ::Regexp::Expression::Group::Capture]
+              [:regexp_alternation_meta,      [:meta,        :alternation,  '|'],    ::Regexp::Expression::Alternation],
+              [:regexp_atomic_group,          [:group,       :atomic,       '(?>'],  ::Regexp::Expression::Group::Atomic],
+              [:regexp_capture_group,         [:group,       :capture,      '('],    ::Regexp::Expression::Group::Capture],
+              [:regexp_character_set,         [:set,         :character,    '['],    ::Regexp::Expression::CharacterSet],
+              [:regexp_intersection_set,      [:set,         :intersection, '&&'],   ::Regexp::Expression::CharacterSet::Intersection],
+              [:regexp_lookahead_assertion,   [:assertion,   :lookahead,    '(?='],  ::Regexp::Expression::Assertion::Lookahead],
+              [:regexp_lookbehind_assertion,  [:assertion,   :lookbehind,   '(?<='], ::Regexp::Expression::Assertion::Lookbehind],
+              [:regexp_nlookahead_assertion,  [:assertion,   :nlookahead,   '(?!'],  ::Regexp::Expression::Assertion::NegativeLookahead],
+              [:regexp_nlookbehind_assertion, [:assertion,   :nlookbehind,  '(?<!'], ::Regexp::Expression::Assertion::NegativeLookbehind],
+              [:regexp_open_conditional,      [:conditional, :open,         '(?'],   ::Regexp::Expression::Conditional::Expression],
+              [:regexp_passive_group,         [:group,       :passive,      '(?:'],  ::Regexp::Expression::Group::Passive],
+              [:regexp_range_set,             [:set,         :range,        '-'],    ::Regexp::Expression::CharacterSet::Range],
+              [:regexp_sequence_expression,   [:expression,  :sequence,     ''],     ::Regexp::Expression::Sequence]
             )
 
           private

data/lib/mutant/ast/regexp/transformer/root.rb

@@ -19,7 +19,7 @@ module Mutant
             #
             # @return [Regexp::Expression::Root]
             def transform
-              ::Regexp::Expression::Root.new.tap do |root|
+              ::Regexp::Expression::Root.build.tap do |root|
                 root.expressions = subexpressions
               end
             end

data/lib/mutant/ast/regexp/transformer/text.rb

@@ -20,22 +20,24 @@ module Mutant
           class ASTToExpression < Transformer::ASTToExpression
             include LookupTable
 
+            # rubocop:disable LineLength
             TABLE = Table.create(
               [:regexp_literal_literal,       %i[literal literal],       ::Regexp::Expression::Literal],
               [:regexp_comment_group,         %i[group comment],         ::Regexp::Expression::Group::Comment],
-              [:regexp_named_group,           %i[group named],           ::Regexp::Expression::Group::Named],
               [:regexp_number_backref,        %i[backref number],        ::Regexp::Expression::Backreference::Number],
               [:regexp_name_call_backref,     %i[backref name_call],     ::Regexp::Expression::Backreference::NameCall],
               [:regexp_whitespace_free_space, %i[free_space whitespace], ::Regexp::Expression::WhiteSpace],
               [:regexp_comment_free_space,    %i[free_space comment],    ::Regexp::Expression::WhiteSpace],
-              [:regexp_hex_escape,            %i[escape hex],            ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_hex_escape,            %i[escape hex],            ::Regexp::Expression::EscapeSequence::Hex],
+              [:regexp_octal_escape,          %i[escape octal],          ::Regexp::Expression::EscapeSequence::Octal],
               [:regexp_literal_escape,        %i[escape literal],        ::Regexp::Expression::EscapeSequence::Literal],
               [:regexp_backslash_escape,      %i[escape backslash],      ::Regexp::Expression::EscapeSequence::Literal],
               [:regexp_tab_escape,            %i[escape tab],            ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_codepoint_list_escape, %i[escape codepoint_list], ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_codepoint_escape,      %i[escape codepoint],      ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_codepoint_list_escape, %i[escape codepoint_list], ::Regexp::Expression::EscapeSequence::CodepointList],
+              [:regexp_codepoint_escape,      %i[escape codepoint],      ::Regexp::Expression::EscapeSequence::Codepoint],
               [:regexp_control_escape,        %i[escape control],        ::Regexp::Expression::EscapeSequence::Control],
-              [:regexp_meta_sequence_escape,  %i[escape meta_sequence],  ::Regexp::Expression::EscapeSequence::Control]
+              [:regexp_meta_sequence_escape,  %i[escape meta_sequence],  ::Regexp::Expression::EscapeSequence::Control],
+              [:regexp_condition_conditional, %i[conditional condition], ::Regexp::Expression::Conditional::Condition]
             )
 
           private

data/lib/mutant/ast/types.rb

@@ -45,23 +45,32 @@ module Mutant
 
       # Nodes generated by regular expression body parsing
       REGEXP = symbolset.(%w[
+        regexp_alnum_posixclass
+        regexp_alpha_posixclass
         regexp_alpha_property
         regexp_alternation_escape
         regexp_alternation_meta
+        regexp_arabic_property
+        regexp_ascii_posixclass
         regexp_atomic_group
         regexp_backslash_escape
+        regexp_backspace_escape
         regexp_bell_escape
+        regexp_blank_posixclass
         regexp_bol_anchor
         regexp_bol_escape
         regexp_bos_anchor
         regexp_capture_group
         regexp_carriage_escape
         regexp_character_set
+        regexp_cntrl_posixclass
         regexp_codepoint_escape
         regexp_codepoint_list_escape
         regexp_comment_free_space
         regexp_comment_group
+        regexp_condition_conditional
         regexp_control_escape
+        regexp_digit_posixclass
         regexp_digit_type
         regexp_dot_escape
         regexp_dot_meta
@@ -71,21 +80,29 @@ module Mutant
         regexp_eos_ob_eol_anchor
         regexp_escape_escape
         regexp_form_feed_escape
+        regexp_graph_posixclass
         regexp_greedy_interval
         regexp_greedy_one_or_more
         regexp_greedy_zero_or_more
         regexp_greedy_zero_or_one
         regexp_group_close_escape
         regexp_group_open_escape
+        regexp_han_property
+        regexp_hangul_property
         regexp_hex_escape
         regexp_hex_type
+        regexp_hiragana_property
+        regexp_intersection_set
         regexp_interval_close_escape
         regexp_interval_open_escape
-        regexp_letter_any_property
+        regexp_katakana_property
+        regexp_letter_property
+        regexp_linebreak_type
         regexp_literal_escape
         regexp_literal_literal
         regexp_lookahead_assertion
         regexp_lookbehind_assertion
+        regexp_lower_posixclass
         regexp_mark_keep
         regexp_match_start_anchor
         regexp_meta_sequence_escape
@@ -100,34 +117,40 @@ module Mutant
         regexp_nonword_boundary_anchor
         regexp_nonword_type
         regexp_number_backref
+        regexp_octal_escape
         regexp_one_or_more_escape
         regexp_open_conditional
         regexp_options_group
+        regexp_options_switch_group
         regexp_passive_group
         regexp_possessive_interval
         regexp_possessive_one_or_more
         regexp_possessive_zero_or_more
         regexp_possessive_zero_or_one
+        regexp_print_nonposixclass
         regexp_print_nonproperty
+        regexp_print_posixclass
+        regexp_print_posixclass
         regexp_print_property
+        regexp_punct_posixclass
+        regexp_range_set
         regexp_reluctant_interval
         regexp_reluctant_one_or_more
         regexp_reluctant_zero_or_more
         regexp_root_expression
-        regexp_script_arabic_property
-        regexp_script_han_property
-        regexp_script_hangul_property
-        regexp_script_hiragana_property
-        regexp_script_katakana_property
         regexp_sequence_expression
         regexp_set_close_escape
         regexp_set_open_escape
+        regexp_space_posixclass
         regexp_space_type
         regexp_tab_escape
+        regexp_upper_posixclass
         regexp_vertical_tab_escape
         regexp_whitespace_free_space
         regexp_word_boundary_anchor
+        regexp_word_posixclass
         regexp_word_type
+        regexp_xdigit_posixclass
         regexp_xgrapheme_type
         regexp_zero_or_more_escape
         regexp_zero_or_one_escape

data/lib/mutant/expression/namespace.rb

@@ -44,7 +44,7 @@ module Mutant
         #
         # @return [Integer]
         def match_length(expression)
-          if @recursion_pattern =~ expression.syntax
+          if @recursion_pattern.match?(expression.syntax)
             scope_name.length
           else
             0

data/lib/mutant/matcher/method/instance.rb

@@ -12,10 +12,12 @@ module Mutant
         # @param [UnboundMethod] method
         #
         # @return [Matcher::Method::Instance]
+        #
+        # :reek:ManualDispatch
         def self.new(scope, target_method)
           name = target_method.name
           evaluator =
-            if scope.include?(Memoizable) && scope.memoized?(name)
+            if scope.respond_to?(:memoized?) && scope.memoized?(name)
               Evaluator::Memoized
             else
               Evaluator

data/lib/mutant/mutator/node/generic.rb

@@ -47,6 +47,7 @@ module Mutant
           regexp_eos_ob_eol_anchor
           regexp_greedy_zero_or_more
           regexp_hex_type
+          regexp_linebreak_type
           regexp_nondigit_type
           regexp_nonhex_type
           regexp_nonspace_type

data/lib/mutant/mutator/node/literal/regex.rb

@@ -43,7 +43,6 @@ module Mutant
           # @return [undefined]
           def mutate_body
             return unless body.all?(&method(:n_str?))
-            return unless AST::Regexp.supported?(body_expression)
 
             Mutator.mutate(body_ast).each do |mutation|
               source = AST::Regexp.to_expression(mutation).to_s

data/lib/mutant/mutator/node/regexp/character_type.rb

@@ -12,7 +12,7 @@ module Mutant
             regexp_space_type:           :regexp_nonspace_type,
             regexp_word_boundary_anchor: :regexp_nonword_boundary_anchor,
             regexp_word_type:            :regexp_nonword_type,
-            regexp_xgrapheme_type:       :regexp_space_type
+            regexp_xgrapheme_type:       :regexp_linebreak_type
           }
 
           MAP = IceNine.deep_freeze(map.merge(map.invert))

data/lib/mutant/version.rb

@@ -2,5 +2,5 @@
 
 module Mutant
   # Current mutant version
-  VERSION = '0.8.18'.freeze
+  VERSION = '0.8.19'.freeze
 end # Mutant

data/lib/mutant/warning_filter.rb

@@ -36,7 +36,7 @@ module Mutant
     #
     # @return [self]
     def write(message)
-      if WARNING_PATTERN =~ message
+      if WARNING_PATTERN.match?(message)
         warnings << message
       else
         target.write(message)

data/meta/regexp.rb

@@ -71,6 +71,9 @@ Mutant::Meta::Example.add :regexp do
 
   singleton_mutations
   regexp_mutations
+
+  mutation '/(?(1)(?:foo)(bar))/'
+  mutation '/(?(1)(foo)(?:bar))/'
 end
 
 Pathname

data/meta/regexp/character_types.rb

@@ -6,7 +6,7 @@ mutations = {
   [:regexp_space_type,           '/\s/'] => [:regexp_nonspace_type,           '/\S/'],
   [:regexp_word_boundary_anchor, '/\b/'] => [:regexp_nonword_boundary_anchor, '/\B/'],
   [:regexp_word_type,            '/\w/'] => [:regexp_nonword_type,            '/\W/'],
-  [:regexp_xgrapheme_type,       '/\X/'] => [:regexp_space_type,              '/\s/']
+  [:regexp_xgrapheme_type,       '/\X/'] => [:regexp_linebreak_type,          '/\R/']
 }
 
 mutations = mutations.merge(mutations.invert)

data/mutant.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |gem|
   gem.extra_rdoc_files = %w[LICENSE]
   gem.executables      = %w[mutant]
 
-  gem.required_ruby_version = '>= 2.3'
+  gem.required_ruby_version = '>= 2.5'
 
   gem.add_runtime_dependency('abstract_type', '~> 0.0.7')
   gem.add_runtime_dependency('adamantium',    '~> 0.2.0')
@@ -36,7 +36,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency('parallel',      '~> 1.3')
   gem.add_runtime_dependency('parser',        '~> 2.5.1')
   gem.add_runtime_dependency('procto',        '~> 0.0.2')
-  gem.add_runtime_dependency('regexp_parser', '~> 0.4.9')
+  gem.add_runtime_dependency('regexp_parser', '~> 1.2')
   gem.add_runtime_dependency('unparser',      '~> 0.2.5')
 
   gem.add_development_dependency('bundler',  '~> 1.10')

data/spec/integrations.yml

@@ -23,13 +23,11 @@
 - name: regexp_parser
   namespace: Regexp
   repo_uri: 'https://github.com/ammar/regexp_parser.git'
-  repo_ref: 'v0.4.4'
+  repo_ref: 'v1.2.0'
   ruby_glob_pattern: '**/*.rb'
   mutation_coverage: false
   mutation_generation: true
-  expected_errors:
-    "Regexp::Syntax::Ruby::V233 does not implement: [escape:codepoint]":
-     - regexp_parser/test/parser/test_escapes.rb
+  expected_errors: {}
   exclude: []
 - name: auom
   namespace: AUOM

data/spec/support/warnings.yml

@@ -3,6 +3,4 @@
 - 'lib/parallel.rb:222: warning: shadowing outer local variable - args'
 - 'lib/parallel.rb:227: warning: shadowing outer local variable - args'
 - 'lib/parser/lexer.rb:10836: warning: assigned but unused variable - testEof'
-- 'lib/regexp_parser/scanner.rb:1675: warning: assigned but unused variable - testEof'
-- 'lib/regexp_parser/scanner.rb:1689: warning: assigned but unused variable - testEof'
-- 'lib/regexp_parser/scanner.rb:1692: warning: assigned but unused variable - testEof'
+- 'lib/regexp_parser/scanner.rb:1146: warning: assigned but unused variable - testEof'

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

@@ -202,17 +202,53 @@ 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')))
+      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, 'a', 'b'))
+    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, 'a-j'))
+    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
@@ -225,7 +261,7 @@ RegexpSpec.expect_mapping(/(?#foo)/, :regexp_comment_group) do
     s(:regexp_comment_group, '(?#foo)'))
 end
 
-RegexpSpec.expect_mapping(/(?x-: # comment
+RegexpSpec.expect_mapping(/(?x: # comment
 )/, :regexp_comment_free_space) do
   s(:regexp_root_expression,
     s(:regexp_options_group, {
@@ -304,7 +340,9 @@ 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')))
+      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
@@ -336,6 +374,11 @@ RegexpSpec.expect_mapping(/\(/, :regexp_group_open_escape) do
     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'))
@@ -346,11 +389,16 @@ RegexpSpec.expect_mapping(/\h/, :regexp_hex_type) do
     s(:regexp_hex_type))
 end
 
-RegexpSpec.expect_mapping(/\H/, :regexp_hex_type) do
+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))
@@ -366,9 +414,9 @@ RegexpSpec.expect_mapping(/\{/, :regexp_interval_open_escape) do
     s(:regexp_interval_open_escape))
 end
 
-RegexpSpec.expect_mapping(/\p{L}/, :regexp_letter_any_property) do
+RegexpSpec.expect_mapping(/\p{L}/, :regexp_letter_property) do
   s(:regexp_root_expression,
-    s(:regexp_letter_any_property))
+    s(:regexp_letter_property))
 end
 
 RegexpSpec.expect_mapping(/\-/, :regexp_literal_escape) do
@@ -424,14 +472,16 @@ RegexpSpec.expect_mapping(/\G/, :regexp_match_start_anchor) do
     s(:regexp_match_start_anchor))
 end
 
-RegexpSpec.expect_mapping(/(?<foo>)/, :regexp_named_group) do
+RegexpSpec.expect_mapping(/(?<foo>a)+/, :regexp_named_group) do
   s(:regexp_root_expression,
-    s(:regexp_named_group, '(?<foo>'))
+    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_named_group, 'a'),
     s(:regexp_name_call_backref, '\\g<a>'))
 end
 
@@ -477,7 +527,7 @@ RegexpSpec.expect_mapping(/\+/, :regexp_one_or_more_escape) do
     s(:regexp_one_or_more_escape))
 end
 
-RegexpSpec.expect_mapping(/(?i-:a)+/, :regexp_options_group) do
+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,
@@ -487,7 +537,25 @@ RegexpSpec.expect_mapping(/(?i-:a)+/, :regexp_options_group) do
         s(:regexp_literal_literal, 'a'))))
 end
 
-RegexpSpec.expect_mapping(/(?x-: #{"\n"} )/, :regexp_whitespace_free_space) do
+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,
       {
@@ -526,6 +594,23 @@ RegexpSpec.expect_mapping(/.?+/, :regexp_possessive_zero_or_one) do
       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,
@@ -544,29 +629,29 @@ RegexpSpec.expect_mapping(/.*?/, :regexp_reluctant_zero_or_more) do
       s(:regexp_dot_meta)))
 end
 
-RegexpSpec.expect_mapping(/\p{Arabic}/, :regexp_script_arabic_property) do
+RegexpSpec.expect_mapping(/\p{Arabic}/, :regexp_arabic_property) do
   s(:regexp_root_expression,
-    s(:regexp_script_arabic_property))
+    s(:regexp_arabic_property))
 end
 
-RegexpSpec.expect_mapping(/\p{Han}/, :regexp_script_han_property) do
+RegexpSpec.expect_mapping(/\p{Han}/, :regexp_han_property) do
   s(:regexp_root_expression,
-    s(:regexp_script_han_property))
+    s(:regexp_han_property))
 end
 
-RegexpSpec.expect_mapping(/\p{Hangul}/, :regexp_script_hangul_property) do
+RegexpSpec.expect_mapping(/\p{Hangul}/, :regexp_hangul_property) do
   s(:regexp_root_expression,
-    s(:regexp_script_hangul_property))
+    s(:regexp_hangul_property))
 end
 
-RegexpSpec.expect_mapping(/\p{Hiragana}/, :regexp_script_hiragana_property) do
+RegexpSpec.expect_mapping(/\p{Hiragana}/, :regexp_hiragana_property) do
   s(:regexp_root_expression,
-    s(:regexp_script_hiragana_property))
+    s(:regexp_hiragana_property))
 end
 
-RegexpSpec.expect_mapping(/\p{Katakana}/, :regexp_script_katakana_property) do
+RegexpSpec.expect_mapping(/\p{Katakana}/, :regexp_katakana_property) do
   s(:regexp_root_expression,
-    s(:regexp_script_katakana_property))
+    s(:regexp_katakana_property))
 end
 
 RegexpSpec.expect_mapping(/foo|bar/, :regexp_sequence_expression) do

data/spec/unit/mutant/matcher/method/instance_spec.rb

@@ -28,8 +28,8 @@ RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
   end
 
   context 'when method is defined inside eval' do
-    let(:scope)             { base::WithMemoizer          }
-    let(:method)            { scope.instance_method(:boz) }
+    let(:scope)  { base::WithMemoizer          }
+    let(:method) { scope.instance_method(:boz) }
 
     let(:expected_warnings) do
       [
@@ -41,8 +41,8 @@ RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
   end
 
   context 'when method is defined without source location' do
-    let(:scope)             { Module                            }
-    let(:method)            { scope.instance_method(:object_id) }
+    let(:scope)  { Module                            }
+    let(:method) { scope.instance_method(:object_id) }
 
     let(:expected_warnings) do
       [

data/test_app/lib/test_app.rb

@@ -7,7 +7,7 @@ $VERBOSE = false
 # Namespace for test application
 module TestApp
   module InstanceMethodTests
-    class WithMemoizer
+    module WithMemoizer
       include Adamantium
 
       def bar; end; def baz; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mutant
 version: !ruby/object:Gem::Version
-  version: 0.8.18
+  version: 0.8.19
 platform: ruby
 authors:
 - Markus Schirp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-24 00:00:00.000000000 Z
+date: 2018-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abstract_type
@@ -198,14 +198,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.9
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.9
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: unparser
   requirement: !ruby/object:Gem::Requirement
@@ -271,6 +271,7 @@ extensions: []
 extra_rdoc_files:
 - LICENSE
 files:
+- ".circleci/config.yml"
 - ".gitattributes"
 - ".gitignore"
 - ".rspec"
@@ -284,7 +285,6 @@ files:
 - README.md
 - Rakefile
 - bin/mutant
-- circle.yml
 - config/devtools.yml
 - config/flay.yml
 - config/flog.yml
@@ -311,9 +311,8 @@ files:
 - lib/mutant/ast/nodes.rb
 - lib/mutant/ast/regexp.rb
 - lib/mutant/ast/regexp/transformer.rb
-- lib/mutant/ast/regexp/transformer/alternative.rb
-- lib/mutant/ast/regexp/transformer/character_set.rb
 - lib/mutant/ast/regexp/transformer/direct.rb
+- lib/mutant/ast/regexp/transformer/named_group.rb
 - lib/mutant/ast/regexp/transformer/options_group.rb
 - lib/mutant/ast/regexp/transformer/quantifier.rb
 - lib/mutant/ast/regexp/transformer/recursive.rb
@@ -567,7 +566,6 @@ files:
 - spec/unit/mutant/ast/meta/send_spec.rb
 - spec/unit/mutant/ast/named_children_spec.rb
 - spec/unit/mutant/ast/regexp/parse_spec.rb
-- spec/unit/mutant/ast/regexp/supported_predicate_spec.rb
 - spec/unit/mutant/ast/regexp/transformer/lookup_table/table_spec.rb
 - spec/unit/mutant/ast/regexp/transformer/lookup_table_spec.rb
 - spec/unit/mutant/ast/regexp/transformer_spec.rb
@@ -670,7 +668,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -700,7 +698,6 @@ test_files:
 - spec/unit/mutant/ast/meta/send_spec.rb
 - spec/unit/mutant/ast/named_children_spec.rb
 - spec/unit/mutant/ast/regexp/parse_spec.rb
-- spec/unit/mutant/ast/regexp/supported_predicate_spec.rb
 - spec/unit/mutant/ast/regexp/transformer/lookup_table/table_spec.rb
 - spec/unit/mutant/ast/regexp/transformer/lookup_table_spec.rb
 - spec/unit/mutant/ast/regexp/transformer_spec.rb

data/lib/mutant/ast/regexp/transformer/alternative.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  module AST
-    module Regexp
-      class Transformer
-        # Transformer for Regexp `alternative` nodes
-        #
-        # This transformer is very similar to the generic recursive mapper
-        # except for the fact that the `Regexp::Expression` class for
-        # `alternative` nodes has a unique constructor
-        class Alternative < self
-          register :regexp_sequence_expression
-
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          ExpressionToAST = Class.new(Recursive::ExpressionToAST)
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            # Alternative instance with dummy values for `level`, `set_level`,
-            # and `conditional_level`. These values do not affect unparsing
-            ALTERNATIVE = IceNine.deep_freeze(
-              ::Regexp::Expression::Alternative.new(0, 0, 0)
-            )
-
-          private
-
-            # Transform ast into expression
-            #
-            # @return [Regexp::Expression::Alternative]
-            def transform
-              ALTERNATIVE.dup.tap do |alt|
-                alt.expressions = subexpressions
-              end
-            end
-          end # ASTToExpression
-        end # Alternative
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

data/lib/mutant/ast/regexp/transformer/character_set.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  module AST
-    module Regexp
-      class Transformer
-        # Transformer for character sets
-        #
-        # The `Regexp::Expression` representation of a character set
-        # is unique due to its usage of the `#members` attribute which
-        # is why it gets its own transformer
-        class CharacterSet < self
-          register :regexp_character_set
-
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-            # Transform character set expression into node
-            #
-            # @return [Parser::AST::Node]
-            def call
-              quantify(ast(*expression.members))
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            CHARACTER_SET = IceNine.deep_freeze(
-              ::Regexp::Expression::CharacterSet.new(
-                ::Regexp::Token.new(:set, :character, '[')
-              )
-            )
-
-          private
-
-            # Transform node into expression
-            #
-            # @return [Regexp::Expression]
-            def transform
-              CHARACTER_SET.dup.tap do |expression|
-                expression.members = node.children
-              end
-            end
-          end # ASTToExpression
-        end # CharacterSet
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-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