mutant 0.10.21 → 0.10.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ace60aadd53eaa9d10a47ad5bfd16cc0bd825be0588356fdfacc8e00ee767c20
-  data.tar.gz: 89f5a6460423c7ae12a735f55df13aa8e0077e76243a6fb0bf09d31babafc774
+  metadata.gz: 05b03b60df6a63d9fa7a8b64affcaae0a804a753764b636fee625b1edc597e25
+  data.tar.gz: b61c7b228cdffed5d67cd38ffb3cc55b00d2bace308e56f8f48e828987fa76ba
 SHA512:
-  metadata.gz: 3dd24a1870b332e38dd4e40041d6ce60f1fe23bdf26490ace7bb8f5a285f927880a1898cf6e85d04055723aca9043fa382b19bc86ad29565bafd7a51258b1727
-  data.tar.gz: a855387e41f516caf8759eba4e0c0fe10f144dd4d5e9241bf3f41a768d3fde8bcee0ae70ff3b1ddaeeaf97aa8cd38301832c6b963d0c5eff8d245dc721638594
+  metadata.gz: 50fbc446b2f03edb5015136920a95e3fa9dbbc55b10a530dcea755ed9bf0bb0fea2e99bc3bdf6503cc564fc4d71ea8b1fbcabe97f6959df9ec800e68c81220cb
+  data.tar.gz: fa841fc57b3422780840b66368bbac984b42bd2cef27aee58d07b783b952cbece2fddb0d821ff489279c808db64802c254df84774fcc4a50b887ec068c455b00

data/lib/mutant.rb

@@ -1,27 +1,20 @@
 # frozen_string_literal: true
 
-require 'abstract_type'
-require 'adamantium'
-require 'anima'
-require 'concord'
 require 'diff/lcs'
 require 'diff/lcs/hunk'
 require 'digest/sha1'
-require 'equalizer'
 require 'etc'
-require 'ice_nine'
-require 'mprelude'
 require 'json'
 require 'open3'
 require 'optparse'
 require 'parser'
 require 'parser/current'
 require 'pathname'
+require 'regexp_parser'
 require 'set'
 require 'singleton'
 require 'stringio'
 require 'unparser'
-require 'variable'
 require 'yaml'
 
 # This setting is done to make errors within the parallel
@@ -32,7 +25,12 @@ Thread.abort_on_exception = true
 #
 # @api private
 module Mutant
-  Either = MPrelude::Either
+  AbstractType = Unparser::AbstractType
+  Adamantium   = Unparser::Adamantium
+  Anima        = Unparser::Anima
+  Concord      = Unparser::Concord
+  Either       = Unparser::Either
+  Equalizer    = Unparser::Equalizer
 
   EMPTY_STRING   = ''
   EMPTY_ARRAY    = [].freeze
@@ -40,6 +38,9 @@ module Mutant
   SCOPE_OPERATOR = '::'
 end # Mutant
 
+require 'mutant/procto'
+require 'mutant/transform'
+require 'mutant/variable'
 require 'mutant/bootstrap'
 require 'mutant/version'
 require 'mutant/env'
@@ -53,6 +54,15 @@ require 'mutant/ast/nodes'
 require 'mutant/ast/named_children'
 require 'mutant/ast/node_predicates'
 require 'mutant/ast/find_metaclass_containing'
+require 'mutant/ast/regexp'
+require 'mutant/ast/regexp/transformer'
+require 'mutant/ast/regexp/transformer/direct'
+require 'mutant/ast/regexp/transformer/named_group'
+require 'mutant/ast/regexp/transformer/options_group'
+require 'mutant/ast/regexp/transformer/quantifier'
+require 'mutant/ast/regexp/transformer/recursive'
+require 'mutant/ast/regexp/transformer/root'
+require 'mutant/ast/regexp/transformer/text'
 require 'mutant/ast/meta'
 require 'mutant/ast/meta/send'
 require 'mutant/ast/meta/const'
@@ -75,6 +85,15 @@ require 'mutant/mutator/util/array'
 require 'mutant/mutator/util/symbol'
 require 'mutant/mutator/node'
 require 'mutant/mutator/node/generic'
+require 'mutant/mutator/node/regexp'
+require 'mutant/mutator/node/regexp/alternation_meta'
+require 'mutant/mutator/node/regexp/beginning_of_line_anchor'
+require 'mutant/mutator/node/regexp/capture_group'
+require 'mutant/mutator/node/regexp/named_group'
+require 'mutant/mutator/node/regexp/character_type'
+require 'mutant/mutator/node/regexp/end_of_line_anchor'
+require 'mutant/mutator/node/regexp/end_of_string_or_before_end_of_line_anchor'
+require 'mutant/mutator/node/regexp/zero_or_more'
 require 'mutant/mutator/node/literal'
 require 'mutant/mutator/node/literal/boolean'
 require 'mutant/mutator/node/literal/range'
@@ -130,6 +149,7 @@ require 'mutant/mutator/node/rescue'
 require 'mutant/mutator/node/match_current_line'
 require 'mutant/mutator/node/index'
 require 'mutant/mutator/node/procarg_zero'
+require 'mutant/mutator/node/kwargs'
 require 'mutant/loader'
 require 'mutant/context'
 require 'mutant/scope'
@@ -158,7 +178,6 @@ require 'mutant/expression/methods'
 require 'mutant/expression/namespace'
 require 'mutant/test'
 require 'mutant/timer'
-require 'mutant/transform'
 require 'mutant/integration'
 require 'mutant/integration/null'
 require 'mutant/selector'
@@ -166,6 +185,7 @@ require 'mutant/selector/expression'
 require 'mutant/selector/null'
 require 'mutant/world'
 require 'mutant/config'
+require 'mutant/config/coverage_criteria'
 require 'mutant/cli'
 require 'mutant/cli/command'
 require 'mutant/cli/command/subscription'
@@ -173,6 +193,7 @@ require 'mutant/cli/command/environment'
 require 'mutant/cli/command/environment/run'
 require 'mutant/cli/command/environment/show'
 require 'mutant/cli/command/environment/subject'
+require 'mutant/cli/command/environment/test'
 require 'mutant/cli/command/root'
 require 'mutant/runner'
 require 'mutant/runner/sink'
@@ -195,7 +216,6 @@ require 'mutant/reporter/cli/format'
 require 'mutant/repository'
 require 'mutant/repository/diff'
 require 'mutant/repository/diff/ranges'
-require 'mutant/warnings'
 require 'mutant/zombifier'
 require 'mutant/range'
 require 'mutant/license'
@@ -221,8 +241,7 @@ module Mutant
     stderr:             $stderr,
     stdout:             $stdout,
     thread:             Thread,
-    timer:              Timer.new(Process),
-    warnings:           Warnings.new(Warning)
+    timer:              Timer.new(Process)
   )
 
   # Reopen class to initialize constant to avoid dep circle

data/lib/mutant/ast/find_metaclass_containing.rb

@@ -10,7 +10,7 @@ module Mutant
     # Descending into 'begin' nodes is supported because these are generated for
     # the one-line syntax class << self; def foo; end
     class FindMetaclassContaining
-      include NodePredicates, Concord.new(:root, :target), Procto.call
+      include NodePredicates, Concord.new(:root, :target), Procto
 
       SCLASS_BODY_INDEX = 1
 

data/lib/mutant/ast/regexp.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    # Regexp source mapper
+    module Regexp
+      # Parse regex string into expression
+      #
+      # @param regexp [String]
+      #
+      # @return [Regexp::Expression, nil]
+      def self.parse(regexp)
+        ::Regexp::Parser.parse(regexp)
+      end
+
+      # Convert expression into ast node
+      #
+      # @param expression [Regexp::Expression]
+      #
+      # @return [Parser::AST::Node]
+      def self.to_ast(expression)
+        ast_type = :"regexp_#{expression.token}_#{expression.type}"
+
+        Transformer.lookup(ast_type).to_ast(expression)
+      end
+
+      # Convert node into expression
+      #
+      # @param node [Parser::AST::Node]
+      #
+      # @return [Regexp::Expression]
+      def self.to_expression(node)
+        Transformer.lookup(node.type).to_expression(node)
+      end
+
+      # Convert's a `parser` `regexp` node into more fine-grained AST nodes.
+      #
+      # @param node [Parser::AST::Node]
+      #
+      # @return [Parser::AST::Node]
+      def self.expand_regexp_ast(node)
+        *body, _opts = node.children
+
+        # NOTE: We only mutate parts of regexp body if the body is composed of
+        # only strings. Regular expressions with interpolation are skipped
+        return unless body.all? { |child| child.type.equal?(:str) }
+
+        body_expression = parse(body.map(&:children).join)
+
+        to_ast(body_expression)
+      end
+    end # Regexp
+  end # AST
+end # Mutant

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    module Regexp
+      # Regexp bijective mapper
+      #
+      # Transforms parsed regular expression representation from
+      # `Regexp::Expression` instances (provided by `regexp_parser`) into
+      # equivalent representations using `Parser::AST::Node`
+      class Transformer
+        include AbstractType
+
+        REGISTRY = Registry.new
+
+        # Lookup transformer class for regular expression node type
+        #
+        # @param type [Symbol]
+        #
+        # @return [Class<Transformer>]
+        def self.lookup(type)
+          REGISTRY.lookup(type)
+        end
+
+        def self.register(type)
+          REGISTRY.register(type, self)
+        end
+        private_class_method :register
+
+        # Transform expression
+        #
+        # @param expression [Regexp::Expression]
+        #
+        # @return [Parser::AST::Node]
+        def self.to_ast(expression)
+          self::ExpressionToAST.call(expression)
+        end
+
+        # Transform node
+        #
+        # @param node [Parser::AST::Node]
+        #
+        # @return [Regexp::Expression]
+        def self.to_expression(node)
+          self::ASTToExpression.call(node)
+        end
+
+        # Abstract expression transformer
+        class ExpressionToAST
+          PREFIX = :regexp
+
+          include Concord.new(:expression), Procto, AST::Sexp, AbstractType, Adamantium
+
+        private
+
+          def ast(*children)
+            s(type, *children)
+          end
+
+          def quantify(node)
+            return node unless expression.quantified?
+
+            Quantifier.to_ast(expression.quantifier).append(node)
+          end
+
+          def children
+            expression.map(&Regexp.public_method(:to_ast))
+          end
+
+          def type
+            :"#{PREFIX}_#{expression.token}_#{expression.type}"
+          end
+        end # ExpressionToAST
+
+        # Abstract node transformer
+        class ASTToExpression
+          include Concord.new(:node), Procto, AbstractType, Adamantium
+
+          # Call generic transform method and freeze result
+          #
+          # @return [Regexp::Expression]
+          def call
+            transform.freeze
+          end
+
+        private
+
+          abstract_method :transform
+
+          def subexpressions
+            node.children.map(&Regexp.public_method(:to_expression))
+          end
+        end # ASTToExpression
+
+        # Mixin for node transformers
+        #
+        # Helps construct a mapping from Parser::AST::Node domain to
+        # Regexp::Expression domain
+        module LookupTable
+          Mapping = Class.new.include(Concord::Public.new(:token, :regexp_class))
+
+          # Table mapping ast types to object information for regexp domain
+          class Table
+
+            # Coerce array of mapping information into structured table
+            #
+            # @param [Array(Symbol, Array, Class<Regexp::Expression>)]
+            #
+            # @return [Table]
+            def self.create(*rows)
+              table = rows.map do |ast_type, token, klass|
+                [ast_type, Mapping.new(::Regexp::Token.new(*token), klass)]
+              end.to_h
+
+              new(table)
+            end
+
+            include Concord.new(:table), Adamantium
+
+            # Types defined by the table
+            #
+            # @return [Array<Symbol>]
+            def types
+              table.keys
+            end
+
+            # Lookup mapping information given an ast node type
+            #
+            # @param type [Symbol]
+            #
+            # @return [Mapping]
+            def lookup(type)
+              table.fetch(type)
+            end
+          end # Table
+
+        private
+
+          def expression_token
+            self.class::TABLE.lookup(node.type).token
+          end
+
+          def expression_class
+            self.class::TABLE.lookup(node.type).regexp_class
+          end
+        end # LookupTable
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    module Regexp
+      class Transformer
+        # Transformer for nodes which map directly to other domain
+        #
+        # A node maps "directly" to another domain if the node never
+        # has children or text which needs to be preserved for a mapping
+        #
+        # @example direct mapping
+        #
+        #     input      = /\d/
+        #     expression = Regexp::Parser.parse(input).first
+        #     node       = Transformer::Direct.to_ast(expression)
+        #
+        #     # the digit type always has the same text and no children
+        #     expression.text      # => "\\d"
+        #     expression.terminal? # => true
+        #
+        #     # therefore the `Parser::AST::Node` is always the same
+        #     node # => s(:regexp_digit_type)
+        class Direct < self
+          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
+          class ExpressionToAST < Transformer::ExpressionToAST
+            # Transform expression into node
+            #
+            # @return [Parser::AST::Node]
+            def call
+              quantify(ast)
+            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_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]
+            )
+          # rubocop:enable Layout/LineLength
+
+          private
+
+            def transform
+              expression_class.new(expression_token)
+            end
+          end # ASTToExpression
+
+          ASTToExpression::TABLE.types.each(&method(:register))
+        end # Direct
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant