mutant 0.16.3 → 0.17.1

data/lib/mutant/selector/context_map.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Selector
+    # Test selector backed by a per test coverage recording
+    #
+    # Selects the tests that executed the subject's own source lines, which
+    # finds the tests that cover a subject regardless of where they live or how
+    # they are named. Subjects the recording says nothing about fall back to the
+    # expression selector: code that only runs while the suite loads (a constant
+    # body, a class level DSL call) executes under no test, and reporting its
+    # mutations alive without running a single test would be a lie.
+    class ContextMap < self
+      include Anima.new(:context_map, :fallback, :integration)
+
+      # Name of the strategy this selector implements
+      #
+      # @return [String]
+      def name = 'context_map'
+
+      # Tests for subject, likeliest killer first
+      #
+      # @param [Subject] subject
+      #
+      # @return [Enumerable<Test>]
+      def call(subject)
+        reach = context_map.reach(path: subject.source_path, lines: subject.source_lines)
+
+        covering = reach.flat_map do |location, lines|
+          index.fetch(location, EMPTY_ARRAY).map { |test| [test, lines, context_map.footprint(location)] }
+        end
+
+        return fallback.call(subject) if covering.empty?
+
+        order(covering, subject)
+      end
+
+      # Whether the recording names no test this suite runs
+      #
+      # A recording taken from another project root, or from a suite that has
+      # since been renamed away, covers everything and matches nothing. Left
+      # unsaid it looks exactly like a suite in which no test covers anything.
+      #
+      # @return [Boolean]
+      def unmatched?
+        index.each_key.none? { |location| context_map.context_ids.include?(location) }
+      end
+
+    private
+
+      # A run against a mutation stops at the first failing test, so this order
+      # is the difference between running one test and running all of them.
+      #
+      # A test the expressions would also have picked is the subject's own unit
+      # test, and no measurement beats that prior, so those go first as a block.
+      # Within each block comes the test spending the largest share of its own
+      # footprint inside this subject, since a test that exists for this code
+      # asserts on it where a feature spec passing through may swallow the
+      # difference. Reach breaks the remaining ties, because a test that ran
+      # more of the subject's lines is likelier to have run the mutated one.
+      def order(covering, subject)
+        named, rest = covering.partition { |test, _lines, _footprint| expression_match?(subject, test) }
+
+        (by_focus(named) + by_focus(rest)).map(&:first)
+      end
+
+      # The test id breaks a full tie, so the order depends on the recording's
+      # content rather than on the order a coverage tool happened to write it.
+      def by_focus(covering)
+        covering.sort_by { |test, lines, footprint| [-Rational(lines, footprint), -lines, test.id] }
+      end
+
+      # The question the expression selector asks of one test, rather than the
+      # set it builds by asking it of every test in the suite.
+      def expression_match?(subject, test)
+        subject.match_expressions.any? do |match_expression|
+          test.expressions.any? { |test_expression| match_expression.prefix?(test_expression) }
+        end
+      end
+
+      # Tests by the location the recording would name them under. A location
+      # holds more than one test whenever a framework generates examples from
+      # one line, so the value is a list.
+      def index
+        integration.available_tests.each_with_object({}) do |test, index|
+          location = test.location or next
+
+          (index[context_map.normalize(location)] ||= []) << test
+        end
+      end
+      memoize :index
+    end # ContextMap
+  end # Selector
+end # Mutant

data/lib/mutant/selector/expression.rb

@@ -6,6 +6,11 @@ module Mutant
     class Expression < self
       include Anima.new(:integration)
 
+      # Name of the strategy this selector implements
+      #
+      # @return [String]
+      def name = 'expression'
+
       # Tests for subject
       #
       # @param [Subject] subject

data/lib/mutant/selector/null.rb

@@ -6,6 +6,11 @@ module Mutant
     class Null < self
       include Equalizer.new
 
+      # Name of the strategy this selector implements
+      #
+      # @return [String]
+      def name = 'null'
+
       # Tests for subject
       #
       # @param [Subject] subject

data/lib/mutant/selector.rb

@@ -12,5 +12,10 @@ module Mutant
     # @return [Enumerable<Test>]
     abstract_method :call
 
+    # Name of the strategy this selector implements
+    #
+    # @return [String]
+    abstract_method :name
+
   end # Selector
 end # Mutant

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

@@ -38,6 +38,28 @@ module Mutant
             s(:begin, mutant, s(:send, nil, :memoize, s(:sym, name)))
           end
         end # Memoized
+
+        # Subject for instance methods exposed via module_function
+        #
+        # module_function copies the method onto the module's singleton
+        # class. Redefining only the instance method would leave that copy,
+        # which callers use, unmutated.
+        class ModuleFunction < self
+
+          # Prepare subject for mutation insertion
+          #
+          # @return [self]
+          def prepare
+            scope.raw.singleton_class.undef_method(name)
+
+            super
+          end
+
+          # Copy the inserted method onto the singleton class again
+          #
+          # @return [self]
+          def post_insert = tap { scope.raw.__send__(:module_function, name) }
+        end # ModuleFunction
       end # Instance
     end # Method
   end # Subject

data/lib/mutant/test.rb

@@ -5,7 +5,8 @@ module Mutant
   class Test
     include Anima.new(
       :expressions,
-      :id
+      :id,
+      :location
     )
 
     # Identification string

data/lib/mutant/transform.rb

@@ -295,6 +295,75 @@ module Mutant
         end
       end # Key
 
+      # Transform reducing a hash to the keys it names
+      #
+      # A document another tool writes carries keys mutant has no use for,
+      # and gains more between versions. Slicing ahead of a Hash transform
+      # lets that transform stay strict about the keys it does know.
+      class Slice < Transform
+        include Anima.new(:keys)
+
+        # Apply transformation to input
+        #
+        # @param [Object] input
+        #
+        # @return [Either<Error, Hash>]
+        def call(input)
+          PRIMITIVE
+            .call(input)
+            .lmap(&method(:lift_error))
+            .fmap { |hash| hash.slice(*keys) }
+        end
+      end # Slice
+
+      # Transform a hash keyed by data via mapping its pairs over key and
+      # value transforms
+      #
+      # Where Hash names the keys it accepts, this accepts every key the key
+      # transform does.
+      class Map < Transform
+        include Anima.new(:key, :value)
+
+        DUPLICATE_MESSAGE = 'Key transform maps distinct keys onto one'
+
+        private_constant(*constants(false))
+
+        # Apply transformation to input
+        #
+        # @param [Object] input
+        #
+        # @return [Either<Error, Hash>]
+        def call(input)
+          PRIMITIVE
+            .call(input)
+            .lmap(&method(:lift_error))
+            .bind(&method(:run))
+        end
+
+      private
+
+        # rubocop:disable Metrics/MethodLength
+        def run(input)
+          output = input.to_h do |key_input, value_input|
+            [
+              coerce(key, key_input, key_input).from_right { |error| return failure(error(cause: error, input:)) },
+              coerce(value, key_input, value_input).from_right { |error| return failure(error(cause: error, input:)) }
+            ]
+          end
+
+          if output.size.equal?(input.size)
+            success(output)
+          else
+            failure(error(input:, message: DUPLICATE_MESSAGE))
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def coerce(transform, key, input)
+          Key.new(value: key, transform:).call(input)
+        end
+      end # Map
+
       # Apply transformation to input
       #
       # @param [Object] input

data/lib/mutant.rb

@@ -42,6 +42,7 @@ module Mutant
       stringio
       unparser
       yaml
+      zlib
     ].each { |name| require(name) }
   end
 
@@ -187,6 +188,7 @@ module Mutant
     require 'mutant/mutator/node/procarg_zero'
     require 'mutant/mutator/node/kwargs'
     require 'mutant/mutator/node/numblock'
+    require 'mutant/mutator/node/itblock' if RUBY_VERSION > '3.4.0'
     require 'mutant/mutator/node/const_pattern'
     require 'mutant/mutator/regexp'
     require 'mutant/loader'
@@ -225,13 +227,17 @@ module Mutant
     require 'mutant/timer'
     require 'mutant/integration'
     require 'mutant/integration/null'
+    require 'mutant/context_map'
+    require 'mutant/context_map/loader'
     require 'mutant/selector'
+    require 'mutant/selector/context_map'
     require 'mutant/selector/expression'
     require 'mutant/selector/null'
     require 'mutant/world'
     require 'mutant/hooks'
     require 'mutant/config'
     require 'mutant/config/coverage_criteria'
+    require 'mutant/config/selection'
     require 'mutant/cli'
     require 'mutant/cli/command'
     require 'mutant/cli/command/environment'
@@ -245,6 +251,7 @@ module Mutant
     require 'mutant/mutation/runner/sink'
     require 'mutant/result'
     require 'mutant/result/session'
+    require 'mutant/result/session_files'
     require 'mutant/result/json_writer'
     require 'mutant/reporter'
     require 'mutant/reporter/null'
@@ -378,6 +385,7 @@ module Mutant
       mutation:              Mutation::Config::EMPTY,
       reporter:              Reporter::CLI.build(WORLD.stdout),
       requires:              EMPTY_ARRAY,
+      selection:             Config::Selection::DEFAULT,
       usage:                 Usage::Unknown.new
     )
   end # Config

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutant
 version: !ruby/object:Gem::Version
-  version: 0.16.3
+  version: 0.17.1
 platform: ruby
 authors:
 - Markus Schirp
@@ -235,7 +235,10 @@ files:
 - lib/mutant/cli/command/util.rb
 - lib/mutant/config.rb
 - lib/mutant/config/coverage_criteria.rb
+- lib/mutant/config/selection.rb
 - lib/mutant/context.rb
+- lib/mutant/context_map.rb
+- lib/mutant/context_map/loader.rb
 - lib/mutant/env.rb
 - lib/mutant/expression.rb
 - lib/mutant/expression/descendants.rb
@@ -301,6 +304,7 @@ files:
 - lib/mutant/mutator/node/if.rb
 - lib/mutant/mutator/node/in_pattern.rb
 - lib/mutant/mutator/node/index.rb
+- lib/mutant/mutator/node/itblock.rb
 - lib/mutant/mutator/node/kwargs.rb
 - lib/mutant/mutator/node/kwbegin.rb
 - lib/mutant/mutator/node/literal.rb
@@ -386,11 +390,13 @@ files:
 - lib/mutant/result/json_writer.rb
 - lib/mutant/result/process_status.rb
 - lib/mutant/result/session.rb
+- lib/mutant/result/session_files.rb
 - lib/mutant/result/test.rb
 - lib/mutant/scope.rb
 - lib/mutant/segment.rb
 - lib/mutant/segment/recorder.rb
 - lib/mutant/selector.rb
+- lib/mutant/selector/context_map.rb
 - lib/mutant/selector/expression.rb
 - lib/mutant/selector/null.rb
 - lib/mutant/subject.rb
@@ -431,7 +437,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.20
 specification_version: 4
 summary: ''
 test_files: []