mutant 0.8.7 → 0.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f0d162e90a523f4f62c1f3541b1157fb78d6080
-  data.tar.gz: fa8dcc8abc2f6960ebd74a53711bf8e87ec0f32c
+  metadata.gz: d83617d43f73b49c391d1b7e8f3317a666297c83
+  data.tar.gz: 186b8ce58089718ba3cafa1c08f609b89941541e
 SHA512:
-  metadata.gz: 4c672d952620acf28cff4a26127a03facbc32c13bece89934b487433dc1fd2a918a76188fa0efe86588c7a480e8bf54383baa66eed869eeaf27752dce5ab313e
-  data.tar.gz: f3e533b36d8f52544523fbd81cda480a0653861106cf841420e11043a953c41a043e7a3b88fd8838629272d3bd960e76d22494bce9b7f014b10c67601d7a2c6e
+  metadata.gz: 3d4ee1e94a96ba909cf327bde6afdca8ff5e50f80603ca8835115fdba2abbfa05ad89897366908f8b64bca2e9302605e7accddf1167260c187cf4e40417d0df5
+  data.tar.gz: 7b599e22fa7ddd03e9f9ac91af9ce0e730b155c8df2b5ab1b5a67fc8cd62f8bf8972ca8df64b45fb5114a556e7416f3c86baf666ea62f5de5201e8b068406afc

data/Changelog.md

@@ -1,3 +1,8 @@
+# v0.8.8 2015-11-15
+
+* Add support for rspec-3.3.4
+* Add mutations/s performance metric to report
+
 # v0.8.7 2015-10-30
 
 * Fix blackliting regexp to correctly match the String `(eval)` absolutely.

data/README.md

@@ -73,6 +73,54 @@ To mutation test Rails models with rspec comment out ```require 'rspec/autorun'`
 RAILS_ENV=test bundle exec mutant -r ./config/environment --use rspec User
 ```
 
+Limitations
+-----------
+
+Mutant cannot emit mutations for...
+
+* methods defined within a closure.  For example, methods defined using `module_eval`, `class_eval`,
+  `define_method`, or `define_singleton_method`:
+
+    ```ruby
+    class Example
+      class_eval do
+        def example1
+        end
+      end
+
+      module_eval do
+        def example2
+        end
+      end
+
+      define_method(:example3) do
+      end
+
+      define_singleton_method(:example4) do
+      end
+    end
+    ```
+
+* singleton methods not defined on a constant or `self`
+
+    ```ruby
+    class Foo
+      def self.bar; end   # ok
+      def Foo.baz; end    # ok
+
+      myself = self
+      def myself.qux; end # cannot mutate
+    end
+    ```
+
+* methods defined with eval:
+
+    ```ruby
+    class Foo
+      class_eval('def bar; end') # cannot mutate
+    end
+    ```
+
 Mutation-Operators:
 -------------------
 
@@ -182,11 +230,24 @@ There are some presentations about mutant in the wild:
 * [eurucamp 2013](http://2013.eurucamp.org/) / FrOSCon-2013 http://slid.es/markusschirp/mutation-testing
 * [Cologne.rb](http://www.colognerb.de/topics/mutation-testing-mit-mutant) / https://github.com/DonSchado/colognerb-on-mutant/blob/master/mutation_testing_slides.pdf
 
-Blog-Posts
+Blog posts
 ----------
 
-* http://www.sitepoint.com/mutation-testing-mutant/
-* http://solnic.eu/2013/01/23/mutation-testing-with-mutant.html
+Sorted by recency:
+
+* [How to write better code using mutation testing (November 2015)][blockscore]
+* [How good are your Ruby tests? Testing your tests with mutant (June 2015)][arkency1]
+* [Mutation testing and continuous integration (May 2015)][arkency2]
+* [Why I want to introduce mutation testing to the `rails_event_store` gem (April 2015)][arkency3]
+* [Mutation testing with mutant (April 2014)][sitepoint]
+* [Mutation testing with mutant (January 2013)][solnic]
+
+[blockscore]: https://blog.blockscore.com/how-to-write-better-code-using-mutation-testing/
+[sitepoint]: http://www.sitepoint.com/mutation-testing-mutant/
+[arkency1]: http://blog.arkency.com/2015/06/how-good-are-your-ruby-tests-testing-your-tests-with-mutant/
+[arkency2]: http://blog.arkency.com/2015/05/mutation-testing-and-continuous-integration/
+[arkency3]: http://blog.arkency.com/2015/04/why-i-want-to-introduce-mutation-testing-to-the-rails-event-store-gem/  
+[solnic]: http://solnic.eu/2013/01/23/mutation-testing-with-mutant.html
 
 The Crash / Stuck Problem (MRI)
 -------------------------------

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 18
-total_score: 1253
+total_score: 1232

data/lib/mutant.rb

@@ -132,6 +132,7 @@ require 'mutant/mutator/node/match_current_line'
 require 'mutant/loader'
 require 'mutant/context'
 require 'mutant/context/scope'
+require 'mutant/scope'
 require 'mutant/subject'
 require 'mutant/subject/method'
 require 'mutant/subject/method/instance'
@@ -148,6 +149,7 @@ require 'mutant/matcher/namespace'
 require 'mutant/matcher/scope'
 require 'mutant/matcher/filter'
 require 'mutant/matcher/null'
+require 'mutant/matcher/static'
 require 'mutant/expression'
 require 'mutant/expression/parser'
 require 'mutant/expression/method'

data/lib/mutant/cli.rb

@@ -192,7 +192,7 @@ module Mutant
     #
     # @api private
     def with(attributes)
-      @config = @config.with(attributes)
+      @config = config.with(attributes)
     end
 
     # Add configuration

data/lib/mutant/env/bootstrap.rb

@@ -4,10 +4,18 @@ module Mutant
     class Bootstrap
       include Adamantium::Flat, Concord::Public.new(:config, :cache), Procto.call(:env)
 
-      SEMANTICS_MESSAGE =
-        "Fix your lib to follow normal ruby semantics!\n" \
+      SEMANTICS_MESSAGE_FORMAT =
+        "%<message>s. Fix your lib to follow normal ruby semantics!\n" \
         '{Module,Class}#name should return resolvable constant name as String or nil'.freeze
 
+      CLASS_NAME_RAISED_EXCEPTION =
+        '%<scope_class>s#name from: %<scope>s raised an error: %<exception>s'.freeze
+
+      CLASS_NAME_TYPE_MISMATCH_FORMAT =
+        '%<scope_class>s#name from: %<scope>s returned %<name>s'.freeze
+
+      private_constant(*constants(false))
+
       # Scopes that are eligible for matching
       #
       # @return [Enumerable<Matcher::Scope>]
@@ -84,7 +92,12 @@ module Mutant
       def scope_name(scope)
         scope.name
       rescue => exception
-        warn("#{scope.class}#name from: #{scope.inspect} raised an error: #{exception.inspect}. #{SEMANTICS_MESSAGE}")
+        semantics_warning(
+          CLASS_NAME_RAISED_EXCEPTION,
+          scope_class: scope.class,
+          scope:       scope,
+          exception:   exception.inspect
+        )
         nil
       end
 
@@ -95,7 +108,7 @@ module Mutant
       # @api private
       def infect
         config.includes.each(&$LOAD_PATH.method(:<<))
-        config.requires.each(&method(:require))
+        config.requires.each(&Kernel.method(:require))
         @integration = config.integration.new(config).setup
       end
 
@@ -105,7 +118,7 @@ module Mutant
       #
       # @api private
       def matched_subjects
-        Matcher::Compiler.call(self, config.matcher).to_a
+        Matcher::Compiler.call(config.matcher).call(self)
       end
 
       # Initialize matchable scopes
@@ -115,8 +128,8 @@ module Mutant
       # @api private
       def initialize_matchable_scopes
         scopes = ObjectSpace.each_object(Module).each_with_object([]) do |scope, aggregate|
-          expression = expression(scope)
-          aggregate << Matcher::Scope.new(self, scope, expression) if expression
+          expression = expression(scope) || next
+          aggregate << Scope.new(scope, expression)
         end
 
         @matchable_scopes = scopes.sort_by { |scope| scope.expression.syntax }
@@ -137,12 +150,27 @@ module Mutant
         name = scope_name(scope) or return
 
         unless name.instance_of?(String)
-          warn("#{scope.class}#name from: #{scope.inspect} returned #{name.inspect}. #{SEMANTICS_MESSAGE}")
+          semantics_warning(
+            CLASS_NAME_TYPE_MISMATCH_FORMAT,
+            scope_class: scope.class,
+            scope:       scope,
+            name:        name
+          )
           return
         end
 
         config.expression_parser.try_parse(name)
       end
+
+      # Write a semantics warning
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def semantics_warning(format, options)
+        message = format % options
+        warn(SEMANTICS_MESSAGE_FORMAT % { message: message })
+      end
     end # Boostrap
   end # Env
 end # Mutant

data/lib/mutant/expression/method.rb

@@ -32,15 +32,13 @@ module Mutant
 
       # Matcher for expression
       #
-      # @param [Env] env
-      #
       # @return [Matcher]
       #
       # @api private
-      def matcher(env)
-        methods_matcher = MATCHERS.fetch(scope_symbol).new(env, scope)
+      def matcher
+        methods_matcher = MATCHERS.fetch(scope_symbol).new(scope)
 
-        Matcher::Filter.build(methods_matcher) { |subject| subject.expression.eql?(self) }
+        Matcher::Filter.new(methods_matcher, ->(subject) { subject.expression.eql?(self) })
       end
 
     private

data/lib/mutant/expression/methods.rb

@@ -26,13 +26,11 @@ module Mutant
 
       # Matcher on expression
       #
-      # @param [Env] env
-      #
       # @return [Matcher::Method]
       #
       # @api private
-      def matcher(env)
-        MATCHERS.fetch(scope_symbol).new(env, scope)
+      def matcher
+        MATCHERS.fetch(scope_symbol).new(scope)
       end
 
       # Length of match with other expression

data/lib/mutant/expression/namespace.rb

@@ -35,13 +35,11 @@ module Mutant
 
         # Matcher for expression
         #
-        # @param [Env::Bootstrap] env
-        #
         # @return [Matcher]
         #
         # @api private
-        def matcher(env)
-          Matcher::Namespace.new(env, self)
+        def matcher
+          Matcher::Namespace.new(self)
         end
 
         # Length of match with other expression
@@ -71,13 +69,11 @@ module Mutant
 
         # Matcher matcher on expression
         #
-        # @param [Env::Bootstrap] env
-        #
         # @return [Matcher]
         #
         # @api private
-        def matcher(env)
-          Matcher::Scope.new(env, Object.const_get(scope_name), self)
+        def matcher
+          Matcher::Scope.new(Object.const_get(scope_name))
         end
 
         # Syntax for expression

data/lib/mutant/matcher.rb

@@ -1,30 +1,15 @@
 module Mutant
   # Abstract matcher to find subjects to mutate
   class Matcher
-    include Adamantium::Flat, Enumerable, AbstractType
+    include Adamantium::Flat, AbstractType
 
-    # Default matcher build implementation
+    # Call matcher
     #
     # @param [Env] env
-    # @param [Object] input
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def self.build(*arguments)
-      new(*arguments)
-    end
-
-    # Enumerate subjects
-    #
-    # @return [self]
-    #   if block given
     #
     # @return [Enumerable<Subject>]
-    #   otherwise
     #
-    # @api private
-    abstract_method :each
+    abstract_method :call
 
   end # Matcher
 end # Mutant

data/lib/mutant/matcher/chain.rb

@@ -1,26 +1,20 @@
 module Mutant
   class Matcher
-    # A chain of matchers
+    # Matcher chaining results of other matchers together
     class Chain < self
       include Concord.new(:matchers)
 
-      # Enumerate subjects
+      # Call matcher
       #
-      # @return [Enumerator<Subject]
-      #   if no block given
+      # @param [Env] env
       #
-      # @return [self]
-      #   otherwise
+      # @return [Enumerable<Subject>]
       #
       # @api private
-      def each(&block)
-        return to_enum unless block_given?
-
-        matchers.each do |matcher|
-          matcher.each(&block)
+      def call(env)
+        matchers.flat_map do |matcher|
+          matcher.call(env)
         end
-
-        self
       end
 
     end # Chain

data/lib/mutant/matcher/compiler.rb

@@ -3,7 +3,7 @@ module Mutant
 
     # Compiler for complex matchers
     class Compiler
-      include Concord.new(:env, :config), AST::Sexp, Procto.call(:result)
+      include Concord.new(:config), AST::Sexp, Procto.call(:result)
 
       # Generated matcher
       #
@@ -12,7 +12,7 @@ module Mutant
       # @api private
       def result
         Filter.new(
-          Chain.build(config.match_expressions.map(&method(:matcher))),
+          Chain.new(config.match_expressions.map(&:matcher)),
           Morpher::Evaluator::Predicate::Boolean::And.new(
             [
               ignored_subjects,
@@ -61,17 +61,6 @@ module Mutant
         Morpher::Evaluator::Predicate::Boolean::And.new(config.subject_filters)
       end
 
-      # Matcher for expression on env
-      #
-      # @param [Mutant::Expression] expression
-      #
-      # @return [Matcher]
-      #
-      # @api private
-      def matcher(expression)
-        expression.matcher(env)
-      end
-
     end # Compiler
   end # Matcher
 end # Mutant

data/lib/mutant/matcher/filter.rb

@@ -4,30 +4,17 @@ module Mutant
     class Filter < self
       include Concord.new(:matcher, :predicate)
 
-      # New matcher
-      #
-      # @param [Matcher] matcher
-      #
-      # @return [Matcher]
-      #
-      # @api private
-      def self.build(matcher, &predicate)
-        new(matcher, predicate)
-      end
-
       # Enumerate matches
       #
-      # @return [self]
-      #   if block given
+      # @param [Env] env
       #
-      # @return [Enumerator<Subject>]
-      #   otherwise
+      # @return [Enumerable<Subject>]
       #
       # @api private
-      def each(&block)
-        return to_enum unless block_given?
-        matcher.select(&predicate.method(:call)).each(&block)
-        self
+      def call(env)
+        matcher
+          .call(env)
+          .select(&predicate.method(:call))
       end
 
     end # Filter

data/lib/mutant/matcher/method.rb

@@ -1,133 +1,153 @@
 module Mutant
   class Matcher
-    # Matcher for subjects that are a specific method
+    # Abstract base class for method matchers
     class Method < self
-      include Adamantium::Flat, Concord::Public.new(:env, :scope, :target_method)
-      include AST::NodePredicates
+      include AbstractType,
+              Adamantium::Flat,
+              Concord::Public.new(:scope, :target_method, :evaluator)
 
       # Methods within rbx kernel directory are precompiled and their source
       # cannot be accessed via reading source location. Same for methods created by eval.
       BLACKLIST = %r{\A(kernel/|\(eval\)\z)}.freeze
 
-      # Enumerate matches
+      SOURCE_LOCATION_WARNING_FORMAT =
+        '%s does not have a valid source location, unable to emit subject'.freeze
+
+      CLOSURE_WARNING_FORMAT =
+        '%s is dynamically defined in a closure, unable to emit subject'.freeze
+
+      # Matched subjects
       #
-      # @return [Enumerable<Subject>]
-      #   if no block given
+      # @param [Env] env
       #
-      # @return [self]
-      #   otherwise
+      # @return [Enumerable<Subject>]
       #
       # @api private
-      def each
-        return to_enum unless block_given?
+      def call(env)
+        evaluator.call(scope, target_method, env)
+      end
+
+      # Abstract method match evaluator
+      #
+      # Present to avoid passing the env argument around in case the
+      # logic would be implemnented directly on the Matcher::Method
+      # instance
+      class Evaluator
+        include AbstractType,
+                Adamantium,
+                Concord.new(:scope, :target_method, :env),
+                Procto.call,
+                AST::NodePredicates
+
+        # Matched subjects
+        #
+        # @return [Enumerable<Subject>]
+        #
+        # @api private
+        def call
+          return EMPTY_ARRAY if skip?
 
-        if !skip? && subject
-          yield subject
+          [subject].compact
         end
 
-        self
-      end
+      private
 
-    private
+        # Test if method should be skipped
+        #
+        # @return [Truthy]
+        #
+        # @api private
+        def skip?
+          location = source_location
+          if location.nil? || BLACKLIST.match(location.first)
+            env.warn(SOURCE_LOCATION_WARNING_FORMAT % target_method)
+          elsif matched_node_path.any?(&method(:n_block?))
+            env.warn(CLOSURE_WARNING_FORMAT % target_method)
+          end
+        end
 
-      # Test if method should be skipped
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      def skip?
-        location = source_location
-        if location.nil? || BLACKLIST.match(location.first)
-          env.warn(format('%s does not have valid source location unable to emit subject', target_method.inspect))
-          true
-        elsif matched_node_path.any?(&method(:n_block?))
-          env.warn(format('%s is defined from a 3rd party lib unable to emit subject', target_method.inspect))
-          true
-        else
-          false
+        # Target method name
+        #
+        # @return [String]
+        #
+        # @api private
+        def method_name
+          target_method.name
         end
-      end
 
-      # Target method name
-      #
-      # @return [String]
-      #
-      # @api private
-      def method_name
-        target_method.name
-      end
+        # Target context
+        #
+        # @return [Context::Scope]
+        #
+        # @api private
+        def context
+          Context::Scope.new(scope, source_path)
+        end
 
-      # Target context
-      #
-      # @return [Context::Scope]
-      #
-      # @api private
-      def context
-        Context::Scope.new(scope, source_path)
-      end
+        # Root source node
+        #
+        # @return [Parser::AST::Node]
+        #
+        # @api private
+        def ast
+          env.cache.parse(source_path)
+        end
 
-      # Root source node
-      #
-      # @return [Parser::AST::Node]
-      #
-      # @api private
-      def ast
-        env.cache.parse(source_path)
-      end
+        # Path to source
+        #
+        # @return [Pathname]
+        #
+        # @api private
+        def source_path
+          Pathname.new(source_location.first)
+        end
+        memoize :source_path
 
-      # Path to source
-      #
-      # @return [Pathname]
-      #
-      # @api private
-      def source_path
-        Pathname.new(source_location.first)
-      end
-      memoize :source_path
+        # Source file line
+        #
+        # @return [Fixnum]
+        #
+        # @api private
+        def source_line
+          source_location.last
+        end
 
-      # Source file line
-      #
-      # @return [Fixnum]
-      #
-      # @api private
-      def source_line
-        source_location.last
-      end
+        # Full source location
+        #
+        # @return [Array{String,Fixnum}]
+        #
+        # @api private
+        def source_location
+          target_method.source_location
+        end
 
-      # Full source location
-      #
-      # @return [Array{String,Fixnum}]
-      #
-      # @api private
-      def source_location
-        target_method.source_location
-      end
+        # Matched subject
+        #
+        # @return [Subject]
+        #   if there is a matched node
+        #
+        # @return [nil]
+        #   otherwise
+        #
+        # @api private
+        def subject
+          node = matched_node_path.last || return
+          self.class::SUBJECT_CLASS.new(context, node)
+        end
+        memoize :subject
 
-      # Matched subject
-      #
-      # @return [Subject]
-      #   if there is a matched node
-      #
-      # @return [nil]
-      #   otherwise
-      #
-      # @api private
-      def subject
-        node = matched_node_path.last
-        return unless node
-        self.class::SUBJECT_CLASS.new(context, node)
-      end
-      memoize :subject
+        # Matched node path
+        #
+        # @return [Array<Parser::AST::Node>]
+        #
+        # @api private
+        def matched_node_path
+          AST.find_last_path(ast, &method(:match?))
+        end
+        memoize :matched_node_path
+      end # Evaluator
 
-      # Matched node path
-      #
-      # @return [Array<Parser::AST::Node>]
-      #
-      # @api private
-      def matched_node_path
-        AST.find_last_path(ast, &method(:match?))
-      end
-      memoize :matched_node_path
+      private_constant(*constants(false))
 
     end # Method
   end # Matcher