mutant 0.11.16 → 0.11.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebfdb4dba80abb7c2b06b6b057cebf6db686b598219979ed3d0730b6e5a9ed82
-  data.tar.gz: ee03173b094cf29a9d21ad30b383a0b01b8cac7b7ba1132f24f36c25e9e4fee3
+  metadata.gz: 327c0520e73601c447d4081b428de0111e59627961c82a955e86b2015fef7ce7
+  data.tar.gz: 93dd7338a29a416bce5025d8c95a39cb88cc5e96932435797b60102689726e3d
 SHA512:
-  metadata.gz: 90d9c06d5a2900441b49b3bc0fa039b11bb296e389af41927f711431855a28369a8e31faf0b1cc5ba74ab09c6300c21002ac30c0d6eae6b3d63eac3129a692e8
-  data.tar.gz: 725ecfb369b3c28133d898f3405bb5cec8f780027c8e7c05de59c225719924fde51e192186d2f7a2199a57352b056401fa562a67d75409a637d182bbb50d9390
+  metadata.gz: 433b57a38e8b5d68f579d26cb5352cabc222137eb875183364dcd1f39ff8852c8a7f2a95b7ee64a3258ed87f9620670160d8d98df6b0a4513e174ff4b8775a6d
+  data.tar.gz: 84b5b86c80958651592da077cfbd5e965587ce02b05c9b27fc9cf86506a80f963351011cf4ebfe23e084ab211a2f9ea2ac6e89f0efcfeb90cc019a28ab42a0b1

data/bin/mutant

@@ -1,55 +1,64 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-trap('INT') do |status|
-  effective_status = status ? status + 128 : 128
-  exit! effective_status
-end
+module Mutant
+  # Record executable timestamp
+  @executable_timestamp = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+  trap('INT') do |status|
+    effective_status = status ? status + 128 : 128
+    exit! effective_status
+  end
 
-require 'mutant'
+  require 'mutant'
 
-Mutant::CLI.parse(
-  arguments: ARGV,
-  world:     Mutant::WORLD
-).either(
-  ->(message) { Mutant::WORLD.stderr.puts(message); Kernel.exit(false) },
-  # rubocop:disable Metrics/BlockLength
-  lambda do |command|
-    status =
+  WORLD.record(:cli_parse) do
+    CLI.parse(
+      arguments: ARGV,
+      world:     Mutant::WORLD
+    )
+  end.either(
+    ->(message) { Mutant::WORLD.stderr.puts(message); Kernel.exit(false) },
+    # rubocop:disable Metrics/BlockLength
+    lambda do |command|
       if command.zombie?
-        $stderr.puts('Running mutant zombified!')
-        Mutant::Zombifier.call(
-          namespace:        :Zombie,
-          load_path:        $LOAD_PATH,
-          kernel:           Kernel,
-          pathname:         Pathname,
-          require_highjack: Mutant::RequireHighjack
-            .public_method(:call)
-            .to_proc
-            .curry
-            .call(Kernel),
-          root_require:     'mutant',
-          includes:         %w[
-            adamantium
-            anima
-            concord
-            equalizer
-            mprelude
-            mutant
-            unparser
-            variable
-          ]
-        )
+        command = WORLD.record(:zombify) do
+          $stderr.puts('Running mutant zombified!')
+          Zombifier.call(
+            namespace:        :Zombie,
+            load_path:        $LOAD_PATH,
+            kernel:           Kernel,
+            pathname:         Pathname,
+            require_highjack: RequireHighjack
+              .public_method(:call)
+              .to_proc
+              .curry
+              .call(Kernel),
+            root_require:     'mutant',
+            includes:         %w[
+              adamantium
+              anima
+              concord
+              equalizer
+              mprelude
+              mutant
+              unparser
+              variable
+            ]
+          )
 
-        Zombie::Mutant::CLI.parse(
-          arguments: ARGV,
-          world:     Zombie::Mutant::WORLD
-        ).from_right.call
-      else
-        command.call
+          Zombie::Mutant::CLI.parse(
+            arguments: ARGV,
+            world:     Mutant::WORLD
+          ).from_right
+        end
       end
 
-    Kernel.exit(status)
-  end
-  # rubocop:enable Metrics/BlockLength
-)
+      WORLD.record(:execute) { command.call }.tap do |status|
+        WORLD.recorder.print_profile(WORLD.stderr) if command.print_profile?
+        WORLD.kernel.exit(status)
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  )
+end

data/lib/mutant/bootstrap.rb

@@ -7,6 +7,8 @@ module Mutant
   # the impure world to produce an environment.
   #
   # env = config interpreted against the world
+  #
+  # rubocop:disable Metrics/ModuleLength
   module Bootstrap
     include Adamantium, Anima.new(:config, :parser, :world)
 
@@ -30,66 +32,94 @@ module Mutant
     #
     # rubocop:disable Metrics/MethodLength
     def self.call(env)
-      env = load_hooks(env)
-        .tap(&method(:infect))
-        .with(matchable_scopes: matchable_scopes(env))
-
-      subjects = start_subject(env, Matcher.from_config(env.config.matcher).call(env))
-
-      Integration.setup(env).fmap do |integration|
-        env.with(
-          integration: integration,
-          mutations:   subjects.flat_map(&:mutations),
-          selector:    Selector::Expression.new(integration),
-          subjects:    subjects
-        )
+      env.record(:bootstrap) do
+        env = load_hooks(env)
+          .tap(&method(:infect))
+          .with(matchable_scopes: matchable_scopes(env))
+
+        matched_subjects = env.record(:subject_match) do
+          Matcher.from_config(env.config.matcher).call(env)
+        end
+
+        selected_subjects = subject_select(env, matched_subjects)
+
+        mutations = env.record(:mutation_generate) do
+          selected_subjects.flat_map(&:mutations)
+        end
+
+        Integration.setup(env).fmap do |integration|
+          env.with(
+            integration: integration,
+            mutations:   mutations,
+            selector:    Selector::Expression.new(integration),
+            subjects:    selected_subjects
+          )
+        end
       end
     end
     # rubocop:enable Metrics/MethodLength
 
     def self.load_hooks(env)
-      env.with(hooks: Hooks.load_config(env.config))
+      env.record(__method__) do
+        env.with(hooks: Hooks.load_config(env.config))
+      end
     end
     private_class_method :load_hooks
 
-    def self.start_subject(env, subjects)
-      start_expressions = env.config.matcher.start_expressions
+    def self.subject_select(env, subjects)
+      env.record(__method__) do
+        start_expressions = env.config.matcher.start_expressions
 
-      return subjects if start_expressions.empty?
+        return subjects if start_expressions.empty?
 
-      subjects.drop_while do |subject|
-        start_expressions.none? do |expression|
-          expression.prefix?(subject.expression)
+        subjects.drop_while do |subject|
+          start_expressions.none? do |expression|
+            expression.prefix?(subject.expression)
+          end
         end
       end
     end
-    private_class_method :start_subject
+    private_class_method :subject_select
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def self.infect(env)
-      config, hooks, world = env.config, env.hooks, env.world
+      env.record(__method__) do
+        config, hooks, world = env.config, env.hooks, env.world
 
-      hooks.run(:env_infection_pre, env)
+        env.record(:hooks_env_infection_pre) do
+          hooks.run(:env_infection_pre, env)
+        end
 
-      config.environment_variables.each do |key, value|
-        world.environment_variables[key] = value
-      end
+        env.record(:require_target) do
+          config.environment_variables.each do |key, value|
+            world.environment_variables[key] = value
+          end
 
-      config.includes.each(&world.load_path.public_method(:<<))
-      config.requires.each(&world.kernel.public_method(:require))
+          config.includes.each(&world.load_path.public_method(:<<))
+          config.requires.each(&world.kernel.public_method(:require))
+        end
 
-      hooks.run(:env_infection_post, env)
+        env.record(:hooks_env_infection_post) do
+          hooks.run(:env_infection_post, env)
+        end
+      end
     end
     private_class_method :infect
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
     def self.matchable_scopes(env)
-      config = env.config
+      env.record(__method__) do
+        config = env.config
 
-      scopes = env.world.object_space.each_object(Module).each_with_object([]) do |scope, aggregate|
-        expression = expression(config.reporter, config.expression_parser, scope) || next
-        aggregate << Scope.new(scope, expression)
-      end
+        scopes = env.world.object_space.each_object(Module).with_object([]) do |scope, aggregate|
+          expression = expression(config.reporter, config.expression_parser, scope) || next
+          aggregate << Scope.new(scope, expression)
+        end
 
-      scopes.sort_by { |scope| scope.expression.syntax }
+        scopes.sort_by { |scope| scope.expression.syntax }
+      end
     end
     private_class_method :matchable_scopes
 
@@ -132,4 +162,5 @@ module Mutant
     end
     private_class_method :semantics_warning
   end # Bootstrap
+  # rubocop:enable Metrics/ModuleLength
 end # Mutant

data/lib/mutant/cli/command/environment/run.rb

@@ -41,7 +41,7 @@ module Mutant
           end
 
           def validate_tests(environment)
-            if environment.integration.all_tests.length.zero?
+            if environment.integration.all_tests.empty?
               Either::Left.new(NO_TESTS_MESSAGE)
             else
               Either::Right.new(environment)

data/lib/mutant/cli/command/environment.rb

@@ -27,8 +27,8 @@ module Mutant
         def bootstrap
           env = Env.empty(world, @config)
 
-          Config.load_config_file(env)
-            .fmap(&method(:expand))
+          env
+            .record(:config) { Config.load_config_file(env).fmap(&method(:expand)) }
             .bind { Bootstrap.call(env.with(config: @config)) }
         end
 

data/lib/mutant/cli/command.rb

@@ -4,7 +4,13 @@ module Mutant
   module CLI
     # rubocop:disable Metrics/ClassLength
     class Command
-      include AbstractType, Anima.new(:world, :main, :parent, :zombie)
+      include AbstractType, Anima.new(
+        :main,
+        :parent,
+        :print_profile,
+        :world,
+        :zombie
+      )
 
       OPTIONS     = [].freeze
       SUBCOMMANDS = [].freeze
@@ -21,12 +27,13 @@ module Mutant
       # @return [Command]
       #
       # rubocop:disable Metrics/ParameterLists
-      def self.parse(arguments:, parent: nil, world:, zombie: false)
+      def self.parse(arguments:, parent: nil, print_profile: false, world:, zombie: false)
         new(
-          main:   nil,
-          parent: parent,
-          world:  world,
-          zombie: zombie
+          main:          nil,
+          parent:        parent,
+          print_profile: print_profile,
+          world:         world,
+          zombie:        zombie
         ).__send__(:parse, arguments)
       end
       # rubocop:enable Metrics/ParameterLists
@@ -59,7 +66,8 @@ module Mutant
         [*parent&.full_name, self.class.command_name].join(' ')
       end
 
-      alias_method :zombie?, :zombie
+      alias_method :print_profile?, :print_profile
+      alias_method :zombie?,        :zombie
 
       abstract_method :action
 
@@ -136,6 +144,10 @@ module Mutant
           capture_main { world.stdout.puts("mutant-#{VERSION}"); true }
         end
 
+        parser.on('--profile', 'Profile mutant execution') do
+          @print_profile = true
+        end
+
         parser.on('--zombie', 'Run mutant zombified') do
           @zombie = true
         end
@@ -176,10 +188,11 @@ module Mutant
         else
           find_command(command_name).bind do |command|
             command.parse(
-              arguments: arguments,
-              parent:    self,
-              world:     world,
-              zombie:    zombie
+              arguments:     arguments,
+              parent:        self,
+              print_profile: print_profile,
+              world:         world,
+              zombie:        zombie
             )
           end
         end

data/lib/mutant/env.rb

@@ -134,6 +134,15 @@ module Mutant
     end
     memoize :test_subject_ratio
 
+    # Record segment
+    #
+    # @param [Symbol] name
+    #
+    # @return [self]
+    def record(name, &block)
+      world.record(name, &block)
+    end
+
   private
 
     def run_mutation_tests(mutation, tests)

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

@@ -29,17 +29,17 @@ module Mutant
           end
 
           def mutate_body
-            # NOTE: will only mutate parts of regexp body if the body is composed of only strings.
-            # Regular expressions with interpolation are skipped.
-            return unless (body_ast = AST::Regexp.expand_regexp_ast(input))
+            string = Regexp.regexp_body(input) or return
 
-            mutate(node: body_ast).each do |mutation|
-              source = AST::Regexp.to_expression(mutation).to_s
-              emit_type(s(:str, source), options)
-            end
+            Regexp
+              .mutate(::Regexp::Parser.parse(string))
+              .each(&method(:emit_regexp_body))
           end
 
-        end # Regex
+          def emit_regexp_body(expression)
+            emit_type(s(:str, expression.to_str), options)
+          end
+        end # Regexp
       end # Literal
     end # Node
   end # Mutator

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

@@ -50,9 +50,19 @@ module Mutant
           }.freeze
         }.freeze
 
-        REGEXP_MATCH_METHODS    = %i[=~ match match?].freeze
-        REGEXP_START_WITH_NODES = %i[regexp_bos_anchor regexp_literal_literal].freeze
-        REGEXP_END_WITH_NODES   = %i[regexp_literal_literal regexp_eos_anchor].freeze
+        REGEXP_MATCH_METHODS = %i[=~ match match?].freeze
+
+        REGEXP_START_WITH_NODES =
+          [
+            ::Regexp::Expression::Anchor::BeginningOfString,
+            ::Regexp::Expression::Literal
+          ].freeze
+
+        REGEXP_END_WITH_NODES =
+          [
+            ::Regexp::Expression::Literal,
+            ::Regexp::Expression::Anchor::EndOfString
+          ].freeze
 
       private
 
@@ -114,33 +124,33 @@ module Mutant
           end
         end
 
-        def emit_start_end_with_mutations # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength
+        def emit_start_end_with_mutations
           return unless REGEXP_MATCH_METHODS.include?(selector) && arguments.one?
 
           argument = Mutant::Util.one(arguments)
 
-          return unless argument.type.equal?(:regexp) && (
-            regexp_ast = AST::Regexp.expand_regexp_ast(argument)
-          )
+          return unless argument.type.equal?(:regexp)
+
+          string = Regexp.regexp_body(argument) or return
 
-          regexp_children = regexp_ast.children
+          expressions = ::Regexp::Parser.parse(string)
 
-          case regexp_children.map(&:type)
+          case expressions.map(&:class)
           when REGEXP_START_WITH_NODES
-            emit_start_with(regexp_children)
+            emit_start_with(expressions.last.text)
           when REGEXP_END_WITH_NODES
-            emit_end_with(regexp_children)
+            emit_end_with(expressions.first.text)
           end
         end
 
-        def emit_start_with(regexp_nodes)
-          literal = Mutant::Util.one(regexp_nodes.last.children)
-          emit_type(receiver, :start_with?, s(:str, literal))
+        def emit_start_with(string)
+          emit_type(receiver, :start_with?, s(:str, string))
         end
 
-        def emit_end_with(regexp_nodes)
-          literal = Mutant::Util.one(regexp_nodes.first.children)
-          emit_type(receiver, :end_with?, s(:str, literal))
+        def emit_end_with(string)
+          emit_type(receiver, :end_with?, s(:str, string))
         end
 
         def emit_predicate_mutations