mutant 0.10.20 → 0.10.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a3308efe39e70e35d8c0fc11294280713c3c69f402e3dc59a30e3a3789a5744
-  data.tar.gz: ce590187601f50a475271571b7da3bd744d1b2196fc15f249de3fbec62913de5
+  metadata.gz: f02dec057593b8e61c2b207918ed6f1b9c4aa1d41bc0b2f2390c2a1da9172b5d
+  data.tar.gz: 99a318ed1f02d9976037694b2dbc1de463863f747cc4b8b5e95809b307680f03
 SHA512:
-  metadata.gz: adc7dd97643cd658857712d4ae220fa167777145e9cae93db73a1c43be9db63a98b03fe549c0b7eac5c595b4b8f80892e8ca1c12fcfcf8385ffdc360d4b95f65
-  data.tar.gz: 51e49cfc6d35f60b7b9e5f3bd2c4991ceba3e383a60192a57920aab16860fbebda0f560ec39cf552994c3a1f6319793a0483f9fc3d2b4669ec556b7526df8b8d
+  metadata.gz: 5312bd87fc41b3442b886b40b200357c254c2d7d65081cdfaca2e2e213311539eb23b00eb5b792c9f7978c8eeed5a6cbd72b3a513598b9abc9f72a3beaa9989d
+  data.tar.gz: 922e0ea1878e05f014a3c832d7bfa23e0d8410cc8c8d5b9bd1bc8b81124a18ecd11403be643cd144772863950076b17ab06ce3cd809cda01a9563ec815c95e79

data/lib/mutant.rb

@@ -17,6 +17,7 @@ require 'optparse'
 require 'parser'
 require 'parser/current'
 require 'pathname'
+require 'regexp_parser'
 require 'set'
 require 'singleton'
 require 'stringio'
@@ -40,9 +41,11 @@ module Mutant
   SCOPE_OPERATOR = '::'
 end # Mutant
 
+require 'mutant/transform'
 require 'mutant/bootstrap'
 require 'mutant/version'
 require 'mutant/env'
+require 'mutant/pipe'
 require 'mutant/util'
 require 'mutant/registry'
 require 'mutant/ast'
@@ -52,6 +55,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'
@@ -74,6 +86,14 @@ 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/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'
@@ -129,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'
@@ -157,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'
@@ -165,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'
@@ -194,7 +215,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'
@@ -220,8 +240,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/meta/send.rb

@@ -13,7 +13,6 @@ module Mutant
 
         public :receiver, :selector
 
-        INDEX_ASSIGNMENT_SELECTOR            = :[]=
         ATTRIBUTE_ASSIGNMENT_SELECTOR_SUFFIX = '='
 
         # Arguments of mutated node

data/lib/mutant/ast/regexp.rb

@@ -0,0 +1,37 @@
+# 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
+    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.call, 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.call, 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

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

@@ -0,0 +1,50 @@
+# 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
+
+            def transform
+              named_group.tap do |expression|
+                expression.expressions = subexpressions
+              end
+            end
+
+            def subexpressions
+              remaining_children.map(&Regexp.public_method(:to_expression))
+            end
+
+            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