mutant 0.9.8 → 0.9.13

data/lib/mutant/matcher/methods.rb

@@ -27,16 +27,10 @@ module Mutant
 
     private
 
-      # method matcher class
-      #
-      # @return [Class:Matcher::Method]
       def matcher
         self.class::MATCHER
       end
 
-      # Available methods scope
-      #
-      # @return [Enumerable<Method, UnboundMethod>]
       def methods
         candidate_names.each_with_object([]) do |name, methods|
           method = access(name)
@@ -45,9 +39,6 @@ module Mutant
       end
       memoize :methods
 
-      # Candidate method names on target scope
-      #
-      # @return [Enumerable<Symbol>]
       def candidate_names
         CANDIDATE_NAMES
           .map(&candidate_scope.method(:public_send))
@@ -55,10 +46,8 @@ module Mutant
           .sort
       end
 
-      # Candidate scope
-      #
-      # @return [Class, Module]
       abstract_method :candidate_scope
+      private :candidate_scope
 
       # Matcher for singleton methods
       class Singleton < self
@@ -66,18 +55,10 @@ module Mutant
 
       private
 
-        # Method object on scope
-        #
-        # @param [Symbol] method_name
-        #
-        # @return [Method]
         def access(method_name)
           scope.method(method_name)
         end
 
-        # Candidate scope
-        #
-        # @return [Class]
         def candidate_scope
           scope.singleton_class
         end
@@ -85,24 +66,32 @@ module Mutant
 
       end # Singleton
 
+      # Matcher for metaclass methods
+      class Metaclass < self
+        MATCHER = Matcher::Method::Metaclass
+
+      private
+
+        def access(method_name)
+          scope.method(method_name)
+        end
+
+        def candidate_scope
+          scope.singleton_class
+        end
+        memoize :candidate_scope, freezer: :noop
+      end # Metaclass
+
       # Matcher for instance methods
       class Instance < self
         MATCHER = Matcher::Method::Instance
 
       private
 
-        # Method object on scope
-        #
-        # @param [Symbol] method_name
-        #
-        # @return [UnboundMethod]
         def access(method_name)
           scope.instance_method(method_name)
         end
 
-        # Candidate scope
-        #
-        # @return [Class, Module]
         def candidate_scope
           scope
         end

data/lib/mutant/matcher/namespace.rb

@@ -19,22 +19,12 @@ module Mutant
 
     private
 
-      # The matched scopes
-      #
-      # @param [Env] env
-      #
-      # @return [Enumerable<Scope>]
       def matched_scopes(env)
         env
           .matchable_scopes
           .select(&method(:match?))
       end
 
-      # Test scope if matches expression
-      #
-      # @param [Scope] scope
-      #
-      # @return [Boolean]
       def match?(scope)
         expression.prefix?(scope.expression)
       end

data/lib/mutant/matcher/scope.rb

@@ -13,7 +13,8 @@ module Mutant
 
       MATCHERS = [
         Matcher::Methods::Singleton,
-        Matcher::Methods::Instance
+        Matcher::Methods::Instance,
+        Matcher::Methods::Metaclass
       ].freeze
 
       private_constant(*constants(false))
@@ -29,9 +30,6 @@ module Mutant
 
     private
 
-      # Effective matchers
-      #
-      # @return [Enumerable<Matcher>]
       def effective_matchers
         MATCHERS.map { |matcher| matcher.new(scope) }
       end

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

@@ -49,21 +49,11 @@ module Mutant
 
       private
 
-        # Set original source
-        #
-        # @param [String,Parser::AST::Node] input
-        #
-        # @return [undefined]
         def source(input)
           fail 'source already defined' if @node
           @node = node(input)
         end
 
-        # Add expected mutation
-        #
-        # @param [String,Parser::AST::Node] input
-        #
-        # @return [undefined]
         def mutation(input)
           node = node(input)
           if @expected.include?(node)
@@ -72,22 +62,11 @@ module Mutant
           @expected << node
         end
 
-        # Add singleton mutations
-        #
-        # @return [undefined]
         def singleton_mutations
           mutation('nil')
           mutation('self')
         end
 
-        # Helper method to coerce input to node
-        #
-        # @param [String,Parser::AST::Node] input
-        #
-        # @return [Parser::AST::Node]
-        #
-        # @raise [RuntimeError]
-        #   in case input cannot be coerced
         def node(input)
           case input
           when String

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

@@ -35,9 +35,6 @@ module Mutant
 
       private
 
-        # Unexpected mutations
-        #
-        # @return [Array<Mutation>]
         def unexpected
           mutations.reject do |mutation|
             example.expected.include?(mutation.node)
@@ -45,9 +42,6 @@ module Mutant
         end
         memoize :unexpected
 
-        # Missing mutations
-        #
-        # @return [Array<Mutation>]
         def missing
           (example.expected - mutations.map(&:node)).map do |node|
             Mutation::Evil.new(self, node)
@@ -55,9 +49,6 @@ module Mutant
         end
         memoize :missing
 
-        # Mutations that generated invalid syntax
-        #
-        # @return [Enumerable<Mutation>]
         def invalid_syntax
           mutations.reject do |mutation|
             ::Parser::CurrentRuby.parse(mutation.source)
@@ -66,19 +57,11 @@ module Mutant
         end
         memoize :invalid_syntax
 
-        # Mutations with no diff to original
-        #
-        # @return [Enumerable<Mutation>]
         def no_diffs
           mutations.select { |mutation| mutation.source.eql?(example.source) }
         end
         memoize :no_diffs
 
-        # Mutation report
-        #
-        # @param [Array<Mutation>] mutations
-        #
-        # @return [Array<Hash>]
         def format_mutations(mutations)
           mutations.map do |mutation|
             {
@@ -88,9 +71,6 @@ module Mutant
           end
         end
 
-        # No diff mutation report
-        #
-        # @return [Array, nil]
         def no_diff_report
           no_diffs.map do |mutation|
             {

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)

data/lib/mutant/mutation.rb

@@ -74,9 +74,6 @@ module Mutant
 
   private
 
-    # SHA1 sum of source and subject identification
-    #
-    # @return [String]
     def sha1
       Digest::SHA1.hexdigest(subject.identification + CODE_DELIMITER + source)
     end

data/lib/mutant/mutator.rb

@@ -18,9 +18,6 @@ module Mutant
       self::REGISTRY.lookup(node.type).call(node, parent)
     end
 
-    # Register node class handler
-    #
-    # @return [undefined]
     def self.handle(*types)
       types.each do |type|
         self::REGISTRY.register(type, self)
@@ -35,13 +32,6 @@ module Mutant
 
   private
 
-    # Initialize object
-    #
-    # @param [Object] input
-    # @param [Object] parent
-    # @param [#call(node)] block
-    #
-    # @return [undefined]
     def initialize(_input, _parent = nil)
       super
 
@@ -50,41 +40,23 @@ module Mutant
       dispatch
     end
 
-    # Test if generated object is not guarded from emitting
-    #
-    # @param [Object] object
-    #
-    # @return [Boolean]
     def new?(object)
       !object.eql?(input)
     end
 
-    # Dispatch node generations
-    #
-    # @return [undefined]
     abstract_method :dispatch
+    private :dispatch
 
-    # Emit generated mutation if object is not equivalent to input
-    #
-    # @param [Object] object
-    #
-    # @return [undefined]
     def emit(object)
       return unless new?(object)
 
       output << object
     end
 
-    # Run input with mutator
-    #
-    # @return [undefined]
     def run(mutator)
       mutator.call(input).each(&method(:emit))
     end
 
-    # Shortcut to create a new unfrozen duplicate of input
-    #
-    # @return [Object]
     def dup_input
       input.dup
     end

data/lib/mutant/mutator/node.rb

@@ -34,21 +34,9 @@ module Mutant
 
     private
 
-      # Node to mutate
-      #
-      # @return [Parser::AST::Node]
-      alias_method :node, :input
-
-      # Duplicate of original
-      #
-      # @return [Parser::AST::Node]
+      alias_method :node,     :input
       alias_method :dup_node, :dup_input
 
-      # Dispatch on child index
-      #
-      # @param [Integer] index
-      #
-      # @return [undefined]
       def mutate_child(index, &block)
         block ||= TAUTOLOGY
         Mutator.mutate(children.fetch(index), self).each do |mutation|
@@ -57,108 +45,55 @@ module Mutant
         end
       end
 
-      # Emit delete child mutation
-      #
-      # @param [Integer] index
-      #
-      # @return [undefined]
       def delete_child(index)
         dup_children = children.dup
         dup_children.delete_at(index)
         emit_type(*dup_children)
       end
 
-      # Emit updated child
-      #
-      # @param [Integer] index
-      # @param [Parser::AST::Node] node
-      #
-      # @return [undefined]
       def emit_child_update(index, node)
         new_children = children.dup
         new_children[index] = node
         emit_type(*new_children)
       end
 
-      # Emit a new AST node with same class as wrapped node
-      #
-      # @param [Array<Parser::AST::Node>] children
-      #
-      # @return [undefined]
       def emit_type(*children)
         emit(::Parser::AST::Node.new(node.type, children))
       end
 
-      # Emit propagation if node can stand alone
-      #
-      # @return [undefined]
       def emit_propagation(node)
         emit(node) unless AST::Types::NOT_STANDALONE.include?(node.type)
       end
 
-      # Emit singleton literals
-      #
-      # @return [undefined]
       def emit_singletons
         emit_nil
         emit_self
       end
 
-      # Emit a literal self
-      #
-      # @return [undefined]
       def emit_self
         emit(N_SELF)
       end
 
-      # Emit a literal nil
-      #
-      # @return [undefined]
       def emit_nil
         emit(N_NIL) unless left_assignment?
       end
 
-      # Parent node
-      #
-      # @return [Parser::AST::Node] node
-      #   if parent with node is present
-      #
-      # @return [nil]
-      #   otherwise
       def parent_node
         parent&.node
       end
 
-      # Parent type
-      #
-      # @return [Symbol] type
-      #   if parent with type is present
-      #
-      # @return [nil]
-      #   otherwise
       def parent_type
         parent_node&.type
       end
 
-      # Test if the node is the left of an or_asgn or op_asgn
-      #
-      # @return [Boolean]
       def left_assignment?
         AST::Types::OP_ASSIGN.include?(parent_type) && parent.node.children.first.equal?(node)
       end
 
-      # Children indices
-      #
-      # @param [Range] range
-      #
-      # @return [Enumerable<Integer>]
       def children_indices(range)
         range.begin.upto(children.length + range.end)
       end
 
-      # Emit single child mutation
-      #
-      # @return [undefined]
       def mutate_single_child
         children.each_with_index do |child, index|
           mutate_child(index)