mutant 0.15.1 → 0.16.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4eb76ac40bf4c263a5201b009dbc0760df5191918754bd47452017a4c97ac9b
-  data.tar.gz: b7ed8bb7728602995b796d7950d7c5ed445a3d9e775f7ad69b0dd5e91da3a69f
+  metadata.gz: 8f5176c82dd4c6a57785deebd566c3b29b14b4496d35c06e15c20ff3b98a0b37
+  data.tar.gz: 9f29a560a6c144480d8808cf24ec2ec2127b78bc7f9ef88e8e8a3e0f541e0974
 SHA512:
-  metadata.gz: 27d3948ff6e67c670aefe552fad358d333ee584d48090f13b14d15bee01a756dd6982be5922200dd0d2d939916b9d97e02c862b5d3487c9fd7572688affa544d
-  data.tar.gz: 3155f5599aa51d7d8644fbac0f4f6edb0f2e63d26bd70ca87f20b820f492ba07fa773ec974ad474f3ec08b652acc89eb23033124925c37f933e84eee803f0219
+  metadata.gz: a5e05c7b33041fb609ebcc89683461dba406c53592801d69603fa9003e0d8ee923f54d7b6f0bc9abcfd811ade64054ef3a8b9bf2bc30dbd44f37ca1f1ae2d4b6
+  data.tar.gz: 659e58f9ce856224a2a8f67d073c9006e340bcd838b0f6543cc57f8a12cbf6cc29c6dccad248744748a9f176750dae5240b719b797c7339a8552532e10d4ce22

data/VERSION

@@ -1 +1 @@
-0.15.1
+0.16.2

data/lib/mutant/ast/pattern/lexer.rb

@@ -3,20 +3,43 @@
 module Mutant
   class AST
     class Pattern
+      # rubocop:disable Metrics/ClassLength
       class Lexer
-        WHITESPACE     = [' ', "\t", "\n"].to_set.freeze
-        STRING_PATTERN = /\A[a-zA-Z][_a-zA-Z0-9]*\z/
+        WHITESPACE = [' ', "\t", "\n"].to_set.freeze
 
-        SINGLE_CHAR =
+        STRUCTURAL =
           {
             '(' => :group_start,
             ')' => :group_end,
             ',' => :delimiter,
-            '=' => :eq,
             '{' => :properties_start,
             '}' => :properties_end
           }.freeze
 
+        EQ_OPERATORS = %w[=== == =~].freeze
+
+        OPERATORS_BY_START =
+          {
+            '!' => %w[!= !~ !].freeze,
+            '<' => %w[<=> << <= <].freeze,
+            '>' => %w[>> >= >].freeze,
+            '+' => %w[+@ +].freeze,
+            '-' => %w[-@ -].freeze,
+            '*' => %w[** *].freeze,
+            '[' => ['[]=', '[]'].freeze,
+            '/' => ['/'].freeze,
+            '%' => ['%'].freeze,
+            '&' => ['&'].freeze,
+            '|' => ['|'].freeze,
+            '^' => ['^'].freeze,
+            '~' => ['~'].freeze
+          }.freeze
+
+        IDENTIFIER_START    = /[a-zA-Z]/
+        IDENTIFIER_CONTINUE = /[a-zA-Z0-9_]/
+
+        SETTER_TERMINATORS = (WHITESPACE + [',', ')', '}']).freeze
+
         def self.call(string)
           new(string).__send__(:run)
         end
@@ -31,7 +54,7 @@ module Mutant
                 #{token.display_location}
               MESSAGE
             end
-          end # Token
+          end # InvalidToken
         end # Error
 
         private_class_method :new
@@ -58,71 +81,123 @@ module Mutant
         end
 
         def consume
-          while next? && !instance_variable_defined?(:@error)
+          loop do
             skip_whitespace
+            break unless next? && !instance_variable_defined?(:@error)
 
-            consume_char || consume_string
-
-            skip_whitespace
+            consume_structural \
+              || consume_eq \
+              || consume_operator \
+              || consume_identifier \
+              || consume_invalid
           end
         end
 
-        def consume_char
+        def consume_structural
+          char = peek
+          type = STRUCTURAL.fetch(char) { return }
           start_position = @next_position
+          advance_position
+          @tokens << token(type:, start_position:)
+        end
 
-          char = peek
+        def consume_eq
+          return unless peek.eql?('=')
+
+          start_position = @next_position
 
-          type = SINGLE_CHAR.fetch(char) { return }
+          EQ_OPERATORS.each do |op|
+            next unless matches?(op)
+
+            advance_positions(op.length)
+            @tokens << token(type: :string, start_position:, value: op)
+            return true
+          end
 
           advance_position
+          @tokens << token(type: :eq, start_position:)
+        end
 
-          @tokens << token(type:, start_position:)
+        def consume_operator
+          operators = OPERATORS_BY_START[peek] or return
+          match     = operators.detect { |op| matches?(op) } or return
+
+          start_position = @next_position
+          advance_positions(match.length)
+          @tokens << token(type: :string, start_position:, value: match)
         end
 
-        def token(type:, start_position:, value: nil)
-          Token.new(
-            type:,
-            value:,
-            location: Source::Location.new(
-              source:     @source,
-              line_index: @line_index,
-              line_start: @line_start,
-              range:      range_from(start_position)
-            )
+        def consume_identifier
+          return unless IDENTIFIER_START.match?(peek)
+
+          start_position = @next_position
+          advance_position while IDENTIFIER_CONTINUE.match?(peek)
+          consume_identifier_suffix
+
+          @tokens << token(
+            type:           :string,
+            start_position:,
+            value:          @string[range_from(start_position)]
           )
         end
 
-        def consume_string
-          start_position = @next_position
+        def consume_identifier_suffix
+          advance_position if suffix_char?(peek)
+        end
 
-          token = build_string(start_position, read_string_body)
+        def suffix_char?(char)
+          char.eql?('!') || char.eql?('?') || (char.eql?('=') && setter_suffix_follows?)
+        end
 
-          if valid_string?(token.value)
-            @tokens << token
-          else
-            @error = Error::InvalidToken.new(token:)
-          end
+        def setter_suffix_follows?
+          next_char = @string[@next_position.succ]
+
+          next_char.nil? || SETTER_TERMINATORS.include?(next_char)
         end
 
-        def read_string_body
-          string = +''
+        def consume_invalid
+          start_position = @next_position
+          advance_invalid
+          @error = Error::InvalidToken.new(
+            token: token(
+              type:           :string,
+              start_position:,
+              value:          @string[range_from(start_position)]
+            )
+          )
+        end
 
-          while next?
-            char = peek
-            break if SINGLE_CHAR.key?(char) || whitespace?(char)
+        def advance_invalid
+          loop do
+            break unless next?
+            break if terminates_invalid?(peek)
 
-            string << char
             advance_position
           end
+        end
 
-          string
+        def terminates_invalid?(char)
+          STRUCTURAL.key?(char) || whitespace?(char)
         end
 
-        def build_string(start_position, string)
-          token(
-            type:           :string,
-            value:          string,
-            start_position:
+        def matches?(string)
+          @string[@next_position, string.length].eql?(string)
+        end
+
+        def advance_positions(count)
+          count.times { advance_position }
+        end
+
+        def token(type:, start_position:, value: nil)
+          Token.new(
+            type:,
+            value:,
+            location: Source::Location.new(
+              source:     @source,
+              line_index: @line_index,
+              line_start: @line_start,
+              range:      range_from(start_position)
+            )
           )
         end
 
@@ -130,10 +205,6 @@ module Mutant
           start_position...@next_position
         end
 
-        def valid_string?(string)
-          STRING_PATTERN.match?(string)
-        end
-
         def advance_position
           @next_position += 1
         end
@@ -165,6 +236,7 @@ module Mutant
           @next_position < @string.length
         end
       end # Lexer
+      # rubocop:enable Metrics/ClassLength
     end # Pattern
   end # AST
 end # Mutant

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

@@ -10,7 +10,7 @@ module Mutant
       class Root < self
         NAME              = 'mutant'
         SHORT_DESCRIPTION = 'mutation testing engine main command'
-        SUBCOMMANDS       = [Environment::Run, Environment::Test::Run::Root, Environment, Util].freeze
+        SUBCOMMANDS       = [Environment::Run, Environment::Test::Run::Root, Environment, Session, Util].freeze
       end # Root
     end # Command
   end # CLI

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

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module Mutant
+  module CLI
+    class Command
+      class Session < self
+        NAME              = 'session'
+        SHORT_DESCRIPTION = 'Session history subcommands'
+
+        RESULTS_DIR = '.mutant/results'
+
+      private
+
+        def session_files
+          dir = world.pathname.new(RESULTS_DIR)
+
+          return [] unless dir.directory?
+
+          dir.glob('*.json')
+        end
+
+        def load_session_file(path)
+          world.parse_json(path.read)
+            .bind(&Result::Session::CODEC.load_transform.public_method(:call))
+        end
+
+        # Shared base for commands that operate on a session
+        class SessionCommand < self
+          OPTIONS = %i[add_session_id_option].freeze
+
+          UUID_FORMAT = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/
+
+          private_constant(:UUID_FORMAT)
+
+          def display_config
+            @display_config || Reporter::CLI::Printer::DisplayConfig::DEFAULT
+          end
+
+          def action
+            path = resolve_session_path or return Either::Left.new('No sessions found')
+
+            return Either::Left.new("Session file not found: #{path}") unless path.file?
+
+            load_session_file(path).either(
+              lambda { |error|
+ Either::Left.new("Failed to load session: #{error}\nRun `mutant session gc` to remove incompatible sessions.")
+              },
+              method(:run_report)
+            )
+          end
+
+        private
+
+          def add_session_id_option(parser)
+            parser.on('--session-id=ID', 'Session ID to operate on (default: latest)') do |value|
+              fail(OptionParser::InvalidArgument, "invalid UUID format: #{value}") unless UUID_FORMAT.match?(value)
+
+              @session_id = value
+            end
+          end
+
+          def add_verbose_option(parser)
+            parser.separator("\nDisplay Options:\n\n")
+            parser.on('--verbose', 'Show verbose output') do
+              @display_config = Reporter::CLI::Printer::DisplayConfig::VERBOSE
+            end
+          end
+
+          def resolve_session_path
+            if @session_id
+              world.pathname.new("#{RESULTS_DIR}/#{@session_id}.json")
+            else
+              session_files.last
+            end
+          end
+
+          def run_report(session)
+            print("Session:  #{session.session_id}")
+
+            print_report(session)
+          end
+
+          abstract_method :print_report
+        end # SessionCommand
+
+        class List < self
+          NAME              = 'list'
+          SHORT_DESCRIPTION = 'List past mutation testing sessions'
+          SUBCOMMANDS       = [].freeze
+
+          HEADER_FORMAT    = '%-6s  %-10s  %-8s  %-10s  %-10s  %-36s  %s'
+          ROW_FORMAT       = '%-6s  %-10s  %-8s  %-10s  %-10s  %-36s  %s'
+          INCOMPATIBLE = '--------------- [incompatible] ---------------'
+
+          def action
+            print_header
+            session_files.reverse_each(&method(:print_session))
+
+            Either::Right.new(nil)
+          end
+
+        private
+
+          def print_header
+            print(HEADER_FORMAT % ['ALIVE', 'MUTATIONS', 'SUBJECTS', 'RUNTIME', 'KILLTIME', 'SESSION ID', 'TIMESTAMP'])
+          end
+
+          def print_session(path)
+            load_session_file(path).either(
+              ->(_error) { print(colorize_unsupported(path)) },
+              method(:print_session_row)
+            )
+          end
+
+          def print_session_row(session)
+            subjects = session.subject_results
+
+            print(ROW_FORMAT % [
+              subjects.sum(&:amount_mutations_alive),
+              subjects.sum(&:amount_mutations),
+              subjects.length,
+              format_time(session.runtime),
+              format_time(session.killtime),
+              session.session_id,
+              session.timestamp.strftime('%Y-%m-%d %H:%M:%S')
+            ])
+          end
+
+          def format_time(seconds)
+            '%.2fs' % seconds
+          end
+
+          def colorize_unsupported(path)
+            session_id = path.basename('.json')
+
+            Unparser::Color::RED.format(INCOMPATIBLE.ljust(54)) + session_id.to_s
+          end
+        end # List
+
+        class Show < SessionCommand
+          include Mutant::Reporter::CLI::Printer::AliveResults
+
+          NAME              = 'show'
+          SHORT_DESCRIPTION = 'Show results of a past session'
+          SUBCOMMANDS       = [].freeze
+          OPTIONS           = (superclass::OPTIONS + %i[add_verbose_option]).freeze
+
+        private
+
+          def print_report(session)
+            failed = session.subject_results.reject(&:success?)
+
+            print("Time:     #{session.timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
+            print("Version:  #{session.mutant_version}")
+            print("Ruby:     #{session.ruby_version}")
+            print("Subjects: #{session.subject_results.length}")
+            print("Alive:    #{failed.flat_map(&:uncovered_results).length}")
+
+            print_alive_results(failed)
+
+            Either::Right.new(nil)
+          end
+        end # Show
+
+        class Subject < SessionCommand
+          include Mutant::Reporter::CLI::Printer::AliveResults
+
+          NAME              = 'subject'
+          SHORT_DESCRIPTION = 'List subjects or show alive mutations for a specific subject'
+          SUBCOMMANDS       = [].freeze
+          OPTIONS           = (superclass::OPTIONS + %i[add_verbose_option]).freeze
+
+          HEADER_FORMAT = '%-6s  %-6s  %s'
+          ROW_FORMAT    = '%-6s  %-6s  %s'
+
+          def parse_remaining_arguments(arguments)
+            case arguments.length
+            when 0 then Either::Right.new(self)
+            when 1
+              @expression = Mutant::Util.one(arguments)
+              Either::Right.new(self)
+            else
+              Either::Left.new('Expected zero or one subject expression argument')
+            end
+          end
+
+        private
+
+          def print_report(session)
+            if @expression
+              print_subject_detail(session)
+            else
+              print_subject_list(session)
+            end
+          end
+
+          def print_subject_list(session)
+            print(HEADER_FORMAT % %w[ALIVE TOTAL SUBJECT])
+
+            session.subject_results
+              .sort_by { |subject_result| -subject_result.uncovered_results.length }
+              .each(&method(:print_subject_row))
+
+            Either::Right.new(nil)
+          end
+
+          def print_subject_row(subject_result)
+            alive = subject_result.uncovered_results.length
+            total = subject_result.amount_mutations
+
+            print(ROW_FORMAT % [alive, total, subject_result.expression_syntax])
+          end
+
+          def print_subject_detail(session)
+            subject_result = session.subject_results.detect do |subject_result|
+              subject_result.expression_syntax.eql?(@expression)
+            end
+
+            return Either::Left.new("Subject not found: #{@expression}") unless subject_result
+
+            print_alive_results([subject_result])
+
+            Either::Right.new(nil)
+          end
+        end # Subject
+
+        class GC < self
+          NAME              = 'gc'
+          SHORT_DESCRIPTION = 'Remove incompatible and old session results'
+          SUBCOMMANDS       = [].freeze
+          OPTIONS           = %i[add_gc_options].freeze
+
+          DEFAULT_KEEP = 100
+
+          def initialize(*)
+            super
+            @keep = DEFAULT_KEEP
+          end
+
+          def action
+            incompatible, compatible = partition_sessions
+
+            incompatible.each(&:delete)
+
+            excess = compatible.length > @keep ? compatible.first(compatible.length - @keep) : []
+            excess.each(&:delete)
+
+            print("Removed #{incompatible.length + excess.length} session(s)")
+
+            Either::Right.new(nil)
+          end
+
+        private
+
+          def add_gc_options(parser)
+            parser.on('--keep=N', Integer, "Keep N most recent sessions (default: #{DEFAULT_KEEP})") do |value|
+              @keep = value
+            end
+          end
+
+          def partition_sessions
+            incompatible = []
+            compatible   = []
+
+            session_files.each do |path|
+              load_session_file(path).either(
+                ->(_error) { incompatible << path },
+                ->(_session) { compatible << path }
+              )
+            end
+
+            [incompatible, compatible]
+          end
+
+        end # GC
+
+        SUBCOMMANDS = [List, Show, Subject, GC].freeze
+      end # Session
+    end # Command
+  end # CLI
+end # Mutant

data/lib/mutant/cli/command.rb

@@ -220,8 +220,22 @@ module Mutant
         "#{full_name}: #{message}\n\n#{parser}"
       end
 
-      def print(message)
-        world.stdout.puts(message)
+      def output
+        world.stdout
+      end
+
+      def puts(message)
+        output.puts(message)
+      end
+
+      alias_method :print, :puts
+
+      def parse_remaining_arguments(arguments)
+        if arguments.empty?
+          Either::Right.new(self)
+        else
+          Either::Left.new("unexpected arguments: #{arguments.join(' ')}")
+        end
       end
     end # Command
     # rubocop:enable Metrics/ClassLength

data/lib/mutant/config.rb

@@ -120,7 +120,7 @@ module Mutant
           .lmap { |exception| "MUTANT_JOBS environment variable has invalid value: #{jobs.inspect} - #{exception}" }
           .fmap { |jobs_value| DEFAULT.with(jobs: jobs_value) }
       else
-        Either::Right.new(DEFAULT)
+        Either::Right.new(DEFAULT.with(coverage_criteria: CoverageCriteria::EMPTY))
       end
     end
     private_class_method :load_env_config

data/lib/mutant/expression/method.rb

@@ -13,8 +13,6 @@ module Mutant
         :scope_symbol
       )
 
-      private(*anima.attribute_names)
-
       MATCHERS = {
         '.' => [Matcher::Methods::Singleton, Matcher::Methods::Metaclass].freeze,
         '#' => [Matcher::Methods::Instance].freeze

data/lib/mutant/expression/methods.rb

@@ -10,8 +10,6 @@ module Mutant
         :scope_symbol
       )
 
-      private(*anima.attribute_names)
-
       MATCHERS = {
         '.' => [Matcher::Methods::Singleton, Matcher::Methods::Metaclass].freeze,
         '#' => [Matcher::Methods::Instance].freeze

data/lib/mutant/expression/namespace.rb

@@ -6,8 +6,6 @@ module Mutant
     class Namespace < self
       include AbstractType, Anima.new(:scope_name)
 
-      private(*anima.attribute_names)
-
       # Recursive namespace expression
       class Recursive < self
         REGEXP = /\A#{SCOPE_NAME_PATTERN}?\*\z/

data/lib/mutant/integration/null.rb

@@ -17,7 +17,7 @@ module Mutant
       def call(_tests)
         Result::Test.new(
           job_index: nil,
-          output:    '',
+          output:    LogCapture::String.new(content: ''),
           passed:    true,
           runtime:   0.0
         )

data/lib/mutant/isolation/fork.rb

@@ -89,7 +89,7 @@ module Mutant
         def result
           Result.new(
             exception:      @exception,
-            log:            @log_fragments.join,
+            log:            LogCapture.from_binary(@log_fragments.join),
             process_status: @process_status,
             timeout:        @timeout,
             value:          @value
@@ -132,11 +132,7 @@ module Mutant
         def load_result(result_fragments)
           @value = world.marshal.load(result_fragments.join)
         rescue ArgumentError => exception
-          @exception = Exception.new(
-            backtrace:      exception.backtrace,
-            message:        exception.message,
-            original_class: exception.class
-          )
+          @exception = Mutant::Result::Exception.from_exception(exception)
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -197,7 +193,7 @@ module Mutant
         end
 
         def handle_status(status)
-          @process_status = status
+          @process_status = Mutant::Result::ProcessStatus.from_process_status(status)
         end
 
         def peek_child

data/lib/mutant/isolation/none.rb

@@ -23,7 +23,7 @@ module Mutant
 
         Result.new(
           exception:,
-          log:            '',
+          log:            LogCapture::String.new(content: ''),
           process_status: nil,
           timeout:        nil,
           value: