mutant 0.9.5 → 0.9.10

data/lib/mutant/config.rb

@@ -126,14 +126,6 @@ module Mutant
       end
     end
 
-    # Load contents of file
-    #
-    # @param [Pathname] path
-    #
-    # @return [Config]
-    #
-    # @raise [Either<String, Hash{Symbol => Object}>]
-    #   in case of config file error
     def self.load_contents(path)
       Transform::Named
         .new(path.to_s, TRANSFORM)

data/lib/mutant/context.rb

@@ -81,9 +81,6 @@ module Mutant
 
   private
 
-    # Nesting of names in scope
-    #
-    # @return [Array<String>]
     def name_nesting
       scope.name.split(NAMESPACE_DELIMITER)
     end

data/lib/mutant/env.rb

@@ -126,12 +126,6 @@ module Mutant
 
   private
 
-    # Kill mutation under isolation with integration
-    #
-    # @param [Mutation] mutation
-    # @param [Array<Test>] test
-    #
-    # @return [Result::Isolation]
     def run_mutation_tests(mutation, tests)
       config.isolation.call do
         result = mutation.insert(world.kernel)

data/lib/mutant/expression/method.rb

@@ -14,8 +14,8 @@ module Mutant
       private(*anima.attribute_names)
 
       MATCHERS = IceNine.deep_freeze(
-        '.' => Matcher::Methods::Singleton,
-        '#' => Matcher::Methods::Instance
+        '.' => [Matcher::Methods::Singleton, Matcher::Methods::Metaclass],
+        '#' => [Matcher::Methods::Instance]
       )
 
       METHOD_NAME_PATTERN = Regexp.union(
@@ -39,16 +39,16 @@ module Mutant
       #
       # @return [Matcher]
       def matcher
-        methods_matcher = MATCHERS.fetch(scope_symbol).new(scope)
+        matcher_candidates = MATCHERS.fetch(scope_symbol)
+          .map { |submatcher| submatcher.new(scope) }
+
+        methods_matcher = Matcher::Chain.new(matcher_candidates)
 
         Matcher::Filter.new(methods_matcher, ->(subject) { subject.expression.eql?(self) })
       end
 
     private
 
-      # Scope object
-      #
-      # @return [Class, Method]
       def scope
         Object.const_get(scope_name)
       end

data/lib/mutant/expression/methods.rb

@@ -13,8 +13,8 @@ module Mutant
       private(*anima.attribute_names)
 
       MATCHERS = IceNine.deep_freeze(
-        '.' => Matcher::Methods::Singleton,
-        '#' => Matcher::Methods::Instance
+        '.' => [Matcher::Methods::Singleton, Matcher::Methods::Metaclass],
+        '#' => [Matcher::Methods::Instance]
       )
       private_constant(*constants(false))
 
@@ -32,7 +32,10 @@ module Mutant
       #
       # @return [Matcher::Method]
       def matcher
-        MATCHERS.fetch(scope_symbol).new(scope)
+        matcher_candidates = MATCHERS.fetch(scope_symbol)
+          .map { |submatcher| submatcher.new(scope) }
+
+        Matcher::Chain.new(matcher_candidates)
       end
 
       # Length of match with other expression
@@ -50,9 +53,6 @@ module Mutant
 
     private
 
-      # Scope object
-      #
-      # @return [Class, Method]
       def scope
         Object.const_get(scope_name)
       end

data/lib/mutant/expression/parser.rb

@@ -28,12 +28,6 @@ module Mutant
 
     private
 
-      # Expressions parsed from input
-      #
-      # @param [String] input
-      #
-      # @return [Array<Expression>]
-      #   if expressions can be parsed from input
       def expressions(input)
         types.each_with_object([]) do |type, aggregate|
           expression = type.try_parse(input) and aggregate << expression

data/lib/mutant/integration.rb

@@ -32,14 +32,6 @@ module Mutant
         .fmap { |klass| klass.new(env.config).setup }
     end
 
-    # Attempt to require integration
-    #
-    # @param env [Bootstrap]
-    #
-    # @return [Either<String, undefined>]
-    #
-    # @api private
-    #
     # rubocop:disable Style/MultilineBlockChain
     def self.attempt_require(env)
       integration_name = env.config.integration
@@ -56,13 +48,6 @@ module Mutant
     private_class_method :attempt_require
     # rubocop:enable Style/MultilineBlockChain
 
-    # Attempt const get
-    #
-    # @param env [Boostrap]
-    #
-    # @return [Either<String, Class<Integration>>]
-    #
-    # @api private
     def self.attempt_const_get(env)
       integration_name = env.config.integration
       constant_name    = integration_name.capitalize
@@ -98,9 +83,6 @@ module Mutant
 
   private
 
-    # Expression parser
-    #
-    # @return [Expression::Parser]
     def expression_parser
       config.expression_parser
     end

data/lib/mutant/isolation/fork.rb

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

@@ -4,7 +4,7 @@ module Mutant
   module License
     NAME    = 'mutant-license'
     VERSION = '~> 0.1.0'
-    SLEEP   = 20
+    SLEEP   = 40
 
     UNLICENSED =
       IceNine.deep_freeze(
@@ -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