mutant 0.8.24 → 0.9.0

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

@@ -1,60 +0,0 @@
-# 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 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]
-            )
-
-          private
-
-            # Transform node to expression with text value
-            #
-            # @return [Regexp::Expression]
-            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/env/bootstrap.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Env
-    # Bootstrap environment
-    class Bootstrap
-      include Adamantium::Flat, Concord::Public.new(:config), Procto.call(:env)
-
-      SEMANTICS_MESSAGE_FORMAT =
-        "%<message>s. Fix your lib to follow normal ruby semantics!\n" \
-        '{Module,Class}#name should return resolvable constant name as String or nil'
-
-      CLASS_NAME_RAISED_EXCEPTION =
-        '%<scope_class>s#name from: %<scope>s raised an error: %<exception>s'
-
-      CLASS_NAME_TYPE_MISMATCH_FORMAT =
-        '%<scope_class>s#name from: %<scope>s returned %<name>s'
-
-      private_constant(*constants(false))
-
-      # Scopes that are eligible for matching
-      #
-      # @return [Enumerable<Matcher::Scope>]
-      attr_reader :matchable_scopes
-
-      # Parser for this environment
-      #
-      # @return [Parser]
-      attr_reader :parser
-
-      # Initialize object
-      #
-      # @return [Object]
-      def initialize(*)
-        super
-        @parser = Parser.new
-        infect
-        initialize_matchable_scopes
-        @integration = config.integration.new(config).setup
-      end
-
-      # Print warning message
-      #
-      # @param [String]
-      #
-      # @return [self]
-      def warn(message)
-        config.reporter.warn(message)
-        self
-      end
-
-      # Environment after bootstraping
-      #
-      # @return [Env]
-      # rubocop:disable MethodLength
-      #
-      def env
-        subjects = matched_subjects
-        Env.new(
-          actor_env:        Actor::Env.new(Thread),
-          config:           config,
-          integration:      integration,
-          matchable_scopes: matchable_scopes,
-          mutations:        subjects.flat_map(&:mutations),
-          parser:           parser,
-          selector:         Selector::Expression.new(integration),
-          subjects:         subjects
-        )
-      end
-
-    private
-
-      # Configured mutant integration
-      #
-      # @return [Mutant::Integration]
-      attr_reader :integration
-
-      # Scope name from scoping object
-      #
-      # @param [Class, Module] scope
-      #
-      # @return [String]
-      #   if scope has a name and does not raise exceptions obtaining it
-      #
-      # @return [nil]
-      #   otherwise
-      def scope_name(scope)
-        scope.name
-      rescue => exception
-        semantics_warning(
-          CLASS_NAME_RAISED_EXCEPTION,
-          exception:   exception.inspect,
-          scope:       scope,
-          scope_class: scope.class
-        )
-        nil
-      end
-
-      # Infect environment
-      #
-      # @return [undefined]
-      def infect
-        config.includes.each(&config.load_path.method(:<<))
-        config.requires.each(&config.kernel.method(:require))
-      end
-
-      # Matched subjects
-      #
-      # @return [Enumerable<Subject>]
-      def matched_subjects
-        Matcher::Compiler.call(config.matcher).call(self)
-      end
-
-      # Initialize matchable scopes
-      #
-      # @return [undefined]
-      def initialize_matchable_scopes
-        scopes = ObjectSpace.each_object(Module).each_with_object([]) do |scope, aggregate|
-          expression = expression(scope) || next
-          aggregate << Scope.new(scope, expression)
-        end
-
-        @matchable_scopes = scopes.sort_by { |scope| scope.expression.syntax }
-      end
-
-      # Try to turn scope into expression
-      #
-      # @param [Class, Module] scope
-      #
-      # @return [Expression]
-      #   if scope can be represented in an expression
-      #
-      # @return [nil]
-      #   otherwise
-      def expression(scope)
-        name = scope_name(scope) or return
-
-        unless name.instance_of?(String)
-          semantics_warning(
-            CLASS_NAME_TYPE_MISMATCH_FORMAT,
-            name:        name,
-            scope_class: scope.class,
-            scope:       scope
-          )
-          return
-        end
-
-        config.expression_parser.try_parse(name)
-      end
-
-      # Write a semantics warning
-      #
-      # @return [undefined]
-      def semantics_warning(format, options)
-        message = format % options
-        warn(SEMANTICS_MESSAGE_FORMAT % { message: message })
-      end
-    end # Bootstrap
-  end # Env
-end # Mutant

data/lib/mutant/matcher/compiler.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Matcher
-
-    # Compiler for complex matchers
-    class Compiler
-      include Concord.new(:config), AST::Sexp, Procto.call(:result)
-
-      # Generated matcher
-      #
-      # @return [Matcher]
-      def result
-        Filter.new(
-          Chain.new(config.match_expressions.map(&:matcher)),
-          Morpher::Evaluator::Predicate::Boolean::And.new(
-            [
-              ignored_subjects,
-              filtered_subjects
-            ]
-          )
-        )
-      end
-
-      # Subject expression prefix predicate
-      class SubjectPrefix
-        include Concord.new(:expression)
-
-        # Test if subject expression is matched by prefix
-        #
-        # @return [Boolean]
-        def call(subject)
-          expression.prefix?(subject.expression)
-        end
-
-      end # SubjectPrefix
-
-    private
-
-      # Predicate returning false on expression ignored subject
-      #
-      # @return [#call]
-      def ignored_subjects
-        Morpher::Evaluator::Predicate::Boolean::Negation.new(
-          Morpher::Evaluator::Predicate::Boolean::Or.new(
-            config.ignore_expressions.map(&SubjectPrefix.method(:new))
-          )
-        )
-      end
-
-      # Predicate returning false on filtered subject
-      #
-      # @return [#call]
-      def filtered_subjects
-        Morpher::Evaluator::Predicate::Boolean::And.new(config.subject_filters)
-      end
-
-    end # Compiler
-  end # Matcher
-end # Mutant

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for root expression regexp wrapper
-        class RootExpression < Node
-          handle(:regexp_root_expression)
-
-          # Emit mutations for children of root node
-          #
-          # @return [undefined]
-          def dispatch
-            children.each_index(&method(:mutate_child))
-          end
-        end # RootExpression
-
-        # Mutator for beginning of line anchor `^`
-        class BeginningOfLineAnchor < Node
-          handle(:regexp_bol_anchor)
-
-          # Emit mutations
-          #
-          # Replace `^` with `\A`
-          #
-          # @return [undefined]
-          def dispatch
-            emit(s(:regexp_bos_anchor))
-          end
-        end # BeginningOfLineAnchor
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for pipe in `/foo|bar/` regexp
-        class AlternationMeta < Node
-          handle(:regexp_alternation_meta)
-
-        private
-
-          # Dispatch mutations
-          #
-          # @return [undefined]
-          def dispatch
-            children.each_index(&method(:delete_child))
-          end
-        end # AlternationMeta
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for regexp capture groups, such as `/(foo)/`
-        class CaptureGroup < Node
-          handle(:regexp_capture_group)
-
-          children :group
-
-          # Emit mutations
-          #
-          # Replace `(captured_group)` with `(?:non_captured_group)`
-          #
-          # @return [undefined]
-          def dispatch
-            return unless group
-
-            emit(s(:regexp_passive_group, group))
-            emit_group_mutations
-          end
-        end # EndOfLineAnchor
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Character type mutator
-        class CharacterType < Node
-          map = {
-            regexp_digit_type:           :regexp_nondigit_type,
-            regexp_hex_type:             :regexp_nonhex_type,
-            regexp_space_type:           :regexp_nonspace_type,
-            regexp_word_boundary_anchor: :regexp_nonword_boundary_anchor,
-            regexp_word_type:            :regexp_nonword_type,
-            regexp_xgrapheme_type:       :regexp_linebreak_type
-          }
-
-          MAP = IceNine.deep_freeze(map.merge(map.invert))
-
-          handle(*MAP.keys)
-
-          # Mutate to invert character type
-          #
-          # @return [undefined]
-          def dispatch
-            emit(s(MAP.fetch(node.type)))
-          end
-        end # CharacterType
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for end of line anchor `$`
-        class EndOfLineAnchor < Node
-          handle(:regexp_eol_anchor)
-
-          # Emit mutations
-          #
-          # Replace `$` with `\z`
-          #
-          # @return [undefined]
-          def dispatch
-            emit(s(:regexp_eos_anchor))
-          end
-        end # EndOfLineAnchor
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for end of line or before end of string anchor `\Z`
-        class EndOfStringOrBeforeEndOfLineAnchor < Node
-          handle(:regexp_eos_ob_eol_anchor)
-
-          # Emit mutations
-          #
-          # Replace `\Z` with `\z`
-          #
-          # @return [undefined]
-          def dispatch
-            emit(s(:regexp_eos_anchor))
-          end
-        end # EndOfStringOrBeforeEndOfLineAnchor
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant