mutant 0.11.28 → 0.11.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2580053028745a106b883c1468b4e0c4462d1e5e443f12533ca277149f603239
-  data.tar.gz: db5d4f28324b0846a9872b3a7b841e8dcdb84ae204f6c15def9f9381db064ea3
+  metadata.gz: 6c9ce21c5e092af5e521c5ef2c0e926e60211ddae0c8b552d5b79180dbc8eb6c
+  data.tar.gz: 994dbc55bb97edd121d72aa46a946993e2efcc8642ca0d7dd7d31cdb4cb8fa6e
 SHA512:
-  metadata.gz: 125e846599d5bfbd7ec52d3f7bbcf78f53d2584b7dd447d9313954c10ff4e5176c59fec396833b97f81bcb4bb40d9fdcf1cc0ef138c3a53685af503b0f95678b
-  data.tar.gz: 2fb0163bfcdc01ed03fb34418a9522af0dab49e4fb8fa91cccf8c9e7cbbdcbd00551e2c36087ca8ee587bda317cc391a0bf7eae564be7834b53eff96873abd55
+  metadata.gz: 7047e6694559bb810a7b3b7bc1f01e07745a928c166e6964f0b74d8dae3a4900575bbe12bcf98fc0163bef3ee6869fd2b09ec09b46d91920b3de134421811240
+  data.tar.gz: cf40b6c4d5c5a4ea37a090f7a874e3a2abfd64ea31d0d2d1c5ae32cb6e8b43c2d4b5c7c8c92be24a54339be87604f66c59a7d5f11061299518cf93fdb1da2e44

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,36 @@ 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
+
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Style/MultilineBlockChain
+    def self.setup_integration(env:, mutations:, selected_subjects:)
+      env.record(__method__) do
+        hooks = env.hooks
+        hooks.run(:setup_integration_pre)
         Integration.setup(env).fmap do |integration|
           env.with(
             integration: integration,
@@ -54,10 +84,12 @@ module Mutant
             selector:    Selector::Expression.new(integration: integration),
             subjects:    selected_subjects
           )
-        end
+        end.tap { hooks.run(:setup_integration_post) }
       end
     end
+    private_class_method :setup_integration
     # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Style/MultilineBlockChain
 
     def self.load_hooks(env)
       env.record(__method__) do
@@ -113,9 +145,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 +155,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
@@ -126,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/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,9 @@ module Mutant
       mutation_insert_post
       mutation_insert_pre
       mutation_worker_process_start
+      setup_integration_post
+      setup_integration_pre
+      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

data/lib/mutant/matcher/methods.rb

@@ -57,11 +57,11 @@ module Mutant
       private
 
         def access(_env, method_name)
-          scope.method(method_name)
+          scope.raw.method(method_name)
         end
 
         def candidate_scope
-          scope.singleton_class
+          scope.raw.singleton_class
         end
 
       end # Singleton
@@ -73,11 +73,11 @@ module Mutant
       private
 
         def access(_env, method_name)
-          scope.method(method_name)
+          scope.raw.method(method_name)
         end
 
         def candidate_scope
-          scope.singleton_class
+          scope.raw.singleton_class
         end
       end # Metaclass
 
@@ -105,18 +105,19 @@ module Mutant
       private
 
         # rubocop:disable Lint/RescueException
+        # mutant:disable - unstable source locations under < ruby-3.2
         def access(env, method_name)
-          scope.instance_method(method_name)
+          candidate_scope.instance_method(method_name)
         rescue Exception => exception
           env.warn(
-            MESSAGE % { scope: scope, method_name: method_name, exception: exception }
+            MESSAGE % { scope: scope, method_name: method_name, exception: exception.inspect }
           )
           nil
         end
         # rubocop:enable Lint/RescueException
 
         def candidate_scope
-          scope
+          scope.raw
         end
 
       end # Instance

data/lib/mutant/matcher/namespace.rb

@@ -13,7 +13,7 @@ module Mutant
       # @return [Enumerable<Subject>]
       def call(env)
         Chain.new(
-          matchers: matched_scopes(env).map { |scope| Scope.new(scope: scope.raw) }
+          matchers: matched_scopes(env).map { |scope| Scope.new(scope: scope) }
         ).call(env)
       end