mutant 0.10.14 → 0.10.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83c9b5421a7599da7222232827794b8ed437de3ef3c0044ed904dfb998a86285
-  data.tar.gz: 5ad4553f547c8ffbda6ea025a42526696d721654a88b08d1a2a3b372220c2d33
+  metadata.gz: f4950653df0e159b7d178e4770ad8ecf03994f1d08c99e4ba3589d9d76131840
+  data.tar.gz: 143ea75408ac2d9e6fda64e44e4ee1172317a716e593150df323ef6005f04598
 SHA512:
-  metadata.gz: 4563bb628a8848d55ba0caa2d53ca060f9976d138864811eae84692faa2ab03f3364afc8475a7d8e8ff51457be5033c5d49edb1e34bd90d9f25ae0a0f22ff9a3
-  data.tar.gz: bdd237ce6278db78cebc94e665ef69192c4bb0ddf06ec8f0d1806e8bd9c13b7a2e3ce1eccbbf260c6b3c7974207c4557b0197ed6f3499aed86e340aa88df3dbb
+  metadata.gz: efc662d1906386fbbbf011cabebd4d88450169237680c64e52e2e2432dd22f0ae6dc6a0cecddebf0357932b4520be0ec5e4a3aa63cf0734b9d8f0e47d5b8d5b4
+  data.tar.gz: d0d84126e2bd05e9d6a8b4360821eb4473049f92ac7b7257286b92e48b8c9e1d428ba8bbb7f708e19590c065aa415b1928f58fd50ebeb6ac5decc568afb90b32

data/bin/mutant

@@ -28,12 +28,14 @@ status =
         .call(Kernel),
       root_require:     'mutant',
       includes:         %w[
-        mutant
-        unparser
         adamantium
-        equalizer
         anima
         concord
+        equalizer
+        mprelude
+        mutant
+        unparser
+        variable
       ]
     )
 

data/lib/mutant.rb

@@ -171,6 +171,7 @@ require 'mutant/cli/command/subscription'
 require 'mutant/cli/command/environment'
 require 'mutant/cli/command/environment/run'
 require 'mutant/cli/command/environment/show'
+require 'mutant/cli/command/environment/subject'
 require 'mutant/cli/command/root'
 require 'mutant/runner'
 require 'mutant/runner/sink'
@@ -245,4 +246,17 @@ module Mutant
       zombie:            false
     )
   end # Config
+
+  # Traverse values against action
+  #
+  # Specialized to Either. Its *always* traverse.
+  def self.traverse(action, values)
+    Either::Right.new(
+      values.map do |value|
+        action.call(value).from_right do |error|
+          return Either::Left.new(error)
+        end
+      end
+    )
+  end
 end # Mutant

data/lib/mutant/bootstrap.rb

@@ -30,7 +30,7 @@ module Mutant
     # @return [Either<String, Env>]
     #
     # rubocop:disable Metrics/MethodLength
-    def self.apply(world, config)
+    def self.call(world, config)
       env = Env
         .empty(world, config)
         .tap(&method(:infect))
@@ -109,7 +109,7 @@ module Mutant
         return
       end
 
-      expression_parser.apply(name).from_right {}
+      expression_parser.call(name).from_right {}
     end
     private_class_method :expression
     # rubocop:enable Metrics/MethodLength

data/lib/mutant/cli/command.rb

@@ -75,6 +75,18 @@ module Mutant
         self.class::SUBCOMMANDS
       end
 
+      def execute
+        action.either(
+          method(:fail_message),
+          ->(_) { true }
+        )
+      end
+
+      def fail_message(message)
+        world.stderr.puts(message)
+        false
+      end
+
       def parser
         OptionParser.new do |parser|
           parser.banner = "usage: #{banner}"

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

@@ -25,7 +25,7 @@ module Mutant
         def bootstrap
           Config.load_config_file(world)
             .fmap(&method(:expand))
-            .bind { Bootstrap.apply(world, @config) }
+            .bind { Bootstrap.call(world, @config) }
         end
 
         def expand(file_config)
@@ -33,23 +33,13 @@ module Mutant
         end
 
         def parse_remaining_arguments(arguments)
-          traverse(@config.expression_parser.public_method(:apply), arguments)
+          Mutant.traverse(@config.expression_parser, arguments)
             .fmap do |match_expressions|
               matcher(match_expressions: match_expressions)
               self
             end
         end
 
-        def traverse(action, values)
-          Either::Right.new(
-            values.map do |value|
-              action.call(value).from_right do |error|
-                return Either::Left.new(error)
-              end
-            end
-          )
-        end
-
         def set(**attributes)
           @config = @config.with(attributes)
         end
@@ -92,10 +82,10 @@ module Mutant
           parser.separator('Matcher:')
 
           parser.on('--ignore-subject EXPRESSION', 'Ignore subjects that match EXPRESSION as prefix') do |pattern|
-            add_matcher(:ignore_expressions, @config.expression_parser.apply(pattern).from_right)
+            add_matcher(:ignore_expressions, @config.expression_parser.call(pattern).from_right)
           end
           parser.on('--start-subject EXPRESSION', 'Start mutation testing at a specific subject') do |pattern|
-            add_matcher(:start_expressions, @config.expression_parser.apply(pattern).from_right)
+            add_matcher(:start_expressions, @config.expression_parser.call(pattern).from_right)
           end
           parser.on('--since REVISION', 'Only select subjects touched since REVISION') do |revision|
             add_matcher(

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

@@ -25,12 +25,19 @@ module Mutant
 
         private
 
-          def execute
-            soft_fail(License.apply(world))
+          def action
+            soft_fail(License.call(world))
               .bind { bootstrap }
-              .bind(&Runner.public_method(:apply))
-              .from_right { |error| world.stderr.puts(error); return false }
-              .success?
+              .bind(&Runner.public_method(:call))
+              .bind(&method(:from_result))
+          end
+
+          def from_result(result)
+            if result.success?
+              Either::Right.new(nil)
+            else
+              Either::Left.new('Uncovered mutations detected, exiting nonzero!')
+            end
           end
 
           def soft_fail(result)

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

@@ -11,12 +11,8 @@ module Mutant
 
         private
 
-          def execute
-            Config.load_config_file(world)
-              .fmap(&method(:expand))
-              .bind { Bootstrap.apply(world, @config) }
-              .fmap(&method(:report_env))
-              .right?
+          def action
+            bootstrap.fmap(&method(:report_env))
           end
 
           def report_env(env)

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Mutant
+  module CLI
+    class Command
+      class Environment
+        class Subject < self
+          NAME              = 'subject'
+          SHORT_DESCRIPTION = 'Subject subcommands'
+
+          class List < self
+            NAME              = 'list'
+            SHORT_DESCRIPTION = 'List subjects'
+            SUBCOMMANDS       = EMPTY_ARRAY
+
+          private
+
+            def action
+              bootstrap.fmap(&method(:list_subjects))
+            end
+
+            def list_subjects(env)
+              print('Subjects in environment: %d' % env.subjects.length)
+              env.subjects.each do |subject|
+                print(subject.expression.syntax)
+              end
+            end
+
+            def print(message)
+              world.stdout.puts(message)
+            end
+          end
+
+          SUBCOMMANDS = [List].freeze
+        end # Subject
+      end # Environment
+    end # Command
+  end # CLI
+end # Mutant

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

@@ -4,7 +4,7 @@ module Mutant
   module CLI
     class Command
       class Environment < self
-        SUBCOMMANDS = [Environment::Show].freeze
+        SUBCOMMANDS = [Environment::Subject, Environment::Show].freeze
       end # Environment
 
       class Root < self

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

@@ -10,7 +10,7 @@ module Mutant
       private
 
         def license
-          License.apply(world)
+          License.call(world)
         end
 
         class Test < self

data/lib/mutant/expression.rb

@@ -55,9 +55,14 @@ module Mutant
     #   otherwise
     def self.try_parse(input)
       match = self::REGEXP.match(input)
-      return unless match
+      from_match(match) if match
+    end
+
+    def self.from_match(match)
       names = anima.attribute_names
-      new(Hash[names.zip(names.map(&match.method(:[])))])
+      new(Hash[names.zip(names.map(&match.public_method(:[])))])
     end
+    private_class_method :from_match
+
   end # Expression
 end # Mutant

data/lib/mutant/expression/method.rb

@@ -5,6 +5,8 @@ module Mutant
 
     # Explicit method expression
     class Method < self
+      extend AST::Sexp
+
       include Anima.new(
         :method_name,
         :scope_name,
@@ -18,10 +20,7 @@ module Mutant
         '#' => [Matcher::Methods::Instance]
       )
 
-      METHOD_NAME_PATTERN = Regexp.union(
-        /(?<method_name>[A-Za-z_][A-Za-z\d_]*[!?=]?)/,
-        *AST::Types::OPERATOR_METHODS.map(&:to_s)
-      ).freeze
+      METHOD_NAME_PATTERN = /(?<method_name>.+)/.freeze
 
       private_constant(*constants(false))
 
@@ -47,6 +46,30 @@ module Mutant
         Matcher::Filter.new(methods_matcher, ->(subject) { subject.expression.eql?(self) })
       end
 
+      def self.try_parse(input)
+        match = REGEXP.match(input) or return
+
+        from_match(match) if valid_method_name?(match[:method_name])
+      end
+
+      # Test if string is a valid Ruby method name
+      #
+      # Note that this crazyness is indeed the "correct" solution.
+      #
+      # See: https://github.com/whitequark/parser/issues/213
+      #
+      # @param [String]
+      #
+      # @return [Boolean]
+      def self.valid_method_name?(name)
+        buffer = ::Parser::Source::Buffer.new(nil, source: "def #{name}; end")
+
+        ::Parser::CurrentRuby
+          .new
+          .parse(buffer).eql?(s(:def, name.to_sym, s(:args), nil))
+      end
+      private_class_method :valid_method_name?
+
     private
 
       def scope

data/lib/mutant/expression/namespace.rb

@@ -67,7 +67,13 @@ module Mutant
         #
         # @return [Matcher]
         def matcher
-          Matcher::Scope.new(Object.const_get(scope_name))
+          scope = find_scope
+
+          if scope
+            Matcher::Scope.new(scope)
+          else
+            Matcher::Null.new
+          end
         end
 
         # Syntax for expression
@@ -76,6 +82,13 @@ module Mutant
         alias_method :syntax, :scope_name
         public :syntax
 
+      private
+
+        def find_scope
+          Object.const_get(scope_name)
+        rescue NameError # rubocop:disable Lint/SuppressedException
+        end
+
       end # Exact
     end # Namespace
   end # Expression

data/lib/mutant/expression/parser.rb

@@ -5,7 +5,7 @@ module Mutant
     class Parser
       include Concord.new(:types)
 
-      # Apply expression parsing
+      # Parse expression
       #
       # @param [String] input
       #
@@ -14,7 +14,7 @@ module Mutant
       #
       # @return [nil]
       #   otherwise
-      def apply(input)
+      def call(input)
         expressions = expressions(input)
         case expressions.length
         when 0

data/lib/mutant/isolation/fork.rb

@@ -64,6 +64,7 @@ module Mutant
         end
       end # Pipe
 
+      # rubocop:disable Metrics/ClassLength
       class Parent
         include(
           Anima.new(*ATTRIBUTES),
@@ -149,17 +150,26 @@ module Mutant
 
             break unless ready
 
-            ready.each do |fd|
-              if fd.eof?
-                targets.delete(fd)
+            ready.each do |target|
+              if target.eof?
+                targets.delete(target)
               else
-                targets.fetch(fd) << fd.read_nonblock(READ_SIZE)
+                read_fragment(target, targets.fetch(target))
               end
             end
           end
         end
         # rubocop:enable Metrics/MethodLength
 
+        def read_fragment(target, fragments)
+          loop do
+            result = target.read_nonblock(READ_SIZE, exception: false)
+            break unless result.instance_of?(String)
+            fragments << result
+            break if result.bytesize < READ_SIZE
+          end
+        end
+
         # rubocop:disable Metrics/MethodLength
         def terminate_graceful
           status = nil
@@ -199,6 +209,7 @@ module Mutant
           @result = defined?(@result) ? @result.add_error(result) : result
         end
       end # Parent
+      # rubocop:enable Metrics/ClassLength
 
       class Child
         include(

data/lib/mutant/license.rb

@@ -12,7 +12,7 @@ module Mutant
     # @return [Either<String,Subscription>]
     #
     # @api private
-    def self.apply(world)
+    def self.call(world)
       load_mutant_license(world)
         .fmap { license_path(world) }
         .bind { |path| Subscription.load(world, world.json.load(path)) }

data/lib/mutant/license/subscription.rb

@@ -30,7 +30,7 @@ module Mutant
           'oss' => Opensource
         }.fetch(value.fetch('type'))
           .from_json(value.fetch('contents'))
-          .apply(world)
+          .call(world)
       end
 
       # Subscription self description

data/lib/mutant/license/subscription/commercial.rb

@@ -15,7 +15,7 @@ module Mutant
           new(value.fetch('authors').map(&Author.public_method(:new)).to_set)
         end
 
-        def apply(world)
+        def call(world)
           candidates = candidates(world)
 
           if (licensed & candidates).any?

data/lib/mutant/license/subscription/opensource.rb

@@ -50,7 +50,7 @@ module Mutant
           )
         end
 
-        def apply(world)
+        def call(world)
           world
             .capture_stdout(%w[git remote --verbose])
             .fmap(&method(:parse_remotes))

data/lib/mutant/mutation.rb

@@ -9,34 +9,37 @@ module Mutant
     CODE_DELIMITER = "\0"
     CODE_RANGE     = (0..4).freeze
 
-    def initialize(subject, node)
-      super(subject, node)
-
-      @source         = Unparser.unparse(node)
-      @code           = sha1[CODE_RANGE]
-      @identification = "#{self.class::SYMBOL}:#{subject.identification}:#{code}"
-      @monkeypatch    = Unparser.unparse(subject.context.root(node))
-    end
-
     # Mutation identification code
     #
     # @return [String]
-    attr_reader :code
+    def code
+      sha1[CODE_RANGE]
+    end
+    memoize :code
 
     # Normalized mutation source
     #
     # @return [String]
-    attr_reader :source
+    def source
+      Unparser.unparse(node)
+    end
+    memoize :source
 
     # Identification string
     #
     # @return [String]
-    attr_reader :identification
+    def identification
+      "#{self.class::SYMBOL}:#{subject.identification}:#{code}"
+    end
+    memoize :identification
 
     # The monkeypatch to insert the mutation
     #
     # @return [String]
-    attr_reader :monkeypatch
+    def monkeypatch
+      Unparser.unparse(subject.context.root(node))
+    end
+    memoize :monkeypatch
 
     # Normalized original source
     #

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

@@ -13,10 +13,19 @@ module Mutant
       private
 
         def dispatch
-          emit_singletons
-          emit(N_TRUE)
+          emit(N_NIL)
+          emit_instance_variable_mutation
+        end
+
+        def emit_instance_variable_mutation
+          return unless n_ivar?(expression)
+
+          instance_variable_name = Mutant::Util.one(expression.children)
 
-          emit_expression_mutations { |node| !n_self?(node) }
+          emit(
+            s(:send, nil, :instance_variable_defined?,
+              s(:sym, instance_variable_name))
+          )
         end
 
       end # Defined

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

@@ -4,12 +4,6 @@ module Mutant
   class Mutator
     class Node
       class ProcargZero < self
-        MAP = {
-          ::Parser::AST::Node => :emit_argument_node_mutations,
-          Symbol              => :emit_argument_symbol_mutations
-        }.freeze
-
-        private_constant(*constants(false))
 
         handle :procarg0
 

data/lib/mutant/repository/diff.rb

@@ -23,39 +23,55 @@ module Mutant
       #   when git command failed
       def touches?(path, line_range)
         touched_paths
+          .from_right { |message| fail Error, message }
           .fetch(path) { return false }
           .touches?(line_range)
       end
 
     private
 
-      # rubocop:disable Metrics/MethodLength
+      def repository_root
+        world
+          .capture_stdout(%w[git rev-parse --show-toplevel])
+          .fmap(&:chomp)
+          .fmap(&world.pathname.public_method(:new))
+      end
+
       def touched_paths
-        pathname = world.pathname
-        work_dir = pathname.pwd
+        repository_root.bind(&method(:diff_index))
+      end
+      memoize :touched_paths
 
+      def diff_index(root)
         world
           .capture_stdout(%W[git diff-index #{to}])
-          .from_right
-          .lines
-          .map do |line|
-            path = parse_line(work_dir, line)
-            [path.path, path]
+          .fmap(&:lines)
+          .bind do |lines|
+            Mutant
+              .traverse(->(line) { parse_line(root, line) }, lines)
+              .fmap do |paths|
+                paths.map { |path| [path.path, path] }.to_h
+              end
           end
-          .to_h
       end
-      memoize :touched_paths
-      # rubocop:enable Metrics/MethodLength
-
-      def parse_line(work_dir, line)
-        match = FORMAT.match(line) or fail Error, "Invalid git diff-index line: #{line}"
 
-        Path.new(
-          path:  work_dir.join(match.captures.first),
-          to:    to,
-          world: world
-        )
+      # rubocop:disable Metrics/MethodLength
+      def parse_line(root, line)
+        match = FORMAT.match(line)
+
+        if match
+          Either::Right.new(
+            Path.new(
+              path:  root.join(match.captures.first),
+              to:    to,
+              world: world
+            )
+          )
+        else
+          Either::Left.new("Invalid git diff-index line: #{line}")
+        end
       end
+      # rubocop:enable Metrics/MethodLength
 
       # Path touched by a diff
       class Path

data/lib/mutant/runner.rb

@@ -6,7 +6,7 @@ module Mutant
     # Run against env
     #
     # @return [Either<String, Result>]
-    def self.apply(env)
+    def self.call(env)
       reporter(env).start(env)
 
       Either::Right.new(run_mutation_analysis(env))

data/lib/mutant/version.rb

@@ -2,5 +2,5 @@
 
 module Mutant
   # Current mutant version
-  VERSION = '0.10.14'
+  VERSION = '0.10.19'
 end # Mutant

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mutant
 version: !ruby/object:Gem::Version
-  version: 0.10.14
+  version: 0.10.19
 platform: ruby
 authors:
 - Markus Schirp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-04 00:00:00.000000000 Z
+date: 2020-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abstract_type
@@ -307,6 +307,7 @@ files:
 - lib/mutant/cli/command/environment.rb
 - lib/mutant/cli/command/environment/run.rb
 - lib/mutant/cli/command/environment/show.rb
+- lib/mutant/cli/command/environment/subject.rb
 - lib/mutant/cli/command/root.rb
 - lib/mutant/cli/command/subscription.rb
 - lib/mutant/config.rb