mutant 0.10.22 → 0.10.27

data/lib/mutant/bootstrap.rb

@@ -8,7 +8,7 @@ module Mutant
   #
   # env = config interpreted against the world
   module Bootstrap
-    include Adamantium::Flat, Anima.new(:config, :parser, :world)
+    include Adamantium, Anima.new(:config, :parser, :world)
 
     SEMANTICS_MESSAGE_FORMAT =
       "%<message>s. Fix your lib to follow normal ruby semantics!\n" \

data/lib/mutant/cli/command.rb

@@ -204,6 +204,10 @@ module Mutant
       def with_help(message)
         "#{full_name}: #{message}\n\n#{parser}"
       end
+
+      def print(message)
+        world.stdout.puts(message)
+      end
     end # Command
     # rubocop:enable Metrics/ClassLength
   end # CLI

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

@@ -29,13 +29,19 @@ module Mutant
         end
 
         def expand(file_config)
+          if @config.matcher.subjects.any?
+            file_config = file_config.with(
+              matcher: file_config.matcher.with(subjects: [])
+            )
+          end
+
           @config = Config.env.merge(file_config).merge(@config).expand_defaults
         end
 
         def parse_remaining_arguments(arguments)
           Mutant.traverse(@config.expression_parser, arguments)
-            .fmap do |match_expressions|
-              matcher(match_expressions: match_expressions)
+            .fmap do |expressions|
+              matcher(subjects: expressions)
               self
             end
         end
@@ -82,7 +88,7 @@ module Mutant
           parser.separator('Matcher:')
 
           parser.on('--ignore-subject EXPRESSION', 'Ignore subjects that match EXPRESSION as prefix') do |pattern|
-            add_matcher(:ignore_expressions, @config.expression_parser.call(pattern).from_right)
+            add_matcher(:ignore, @config.expression_parser.call(pattern).from_right)
           end
           parser.on('--start-subject EXPRESSION', 'Start mutation testing at a specific subject') do |pattern|
             add_matcher(:start_expressions, @config.expression_parser.call(pattern).from_right)

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

@@ -25,10 +25,6 @@ module Mutant
                 print(subject.expression.syntax)
               end
             end
-
-            def print(message)
-              world.stdout.puts(message)
-            end
           end
 
           SUBCOMMANDS = [List].freeze

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Mutant
+  module CLI
+    class Command
+      class Environment
+        class Test < self
+          NAME              = 'test'
+          SHORT_DESCRIPTION = 'test subcommands'
+
+          class List < self
+            NAME              = 'list'
+            SHORT_DESCRIPTION = 'List tests detected in the environment'
+            SUBCOMMANDS       = EMPTY_ARRAY
+
+          private
+
+            def action
+              bootstrap.fmap(&method(:list_tests))
+            end
+
+            def list_tests(env)
+              tests = env.integration.all_tests
+              print('Tests in environment: %d' % tests.length)
+              tests.each do |test|
+                print(test.identification)
+              end
+            end
+          end
+
+          SUBCOMMANDS = [List].freeze
+        end # Test
+      end # Environment
+    end # Command
+  end # CLI
+end # Mutant

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

@@ -4,7 +4,7 @@ module Mutant
   module CLI
     class Command
       class Environment < self
-        SUBCOMMANDS = [Environment::Subject, Environment::Show].freeze
+        SUBCOMMANDS = [Environment::Subject, Environment::Show, Environment::Test].freeze
       end # Environment
 
       class Root < self

data/lib/mutant/config.rb

@@ -6,7 +6,7 @@ module Mutant
   # Does not reference any "external" volatile state. The configuration applied
   # to current environment is being represented by the Mutant::Env object.
   class Config
-    include Adamantium::Flat, Anima.new(
+    include Adamantium, Anima.new(
       :coverage_criteria,
       :expression_parser,
       :fail_fast,
@@ -37,54 +37,6 @@ module Mutant
 
     private_constant(*constants(false))
 
-    class CoverageCriteria
-      include Anima.new(:process_abort, :test_result, :timeout)
-
-      EMPTY = new(
-        process_abort: nil,
-        test_result:   nil,
-        timeout:       nil
-      )
-
-      DEFAULT = new(
-        process_abort: false,
-        test_result:   true,
-        timeout:       false
-      )
-
-      TRANSFORM =
-        Transform::Sequence.new(
-          [
-            Transform::Hash.new(
-              optional: [
-                Transform::Hash::Key.new('process_abort', Transform::BOOLEAN),
-                Transform::Hash::Key.new('test_result',   Transform::BOOLEAN),
-                Transform::Hash::Key.new('timeout',       Transform::BOOLEAN)
-              ],
-              required: []
-            ),
-            Transform::Hash::Symbolize.new,
-            ->(value) { Either::Right.new(DEFAULT.with(**value)) }
-          ]
-        )
-
-      def merge(other)
-        self.class.new(
-          process_abort: overwrite(other, :process_abort),
-          test_result:   overwrite(other, :test_result),
-          timeout:       overwrite(other, :timeout)
-        )
-      end
-
-    private
-
-      def overwrite(other, attribute_name)
-        other_value = other.public_send(attribute_name)
-
-        other_value.nil? ? public_send(attribute_name) : other_value
-      end
-    end # CoverageCriteria
-
     # Merge with other config
     #
     # @param [Config] other
@@ -116,13 +68,14 @@ module Mutant
     #
     # @return [Either<String,Config>]
     def self.load_config_file(world)
-      config = DEFAULT
-      files = CANDIDATES.map(&world.pathname.public_method(:new)).select(&:readable?)
+      files = CANDIDATES
+        .map(&world.pathname.public_method(:new))
+        .select(&:readable?)
 
       if files.one?
-        load_contents(files.first).fmap(&config.public_method(:with))
+        load_contents(files.first).fmap(&DEFAULT.public_method(:with))
       elsif files.empty?
-        Either::Right.new(config)
+        Either::Right.new(DEFAULT)
       else
         Either::Left.new(MORE_THAN_ONE_CONFIG_FILE % files.join(', '))
       end
@@ -159,13 +112,14 @@ module Mutant
         Transform::Exception.new(YAML::SyntaxError, YAML.method(:safe_load)),
         Transform::Hash.new(
           optional: [
-            Transform::Hash::Key.new('coverage_criteria', CoverageCriteria::TRANSFORM),
+            Transform::Hash::Key.new('coverage_criteria', ->(value) { CoverageCriteria::TRANSFORM.call(value) }),
             Transform::Hash::Key.new('fail_fast',         Transform::BOOLEAN),
             Transform::Hash::Key.new('includes',          Transform::STRING_ARRAY),
             Transform::Hash::Key.new('integration',       Transform::STRING),
             Transform::Hash::Key.new('jobs',              Transform::INTEGER),
             Transform::Hash::Key.new('mutation_timeout',  Transform::FLOAT),
-            Transform::Hash::Key.new('requires',          Transform::STRING_ARRAY)
+            Transform::Hash::Key.new('requires',          Transform::STRING_ARRAY),
+            Transform::Hash::Key.new('matcher',           Matcher::Config::LOADER)
           ],
           required: []
         ),

data/lib/mutant/config/coverage_criteria.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Config
+    # Configuration of coverge conditions
+    class CoverageCriteria
+      include Anima.new(:process_abort, :test_result, :timeout)
+
+      EMPTY = new(
+        process_abort: nil,
+        test_result:   nil,
+        timeout:       nil
+      )
+
+      DEFAULT = new(
+        process_abort: false,
+        test_result:   true,
+        timeout:       false
+      )
+
+      TRANSFORM =
+        Transform::Sequence.new(
+          [
+            Transform::Hash.new(
+              optional: [
+                Transform::Hash::Key.new('process_abort', Transform::BOOLEAN),
+                Transform::Hash::Key.new('test_result',   Transform::BOOLEAN),
+                Transform::Hash::Key.new('timeout',       Transform::BOOLEAN)
+              ],
+              required: []
+            ),
+            Transform::Hash::Symbolize.new,
+            ->(value) { Either::Right.new(DEFAULT.with(**value)) }
+          ]
+        )
+
+      # Merge coverage criteria with other instance
+      #
+      # Values from the other instance have precedence.
+      #
+      # @param [CoverageCriteria] other
+      #
+      # @return [CoverageCriteria]
+      def merge(other)
+        self.class.new(
+          process_abort: overwrite(other, :process_abort),
+          test_result:   overwrite(other, :test_result),
+          timeout:       overwrite(other, :timeout)
+        )
+      end
+
+    private
+
+      def overwrite(other, attribute_name)
+        other_value = other.public_send(attribute_name)
+
+        other_value.nil? ? public_send(attribute_name) : other_value
+      end
+    end # CoverageCriteria
+  end # Config
+end # Mutant

data/lib/mutant/context.rb

@@ -3,7 +3,7 @@
 module Mutant
   # An abstract context where mutations can be applied to.
   class Context
-    include Adamantium::Flat, Concord::Public.new(:scope, :source_path)
+    include Adamantium, Concord::Public.new(:scope, :source_path)
     extend AST::Sexp
 
     NAMESPACE_DELIMITER = '::'

data/lib/mutant/env.rb

@@ -3,7 +3,7 @@
 module Mutant
   # Abstract base class for mutant environments
   class Env
-    include Adamantium::Flat, Anima.new(
+    include Adamantium, Anima.new(
       :config,
       :integration,
       :matchable_scopes,
@@ -31,7 +31,7 @@ module Mutant
         config:           config,
         integration:      Integration::Null.new(
           expression_parser: config.expression_parser,
-          timer:             world.timer
+          world:             world
         ),
         matchable_scopes: EMPTY_ARRAY,
         mutations:        EMPTY_ARRAY,

data/lib/mutant/expression.rb

@@ -4,8 +4,6 @@ module Mutant
 
   # Abstract base class for match expression
   class Expression
-    include AbstractType
-
     fragment             = /[A-Za-z][A-Za-z\d_]*/.freeze
     SCOPE_NAME_PATTERN   = /(?<scope_name>#{fragment}(?:#{SCOPE_OPERATOR}#{fragment})*)/.freeze
     SCOPE_SYMBOL_PATTERN = '(?<scope_symbol>[.#])'
@@ -16,16 +14,6 @@ module Mutant
       super.freeze
     end
 
-    # Syntax of expression
-    #
-    # @return [Matcher]
-    abstract_method :matcher
-
-    # Syntax of expression
-    #
-    # @return [String]
-    abstract_method :syntax
-
     # Match length with other expression
     #
     # @param [Expression] other

data/lib/mutant/expression/method.rb

@@ -15,10 +15,10 @@ module Mutant
 
       private(*anima.attribute_names)
 
-      MATCHERS = IceNine.deep_freeze(
-        '.' => [Matcher::Methods::Singleton, Matcher::Methods::Metaclass],
-        '#' => [Matcher::Methods::Instance]
-      )
+      MATCHERS = {
+        '.' => [Matcher::Methods::Singleton, Matcher::Methods::Metaclass].freeze,
+        '#' => [Matcher::Methods::Instance].freeze
+      }.freeze
 
       METHOD_NAME_PATTERN = /(?<method_name>.+)/.freeze
 

data/lib/mutant/expression/methods.rb

@@ -12,10 +12,11 @@ module Mutant
 
       private(*anima.attribute_names)
 
-      MATCHERS = IceNine.deep_freeze(
-        '.' => [Matcher::Methods::Singleton, Matcher::Methods::Metaclass],
-        '#' => [Matcher::Methods::Instance]
-      )
+      MATCHERS = {
+        '.' => [Matcher::Methods::Singleton, Matcher::Methods::Metaclass].freeze,
+        '#' => [Matcher::Methods::Instance].freeze
+      }.freeze
+
       private_constant(*constants(false))
 
       REGEXP = /\A#{SCOPE_NAME_PATTERN}#{SCOPE_SYMBOL_PATTERN}\z/.freeze

data/lib/mutant/integration.rb

@@ -4,7 +4,7 @@ module Mutant
 
   # Abstract base class mutant test framework integrations
   class Integration
-    include AbstractType, Adamantium::Flat, Anima.new(:expression_parser, :timer)
+    include AbstractType, Adamantium, Anima.new(:expression_parser, :world)
 
     LOAD_MESSAGE = <<~'MESSAGE'
       Unable to load integration mutant-%<integration_name>s:
@@ -39,7 +39,7 @@ module Mutant
       attempt_require(env).bind { attempt_const_get(env) }.fmap do |klass|
         klass.new(
           expression_parser: env.config.expression_parser,
-          timer:             env.world.timer
+          world:             env.world
         ).setup
       end
     end
@@ -92,5 +92,11 @@ module Mutant
     #
     # @return [Enumerable<Test>]
     abstract_method :all_tests
+
+  private
+
+    def timer
+      world.timer
+    end
   end # Integration
 end # Mutant

data/lib/mutant/isolation/exception.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Mutant
+  # Module providing isolation
+  class Isolation
+    # Generic serializable exception data.
+    #
+    # This is required as our honored guests the Rails* ecosystem
+    # makes Marshal.dump on exceptions impossible.
+    #
+    # @see https://twitter.com/_m_b_j_/status/1356433184850907137
+    #
+    # for the full story and eventual reactions.
+    class Exception
+      include Anima.new(
+        :backtrace,
+        :message,
+        :original_class
+      )
+    end # Exception
+  end # Isolation
+end # Mutant

data/lib/mutant/isolation/fork.rb

@@ -28,7 +28,7 @@ module Mutant
     # * Child process freezing after closing the pipes needs to be
     #   detected by parent process.
     class Fork < self
-      include(Adamantium::Flat, Concord.new(:world))
+      include(Adamantium, Concord.new(:world))
 
       READ_SIZE = 4096
 
@@ -36,7 +36,7 @@ module Mutant
 
       # Pipe abstraction
       class Pipe
-        include Adamantium::Flat, Anima.new(:reader, :writer)
+        include Adamantium, Anima.new(:reader, :writer)
 
         # Run block with pipe in binmode
         #
@@ -66,10 +66,7 @@ module Mutant
 
       # rubocop:disable Metrics/ClassLength
       class Parent
-        include(
-          Anima.new(*ATTRIBUTES),
-          Procto.call
-        )
+        include(Anima.new(*ATTRIBUTES), Procto)
 
         # Prevent mutation from `process.fork` to `fork` to call Kernel#fork
         undef_method :fork
@@ -136,7 +133,11 @@ module Mutant
         def load_result(result_fragments)
           @value = world.marshal.load(result_fragments.join)
         rescue ArgumentError => exception
-          @exception = exception
+          @exception = Exception.new(
+            backtrace:      exception.backtrace,
+            message:        exception.message,
+            original_class: exception.class
+          )
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -212,11 +213,7 @@ module Mutant
       # rubocop:enable Metrics/ClassLength
 
       class Child
-        include(
-          Adamantium::Flat,
-          Anima.new(*ATTRIBUTES),
-          Procto.call
-        )
+        include(Adamantium, Anima.new(*ATTRIBUTES), Procto)
 
         # Handle child process
         #