mutant 0.9.8 → 0.9.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ac360cb601cc521059ca91167f18898ca897a7c475244e122c2fa46c80213b6
-  data.tar.gz: 557f073ba78b87381f7a424b198df8a6450e16b2f4bf3b3863ba370aa4fe7207
+  metadata.gz: e6e6e125d0e2736934ed481945e35eada9a1b8fffaf05641a5410a2ed25b9b20
+  data.tar.gz: 13e2b48cbc500aab1ef792ccbaff86de593337f7213bdcf7d0d81afa21e7a641
 SHA512:
-  metadata.gz: d8375c95cab6deab2f6b460892e40c3922dc5adf2b2dc188f9a3ac459dfe5c5a453da543b4fb8f95e7596019989aca80cf01c66d49a3796ef678b3f48c30b136
-  data.tar.gz: 4dc79e273ef83112e0e4b2d4e6c74dd8f0bc0366537cb7efc5f71fbdd0a22a93ab29e8c7726c1a78224fc020a92b202eed2ab1ef9a534fd008f5a621779a7aa8
+  metadata.gz: 7a3bfbaffad39ee2bc7cf41a07c19031704c26c7d05ba9b3f07d59d3b82965311c0822aec10ab359570fc8c3d3235f36d461fbe39cddb6349997b2b8bd0fa5d3
+  data.tar.gz: a1caa7e5f3318001137239c613ddd50bdeabe981fa132f4e9e5a383019a24a53075da121b290e98dcb61c93a1900f79f8e1207ce7ac282d049b2af0351b26e64

data/.github/workflows/ci.yml

@@ -31,7 +31,7 @@ jobs:
   ruby-mutant:
     name: Mutation coverage
     runs-on: ${{ matrix.os }}
-    timeout-minutes: 5
+    timeout-minutes: 30
     strategy:
       fail-fast: false
       matrix:
@@ -47,7 +47,7 @@ jobs:
     - run: |
         gem install bundler
         bundle install
-    - run: bundle exec mutant --since HEAD~1 --zombie -- 'Mutant*'
+    - run: ./mutant.sh
   ruby-integration-minitest:
     name: Integration Minitest
     runs-on: ${{ matrix.os }}

data/Changelog.md

@@ -1,3 +1,9 @@
+# v0.9.9 2020-09-25
+
++ Add support for mutating methods inside eigenclasses `class <<`. [#1009](https://github.com/mbj/mutant/pull/1009)
+- Remove `<` -> `<=` and `>` -> `>=` mutations as non canonical. [#1020](https://github.com/mbj/mutant/pull/1020)
+- Remove `true` -> `nil` and `false` -> `nil` mutations as non canonical. [#1018](https://github.com/mbj/mutant/pull/1018)
+
 # v0.9.8 2020-08-02
 
 * Change to generic catch all node mutator. This allows better cross parser version compatibility.

data/README.md

@@ -7,31 +7,41 @@ mutant
 
 ## What is Mutant?
 
-Mutant is a mutation testing tool for Ruby. Mutation testing is a technique to verify semantic coverage of your code.
+An automated code review tool, with a side effect of producing semantic code coverage
+metrics.
 
-## Why do I want it?
+Think of mutant as an expert developer that simplifies your code while making sure that all tests pass.
 
-Mutant adds to your toolbox: Detection of uncovered semantics in your code.
-Coverage becomes a meaningful metric!
+That developer never has a bad day and is always ready to jump on your PR.
 
-On each detection of uncovered semantics you have the opportunity to:
+Each reported simplification signifies either:
 
-* Delete dead code, as you do not want the extra semantics not specified by the tests
-* Add (or improve a test) to cover the unwanted semantics.
-* Learn something new about the semantics of Ruby and your direct and indirect dependencies.
+A) A piece of code that does more than the tests ask for.
+   You can probably use the simplified version of the code. OR:
 
-## How Do I use it?
+B) If you have a reason to not take the simplified version as it violates a requirement:
+   There was no test that proves the extra requirement. Likely you are missing an
+   important test for that requirement.
 
-* Start with reading the [nomenclature](/docs/nomenclature.md) documentation.
+On extensive mutant use A) happens more often than B), which leads to overall less code enter
+your repository at higher confidence for both the author and the reviewer.
+
+BTW: Mutant is a mutation testing tool, which is a form of code coverage.
+But each reported uncovered mutation is actually a call to action, just like a flag in a code review
+would be.
+
+## Getting started:
+
+* Start with reading the [nomenclature](/docs/nomenclature.md). No way around that one, sorry.
 * Then select and setup your [integration](/docs/nomenclature.md#integration), also make sure
   you can reproduce the examples in the integration specific documentation.
-* Identify your preferred mutation testing strategy. It is recommended to start at the commit level,
-  to test only the code you had been touching. See the [incremental](#only-mutating-changed-code)
-  mutation testing documentation.
+* Use mutant during code reviews and on CI in [incremental](/docs/incremental.md) mode.
+* Do not merge code with new alive mutations. If you really must bypass:
+  Add the subjects with open problems to the ignored subjects.
 
 ## Ruby Versions
 
-Mutant currently only works on cRuby/MRI. Starting with version 2.5.x. It supports all syntax features upto and
+Mutant currently only works on cRuby/MRI. Starting with version 2.5.x. It supports all syntax features up to and
 including Ruby 2.6.
 
 Support for 2.7 syntax features is pending, see unparser issue: https://github.com/mbj/unparser/issues/129.
@@ -43,7 +53,7 @@ Mutant will work under Ruby 2.7 just fine, unless a 2.7 syntax feature is used.
 Mutant was recently transitioned commercial software, with a free usage plan for opensource projects.
 
 Commercial projects have to acquire a license per developer, with unlimited repositories
-per developer.
+per developer. CI usage for licensed developers is included.
 
 Opensource projects have to acquire their free license per repository.
 
@@ -65,22 +75,52 @@ The mutant license gem contains metadata that allows mutant to verify licensed u
 For commercial licenses mutant checks the git commit author or the configured git email
 to be in the set of licensed developers.
 
-For opensource licenses mutant checks the git remotes against the license whitelist.
+For opensource licenses mutant checks the git remotes against the licensed git repositories.
 This allows the project maintainer to sign up and not bother collaborators with the details.
 
-There are, apart from initial license gem installation, no remote interactions for
+There are, apart from initial license gem installation, no remote interaction for
 license validation.
 
-To inquire for license please contact [Markus Schirp](mailto:mbj@schirp-dso.com?subject=Mutant%20License).
+### Getting an Opensource license
+
+As stated above: Opensource projects of any kind are free to use mutant.
+
+Just mail [me](mailto:mbj@schirp-dso.com?subject=Mutant%20Opensource%20License): Please
+include:
+
+* Just the git remote URL of your repository. Repository can be anywhere, must not be on Github, just has to be public.
+
+I do not need any more details.
+
+### Getting a commercial license
+
+Mutant offers a per developer subscription a monthly plan for 30$, or an annual plan for 300$.
+
+Above 10 developer licensees per customer I'm open to negotiate more discounts.
+
+Should you want to procure a commercial mutant license please [mail me](mailto:mbj@schirp-dso.com?subject=Mutant%20Commercial%20License).
+
+Please include the following information:
+
+* Your invoice address, including your Tax ID (For EU customers VAT-ID is mandatory)
+* Per licensed user the git author email address as returned by `git config user.email`
+
+Also feel free to ask any other question I forgot to proactively answer here.
+
+#### Payment methods
+
+* For monthly subscriptions: Exclusively CC.
+* For annual subscriptions: CC (worldwide) or ACH (US) / SEPA (EU) wire transfer.
 
-### Pricing
+#### Pricing Why?
 
-Only relevant for commercial use.
+The idea is to charge 1$ per developer per day. Mutant reduces the time spend on code reviews.
 
-Mutant offers a subscription model under a monthly plan.
-Yearly prepayments with discounts are available.
+This time saved should be worth way more than the 1$ per day.
 
-For higher volumes different arrangements can be negotiated.
+If you think this is not true for your code base, either my claims are wrong our your use of mutant is wrong.
+I'd be happy to hear about your case as I'm certainly willing to help you in using mutant right, and in case
+I'm wrong I'd be happy to improve mutant to the point I'm right again.
 
 ## Topics
 

data/config/reek.yml

@@ -136,3 +136,4 @@ detectors:
     - Mutant::Reporter::CLI::Printer::StatusProgressive#object # False positive calls super
     - Mutant::Repository::Diff#tracks? # intentional, private
     - Mutant::Repository::Diff#within_working_directory? # intentional, private
+    - Mutant::AST::FindMetaclassContaining#include_exact? # intentional, private

data/lib/mutant.rb

@@ -51,6 +51,7 @@ require 'mutant/ast/types'
 require 'mutant/ast/nodes'
 require 'mutant/ast/named_children'
 require 'mutant/ast/node_predicates'
+require 'mutant/ast/find_metaclass_containing'
 require 'mutant/ast/meta'
 require 'mutant/ast/meta/send'
 require 'mutant/ast/meta/const'
@@ -112,6 +113,7 @@ require 'mutant/mutator/node/send/conditional'
 require 'mutant/mutator/node/send/attribute_assignment'
 require 'mutant/mutator/node/when'
 require 'mutant/mutator/node/class'
+require 'mutant/mutator/node/sclass'
 require 'mutant/mutator/node/define'
 require 'mutant/mutator/node/mlhs'
 require 'mutant/mutator/node/nthref'
@@ -134,11 +136,13 @@ require 'mutant/subject'
 require 'mutant/subject/method'
 require 'mutant/subject/method/instance'
 require 'mutant/subject/method/singleton'
+require 'mutant/subject/method/metaclass'
 require 'mutant/matcher'
 require 'mutant/matcher/config'
 require 'mutant/matcher/chain'
 require 'mutant/matcher/method'
 require 'mutant/matcher/method/singleton'
+require 'mutant/matcher/method/metaclass'
 require 'mutant/matcher/method/instance'
 require 'mutant/matcher/methods'
 require 'mutant/matcher/namespace'

data/lib/mutant/ast.rb

@@ -27,15 +27,6 @@ module Mutant
       path
     end
 
-    # Walk all ast nodes keeping track of path
-    #
-    # @param [Parser::AST::Node] root
-    # @param [Array<Parser::AST::Node>] stack
-    #
-    # @yield [Parser::AST::Node]
-    #   all nodes visited recursively including root
-    #
-    # @return [undefined]
     def self.walk(node, stack, &block)
       block.call(node, stack)
       node.children.grep(::Parser::AST::Node) do |child|

data/lib/mutant/ast/find_metaclass_containing.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    # Given an AST, finds the sclass that directly(-ish) contains the provided
+    # node.
+    # This won't match arbitrarily complex structures - it only searches the
+    # first level deep (no begins-in-begins, for example). This is in
+    # keeping with mutant generally not supporting 'weird' syntax.
+    # Descending into 'begin' nodes is supported because these are generated for
+    # the one-line syntax class << self; def foo; end
+    class FindMetaclassContaining
+      include NodePredicates, Concord.new(:root, :target), Procto.call
+
+      SCLASS_BODY_INDEX = 1
+
+      private_constant(*constants(false))
+
+      # Find metaclass node containing target node
+      #
+      # @return [Parser::AST::Node, nil]
+      #
+      # @api private
+      def call
+        AST.find_last_path(root) do |current|
+          next unless n_sclass?(current)
+
+          metaclass_of?(current)
+        end.last
+      end
+
+    private
+
+      def metaclass_of?(sclass)
+        body = sclass.children.fetch(SCLASS_BODY_INDEX)
+        body.equal?(target) || transparently_contains?(body)
+      end
+
+      def transparently_contains?(body)
+        n_begin?(body) && include_exact?(body.children, target)
+      end
+
+      def include_exact?(haystack, needle)
+        haystack.any? { |elem| elem.equal?(needle) }
+      end
+    end
+  end
+end

data/lib/mutant/ast/meta/send.rb

@@ -56,16 +56,10 @@ module Mutant
 
       private
 
-        # Test if node is `proc { ... }`
-        #
-        # @return [Boolean]
         def naked_proc?
           !receiver && selector.equal?(:proc)
         end
 
-        # Test if node is `Proc.new { ... }`
-        #
-        # @return [Boolean]
         def proc_new?
           receiver                &&
             selector.equal?(:new) &&

data/lib/mutant/bootstrap.rb

@@ -49,9 +49,6 @@ module Mutant
     end
     # rubocop:enable Metrics/MethodLength
 
-    # Infect environment
-    #
-    # @return [undefined]
     def self.infect(env)
       config, world = env.config, env.world
 
@@ -60,12 +57,6 @@ module Mutant
     end
     private_class_method :infect
 
-    # Matchable scopes
-    #
-    # @param [World] world
-    # @param [Config] config
-    #
-    # @return [Array<Scope>]
     def self.matchable_scopes(world, config)
       scopes = world.object_space.each_object(Module).each_with_object([]) do |scope, aggregate|
         expression = expression(config.reporter, config.expression_parser, scope) || next
@@ -76,15 +67,6 @@ module Mutant
     end
     private_class_method :matchable_scopes
 
-    # Scope name from scoping object
-    #
-    # @param [Class, Module] scope
-    #
-    # @return [String]
-    #   if scope has a name and does not raise exceptions obtaining it
-    #
-    # @return [nil]
-    #   otherwise
     def self.scope_name(reporter, scope)
       scope.name
     rescue => exception
@@ -99,20 +81,7 @@ module Mutant
     end
     private_class_method :scope_name
 
-    # Try to turn scope into expression
-    #
-    # @param [Expression::Parser] expression_parser
-    # @param [Class, Module] scope
-    #
-    # @return [Expression]
-    #   if scope can be represented in an expression
-    #
-    # @return [nil]
-    #   otherwise
-    #
     # rubocop:disable Metrics/MethodLength
-    #
-    # ignore :reek:LongParameterList
     def self.expression(reporter, expression_parser, scope)
       name = scope_name(reporter, scope) or return
 
@@ -132,11 +101,6 @@ module Mutant
     private_class_method :expression
     # rubocop:enable Metrics/MethodLength
 
-    # Write a semantics warning
-    #
-    # @return [undefined]
-    #
-    # ignore :reek:LongParameterList
     def self.semantics_warning(reporter, format, options)
       reporter.warn(SEMANTICS_MESSAGE_FORMAT % { message: format % options })
     end

data/lib/mutant/cli.rb

@@ -88,23 +88,12 @@ module Mutant
 
   private
 
-    # Parse matchers
-    #
-    # @param [Array<String>] expressions
-    #
-    # @return [undefined]
     def parse_match_expressions(expressions)
       expressions.each do |expression|
         add_matcher(:match_expressions, config.expression_parser.apply(expression).from_right)
       end
     end
 
-    # Add environmental options
-    #
-    # @param [Object] opts
-    #
-    # @return [undefined]
-    #
     # rubocop:disable Metrics/MethodLength
     def add_environment_options(opts)
       opts.separator('Environment:')
@@ -121,12 +110,8 @@ module Mutant
         with(jobs: Integer(number))
       end
     end
+    # rubocop:enable Metrics/MethodLength
 
-    # Add mutation options
-    #
-    # @param [OptionParser] opts
-    #
-    # @return [undefined]
     def add_mutation_options(opts)
       opts.separator(nil)
       opts.separator('Options:')
@@ -136,11 +121,7 @@ module Mutant
       end
     end
 
-    # Add filter options
-    #
-    # @param [OptionParser] opts
-    #
-    # @return [undefined]
+    # rubocop:disable Metrics/MethodLength
     def add_filter_options(opts)
       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)
@@ -154,12 +135,9 @@ module Mutant
         )
       end
     end
+    # rubocop:enable Metrics/MethodLength
 
-    # Add debug options
-    #
-    # @param [OptionParser] opts
-    #
-    # @return [undefined]
+    # rubocop:disable Metrics/MethodLength
     def add_debug_options(opts)
       opts.on('--fail-fast', 'Fail fast') do
         with(fail_fast: true)
@@ -173,38 +151,16 @@ module Mutant
         world.kernel.exit
       end
     end
+    # rubocop:enable Metrics/MethodLength
 
-    # With configuration
-    #
-    # @param [Hash<Symbol, Object>] attributes
-    #
-    # @return [undefined]
     def with(attributes)
       @config = config.with(attributes)
     end
 
-    # Add configuration
-    #
-    # @param [Symbol] attribute
-    #   the attribute to add to
-    #
-    # @param [Object] value
-    #   the value to add
-    #
-    # @return [undefined]
     def add(attribute, value)
       with(attribute => config.public_send(attribute) + [value])
     end
 
-    # Add matcher configuration
-    #
-    # @param [Symbol] attribute
-    #   the attribute to add to
-    #
-    # @param [Object] value
-    #   the value to add
-    #
-    # @return [undefined]
     def add_matcher(attribute, value)
       with(matcher: config.matcher.add(attribute, value))
     end