mutant 0.11.18 → 0.11.20

data/lib/mutant/matcher/method/instance.rb

@@ -12,7 +12,9 @@ module Mutant
         # @param [UnboundMethod] method
         #
         # @return [Matcher::Method::Instance]
-        def self.new(scope, target_method)
+        #
+        # rubocop:disable Metrics/MethodLength
+        def self.new(scope:, target_method:)
           evaluator =
             if memoized_method?(scope, target_method.name)
               Evaluator::Memoized
@@ -20,8 +22,13 @@ module Mutant
               Evaluator
             end
 
-          super(scope, target_method, evaluator)
+          super(
+            evaluator:     evaluator,
+            scope:         scope,
+            target_method: target_method
+          )
         end
+        # rubocop:enable Metrics/MethodLength
 
         def self.memoized_method?(scope, method_name)
           scope < Adamantium && scope.memoized?(method_name)
@@ -37,8 +44,6 @@ module Mutant
         private
 
           def match?(node)
-            n_def?(node)                           &&
-            node.location.line.equal?(source_line) &&
             node.children.fetch(NAME_INDEX).equal?(method_name)
           end
 

data/lib/mutant/matcher/method/metaclass.rb

@@ -11,12 +11,9 @@ module Mutant
 
         # New singleton method matcher
         #
-        # @param [Class, Module] scope
-        # @param [Symbol] method_name
-        #
         # @return [Matcher::Method::Singleton]
-        def self.new(scope, method_name)
-          super(scope, method_name, Evaluator)
+        def self.new(scope:, target_method:)
+          super(scope: scope, target_method: target_method, evaluator: Evaluator)
         end
 
         # Metaclass method evaluator
@@ -34,10 +31,7 @@ module Mutant
         private
 
           def match?(node)
-            n_def?(node) &&
-              name?(node) &&
-              line?(node) &&
-              metaclass_receiver?(node)
+            name?(node) && metaclass_receiver?(node)
           end
 
           def metaclass_receiver?(node)
@@ -46,14 +40,7 @@ module Mutant
           end
 
           def metaclass_containing(node)
-            AST::FindMetaclassContaining.call(ast, node)
-          end
-
-          def line?(node)
-            node
-              .location
-              .line
-              .equal?(source_line)
+            AST::FindMetaclassContaining.call(ast: ast, target: node)
           end
 
           def name?(node)

data/lib/mutant/matcher/method/singleton.rb

@@ -8,12 +8,9 @@ module Mutant
 
         # New singleton method matcher
         #
-        # @param [Class, Module] scope
-        # @param [Symbol] method_name
-        #
         # @return [Matcher::Method::Singleton]
-        def self.new(scope, method_name)
-          super(scope, method_name, Evaluator)
+        def self.new(scope:, target_method:)
+          super(scope: scope, target_method: target_method, evaluator: Evaluator)
         end
 
         # Singleton method evaluator
@@ -27,14 +24,7 @@ module Mutant
         private
 
           def match?(node)
-            n_defs?(node) && line?(node) && name?(node) && receiver?(node)
-          end
-
-          def line?(node)
-            node
-              .location
-              .line
-              .equal?(source_line)
+            name?(node) && receiver?(node)
           end
 
           def name?(node)

data/lib/mutant/matcher/method.rb

@@ -6,7 +6,7 @@ module Mutant
     class Method < self
       include AbstractType,
               Adamantium,
-              Concord::Public.new(:scope, :target_method, :evaluator)
+              Anima.new(:scope, :target_method, :evaluator)
 
       SOURCE_LOCATION_WARNING_FORMAT =
         '%s does not have a valid source location, unable to emit subject'
@@ -20,7 +20,7 @@ module Mutant
       #
       # @return [Enumerable<Subject>]
       def call(env)
-        evaluator.call(scope, target_method, env)
+        evaluator.call(scope: scope, target_method: target_method, env: env)
       end
 
       # Abstract method match evaluator
@@ -32,7 +32,7 @@ module Mutant
         include(
           AbstractType,
           Adamantium,
-          Concord.new(:scope, :target_method, :env),
+          Anima.new(:scope, :target_method, :env),
           Procto,
           AST::NodePredicates
         )
@@ -80,7 +80,7 @@ module Mutant
         end
 
         def context
-          Context.new(scope, source_path)
+          Context.new(scope: scope, source_path: source_path)
         end
 
         def ast
@@ -120,6 +120,11 @@ module Mutant
         def matched_view
           return if source_location.nil?
 
+          # This is a performance optimization when using --since to avoid the cost of parsing
+          # every source file that could possibly map to a subject. A more fine-grained filtering
+          # takes places later in the process.
+          return unless relevant_source_file?
+
           ast
             .on_line(source_line)
             .select { |view| view.node.type.eql?(self.class::MATCH_NODE_TYPE) && match?(view.node) }
@@ -127,6 +132,10 @@ module Mutant
         end
         memoize :matched_view
 
+        def relevant_source_file?
+          env.config.matcher.diffs.all? { |diff| diff.touches_path?(source_path) }
+        end
+
         def visibility
           # This can be cleaned up once we are on >ruby-3.0
           # Method#{public,private,protected}? exists there.

data/lib/mutant/matcher/methods.rb

@@ -4,7 +4,7 @@ module Mutant
   class Matcher
     # Abstract base class for matcher that returns method subjects from scope
     class Methods < self
-      include AbstractType, Concord.new(:scope)
+      include AbstractType, Anima.new(:scope)
 
       CANDIDATE_NAMES = %i[
         public_instance_methods
@@ -21,7 +21,9 @@ module Mutant
       # @return [Enumerable<Subject>]
       def call(env)
         Chain.new(
-          methods(env).map { |method| matcher.new(scope, method) }
+          matchers: methods(env).map do |target_method|
+            matcher.new(scope: scope, target_method: target_method)
+          end
         ).call(env)
       end
 

data/lib/mutant/matcher/namespace.rb

@@ -4,7 +4,7 @@ module Mutant
   class Matcher
     # Matcher for specific namespace
     class Namespace < self
-      include Concord::Public.new(:expression)
+      include Anima.new(:expression)
 
       # Enumerate subjects
       #
@@ -13,7 +13,7 @@ module Mutant
       # @return [Enumerable<Subject>]
       def call(env)
         Chain.new(
-          matched_scopes(env).map { |scope| Scope.new(scope.raw) }
+          matchers: matched_scopes(env).map { |scope| Scope.new(scope: scope.raw) }
         ).call(env)
       end
 

data/lib/mutant/matcher/scope.rb

@@ -9,7 +9,7 @@ module Mutant
     # to hook in custom matchers. In that case the scope matchers to expand
     # should be passed as arguments to the constructor.
     class Scope < self
-      include Concord.new(:scope)
+      include Anima.new(:scope)
 
       MATCHERS = [
         Matcher::Methods::Singleton,
@@ -25,13 +25,13 @@ module Mutant
       #
       # @return [Enumerable<Subject>]
       def call(env)
-        Chain.new(effective_matchers).call(env)
+        Chain.new(matchers: effective_matchers).call(env)
       end
 
     private
 
       def effective_matchers
-        MATCHERS.map { |matcher| matcher.new(scope) }
+        MATCHERS.map { |matcher| matcher.new(scope: scope) }
       end
 
     end # Scope

data/lib/mutant/matcher/static.rb

@@ -4,7 +4,7 @@ module Mutant
   class Matcher
     # Matcher returning subjects already known at its creation time
     class Static
-      include Concord.new(:subjects)
+      include Anima.new(:subjects)
 
       # Call matcher
       #

data/lib/mutant/matcher.rb

@@ -20,8 +20,8 @@ module Mutant
     # @return [Matcher]
     def self.from_config(config)
       Filter.new(
-        Chain.new(config.subjects.map(&:matcher)),
-        method(:allowed_subject?).curry.call(config)
+        matcher:   Chain.new(matchers: config.subjects.map(&:matcher)),
+        predicate: method(:allowed_subject?).curry.call(config)
       )
     end
 
@@ -31,7 +31,9 @@ module Mutant
     private_class_method :allowed_subject?
 
     def self.select_subject?(config, subject)
-      config.subject_filters.all? { |filter| filter.call(subject) }
+      config.diffs.all? do |diff|
+        diff.touches?(subject.source_path, subject.source_lines)
+      end
     end
     private_class_method :select_subject?
 

data/lib/mutant/meta/example/verification.rb

@@ -5,7 +5,7 @@ module Mutant
     class Example
       # Example verification
       class Verification
-        include Adamantium, Concord.new(:example, :mutations)
+        include Adamantium, Anima.new(:example, :mutations)
 
         # Test if mutation was verified successfully
         #
@@ -94,7 +94,7 @@ module Mutant
 
         def missing
           (example.expected.map(&:node) - mutations.map(&:node)).map do |node|
-            Mutation::Evil.new(example, node)
+            Mutation::Evil.new(subject: example, node: node)
           end
         end
         memoize :missing

data/lib/mutant/meta/example.rb

@@ -22,7 +22,7 @@ module Mutant
       #
       # @return [Verification]
       def verification
-        Verification.new(self, generated)
+        Verification.new(example: self, mutations: generated)
       end
       memoize :verification
 
@@ -38,8 +38,8 @@ module Mutant
       # @return [Context]
       def context
         Context.new(
-          Object,
-          location.path
+          scope:       Object,
+          source_path: location.path
         )
       end
 
@@ -59,7 +59,7 @@ module Mutant
           config: Mutation::Config::DEFAULT,
           node:   node
         ).map do |node|
-          Mutation::Evil.new(self, node)
+          Mutation::Evil.new(subject: self, node: node)
         end
       end
       memoize :generated

data/lib/mutant/mutation/config.rb

@@ -13,16 +13,22 @@ module Mutant
       ignore_pattern = Transform::Block.capture('ignore pattern', &AST::Pattern.method(:parse))
 
       TRANSFORM = Transform::Sequence.new(
-        [
+        steps: [
           Transform::Hash.new(
             optional: [
-              Transform::Hash::Key.new('ignore_patterns', Transform::Array.new(ignore_pattern)),
-              Transform::Hash::Key.new('timeout',         Transform::FLOAT)
+              Transform::Hash::Key.new(
+                transform: Transform::Array.new(transform: ignore_pattern),
+                value:     'ignore_patterns'
+              ),
+              Transform::Hash::Key.new(
+                transform: Transform::FLOAT,
+                value:     'timeout'
+              )
             ],
             required: []
           ),
           Transform::Hash::Symbolize.new,
-          Transform::Success.new(DEFAULT.method(:with))
+          Transform::Success.new(block: DEFAULT.method(:with))
         ]
       )
 

data/lib/mutant/mutation/runner/sink.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutation
+    module Runner
+      class Sink
+        include Anima.new(:env)
+
+        # Initialize object
+        #
+        # @return [undefined]
+        def initialize(*)
+          super
+          @start           = env.world.timer.now
+          @subject_results = {}
+        end
+
+        # Runner status
+        #
+        # @return [Result::Env]
+        def status
+          Result::Env.new(
+            env:             env,
+            runtime:         env.world.timer.now - @start,
+            subject_results: @subject_results.values
+          )
+        end
+
+        # Test if scheduling stopped
+        #
+        # @return [Boolean]
+        def stop?
+          status.stop?
+        end
+
+        # Handle mutation finish
+        #
+        # @param [Result::MutationIndex] mutation_index_result
+        #
+        # @return [self]
+        def result(mutation_index_result)
+          mutation_result = mutation_result(mutation_index_result)
+
+          subject = mutation_result.mutation.subject
+
+          @subject_results[subject] = Result::Subject.new(
+            subject:          subject,
+            coverage_results: previous_coverage_results(subject).dup << coverage_result(mutation_result),
+            tests:            env.selections.fetch(subject)
+          )
+
+          self
+        end
+
+      private
+
+        def coverage_result(mutation_result)
+          Result::Coverage.new(
+            mutation_result: mutation_result,
+            criteria_result: mutation_result.criteria_result(env.config.coverage_criteria)
+          )
+        end
+
+        def mutation_result(mutation_index_result)
+          Result::Mutation.new(
+            isolation_result: mutation_index_result.isolation_result,
+            mutation:         env.mutations.fetch(mutation_index_result.mutation_index),
+            runtime:          mutation_index_result.runtime
+          )
+        end
+
+        def previous_coverage_results(subject)
+          subject_result = @subject_results.fetch(subject) { return EMPTY_ARRAY }
+          subject_result.coverage_results
+        end
+
+      end # Sink
+    end # Runner
+  end # Mutation
+end # Mutant

data/lib/mutant/mutation/runner.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutation
+    module Runner
+      # Run against env
+      #
+      # @return [Either<String, Result>]
+      def self.call(env)
+        reporter(env).start(env)
+
+        Either::Right.new(run_mutation_analysis(env))
+      end
+
+      def self.run_mutation_analysis(env)
+        reporter = reporter(env)
+
+        env
+          .record(:analysis) { run_driver(reporter, async_driver(env)) }
+          .tap { |result| env.record(:report) { reporter.report(result) } }
+      end
+      private_class_method :run_mutation_analysis
+
+      def self.async_driver(env)
+        Parallel.async(env.world, mutation_test_config(env))
+      end
+      private_class_method :async_driver
+
+      def self.run_driver(reporter, driver)
+        Signal.trap('INT') do
+          driver.stop
+        end
+
+        loop do
+          status = driver.wait_timeout(reporter.delay)
+          break status.payload if status.done?
+          reporter.progress(status)
+        end
+      end
+      private_class_method :run_driver
+
+      def self.mutation_test_config(env)
+        Parallel::Config.new(
+          block:            env.method(:cover_index),
+          jobs:             env.config.jobs,
+          on_process_start: env.method(:emit_mutation_worker_process_start),
+          process_name:     'mutant-worker-process',
+          sink:             Sink.new(env: env),
+          source:           Parallel::Source::Array.new(jobs: env.mutations.each_index.to_a),
+          thread_name:      'mutant-worker-thread'
+        )
+      end
+      private_class_method :mutation_test_config
+
+      def self.reporter(env)
+        env.config.reporter
+      end
+      private_class_method :reporter
+
+    end # Runner
+  end # Mutation
+end # Mutant

data/lib/mutant/mutation.rb

@@ -4,7 +4,7 @@ module Mutant
   # Represent a mutated node with its subject
   class Mutation
     include AbstractType, Adamantium
-    include Concord::Public.new(:subject, :node)
+    include Anima.new(:subject, :node)
 
     CODE_DELIMITER = "\0"
     CODE_RANGE     = (..4).freeze

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

@@ -48,7 +48,7 @@ module Mutant
         def mutate_body_receiver
           return if n_lambda?(send) || !n_send?(body)
 
-          body_meta = AST::Meta::Send.new(body)
+          body_meta = AST::Meta::Send.new(node: body)
 
           emit(s(:send, send, body_meta.selector, *body_meta.arguments))
         end
@@ -56,7 +56,7 @@ module Mutant
         def valid_send_mutation?(node)
           return unless n_send?(node)
 
-          last = AST::Meta::Send.new(node).arguments.last
+          last = AST::Meta::Send.new(node: node).arguments.last
 
           !last&.type.equal?(:block_pass)
         end

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

@@ -23,7 +23,7 @@ module Mutant
 
         def emit_optarg_body_assignments
           arguments.children.each do |argument|
-            next unless n_optarg?(argument) && AST::Meta::Optarg.new(argument).used?
+            next unless n_optarg?(argument) && AST::Meta::Optarg.new(node: argument).used?
 
             emit_body_prepend(s(:lvasgn, *argument))
           end

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

@@ -5,6 +5,7 @@ module Mutant
     class Node
       # Mutator for if nodes
       class If < self
+        FLOW_MODIFIER = %i[return next break].to_set.freeze
 
         handle(:if)
 
@@ -43,6 +44,14 @@ module Mutant
           emit_type(condition, nil, else_branch)
         end
 
+        def emit_type(_condition, if_branch, else_branch)
+          super unless ternary? && (if_branch.nil? || else_branch.nil?)
+        end
+
+        def ternary?
+          parent && FLOW_MODIFIER.include?(parent.node.type)
+        end
+
       end # If
     end # Node
   end # Mutator

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

@@ -25,7 +25,7 @@ module Mutant
         def mutate_rescue_bodies
           children_indices(RESCUE_INDICES).each do |index|
             mutate_child(index)
-            resbody_body = AST::Meta::Resbody.new(children.fetch(index)).body
+            resbody_body = AST::Meta::Resbody.new(node: children.fetch(index)).body
             emit_concat(resbody_body) if resbody_body
           end
         end

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

@@ -79,7 +79,7 @@ module Mutant
         end
 
         def meta
-          AST::Meta::Send.new(node)
+          AST::Meta::Send.new(node: node)
         end
         memoize :meta
 
@@ -173,7 +173,7 @@ module Mutant
 
           return unless dynamic_selector && n_sym?(dynamic_selector)
 
-          method_name = AST::Meta::Symbol.new(dynamic_selector).name
+          method_name = AST::Meta::Symbol.new(node: dynamic_selector).name
 
           emit(s(node.type, receiver, method_name, *actual_arguments))
         end
@@ -194,7 +194,7 @@ module Mutant
         def emit_double_negation_mutation
           return unless selector.equal?(:!) && n_send?(receiver)
 
-          negated = AST::Meta::Send.new(meta.receiver)
+          negated = AST::Meta::Send.new(node: receiver)
           emit(negated.receiver) if negated.selector.equal?(:!)
         end
 
@@ -223,7 +223,7 @@ module Mutant
         def emit_const_get_mutation
           return unless selector.equal?(:const_get) && n_sym?(arguments.first)
 
-          emit(s(:const, receiver, AST::Meta::Symbol.new(arguments.first).name))
+          emit(s(:const, receiver, AST::Meta::Symbol.new(node: arguments.first).name))
         end
 
         def emit_selector_replacement

data/lib/mutant/mutator/regexp.rb

@@ -13,10 +13,10 @@ module Mutant
       end
 
       class Registry
-        include Concord.new(:contents)
+        include Anima.new(:contents)
 
         def initialize
-          super({})
+          super(contents: {})
         end
 
         def register(expression_class, mutator_class)

data/lib/mutant/parallel/source.rb

@@ -27,7 +27,7 @@ module Mutant
 
       # Job source backed by a finite array
       class Array
-        include Concord.new(:jobs)
+        include Anima.new(:jobs)
 
         # Initialize objecto
         #