mutant 0.11.27 → 0.11.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 594919332bf75ff59d19206e356cc568d4b59c859dd2d6eccc459805e3445cf3
-  data.tar.gz: c8e919b4826b6596c51ce26c8ca2eda5ff19e50bc1e8ff785b48ab479e6ad42f
+  metadata.gz: 3e57360ec50ffdef54f132f4764c940caad83a2d3692ac812b95c236cd8ff52d
+  data.tar.gz: cc69f0948238d888f569caeee901dc9197b620a3693474323a0959212d73fc30
 SHA512:
-  metadata.gz: e0e91da3e7ed933633c00ba849f502df74bff6407afaed8f2f7bfe167efb4d100bf89eac7ea4f7cf3872a2b257a0093d0c359956f01ea4365f870fd1ce731132
-  data.tar.gz: ed1f39b700889360dd049edd5dc00391fc978b7be64cf3f0662e890d39a9b8b1b2001f6df3291b3760e9866f48efc32b344b84ded8d94921ad12a29e089bc748
+  metadata.gz: cf4a364cc90b650a6c9dff90b38fb22aaa54d62f98f3b85ae732894a112f89a72b7c6e81b25fdd051b4436e8b55c58203fa4645a1c471cd5745fd665c7f0418b
+  data.tar.gz: 27a2195e3cd277816e37970fbbf66ed3d4f5237d9be667345229a9739deebaa45366914c71ce41254b7e0a65ea3e40af6012ddf4f8d654164d5eab904345dcf0

data/lib/mutant/ast.rb

@@ -8,12 +8,12 @@ module Mutant
     )
 
     class View
-      include Adamantium, Anima.new(:node, :path)
+      include Adamantium, Anima.new(:node, :stack)
     end
 
     def on_line(line)
-      line_map.fetch(line, EMPTY_HASH).map do |node, path|
-        View.new(node: node, path: path)
+      line_map.fetch(line, EMPTY_HASH).map do |node, stack|
+        View.new(node: node, stack: stack)
       end
     end
 
@@ -22,21 +22,20 @@ module Mutant
     def line_map
       line_map = {}
 
-      walk_path(node) do |node, path|
+      walk_path(node, []) do |node, stack|
         expression = node.location.expression || next
-        (line_map[expression.line] ||= []) << [node, path]
+        (line_map[expression.line] ||= []) << [node, stack]
       end
 
       line_map
     end
     memoize :line_map
 
-    def walk_path(node, stack = [node.type], &block)
-      block.call(node, stack.dup)
+    def walk_path(node, stack, &block)
+      block.call(node, stack)
+      stack = [*stack, node]
       node.children.grep(::Parser::AST::Node) do |child|
-        stack.push(child.type)
         walk_path(child, stack, &block)
-        stack.pop
       end
     end
   end # AST

data/lib/mutant/bootstrap.rb

@@ -20,7 +20,7 @@ module Mutant
       '%<scope_class>s#name from: %<scope>s raised an error: %<exception>s'
 
     CLASS_NAME_TYPE_MISMATCH_FORMAT =
-      '%<scope_class>s#name from: %<scope>s returned %<name>s'
+      '%<scope_class>s#name from: %<raw_scope>s returned %<name>s'
 
     private_constant(*constants(false))
 
@@ -47,6 +47,32 @@ module Mutant
           selected_subjects.flat_map(&:mutations)
         end
 
+        setup_integration(
+          env:               env,
+          mutations:         mutations,
+          selected_subjects: selected_subjects
+        )
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Run test only bootstrap
+    #
+    # @param [Env] env
+    #
+    # @return [Either<String, Env>]
+    def self.call_test(env)
+      env.record(:bootstrap) do
+        setup_integration(
+          env:               load_hooks(env),
+          mutations:         [],
+          selected_subjects: []
+        )
+      end
+    end
+
+    def self.setup_integration(env:, mutations:, selected_subjects:)
+      env.record(__method__) do
         Integration.setup(env).fmap do |integration|
           env.with(
             integration: integration,
@@ -57,7 +83,7 @@ module Mutant
         end
       end
     end
-    # rubocop:enable Metrics/MethodLength
+    private_class_method :setup_integration
 
     def self.load_hooks(env)
       env.record(__method__) do
@@ -113,9 +139,9 @@ module Mutant
       env.record(__method__) do
         config = env.config
 
-        scopes = env.world.object_space.each_object(Module).with_object([]) do |scope, aggregate|
-          expression = expression(config.reporter, config.expression_parser, scope) || next
-          aggregate << Scope.new(raw: scope, expression: expression)
+        scopes = env.world.object_space.each_object(Module).with_object([]) do |raw_scope, aggregate|
+          expression = expression(config.reporter, config.expression_parser, raw_scope) || next
+          aggregate << Scope.new(raw: raw_scope, expression: expression)
         end
 
         scopes.sort_by { |scope| scope.expression.syntax }
@@ -123,31 +149,31 @@ module Mutant
     end
     private_class_method :matchable_scopes
 
-    def self.scope_name(reporter, scope)
-      scope.name
+    def self.scope_name(reporter, raw_scope)
+      raw_scope.name
     rescue => exception
       semantics_warning(
         reporter,
         CLASS_NAME_RAISED_EXCEPTION,
         exception:   exception.inspect,
-        scope:       scope,
-        scope_class: scope.class
+        scope:       raw_scope,
+        scope_class: raw_scope.class
       )
       nil
     end
     private_class_method :scope_name
 
     # rubocop:disable Metrics/MethodLength
-    def self.expression(reporter, expression_parser, scope)
-      name = scope_name(reporter, scope) or return
+    def self.expression(reporter, expression_parser, raw_scope)
+      name = scope_name(reporter, raw_scope) or return
 
       unless name.instance_of?(String)
         semantics_warning(
           reporter,
           CLASS_NAME_TYPE_MISMATCH_FORMAT,
           name:        name,
-          scope_class: scope.class,
-          scope:       scope
+          scope_class: raw_scope.class,
+          raw_scope:   raw_scope
         )
         return
       end

data/lib/mutant/cli/command/environment/test.rb

@@ -8,6 +8,21 @@ module Mutant
           NAME              = 'test'
           SHORT_DESCRIPTION = 'test subcommands'
 
+        private
+
+          def parse_remaining_arguments(arguments)
+            arguments.each(&method(:add_integration_argument))
+            Either::Right.new(self)
+          end
+
+          def bootstrap
+            env = Env.empty(world, @config)
+
+            env
+              .record(:config) { Config.load(cli_config: @config, world: world) }
+              .bind { |config| Bootstrap.call_test(env.with(config: config)) }
+          end
+
           class List < self
             NAME              = 'list'
             SHORT_DESCRIPTION = 'List tests detected in the environment'
@@ -28,7 +43,29 @@ module Mutant
             end
           end
 
-          SUBCOMMANDS = [List].freeze
+          class Run < self
+            NAME              = 'run'
+            SHORT_DESCRIPTION = 'Run tests'
+            SUBCOMMANDS       = EMPTY_ARRAY
+
+          private
+
+            def action
+              bootstrap
+                .bind(&Mutant::Test::Runner.public_method(:call))
+                .bind(&method(:from_result))
+            end
+
+            def from_result(result)
+              if result.success?
+                Either::Right.new(nil)
+              else
+                Either::Left.new('Test failures, exiting nonzero!')
+              end
+            end
+          end
+
+          SUBCOMMANDS = [List, Run].freeze
         end # Test
       end # Environment
     end # Command

data/lib/mutant/cli/command/environment.rb

@@ -3,6 +3,7 @@
 module Mutant
   module CLI
     class Command
+      # rubocop:disable Metrics/ClassLength
       class Environment < self
         NAME              = 'environment'
         SHORT_DESCRIPTION = 'Environment subcommands'
@@ -13,6 +14,7 @@ module Mutant
             add_runner_options
             add_integration_options
             add_matcher_options
+            add_reporter_options
           ].freeze
 
       private
@@ -56,6 +58,10 @@ module Mutant
           set(matcher: @config.matcher.add(attribute, value))
         end
 
+        def effective_options
+          instance_of?(Environment) ? EMPTY_ARRAY : super()
+        end
+
         # rubocop:disable Metrics/MethodLength
         def add_environment_options(parser)
           parser.separator('Environment:')
@@ -122,7 +128,16 @@ module Mutant
             set(mutation: @config.mutation.with(timeout: Float(number)))
           end
         end
+
+        def add_reporter_options(parser)
+          parser.separator('Reporting:')
+
+          parser.on('--print-warnings', 'Print warnings') do
+            set(reporter: @config.reporter.with(print_warnings: true))
+          end
+        end
       end # Run
+      # rubocop:enable Metrics/ClassLength
     end # Command
   end # CLI
 end # Mutant

data/lib/mutant/cli/command.rb

@@ -6,7 +6,7 @@ module Mutant
     class Command
       include AbstractType, Anima.new(
         :main,
-        :parent,
+        :parent_names,
         :print_profile,
         :world,
         :zombie
@@ -27,10 +27,10 @@ module Mutant
       # @return [Command]
       #
       # rubocop:disable Metrics/ParameterLists
-      def self.parse(arguments:, parent: nil, print_profile: false, world:, zombie: false)
+      def self.parse(arguments:, parent_names: nil, print_profile: false, world:, zombie: false)
         new(
           main:          nil,
-          parent:        parent,
+          parent_names:  parent_names,
           print_profile: print_profile,
           world:         world,
           zombie:        zombie
@@ -63,7 +63,7 @@ module Mutant
       #
       # @return [String]
       def full_name
-        [*parent&.full_name, self.class.command_name].join(' ')
+        [*parent_names, self.class.command_name].join(' ')
       end
 
       alias_method :print_profile?, :print_profile
@@ -97,13 +97,17 @@ module Mutant
           add_global_options(parser)
           add_subcommands(parser)
 
-          self.class::OPTIONS.each do |method_name|
+          effective_options.each do |method_name|
             2.times { parser.separator(nil) }
             __send__(method_name, parser)
           end
         end
       end
 
+      def effective_options
+        self.class::OPTIONS
+      end
+
       def capture_main(&block)
         @main = block
       end
@@ -189,7 +193,7 @@ module Mutant
           find_command(command_name).bind do |command|
             command.parse(
               arguments:     arguments,
-              parent:        self,
+              parent_names:  [*parent_names, self.class::NAME],
               print_profile: print_profile,
               world:         world,
               zombie:        zombie

data/lib/mutant/context.rb

@@ -3,83 +3,53 @@
 module Mutant
   # An abstract context where mutations can be applied to.
   class Context
-    include Adamantium, Anima.new(:scope, :source_path)
-    extend AST::Sexp
+    include Adamantium, Anima.new(:constant_scope, :scope, :source_path)
 
-    NAMESPACE_DELIMITER = '::'
+    class ConstantScope
+      include AST::Sexp
 
-    # Return root node for mutation
-    #
-    # @return [Parser::AST::Node]
-    def root(node)
-      nesting.reverse.reduce(node) do |current, scope|
-        self.class.wrap(scope, current)
+      class Class < self
+        include Anima.new(:const, :descendant)
+
+        def call(node)
+          s(:class, const, nil, descendant.call(node))
+        end
       end
-    end
 
-    # Identification string
-    #
-    # @return [String]
-    def identification
-      scope.name
-    end
+      class Module < self
+        include Anima.new(:const, :descendant)
 
-    # Wrap node into ast node
-    #
-    # @param [Class, Module] scope
-    # @param [Parser::AST::Node] node
-    #
-    # @return [Parser::AST::Class]
-    #   if scope is of kind Class
-    #
-    # @return [Parser::AST::Module]
-    #   if scope is of kind module
-    def self.wrap(scope, node)
-      name = s(:const, nil, scope.name.split(NAMESPACE_DELIMITER).last.to_sym)
-      case scope
-      when Class
-        s(:class, name, nil, node)
-      when Module
-        s(:module, name, node)
+        def call(node)
+          s(:module, const, descendant.call(node))
+        end
       end
-    end
 
-    # Nesting of scope
-    #
-    # @return [Enumerable<Class,Module>]
-    def nesting
-      const = Object
-      name_nesting.map do |name|
-        const = const.const_get(name)
+      class None < self
+        include Equalizer.new
+
+        def call(node)
+          node
+        end
       end
     end
-    memoize :nesting
 
-    # Unqualified name of scope
-    #
-    # @return [String]
-    def unqualified_name
-      name_nesting.last
+    def match_expressions
+      scope.match_expressions
     end
 
-    # Match expressions for scope
+    # Return root node for mutation
     #
-    # @return [Enumerable<Expression>]
-    def match_expressions
-      name_nesting.each_index.reverse_each.map do |index|
-        Expression::Namespace::Recursive.new(
-          scope_name: name_nesting.take(index.succ).join(NAMESPACE_DELIMITER)
-        )
-      end
+    # @return [Parser::AST::Node]
+    def root(node)
+      constant_scope.call(node)
     end
-    memoize :match_expressions
 
-  private
-
-    def name_nesting
-      scope.name.split(NAMESPACE_DELIMITER)
+    # Identification string
+    #
+    # @return [String]
+    def identification
+      scope.raw.name
     end
-    memoize :name_nesting
 
   end # Context
 end # Mutant

data/lib/mutant/env.rb

@@ -66,10 +66,18 @@ module Mutant
       )
     end
 
+    def run_test_index(test_index)
+      integration.call([integration.all_tests.fetch(test_index)])
+    end
+
     def emit_mutation_worker_process_start(index:)
       hooks.run(:mutation_worker_process_start, index: index)
     end
 
+    def emit_test_worker_process_start(index:)
+      hooks.run(:test_worker_process_start, index: index)
+    end
+
     # The test selections
     #
     # @return Hash{Mutation => Enumerable<Test>}
@@ -175,7 +183,6 @@ module Mutant
     def timer
       world.timer
     end
-
   end # Env
   # rubocop:enable Metrics/ClassLength
 end # Mutant

data/lib/mutant/expression/method.rb

@@ -78,7 +78,10 @@ module Mutant
     private
 
       def scope
-        Object.const_get(scope_name)
+        Scope.new(
+          raw:        Object.const_get(scope_name),
+          expression: Namespace::Exact.new(scope_name: scope_name)
+        )
       end
 
     end # Method

data/lib/mutant/expression/methods.rb

@@ -57,7 +57,10 @@ module Mutant
     private
 
       def scope
-        Object.const_get(scope_name)
+        Scope.new(
+          expression: Namespace::Exact.new(scope_name: scope_name),
+          raw:        Object.const_get(scope_name)
+        )
       end
 
     end # Methods

data/lib/mutant/expression/namespace.rb

@@ -66,10 +66,10 @@ module Mutant
         #
         # @return [Matcher]
         def matcher
-          scope = find_scope
+          raw_scope = find_raw_scope
 
-          if scope
-            Matcher::Scope.new(scope: scope)
+          if raw_scope
+            Matcher::Scope.new(scope: Scope.new(expression: self, raw: raw_scope))
           else
             Matcher::Null.new
           end
@@ -83,7 +83,7 @@ module Mutant
 
       private
 
-        def find_scope
+        def find_raw_scope
           Object.const_get(scope_name)
         rescue NameError # rubocop:disable Lint/SuppressedException
         end

data/lib/mutant/hooks.rb

@@ -10,6 +10,7 @@ module Mutant
       mutation_insert_post
       mutation_insert_pre
       mutation_worker_process_start
+      test_worker_process_start
     ].product([EMPTY_ARRAY]).to_h.transform_values(&:freeze).freeze
 
     MESSAGE = 'Unknown hook %s'

data/lib/mutant/integration/null.rb

@@ -18,6 +18,7 @@ module Mutant
       # @return [Result::Test]
       def call(_tests)
         Result::Test.new(
+          output:  '',
           passed:  true,
           runtime: 0.0
         )

data/lib/mutant/integration.rb

@@ -4,7 +4,11 @@ module Mutant
 
   # Abstract base class mutant test framework integrations
   class Integration
-    include AbstractType, Adamantium, Anima.new(:arguments, :expression_parser, :world)
+    include AbstractType, Adamantium, Anima.new(
+      :arguments,
+      :expression_parser,
+      :world
+    )
 
     LOAD_MESSAGE = <<~'MESSAGE'
       Unable to load integration mutant-%<integration_name>s:

data/lib/mutant/matcher/descendants.rb

@@ -10,7 +10,7 @@ module Mutant
         const = env.world.try_const_get(const_name) or return EMPTY_ARRAY
 
         Chain.new(
-          matchers: matched_scopes(env, const).map { |scope| Scope.new(scope: scope.raw) }
+          matchers: matched_scopes(env, const).map { |scope| Scope.new(scope: scope) }
         ).call(env)
       end
 

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

@@ -8,7 +8,7 @@ module Mutant
 
         # Dispatching builder, detects memoizable case
         #
-        # @param [Class, Module] scope
+        # @param [Scope] scope
         # @param [UnboundMethod] method
         #
         # @return [Matcher::Method::Instance]
@@ -31,7 +31,7 @@ module Mutant
         # rubocop:enable Metrics/MethodLength
 
         def self.memoized_method?(scope, method_name)
-          scope < Adamantium && scope.memoized?(method_name)
+          scope.raw < Adamantium && scope.raw.memoized?(method_name)
         end
         private_class_method :memoized_method?
 
@@ -48,9 +48,9 @@ module Mutant
           end
 
           def visibility
-            if scope.private_instance_methods.include?(method_name)
+            if scope.raw.private_instance_methods.include?(method_name)
               :private
-            elsif scope.protected_instance_methods.include?(method_name)
+            elsif scope.raw.protected_instance_methods.include?(method_name)
               :protected
             else
               :public
@@ -65,6 +65,7 @@ module Mutant
 
             def source_location
               scope
+                .raw
                 .unmemoized_instance_method(method_name)
                 .source_location
             end

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

@@ -62,7 +62,7 @@ module Mutant
 
           def sclass_const_name?(node)
             name = node.children.fetch(CONST_NAME_INDEX)
-            name.to_s.eql?(context.unqualified_name)
+            name.to_s.eql?(scope.unqualified_name)
           end
 
         end # Evaluator

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

@@ -46,7 +46,7 @@ module Mutant
 
           def receiver_name?(node)
             name = node.children.fetch(NAME_INDEX)
-            name.to_s.eql?(context.unqualified_name)
+            name.to_s.eql?(scope.unqualified_name)
           end
 
         end # Evaluator

data/lib/mutant/matcher/method.rb

@@ -14,6 +14,11 @@ module Mutant
       CLOSURE_WARNING_FORMAT =
         '%s is dynamically defined in a closure, unable to emit subject'
 
+      CONSTANT_SCOPES = {
+        class:  Context::ConstantScope::Class,
+        module: Context::ConstantScope::Module
+      }.freeze
+
       # Matched subjects
       #
       # @param [Env] env
@@ -28,6 +33,8 @@ module Mutant
       # Present to avoid passing the env argument around in case the
       # logic would be implemented directly on the Matcher::Method
       # instance
+      #
+      # rubocop:disable Metrics/ClassLength
       class Evaluator
         include(
           AbstractType,
@@ -57,7 +64,7 @@ module Mutant
         def match_view
           return EMPTY_ARRAY if matched_view.nil?
 
-          if matched_view.path.any?(&:block.public_method(:equal?))
+          if matched_view.stack.any? { |node| node.type.equal?(:block) }
             env.warn(CLOSURE_WARNING_FORMAT % target_method)
 
             return EMPTY_ARRAY
@@ -80,7 +87,26 @@ module Mutant
         end
 
         def context
-          Context.new(scope: scope, source_path: source_path)
+          Context.new(constant_scope: constant_scope, scope: scope, source_path: source_path)
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def constant_scope
+          matched_view
+            .stack
+            .reverse
+            .reduce(Context::ConstantScope::None.new) do |descendant, node|
+              klass = CONSTANT_SCOPES[node.type]
+
+              if klass
+                klass.new(
+                  const:      node.children.fetch(0),
+                  descendant: descendant
+                )
+              else
+                descendant
+              end
+          end
         end
 
         def ast
@@ -151,9 +177,9 @@ module Mutant
           # end
           #
           # Change to this once 3.0 is EOL.
-          if scope.private_methods.include?(method_name)
+          if scope.raw.private_methods.include?(method_name)
             :private
-          elsif scope.protected_methods.include?(method_name)
+          elsif scope.raw.protected_methods.include?(method_name)
             :protected
           else
             :public