mutant 0.10.20 → 0.10.25

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    module Regexp
+      class Transformer
+        # 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
+
+            # Transform options group into node
+            #
+            # @return [Parser::AST::Node]
+            def call
+              quantify(ast(expression.option_changes, *children))
+            end
+          end # ExpressionToAST
+
+          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
+          class ASTToExpression < Transformer::ASTToExpression
+            include NamedChildren
+
+            children :option_changes
+
+          private
+
+            def transform
+              options_group.tap do |expression|
+                expression.expressions = subexpressions
+              end
+            end
+
+            def subexpressions
+              remaining_children.map(&Regexp.public_method(:to_expression))
+            end
+
+            def options_group
+              ::Regexp::Expression::Group::Options.new(
+                ::Regexp::Token.new(:group, type, text)
+              )
+            end
+
+            def type
+              {
+                regexp_options_group:        :options,
+                regexp_options_switch_group: :options_switch
+              }.fetch(node.type)
+            end
+
+            def text
+              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)
+
+              "(?#{pos}#{neg_opt_sep}#{neg}#{content_sep}"
+            end
+          end # ASTToExpression
+        end # OptionsGroup
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    module Regexp
+      class Transformer
+        # Transformer for regexp quantifiers
+        class Quantifier < self
+          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
+          class ExpressionToAST < Transformer::ExpressionToAST
+            # Transform quantifier into node
+            #
+            # @return [Parser::AST::Node]
+            def call
+              ast(expression.min, expression.max)
+            end
+
+          private
+
+            def type
+              :"regexp_#{expression.mode}_#{expression.token}"
+            end
+          end # ExpressionToAST
+
+          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
+          class ASTToExpression < Transformer::ASTToExpression
+            include NamedChildren
+
+            children :min, :max, :subject
+
+            Quantifier = Class.new.include(Concord::Public.new(:type, :suffix, :mode))
+
+            QUANTIFIER_MAP = IceNine.deep_freeze({
+              regexp_greedy_zero_or_more:     [:zero_or_more, '*',  :greedy],
+              regexp_greedy_one_or_more:      [:one_or_more,  '+',  :greedy],
+              regexp_greedy_zero_or_one:      [:zero_or_one,  '?',  :greedy],
+              regexp_possessive_zero_or_one:  [:zero_or_one,  '?+', :possessive],
+              regexp_reluctant_zero_or_more:  [:zero_or_more, '*?', :reluctant],
+              regexp_reluctant_one_or_more:   [:one_or_more,  '+?', :reluctant],
+              regexp_possessive_zero_or_more: [:zero_or_more, '*+', :possessive],
+              regexp_possessive_one_or_more:  [:one_or_more,  '++', :possessive],
+              regexp_greedy_interval:         [:interval,     '',   :greedy],
+              regexp_reluctant_interval:      [:interval,     '?',  :reluctant],
+              regexp_possessive_interval:     [:interval,     '+',  :possessive]
+            }.transform_values { |arguments| Quantifier.new(*arguments) }.to_h)
+
+          private
+
+            def transform
+              Regexp.to_expression(subject).dup.tap do |expression|
+                expression.quantify(type, text, min, max, mode)
+              end
+            end
+
+            def text
+              if type.equal?(:interval)
+                interval_text + suffix
+              else
+                suffix
+              end
+            end
+
+            def type
+              quantifier.type
+            end
+
+            def suffix
+              quantifier.suffix
+            end
+
+            def mode
+              quantifier.mode
+            end
+
+            def quantifier
+              QUANTIFIER_MAP.fetch(node.type)
+            end
+
+            def interval_text
+              interval = [min, max].map { |num| num if num.positive? }.uniq
+              "{#{interval.join(',')}}"
+            end
+          end # ASTToExpression
+
+          ASTToExpression::QUANTIFIER_MAP.keys.each(&method(:register))
+        end # Quantifier
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    module Regexp
+      class Transformer
+        # Transformer for nodes with children
+        class Recursive < self
+          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
+          class ExpressionToAST < Transformer::ExpressionToAST
+            # Transform expression and children into nodes
+            #
+            # @return [Parser::AST::Node]
+            def call
+              quantify(ast(*children))
+            end
+          end # ExpressionToAST
+
+          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
+          class ASTToExpression < Transformer::ASTToExpression
+            include LookupTable
+
+            # Expression::Sequence represents conditional branches, alternation branches, and intersection branches
+            # rubocop:disable Layout/LineLength
+            TABLE = Table.create(
+              [: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]
+            )
+          # rubocop:enable Layout/LineLength
+
+          private
+
+            def transform
+              expression_class.new(expression_token).tap do |expression|
+                expression.expressions = subexpressions
+              end
+            end
+          end # ASTToExpression
+
+          ASTToExpression::TABLE.types.each(&method(:register))
+        end # Recursive
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    module Regexp
+      class Transformer
+        # Transformer for root nodes
+        class Root < self
+          register :regexp_root_expression
+
+          ExpressionToAST = Class.new(Recursive::ExpressionToAST)
+
+          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
+          class ASTToExpression < Transformer::ASTToExpression
+
+          private
+
+            def transform
+              ::Regexp::Expression::Root.build.tap do |root|
+                root.expressions = subexpressions
+              end
+            end
+          end # ASTToExpression
+        end # Root
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    module Regexp
+      class Transformer
+        # Regexp AST transformer for nodes that encode a text value
+        class Text < self
+          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
+          class ExpressionToAST < Transformer::ExpressionToAST
+            # Transform expression into node preserving text value
+            #
+            # @return [Parser::AST::Node]
+            def call
+              quantify(ast(expression.text))
+            end
+          end # ExpressionToAST
+
+          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
+          class ASTToExpression < Transformer::ASTToExpression
+            include LookupTable
+
+            # rubocop:disable Layout/LineLength
+            TABLE = Table.create(
+              [:regexp_literal_literal,       %i[literal literal],       ::Regexp::Expression::Literal],
+              [:regexp_comment_group,         %i[group comment],         ::Regexp::Expression::Group::Comment],
+              [: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::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::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_condition_conditional, %i[conditional condition], ::Regexp::Expression::Conditional::Condition]
+            )
+          # rubocop:enable Layout/LineLength
+
+          private
+
+            def transform
+              token = expression_token.dup
+              token.text = Util.one(node.children)
+              expression_class.new(token)
+            end
+          end # ASTToExpression
+
+          ASTToExpression::TABLE.types.each(&method(:register))
+        end # Text
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant

data/lib/mutant/ast/types.rb

@@ -3,14 +3,9 @@
 module Mutant
   module AST
     # Groups of node types
-    module Types
+    module Types # rubocop:disable Metrics/ModuleLength
       ASSIGNABLE_VARIABLES = Set.new(%i[ivasgn lvasgn cvasgn gvasgn]).freeze
 
-      INDEX_ASSIGN_OPERATOR = :[]=
-
-      # Set of nodes that cannot be on the LHS of an assignment
-      NOT_ASSIGNABLE         = Set.new(%i[int float str dstr class module self nil]).freeze
-
       # Set of op-assign types
       OP_ASSIGN              = Set.new(%i[or_asgn and_asgn op_asgn]).freeze
       # Set of node types that are not valid when emitted standalone
@@ -53,21 +48,130 @@ module Mutant
         METHOD_OPERATORS - (INDEX_OPERATORS + UNARY_METHOD_OPERATORS)
       )
 
-      OPERATOR_METHODS = Set.new(
-        METHOD_OPERATORS + INDEX_OPERATORS + UNARY_METHOD_OPERATORS
-      ).freeze
-
       # Nodes that are NOT handled by mutant.
       #
       # not - 1.8 only, mutant does not support 1.8
       #
       BLACKLIST = Set.new(%i[not]).freeze
 
+      # Nodes generated by regular expression body parsing
+      REGEXP = Set.new(%i[
+        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
+        regexp_eol_anchor
+        regexp_eol_escape
+        regexp_eos_anchor
+        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_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
+        regexp_name_call_backref
+        regexp_named_group
+        regexp_newline_escape
+        regexp_nlookahead_assertion
+        regexp_nlookbehind_assertion
+        regexp_nondigit_type
+        regexp_nonhex_type
+        regexp_nonspace_type
+        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_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
+      ]).freeze
+
       # Nodes that are NOT generated by parser but used by mutant / unparser.
       GENERATED = Set.new(%i[empty]).freeze
 
       ALL = Set.new(
-        (Parser::Meta::NODE_TYPES + GENERATED) - BLACKLIST
+        (Parser::Meta::NODE_TYPES + GENERATED + REGEXP) - BLACKLIST
       ).freeze
     end # Types
   end # AST