mutant 0.17.0 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 752a1938022756ae4d788946052f227269843741bafc857cb9be24bd94b5a272
-  data.tar.gz: b7f0ec5bc7a221c9503c923d20781a061826826acb3caf605a4601e77a808bb5
+  metadata.gz: fd77b62cd208529f1fd030e87ffbce9c4df69cf18c097f7895ddd76204f8577d
+  data.tar.gz: f4ce398e717e5a8d34aa2ed57eafea5358cdb7af02fb8dc1dbcca2b862f754cc
 SHA512:
-  metadata.gz: ae4b675e810a9b94f340e9888722eb1a72b78f8bcb008dd0dec44919a3f5d4ef3d440f117c4c159db59528a6362b3b53ea6e0ec808833798d7f9f4ca1c0ab633
-  data.tar.gz: a95c6b2b83be6d672284bc6139cd8f37fb29a1a02e5babc3a5c304b6a6eeba143b37d68b6dee39c5de6355c93800435443e9abdf68e4ffd301cdb60b334d9dd5
+  metadata.gz: c6dbb4139015cfe33c91b7c802004aca5d9015299d517552c56bcaa4cc81fa40b5a5f8e39bd17319ff0876da90b2cc7164566c0c65221f6dd0de1758fe767829
+  data.tar.gz: caa47a0c66816fe06b76bf0da184d9b91404abceb93eec83d374c42f1d2c3c51ae578e57b98f00b9fb431ffcc770cb864aabfe203bdd9400b30a77fdf8acade3

data/VERSION

@@ -1 +1 @@
-0.17.0
+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/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/matcher/method/instance.rb

@@ -18,6 +18,8 @@ module Mutant
           evaluator =
             if memoized_method?(scope, target_method.name)
               Evaluator::Memoized
+            elsif module_function?(scope, target_method)
+              Evaluator::ModuleFunction
             else
               Evaluator
             end
@@ -39,6 +41,25 @@ module Mutant
         end
         private_class_method :memoized_method?
 
+        # Test if method was exposed via module_function
+        #
+        # module_function makes the instance method private and copies it
+        # onto the singleton class, where it keeps the source location.
+        #
+        # @param [Scope] scope
+        # @param [UnboundMethod] target_method
+        #
+        # @return [Boolean]
+        def self.module_function?(scope, target_method)
+          raw         = scope.raw
+          method_name = target_method.name
+
+          raw.private_method_defined?(method_name) &&
+            raw.singleton_class.public_method_defined?(method_name) &&
+            raw.singleton_class.instance_method(method_name).source_location.eql?(target_method.source_location)
+        end
+        private_class_method :module_function?
+
         # Instance method specific evaluator
         class Evaluator < Evaluator
           MATCH_NODE_TYPE = :def
@@ -75,6 +96,11 @@ module Mutant
             end
 
           end # Memoized
+
+          # Evaluator specialized for module_function instance methods
+          class ModuleFunction < self
+            SUBJECT_CLASS = Subject::Method::Instance::ModuleFunction
+          end # ModuleFunction
         end # Evaluator
 
         private_constant(*constants(false))

data/lib/mutant/mutation/runner.rb

@@ -19,6 +19,7 @@ module Mutant
           .record(:analysis) { run_driver(reporter, async_driver(env)) }
           .tap { |result| env.record(:report) { reporter.report(result) } }
           .tap { |result| Result::JSONWriter.new(env:, result:).call }
+          .tap { Result::SessionFiles.new(world: env.world).prune(Result::SessionFiles::KEEP) }
       end
       private_class_method :run_mutation_analysis
 

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      class Itblock < self
+
+        handle(:itblock)
+
+        children :receiver, :parameter, :body
+
+      private
+
+        def dispatch
+          emit_nil
+          emit_receiver_mutations(&method(:n_send?))
+          emit_body_mutations(&method(:references_it?))
+        end
+
+        def references_it?(node)
+          return true if node.eql?(s(:lvar, :it))
+
+          children = owns_it?(node) ? [node.children.first] : node.children
+
+          children.any? do |child|
+            child.instance_of?(::Parser::AST::Node) && references_it?(child)
+          end
+        end
+
+        def owns_it?(node)
+          n_block?(node) || n_itblock?(node) || n_def?(node) || n_defs?(node)
+        end
+      end # Itblock
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/result/json_writer.rb

@@ -2,26 +2,30 @@
 
 module Mutant
   module Result
-    # Write result JSON to .mutant/results/
+    # Write result JSON to .mutant/results/, gzip compressed
     class JSONWriter
       include Anima.new(:env, :result)
 
-      RESULTS_DIR = '.mutant/results'
+      # Log stored in place of the log of a covered mutation
+      EMPTY_LOG = LogCapture::String.new(content: '')
 
       # Write result JSON file
       #
+      # The JSON repeats the source, diff, and tests of each mutation,
+      # and compresses about twentyfold.
+      #
       # Written to a temporary file first and renamed into place, so a
       # concurrent reader of the session file never observes a partial
       # document. This matters once the file is rewritten during a run.
       #
       # @return [Pathname]
       def call
-        dir = env.world.pathname.new(RESULTS_DIR)
+        dir = env.world.pathname.new(SessionFiles::DIRECTORY)
         dir.mkpath
 
-        path = dir.join("#{SESSION_ID}.json")
-        tmp_path = dir.join("#{SESSION_ID}.json.tmp")
-        tmp_path.write(json)
+        path = dir.join("#{SESSION_ID}.json.gz")
+        tmp_path = dir.join("#{SESSION_ID}.json.gz.tmp")
+        tmp_path.binwrite(Zlib.gzip(json))
         tmp_path.rename(path)
 
         path
@@ -41,7 +45,29 @@ module Mutant
           ruby_version:    RUBY_VERSION,
           runtime:         result.runtime,
           session_id:      SESSION_ID,
-          subject_results: result.subject_results
+          subject_results: result.subject_results.map(&method(:without_covered_logs))
+        )
+      end
+
+      def without_covered_logs(subject_result)
+        subject_result.with(
+          coverage_results: subject_result.coverage_results.map(&method(:without_log))
+        )
+      end
+
+      # The log of a covered mutation is the output of the tests that
+      # killed it. The session subcommands only report alive mutations,
+      # so nothing reads it back, and on a suite whose failures print
+      # large values it is most of the session file.
+      def without_log(coverage_result)
+        return coverage_result unless coverage_result.success?
+
+        mutation_result = coverage_result.mutation_result
+
+        coverage_result.with(
+          mutation_result: mutation_result.with(
+            isolation_result: mutation_result.isolation_result.with(log: EMPTY_LOG)
+          )
         )
       end
     end # JSONWriter

data/lib/mutant/result/session_files.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Mutant
+  module Result
+    # The session files of past runs in .mutant/results/
+    class SessionFiles
+      include Anima.new(:world)
+
+      DIRECTORY = '.mutant/results'
+
+      # Sessions this version writes gzip compressed, and those earlier
+      # versions wrote as plain JSON. The plain ones are listed first,
+      # each kind oldest first, as the earlier versions wrote them before
+      # this one wrote any.
+      PATTERN = '*.json{,.gz}'
+
+      # Sessions a run keeps, and `mutant session gc` keeps by default
+      KEEP = 100
+
+      # The session files, oldest first
+      #
+      # @return [Array<Pathname>]
+      def paths
+        dir = world.pathname.new(DIRECTORY)
+
+        return EMPTY_ARRAY unless dir.directory?
+
+        dir.glob(PATTERN)
+      end
+
+      # Delete all but the most recent sessions
+      #
+      # A session written alongside this one by a concurrent run may
+      # have been deleted by that run already.
+      #
+      # @param [Integer] keep
+      #
+      # @return [Array<Pathname>]
+      #   the deleted session files
+      def prune(keep)
+        excess = paths.reverse.drop(keep)
+
+        excess.each do |path|
+          path.delete
+        rescue Errno::ENOENT
+          nil
+        end
+      end
+    end # SessionFiles
+  end # Result
+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.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'
@@ -249,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'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutant
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.17.1
 platform: ruby
 authors:
 - Markus Schirp
@@ -304,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
@@ -389,6 +390,7 @@ 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
@@ -435,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: []