mutant 0.9.8 → 0.9.9

data/lib/mutant/matcher/method/metaclass.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Matcher
+    class Method
+      # Matcher for metaclass methods
+      # i.e. ones defined using class << self or class << CONSTANT. It might??
+      # work for methods defined like class << obj, but I don't think the
+      # plumbing will be in place in the subject for that to work
+      class Metaclass < self
+
+        # New singleton method matcher
+        #
+        # @param [Class, Module] scope
+        # @param [Symbol] method_name
+        #
+        # @return [Matcher::Method::Singleton]
+        def self.new(scope, method_name)
+          super(scope, method_name, Evaluator)
+        end
+
+        # Metaclass method evaluator
+        class Evaluator < Evaluator
+          # Terminology note: the "receiver" is the `self` in `class << self`
+          SUBJECT_CLASS         = Subject::Method::Metaclass
+          NAME_INDEX            = 0
+          CONST_NAME_INDEX      = 1
+          SCLASS_RECEIVER_INDEX = 0
+          RECEIVER_WARNING      = 'Can only match :def inside :sclass on ' \
+                                  ':self or :const, got :sclass on %p ' \
+                                  'unable to match'
+
+        private
+
+          def match?(node)
+            n_def?(node) &&
+              name?(node) &&
+              line?(node) &&
+              metaclass_receiver?(node)
+          end
+
+          def metaclass_receiver?(node)
+            candidate = metaclass_containing(node)
+            candidate && metaclass_target?(candidate)
+          end
+
+          def metaclass_containing(node)
+            AST::FindMetaclassContaining.call(ast, node)
+          end
+
+          def line?(node)
+            node
+              .location
+              .line
+              .equal?(source_line)
+          end
+
+          def name?(node)
+            node.children.fetch(NAME_INDEX).equal?(method_name)
+          end
+
+          def metaclass_target?(node)
+            receiver = node.children.fetch(SCLASS_RECEIVER_INDEX)
+            case receiver.type
+            when :self
+              true
+            when :const
+              sclass_const_name?(receiver)
+            else
+              env.warn(RECEIVER_WARNING % receiver.type)
+              nil
+            end
+          end
+
+          def sclass_const_name?(node)
+            name = node.children.fetch(CONST_NAME_INDEX)
+            name.to_s.eql?(context.unqualified_name)
+          end
+
+        end # Evaluator
+
+        private_constant(*constants(false))
+      end # Singleton
+    end # Method
+  end # Matcher
+end # Mutant

data/lib/mutant/matcher/method/singleton.rb

@@ -25,20 +25,10 @@ module Mutant
 
         private
 
-          # Test for node match
-          #
-          # @param [Parser::AST::Node] node
-          #
-          # @return [Boolean]
           def match?(node)
             n_defs?(node) && line?(node) && name?(node) && receiver?(node)
           end
 
-          # Test for line match
-          #
-          # @param [Parser::AST::Node] node
-          #
-          # @return [Boolean]
           def line?(node)
             node
               .location
@@ -46,20 +36,10 @@ module Mutant
               .equal?(source_line)
           end
 
-          # Test for name match
-          #
-          # @param [Parser::AST::Node] node
-          #
-          # @return [Boolean]
           def name?(node)
             node.children.fetch(NAME_INDEX).equal?(method_name)
           end
 
-          # Test for receiver match
-          #
-          # @param [Parser::AST::Node] node
-          #
-          # @return [Boolean]
           def receiver?(node)
             receiver = node.children.fetch(RECEIVER_INDEX)
             case receiver.type
@@ -73,11 +53,6 @@ module Mutant
             end
           end
 
-          # Test if receiver name matches context
-          #
-          # @param [Parser::AST::Node] node
-          #
-          # @return [Boolean]
           def receiver_name?(node)
             name = node.children.fetch(NAME_INDEX)
             name.to_s.eql?(context.unqualified_name)

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/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