mutant 0.9.7 → 0.9.12

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
@@ -73,9 +73,6 @@ module Mutant
 
       private
 
-        # Start child process
-        #
-        # @return [Integer]
         def start_child
           world.process.fork do
             Child.call(
@@ -87,12 +84,6 @@ module Mutant
           end
         end
 
-        # Read child result
-        #
-        # @param [Integer] pid
-        #
-        # @return [undefined]
-        #
         # rubocop:disable Metrics/MethodLength
         def read_child_result(pid)
           result_fragments = []
@@ -115,11 +106,6 @@ module Mutant
         end
         # rubocop:enable Metrics/MethodLength
 
-        # Read fragments
-        #
-        # @param [Hash{FD => Array<String}] targets
-        #
-        # @return [undefined]
         def read_fragments(targets)
           until targets.empty?
             ready, = world.io.select(targets.keys)
@@ -134,11 +120,6 @@ module Mutant
           end
         end
 
-        # Wait for child process
-        #
-        # @param [Integer] pid
-        #
-        # @return [undefined]
         def wait_child(pid, log_fragments)
           _pid, status = world.process.wait2(pid)
 
@@ -147,9 +128,6 @@ module Mutant
           end
         end
 
-        # Add a result
-        #
-        # @param [Result]
         def add_result(result)
           @result = defined?(@result) ? @result.add_error(result) : result
         end

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/license.rb

@@ -43,6 +43,8 @@ module Mutant
     def self.load_mutant_license(world)
       Either
         .wrap_error(LoadError) { world.gem_method.call(NAME, VERSION) }
+        .lmap(&:message)
+        .lmap(&method(:check_for_rubygems_mutant_license))
         .lmap(&method(:unlicensed))
     end
 
@@ -50,6 +52,15 @@ module Mutant
       "[Mutant-License-Error]: #{message}"
     end
 
+    def self.check_for_rubygems_mutant_license(message)
+      if message.include?('already activated mutant-license-0.0.0')
+        'mutant-license gem from rubygems.org is a dummy'
+      else
+        message
+      end
+    end
+    private_class_method :check_for_rubygems_mutant_license
+
     def self.license_path(world)
       world
         .pathname

data/lib/mutant/matcher.rb

@@ -25,25 +25,11 @@ module Mutant
       )
     end
 
-    # Test if subject is allowed do
-    #
-    # @param [Config] config
-    # @param [Subject] subject
-    #
-    # @return [Boolean]
     def self.allowed_subject?(config, subject)
       select_subject?(config, subject) && !ignore_subject?(config, subject)
     end
     private_class_method :allowed_subject?
 
-    # Predicate that tests for selected subject
-    #
-    # @param [Config] config
-    # @param [Subject] subject
-    #
-    # @return [Boolean]
-    #
-    # @api private
     def self.select_subject?(config, subject)
       config.subject_filters.all? { |filter| filter.call(subject) }
     end

data/lib/mutant/matcher/config.rb

@@ -44,16 +44,10 @@ module Mutant
 
     private
 
-      # Present attributes
-      #
-      # @return [Array<Symbol>]
       def present_attributes
         to_h.reject { |_key, value| value.empty? }.keys
       end
 
-      # Formatted attributes
-      #
-      # @return [String]
       def inspect_attributes
         attributes = present_attributes
           .map(&method(:format_attribute))
@@ -62,11 +56,6 @@ module Mutant
         attributes.empty? ? EMPTY_ATTRIBUTES : attributes
       end
 
-      # Format attribute
-      #
-      # @param [Symbol] attribute_name
-      #
-      # @return [String]
       def format_attribute(attribute_name)
         ATTRIBUTE_FORMAT %
           [

data/lib/mutant/matcher/method.rb

@@ -49,9 +49,6 @@ module Mutant
 
       private
 
-        # Test if method should be skipped
-        #
-        # @return [Truthy]
         def skip?
           location = source_location
           if location.nil? || BLACKLIST.include?(location.first)
@@ -61,56 +58,31 @@ module Mutant
           end
         end
 
-        # Target method name
-        #
-        # @return [String]
         def method_name
           target_method.name
         end
 
-        # Target context
-        #
-        # @return [Context]
         def context
           Context.new(scope, source_path)
         end
 
-        # Root source node
-        #
-        # @return [Parser::AST::Node]
         def ast
           env.parser.call(source_path)
         end
 
-        # Path to source
-        #
-        # @return [Pathname]
         def source_path
           env.world.pathname.new(source_location.first)
         end
         memoize :source_path
 
-        # Source file line
-        #
-        # @return [Integer]
         def source_line
           source_location.last
         end
 
-        # Full source location
-        #
-        # @return [Array{String,Integer}]
         def source_location
           target_method.source_location
         end
 
-        # Matched subject
-        #
-        # @return [Subject]
-        #   if there is a matched node
-        #
-        # @return [nil]
-        #   otherwise
         def subject
           node = matched_node_path.last || return
 
@@ -122,9 +94,6 @@ module Mutant
         end
         memoize :subject
 
-        # Matched node path
-        #
-        # @return [Array<Parser::AST::Node>]
         def matched_node_path
           AST.find_last_path(ast, &method(:match?))
         end

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

@@ -33,11 +33,6 @@ module Mutant
 
         private
 
-          # Check if node is matched
-          #
-          # @param [Parser::AST::Node] node
-          #
-          # @return [Boolean]
           def match?(node)
             n_def?(node)                           &&
             node.location.line.equal?(source_line) &&
@@ -50,9 +45,6 @@ module Mutant
 
           private
 
-            # Source location
-            #
-            # @return [Array{String,Integer}]
             def source_location
               scope
                 .unmemoized_instance_method(method_name)

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