mutant 0.16.3 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f7a495dc61f610e15c0b43ee64726016fa2feb694ce948e9554478f15c60c03
-  data.tar.gz: 11c45dd1db15519c9647ac2b13a8c794ddacb3a4a396e90ea2c6accfb6e71dd0
+  metadata.gz: fd77b62cd208529f1fd030e87ffbce9c4df69cf18c097f7895ddd76204f8577d
+  data.tar.gz: f4ce398e717e5a8d34aa2ed57eafea5358cdb7af02fb8dc1dbcca2b862f754cc
 SHA512:
-  metadata.gz: 8c52e9fa61e9b8ad827cd02f37469654201115c06251330a7eb695a9909b79d355fa9c9d555002d96650589c36d71046436462736754e7a33438f2b03c11bf37
-  data.tar.gz: 7a1a190d3e17f1bfc3bee1584023b6f7756b97d2b79ffa6f42a93ce2b70c0d323e29b0bd7bd4010204d3bbac3a26a82deaa04163c4fc83044d1cb799ecd5d4a8
+  metadata.gz: c6dbb4139015cfe33c91b7c802004aca5d9015299d517552c56bcaa4cc81fa40b5a5f8e39bd17319ff0876da90b2cc7164566c0c65221f6dd0de1758fe767829
+  data.tar.gz: caa47a0c66816fe06b76bf0da184d9b91404abceb93eec83d374c42f1d2c3c51ae578e57b98f00b9fb431ffcc770cb864aabfe203bdd9400b30a77fdf8acade3

data/VERSION

@@ -1 +1 @@
-0.16.3
+0.17.1

data/lib/mutant/ast/structure.rb

@@ -177,6 +177,11 @@ module Mutant
           fixed:    EMPTY_ARRAY,
           variable: Node::Variable::Descendants.new(name: :members, range: 0..)
         ),
+        Node.new(
+          type:     :array_pattern_with_tail,
+          fixed:    EMPTY_ARRAY,
+          variable: Node::Variable::Descendants.new(name: :members, range: 0..)
+        ),
         Node.new(
           type:     :back_ref,
           fixed:    Node.fixed([[Node::Fixed::Attribute, :name]]),
@@ -381,6 +386,11 @@ module Mutant
           fixed:    EMPTY_ARRAY,
           variable: nil
         ),
+        Node.new(
+          type:     :find_pattern,
+          fixed:    EMPTY_ARRAY,
+          variable: Node::Variable::Descendants.new(name: :members, range: 0..)
+        ),
         Node.new(
           type:     :float,
           fixed:    Node.fixed([[Node::Fixed::Attribute, :value]]),
@@ -442,6 +452,11 @@ module Mutant
           fixed:    EMPTY_ARRAY,
           variable: Node::Variable::Descendants.new(name: :members, range: 0..)
         ),
+        Node.new(
+          type:     :hash_pattern,
+          fixed:    EMPTY_ARRAY,
+          variable: Node::Variable::Descendants.new(name: :members, range: 0..)
+        ),
         Node.new(
           type:     :index,
           fixed:    Node.fixed([[Node::Fixed::Descendant, :receiver]]),
@@ -505,6 +520,17 @@ module Mutant
           ),
           variable: nil
         ),
+        Node.new(
+          type:     :itblock,
+          fixed:    Node.fixed(
+            [
+              [Node::Fixed::Descendant, :receiver],
+              [Node::Fixed::Attribute, :parameter],
+              [Node::Fixed::Descendant, :body]
+            ]
+          ),
+          variable: nil
+        ),
         Node.new(
           type:     :ivar,
           fixed:    Node.fixed([[Node::Fixed::Attribute, :name]]),
@@ -535,6 +561,11 @@ module Mutant
           fixed:    EMPTY_ARRAY,
           variable: Node::Variable::Descendants.new(name: :members, range: 0..)
         ),
+        Node.new(
+          type:     :kwnilarg,
+          fixed:    EMPTY_ARRAY,
+          variable: nil
+        ),
         Node.new(
           type:     :kwoptarg,
           fixed:    Node.fixed(
@@ -575,11 +606,36 @@ module Mutant
           ),
           variable: nil
         ),
+        Node.new(
+          type:     :match_alt,
+          fixed:    Node.fixed(
+            [
+              [Node::Fixed::Descendant, :left],
+              [Node::Fixed::Descendant, :right]
+            ]
+          ),
+          variable: nil
+        ),
+        Node.new(
+          type:     :match_as,
+          fixed:    Node.fixed(
+            [
+              [Node::Fixed::Descendant, :pattern],
+              [Node::Fixed::Descendant, :target]
+            ]
+          ),
+          variable: nil
+        ),
         Node.new(
           type:     :match_current_line,
           fixed:    Node.fixed([[Node::Fixed::Descendant, :pattern]]),
           variable: nil
         ),
+        Node.new(
+          type:     :match_nil_pattern,
+          fixed:    EMPTY_ARRAY,
+          variable: nil
+        ),
         Node.new(
           type:     :match_pattern,
           fixed:    Node.fixed(
@@ -590,6 +646,16 @@ module Mutant
           ),
           variable: nil
         ),
+        Node.new(
+          type:     :match_pattern_p,
+          fixed:    Node.fixed(
+            [
+              [Node::Fixed::Descendant, :target],
+              [Node::Fixed::Descendant, :pattern]
+            ]
+          ),
+          variable: nil
+        ),
         Node.new(
           type:     :match_rest,
           fixed:    Node.fixed([[Node::Fixed::Descendant, :value]]),
@@ -794,6 +860,11 @@ module Mutant
           ),
           variable: nil
         ),
+        Node.new(
+          type:     :pin,
+          fixed:    Node.fixed([[Node::Fixed::Descendant, :value]]),
+          variable: nil
+        ),
         Node.new(
           type:     :postexe,
           fixed:    Node.fixed([[Node::Fixed::Descendant, :body]]),

data/lib/mutant/bootstrap.rb

@@ -12,6 +12,15 @@ module Mutant
   module Bootstrap
     include Adamantium, Anima.new(:config, :parser, :world)
 
+    UNMATCHED_CONTEXT_MAP = <<~'MESSAGE'
+      The coverage recording names no test that this suite runs, so it cannot
+      say which tests cover a subject.
+
+      Record it again from the project root, with the suite mutant runs. A suite
+      that starts simplecov unconditionally rewrites the recording every time
+      mutant runs it, so start simplecov only when measuring coverage.
+    MESSAGE
+
     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'
@@ -77,18 +86,58 @@ module Mutant
       env.record(__method__) do
         hooks = env.hooks
         hooks.run(:setup_integration_pre)
-        Integration.setup(env).fmap do |integration|
-          env.with(
-            integration:,
-            mutations:,
-            selector:    Selector::Expression.new(integration:),
-            subjects:    selected_subjects
-          ).tap { hooks.run(:setup_integration_post) }
+        Integration.setup(env).bind do |integration|
+          setup_selector(env:, integration:).fmap do |selector|
+            env.with(
+              integration:,
+              mutations:,
+              selector:,
+              subjects:    selected_subjects
+            ).tap { hooks.run(:setup_integration_post) }
+          end
         end
       end
     end
     private_class_method :setup_integration
 
+    # The selector the configured strategy asks for
+    #
+    # The default is to use the coverage recording whenever there is a usable
+    # one and the expressions otherwise, so a project that records per test
+    # coverage gets the better selection without asking for it. Naming
+    # `context_map` explicitly turns every reason the recording cannot be used
+    # into a failed run, rather than a silent downgrade to a selection the user
+    # did not ask for.
+    #
+    # @return [Either<String, Selector>]
+    def self.setup_selector(env:, integration:)
+      selection = env.config.selection
+      fallback  = Selector::Expression.new(integration:)
+
+      return Either::Right.new(fallback) if selection.expression?
+
+      result = env.record(__method__) do
+        ContextMap::Loader
+          .call(path: env.world.pathname.new(selection.effective_path), world: env.world)
+          .bind { |context_map| context_map_selector(context_map:, fallback:, integration:) }
+      end
+
+      selection.context_map? ? result : Either::Right.new(result.from_right { fallback })
+    end
+    private_class_method :setup_selector
+
+    # A recording that names no test of this suite was taken somewhere else, and
+    # answering selection from it would report every mutation alive without ever
+    # running a test that could have killed it.
+    #
+    # @return [Either<String, Selector>]
+    def self.context_map_selector(context_map:, fallback:, integration:)
+      selector = Selector::ContextMap.new(context_map:, fallback:, integration:)
+
+      selector.unmatched? ? Either::Left.new(UNMATCHED_CONTEXT_MAP) : Either::Right.new(selector)
+    end
+    private_class_method :context_map_selector
+
     # rubocop:enable Metrics/MethodLength
     def self.load_hooks(env)
       env.record(__method__) do

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

@@ -5,8 +5,9 @@ module Mutant
     class Command
       # rubocop:disable Metrics/ClassLength
       class Environment < self
-        NAME              = 'environment'
-        SHORT_DESCRIPTION = 'Environment subcommands'
+        NAME                  = 'environment'
+        SHORT_DESCRIPTION     = 'Environment subcommands'
+        SELECTION_DESCRIPTION = 'Select tests via STRATEGY: auto|expression|context_map'
 
         OPTIONS =
           %i[
@@ -14,6 +15,7 @@ module Mutant
             add_runner_options
             add_integration_options
             add_matcher_options
+            add_selection_options
             add_reporter_options
             add_usage_options
           ].freeze
@@ -116,6 +118,22 @@ module Mutant
           end
         end
 
+        def add_selection_options(parser)
+          parser.separator('Selection:')
+
+          parser.on('--selection STRATEGY', Config::Selection::STRATEGIES, SELECTION_DESCRIPTION) do |strategy|
+            selection(strategy:)
+          end
+
+          parser.on('--selection-path PATH', 'Read the coverage report from PATH') do |path|
+            selection(path:)
+          end
+        end
+
+        def selection(**attributes)
+          set(selection: @config.selection.with(attributes))
+        end
+
         def add_runner_options(parser)
           parser.separator('Runner:')
 

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

@@ -7,23 +7,29 @@ module Mutant
         NAME              = 'session'
         SHORT_DESCRIPTION = 'Session history subcommands'
 
-        RESULTS_DIR = '.mutant/results'
+        RESULTS_DIR = Result::SessionFiles::DIRECTORY
 
-      private
+        GZIP_MAGIC = [0x1F, 0x8B].pack('C2')
 
-        def session_files
-          dir = world.pathname.new(RESULTS_DIR)
+        private_constant(:GZIP_MAGIC)
 
-          return [] unless dir.directory?
+      private
 
-          dir.glob('*.json')
+        def session_files
+          Result::SessionFiles.new(world:).paths
         end
 
         def load_session_file(path)
-          world.parse_json(path.read)
+          world.parse_json(read_session_file(path))
             .bind(&Result::Session::CODEC.load_transform.public_method(:call))
         end
 
+        def read_session_file(path)
+          content = path.binread
+
+          content.start_with?(GZIP_MAGIC) ? Zlib.gunzip(content) : content
+        end
+
         # Shared base for commands that operate on a session
         class SessionCommand < self
           OPTIONS = %i[add_session_id_option].freeze
@@ -68,7 +74,9 @@ module Mutant
 
           def resolve_session_path
             if @session_id
-              world.pathname.new("#{RESULTS_DIR}/#{@session_id}.json")
+              compressed = world.pathname.new("#{RESULTS_DIR}/#{@session_id}.json.gz")
+
+              compressed.file? ? compressed : world.pathname.new("#{RESULTS_DIR}/#{@session_id}.json")
             else
               session_files.last
             end
@@ -131,9 +139,9 @@ module Mutant
           end
 
           def colorize_unsupported(path)
-            session_id = path.basename('.json')
+            session_id = path.basename.to_s.delete_suffix('.gz').delete_suffix('.json')
 
-            Unparser::Color::RED.format(INCOMPATIBLE.ljust(54)) + session_id.to_s
+            Unparser::Color::RED.format(INCOMPATIBLE.ljust(54)) + session_id
           end
         end # List
 
@@ -230,7 +238,7 @@ module Mutant
           SUBCOMMANDS       = [].freeze
           OPTIONS           = %i[add_gc_options].freeze
 
-          DEFAULT_KEEP = 100
+          DEFAULT_KEEP = Result::SessionFiles::KEEP
 
           def initialize(*)
             super

data/lib/mutant/config/selection.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Config
+    # Configuration of how tests get selected for a subject
+    class Selection
+      include Adamantium, Anima.new(:path, :strategy)
+
+      # Use the coverage recording when there is one, and the expressions
+      # otherwise. Mutant's default.
+      AUTO = 'auto'
+
+      # Select tests whose expressions match the subject's
+      EXPRESSION = 'expression'
+
+      # Select tests a coverage recording says executed the subject's lines
+      CONTEXT_MAP = 'context_map'
+
+      STRATEGIES = [AUTO, EXPRESSION, CONTEXT_MAP].freeze
+
+      # Directory coverage tools write their report into
+      DEFAULT_PATH = 'coverage'
+
+      UNKNOWN_STRATEGY = 'Unknown test selection strategy %s, expected one of: %s'
+
+      private_constant(:UNKNOWN_STRATEGY)
+
+      # Both attributes stay nil until set, so a value from mutant.yml is not
+      # overwritten by a default coming from the CLI end of the merge.
+      DEFAULT = new(path: nil, strategy: nil)
+
+      TRANSFORM =
+        Transform::Sequence.new(
+          steps: [
+            Transform::Hash.new(
+              optional: [
+                Transform::Hash::Key.new(
+                  transform: Transform::STRING,
+                  value:     'path'
+                ),
+                Transform::Hash::Key.new(
+                  transform: Transform::STRING,
+                  value:     'strategy'
+                )
+              ],
+              required: []
+            ),
+            Transform::Hash::Symbolize.new,
+            Transform::Block.capture(:selection) { |value| new(**DEFAULT.to_h, **value).validate }
+          ]
+        )
+
+      # Whether the recording is the only acceptable source of tests
+      #
+      # @return [Boolean]
+      def context_map? = strategy.eql?(CONTEXT_MAP)
+
+      # Whether the expressions are the only acceptable source of tests
+      #
+      # @return [Boolean]
+      def expression? = strategy.eql?(EXPRESSION)
+
+      # The configured recording location, or the conventional one
+      #
+      # @return [String]
+      def effective_path = path || DEFAULT_PATH
+
+      # Reject a strategy mutant does not implement
+      #
+      # @return [Either<String, Selection>]
+      def validate
+        return Either::Right.new(self) if strategy.nil? || STRATEGIES.include?(strategy)
+
+        Either::Left.new(UNKNOWN_STRATEGY % [strategy.inspect, STRATEGIES.join(', ')])
+      end
+
+      # Merge with other selection config
+      #
+      # Values from the other instance have precedence.
+      #
+      # @param [Selection] other
+      #
+      # @return [Selection]
+      def merge(other)
+        self.class.new(
+          path:     other.path || path,
+          strategy: other.strategy || strategy
+        )
+      end
+    end # Selection
+  end # Config
+end # Mutant

data/lib/mutant/config.rb

@@ -22,6 +22,7 @@ module Mutant
       :mutation,
       :reporter,
       :requires,
+      :selection,
       :usage
     )
 
@@ -89,6 +90,7 @@ module Mutant
         matcher:               matcher.merge(other.matcher),
         mutation:              mutation.merge(other.mutation),
         requires:              requires + other.requires,
+        selection:             selection.merge(other.selection),
         usage:                 other.usage.merge(usage)
       )
     end
@@ -269,6 +271,10 @@ module Mutant
             transform: Transform::STRING_ARRAY,
             value:     'requires'
           ),
+          Transform::Hash::Key.new(
+            transform: ->(value) { Selection::TRANSFORM.call(value) },
+            value:     'selection'
+          ),
           Transform::Hash::Key.new(
             transform: Usage::TRANSFORM,
             value:     'usage'