mutant 0.9.9 → 0.9.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6e6e125d0e2736934ed481945e35eada9a1b8fffaf05641a5410a2ed25b9b20
-  data.tar.gz: 13e2b48cbc500aab1ef792ccbaff86de593337f7213bdcf7d0d81afa21e7a641
+  metadata.gz: 3e92dbf6cbb84cf8d3d5354fc5994cb1ad7cb1fb1364b1927aa89abeedcd0cef
+  data.tar.gz: 5c49178b6766424d6ded707a100ebad86cf9c5403a53b2c2c750baf69b4d636f
 SHA512:
-  metadata.gz: 7a3bfbaffad39ee2bc7cf41a07c19031704c26c7d05ba9b3f07d59d3b82965311c0822aec10ab359570fc8c3d3235f36d461fbe39cddb6349997b2b8bd0fa5d3
-  data.tar.gz: a1caa7e5f3318001137239c613ddd50bdeabe981fa132f4e9e5a383019a24a53075da121b290e98dcb61c93a1900f79f8e1207ce7ac282d049b2af0351b26e64
+  metadata.gz: e786a6ed55abf722515f3b4b9c08200dac35557e48c27430ae5683471ededf67d1fcb17ff4e5f57f1881765d10f3a8b00ef2993f163a1cceb93531d4b75a37e3
+  data.tar.gz: 2a5840a2ecc0ca7c9c6156e8c4596b21808aaf8418ecf134fff9ada56a6c20e94b5ece60a0ebf0b321f1ed51ff0e5c92d26069bcb9473f61276973c46780eb5d

data/lib/mutant.rb

@@ -90,8 +90,7 @@ require 'mutant/mutator/node/arguments'
 require 'mutant/mutator/node/begin'
 require 'mutant/mutator/node/binary'
 require 'mutant/mutator/node/const'
-require 'mutant/mutator/node/dstr'
-require 'mutant/mutator/node/dsym'
+require 'mutant/mutator/node/dynamic_literal'
 require 'mutant/mutator/node/kwbegin'
 require 'mutant/mutator/node/named_value/access'
 require 'mutant/mutator/node/named_value/constant_assignment'
@@ -120,6 +119,7 @@ require 'mutant/mutator/node/nthref'
 require 'mutant/mutator/node/masgn'
 require 'mutant/mutator/node/return'
 require 'mutant/mutator/node/block'
+require 'mutant/mutator/node/block_pass'
 require 'mutant/mutator/node/if'
 require 'mutant/mutator/node/case'
 require 'mutant/mutator/node/splat'
@@ -165,8 +165,6 @@ require 'mutant/selector/expression'
 require 'mutant/selector/null'
 require 'mutant/config'
 require 'mutant/cli'
-require 'mutant/color'
-require 'mutant/diff'
 require 'mutant/runner'
 require 'mutant/runner/sink'
 require 'mutant/result'

data/lib/mutant/bootstrap.rb

@@ -36,7 +36,7 @@ module Mutant
         .tap(&method(:infect))
         .with(matchable_scopes: matchable_scopes(world, config))
 
-      subjects = Matcher.from_config(env.config.matcher).call(env)
+      subjects = start_subject(env, Matcher.from_config(env.config.matcher).call(env))
 
       Integration.setup(env).fmap do |integration|
         env.with(
@@ -49,6 +49,19 @@ module Mutant
     end
     # rubocop:enable Metrics/MethodLength
 
+    def self.start_subject(env, subjects)
+      start_expressions = env.config.matcher.start_expressions
+
+      return subjects if start_expressions.empty?
+
+      subjects.drop_while do |subject|
+        start_expressions.none? do |expression|
+          expression.prefix?(subject.expression)
+        end
+      end
+    end
+    private_class_method :start_subject
+
     def self.infect(env)
       config, world = env.config, env.world
 

data/lib/mutant/cli.rb

@@ -2,6 +2,8 @@
 
 module Mutant
   # Commandline parser / runner
+  #
+  # rubocop:disable Metrics/ClassLength
   class CLI
     include Concord.new(:world, :config)
 
@@ -126,6 +128,9 @@ module Mutant
       opts.on('--ignore-subject EXPRESSION', 'Ignore subjects that match EXPRESSION as prefix') do |pattern|
         add_matcher(:ignore_expressions, config.expression_parser.apply(pattern).from_right)
       end
+      opts.on('--start-subject EXPRESSION', 'Start mutation testing at a specific subject') do |pattern|
+        add_matcher(:start_expressions, config.expression_parser.apply(pattern).from_right)
+      end
       opts.on('--since REVISION', 'Only select subjects touched since REVISION') do |revision|
         add_matcher(
           :subject_filters,
@@ -165,4 +170,5 @@ module Mutant
       with(matcher: config.matcher.add(attribute, value))
     end
   end # CLI
+  # rubocop:enable Metrics/ClassLength
 end # Mutant

data/lib/mutant/isolation.rb

@@ -40,7 +40,7 @@ module Mutant
         instance_of?(Success)
       end
 
-      # Succesful result producing value
+      # Successful result producing value
       class Success < self
         include Concord::Public.new(:value, :log)
 

data/lib/mutant/isolation/fork.rb

@@ -10,12 +10,12 @@ module Mutant
 
       ATTRIBUTES = %i[block log_pipe result_pipe world].freeze
 
-      # Unsucessful result as child exited nonzero
+      # Unsuccessful result as child exited nonzero
       class ChildError < Result
         include Concord::Public.new(:value, :log)
       end # ChildError
 
-      # Unsucessful result as fork failed
+      # Unsuccessful result as fork failed
       class ForkError < Result
         include Equalizer.new
       end # ForkError

data/lib/mutant/isolation/none.rb

@@ -3,7 +3,7 @@
 module Mutant
   # Module providing isolation
   class Isolation
-    # Absolutly no isolation
+    # Absolutely no isolation
     #
     # Only useful for debugging.
     class None < self

data/lib/mutant/matcher/config.rb

@@ -7,6 +7,7 @@ module Mutant
       include Adamantium, Anima.new(
         :ignore_expressions,
         :match_expressions,
+        :start_expressions,
         :subject_filters
       )
 
@@ -18,6 +19,7 @@ module Mutant
       PRESENTATIONS       = IceNine.deep_freeze(
         ignore_expressions: :syntax,
         match_expressions:  :syntax,
+        start_expressions:  :syntax,
         subject_filters:    :inspect
       )
       private_constant(*constants(false))

data/lib/mutant/meta/example.rb

@@ -3,7 +3,19 @@
 module Mutant
   module Meta
     class Example
-      include Adamantium, Anima.new(:file, :node, :types, :expected)
+      include Adamantium
+      include Anima.new(
+        :expected,
+        :file,
+        :lvars,
+        :node,
+        :original_source,
+        :types
+      )
+
+      class Expected
+        include Anima.new(:original_source, :node)
+      end
 
       # Verification instance for example
       #
@@ -13,13 +25,13 @@ module Mutant
       end
       memoize :verification
 
-      # Normalized source
+      # Original source as generated by unparser
       #
       # @return [String]
-      def source
+      def original_source_generated
         Unparser.unparse(node)
       end
-      memoize :source
+      memoize :original_source_generated
 
       # Generated mutations on example source
       #

data/lib/mutant/meta/example/dsl.rb

@@ -25,10 +25,11 @@ module Mutant
         #
         # @return [undefined]
         def initialize(file, types)
+          @expected = []
           @file     = file
+          @lvars    = []
+          @source   = nil
           @types    = types
-          @node     = nil
-          @expected = []
         end
 
         # Example captured by DSL
@@ -38,28 +39,41 @@ module Mutant
         # @raise [RuntimeError]
         #   in case example cannot be build
         def example
-          fail 'source not defined' unless @node
+          fail 'source not defined' unless @source
           Example.new(
-            file:     @file,
-            node:     @node,
-            types:    @types,
-            expected: @expected
+            expected:        @expected,
+            file:            @file,
+            lvars:           @lvars,
+            node:            @node,
+            original_source: @source,
+            types:           @types
           )
         end
 
+        # Declare a local variable
+        #
+        # @param [Symbol]
+        def declare_lvar(name)
+          @lvars << name
+        end
+
       private
 
         def source(input)
-          fail 'source already defined' if @node
-          @node = node(input)
+          fail 'source already defined' if @source
+
+          @source = input
+          @node   = node(input)
         end
 
         def mutation(input)
-          node = node(input)
-          if @expected.include?(node)
+          expected = Expected.new(original_source: input, node: node(input))
+
+          if @expected.include?(expected)
             fail "Mutation for input: #{input.inspect} is already expected"
           end
-          @expected << node
+
+          @expected << expected
         end
 
         def singleton_mutations
@@ -70,14 +84,17 @@ module Mutant
         def node(input)
           case input
           when String
-            Unparser::Preprocessor.run(Unparser.parse(input))
-          when ::Parser::AST::Node
-            input
+            parser.parse(Unparser.buffer(input))
           else
-            fail "Cannot coerce to node: #{input.inspect}"
+            fail "Unsupported input: #{input.inspect}"
           end
         end
 
+        def parser
+          Unparser.parser.tap do |parser|
+            @lvars.each(&parser.static_env.public_method(:declare))
+          end
+        end
       end # DSL
     end # Example
   end # Meta

data/lib/mutant/meta/example/verification.rb

@@ -11,54 +11,96 @@ module Mutant
         #
         # @return [Boolean]
         def success?
-          [missing, unexpected, no_diffs, invalid_syntax].all?(&:empty?)
+          [
+            original_verification,
+            invalid,
+            missing,
+            no_diffs,
+            unexpected
+          ].all?(&:empty?)
         end
         memoize :success?
 
-        # Error report
-        #
-        # @return [String]
         def error_report
-          fail 'no error report on successful validation' if success?
-
-          YAML.dump(
-            'file'            => example.file,
-            'original_ast'    => example.node.inspect,
-            'original_source' => example.source,
-            'missing'         => format_mutations(missing),
-            'unexpected'      => format_mutations(unexpected),
-            'invalid_syntax'  => format_mutations(invalid_syntax),
-            'no_diff'         => no_diff_report
-          )
+          reports.join("\n")
         end
-        memoize :error_report
 
       private
 
+        def reports
+          reports = [example.file]
+          reports.concat(original)
+          reports.concat(original_verification)
+          reports.concat(make_report('Missing mutations:', missing))
+          reports.concat(make_report('Unexpected mutations:', unexpected))
+          reports.concat(make_report('No-Diff mutations:', no_diffs))
+          reports.concat(invalid)
+        end
+
+        def make_report(label, mutations)
+          if mutations.any?
+            [label, mutations.map(&method(:report_mutation))]
+          else
+            []
+          end
+        end
+
+        def report_mutation(mutation)
+          [
+            mutation.node.inspect,
+            mutation.source
+          ]
+        end
+
+        def original
+          [
+            'Original:',
+            example.node,
+            example.original_source
+          ]
+        end
+
+        def original_verification
+          validation = Unparser::Validation.from_string(example.original_source)
+          if validation.success?
+            []
+          else
+            [
+              prefix('[original]', validation.report)
+            ]
+          end
+        end
+
+        def prefix(prefix, string)
+          string.each_line.map do |line|
+            "#{prefix} #{line}"
+          end.join
+        end
+
+        def invalid
+          mutations.each_with_object([]) do |mutation, aggregate|
+            validation = Unparser::Validation.from_node(mutation.node)
+            aggregate << prefix('[invalid-mutation]', validation.report) unless validation.success?
+          end
+        end
+        memoize :invalid
+
         def unexpected
           mutations.reject do |mutation|
-            example.expected.include?(mutation.node)
+            example.expected.any? { |expected| expected.node.eql?(mutation.node) }
           end
         end
         memoize :unexpected
 
         def missing
-          (example.expected - mutations.map(&:node)).map do |node|
-            Mutation::Evil.new(self, node)
+          (example.expected.map(&:node) - mutations.map(&:node)).map do |node|
+            Mutation::Evil.new(nil, node)
           end
         end
         memoize :missing
 
-        def invalid_syntax
-          mutations.reject do |mutation|
-            ::Parser::CurrentRuby.parse(mutation.source)
-          rescue ::Parser::SyntaxError # rubocop:disable Lint/SuppressedException
-          end
-        end
-        memoize :invalid_syntax
-
         def no_diffs
-          mutations.select { |mutation| mutation.source.eql?(example.source) }
+          mutations.select { |mutation| mutation.source.eql?(example.original_source_generated) }
         end
         memoize :no_diffs
 

data/lib/mutant/minitest/coverage.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'minitest'
+
+module Mutant
+  module Minitest
+    module Coverage
+      # Setup coverage declaration for current class
+      #
+      # @param [String]
+      #
+      # @example
+      #
+      #   class MyTest < MiniTest::Test
+      #     cover 'MyCode*'
+      #
+      #     def test_some_stuff
+      #     end
+      #   end
+      #
+      # @api public
+      def cover(expression)
+        if defined?(@cover_expression)
+          fail "#{self} already declares to cover: #{@cover_expression.inspect}"
+        end
+
+        @cover_expression = expression
+      end
+
+      # Effective coverage expression
+      #
+      # @return [String, nil]
+      #
+      # @api private
+      def resolve_cover_expression
+        return @cover_expression if defined?(@cover_expression)
+
+        try_superclass_cover_expression
+      end
+
+    private
+
+      def try_superclass_cover_expression
+        return if superclass.equal?(::Minitest::Runnable)
+
+        superclass.resolve_cover_expression
+      end
+
+    end # Coverage
+  end # Minitest
+end # Mutant
+
+Minitest::Test.extend(Mutant::Minitest::Coverage)