mutant 0.11.11 → 0.11.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6aa7e42cfe0d8ed12281745fc607d4d933fbb03af10b2bb41c41e6df3765ef89
-  data.tar.gz: 2a4a940e72bf2381816cfc0522f236166df7c2f649bd4da6ee8c2f41a6851c33
+  metadata.gz: 3c75928a9c55d93ebfad196c028271b8c82d7d9eb94e48873ac75c9ee4bb212f
+  data.tar.gz: 27149ec498db15629bb18c55a5840e3ea8c369542a85bf9d3658cadc78fc8f4a
 SHA512:
-  metadata.gz: 9ffa1cf3efbe20ba6ac20d7aee9765cbb8833a2934f2d1b874ec800673582c709e76bcbdb6a026191bd751a9f30726720c5f0f81b09e0999805608e22d775dc7
-  data.tar.gz: b4a2cf6f0fc16056e8f92b306828c4e5578f0b1408770b0395b4874ff887a3f1cbe5023613694493736bcdede6c906dfaed06c1b73e78f2b8b5821b2fb61457b
+  metadata.gz: 44867690e5c1c367df8b22ec3fa5b35941328e12fd10a26a252baa3815c955fbd37f1adaaaadfafbcdc1f72280ce013d37996d001c163930c084b95b07905362
+  data.tar.gz: b22e71a0ae7f1ecb96345e7996e61c4ee843c7b82442f21dea3516be132503fa9c0193443f1d7da9196fbb27f23f3ef858ee58f81c03b7cda8d4f4dcced1a9a7

data/lib/mutant/bootstrap.rb

@@ -24,16 +24,15 @@ module Mutant
 
     # Run Bootstrap
     #
-    # @param [World] world
-    # @param [Config] config
+    # @param [Env] env
     #
     # @return [Either<String, Env>]
     #
     # rubocop:disable Metrics/MethodLength
-    def self.call(world, config)
-      env = load_hooks(Env.empty(world, config))
+    def self.call(env)
+      env = load_hooks(env)
         .tap(&method(:infect))
-        .with(matchable_scopes: matchable_scopes(world, config))
+        .with(matchable_scopes: matchable_scopes(env))
 
       subjects = start_subject(env, Matcher.from_config(env.config.matcher).call(env))
 
@@ -82,8 +81,10 @@ module Mutant
     end
     private_class_method :infect
 
-    def self.matchable_scopes(world, config)
-      scopes = world.object_space.each_object(Module).each_with_object([]) do |scope, aggregate|
+    def self.matchable_scopes(env)
+      config = env.config
+
+      scopes = env.world.object_space.each_object(Module).each_with_object([]) do |scope, aggregate|
         expression = expression(config.reporter, config.expression_parser, scope) || next
         aggregate << Scope.new(scope, expression)
       end

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

@@ -23,9 +23,11 @@ module Mutant
         end
 
         def bootstrap
-          Config.load_config_file(world)
+          env = Env.empty(world, @config)
+
+          Config.load_config_file(env)
             .fmap(&method(:expand))
-            .bind { Bootstrap.call(world, @config) }
+            .bind { Bootstrap.call(env.with(config: @config)) }
         end
 
         def expand(file_config)
@@ -121,7 +123,7 @@ module Mutant
             set(jobs: Integer(number))
           end
           parser.on('-t', '--mutation-timeout NUMBER', 'Per mutation analysis timeout') do |number|
-            set(mutation_timeout: Float(number))
+            set(mutation: @config.mutation.with(timeout: Float(number)))
           end
         end
       end # Run

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

@@ -14,6 +14,12 @@ module Mutant
           OPTIONS           = %i[add_target_options].freeze
 
           def action
+            @ignore_patterns.map! do |syntax|
+              AST::Pattern.parse(syntax).from_right do |message|
+                return Either::Left.new(message)
+              end
+            end
+
             @targets.each(&method(:print_mutations))
             Either::Right.new(nil)
           end
@@ -50,18 +56,27 @@ module Mutant
           def initialize(_arguments)
             super
 
-            @targets = []
+            @targets         = []
+            @ignore_patterns = []
           end
 
           def add_target_options(parser)
             parser.on('-e', '--evaluate SOURCE') do |source|
               @targets << Target::Source.new(source)
             end
+
+            parser.on('-i', '--ignore-pattern AST_PATTERN') do |pattern|
+              @ignore_patterns << pattern
+            end
           end
 
           def print_mutations(target)
             world.stdout.puts(target.identification)
-            Mutator.mutate(target.node).each do |mutation|
+
+            Mutator::Node.mutate(
+              config: Mutant::Mutation::Config::DEFAULT.with(ignore_patterns: @ignore_patterns),
+              node:   target.node
+            ).each do |mutation|
               Reporter::CLI::Printer::Mutation.call(
                 world.stdout,
                 Mutant::Mutation::Evil.new(target, mutation)

data/lib/mutant/config.rb

@@ -19,7 +19,7 @@ module Mutant
       :isolation,
       :jobs,
       :matcher,
-      :mutation_timeout,
+      :mutation,
       :reporter,
       :requires,
       :zombie
@@ -39,6 +39,20 @@ module Mutant
       mutant.yml
     ].freeze
 
+    MUTATION_TIMEOUT_DEPRECATION = <<~'MESSAGE'
+      Deprecated configuration toplevel key `mutation_timeout` found.
+
+      This key will be removed in the next mayor version.
+      Instead place your mutation timeout configuration under the `mutation` key
+      like this:
+
+      ```
+      # mutant.yml
+      mutation:
+        timeout: 10.0 # float here.
+      ```
+    MESSAGE
+
     private_constant(*constants(false))
 
     # Merge with other config
@@ -59,7 +73,7 @@ module Mutant
         integration:           other.integration || integration,
         jobs:                  other.jobs || jobs,
         matcher:               matcher.merge(other.matcher),
-        mutation_timeout:      other.mutation_timeout || mutation_timeout,
+        mutation:              mutation.merge(other.mutation),
         requires:              requires + other.requires,
         zombie:                zombie || other.zombie
       )
@@ -69,17 +83,16 @@ module Mutant
 
     # Load config file
     #
-    # @param [World] world
-    # @param [Config] config
+    # @param [Env] env
     #
     # @return [Either<String,Config>]
-    def self.load_config_file(world)
+    def self.load_config_file(env)
       files = CANDIDATES
-        .map(&world.pathname.public_method(:new))
+        .map(&env.world.pathname.public_method(:new))
         .select(&:readable?)
 
       if files.one?
-        load_contents(files.first).fmap(&DEFAULT.public_method(:with))
+        load_contents(env, files.first).fmap(&DEFAULT.public_method(:with))
       elsif files.empty?
         Either::Right.new(DEFAULT)
       else
@@ -97,14 +110,30 @@ module Mutant
       )
     end
 
-    def self.load_contents(path)
+    def self.load_contents(env, path)
       Transform::Named
-        .new(path.to_s, TRANSFORM)
+        .new(
+          path.to_s,
+          sequence(env.config.reporter)
+        )
         .call(path)
         .lmap(&:compact_message)
     end
     private_class_method :load_contents
 
+    def self.sequence(reporter)
+      Transform::Sequence.new(
+        [
+          Transform::Exception.new(SystemCallError, :read.to_proc),
+          Transform::Exception.new(YAML::SyntaxError, YAML.public_method(:safe_load)),
+          Transform::Primitive.new(Hash),
+          Transform::Success.new(->(hash) { deprecations(reporter, hash) }),
+          *TRANSFORMS
+        ]
+      )
+    end
+    private_class_method :sequence
+
     # The configuration from the environment
     #
     # @return [Config]
@@ -139,38 +168,45 @@ module Mutant
 
       Either::Right.new(hash)
     end
-    TRANSFORM = Transform::Sequence.new(
-      [
-        Transform::Exception.new(SystemCallError, :read.to_proc),
-        Transform::Exception.new(YAML::SyntaxError, YAML.public_method(:safe_load)),
-        Transform::Hash.new(
-          optional: [
-            Transform::Hash::Key.new('coverage_criteria', ->(value) { CoverageCriteria::TRANSFORM.call(value) }),
-            Transform::Hash::Key.new(
-              'environment_variables',
-              Transform::Sequence.new(
-                [
-                  Transform::Primitive.new(Hash),
-                  Transform::Block.capture(:environment_variables, &method(:parse_environment_variables))
-                ]
-              )
-            ),
-            Transform::Hash::Key.new('fail_fast',             Transform::BOOLEAN),
-            Transform::Hash::Key.new('hooks',                 PATHNAME_ARRAY),
-            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('matcher',               Matcher::Config::LOADER),
-            Transform::Hash::Key.new('mutation_timeout',      Transform::FLOAT),
-            Transform::Hash::Key.new('requires',              Transform::STRING_ARRAY)
-          ],
-          required: []
-        ),
-        Transform::Hash::Symbolize.new
-      ]
-    )
 
-    private_constant(:TRANSFORM)
+    def self.deprecations(reporter, hash)
+      if hash.key?('mutation_timeout')
+        reporter.warn(MUTATION_TIMEOUT_DEPRECATION)
+
+        (hash['mutation'] ||= {})['timeout'] ||= hash.delete('mutation_timeout')
+      end
+
+      hash
+    end
+
+    TRANSFORMS = [
+      Transform::Hash.new(
+        optional: [
+          Transform::Hash::Key.new('coverage_criteria', ->(value) { CoverageCriteria::TRANSFORM.call(value) }),
+          Transform::Hash::Key.new(
+            'environment_variables',
+            Transform::Sequence.new(
+              [
+                Transform::Primitive.new(Hash),
+                Transform::Block.capture(:environment_variables, &method(:parse_environment_variables))
+              ]
+            )
+          ),
+          Transform::Hash::Key.new('fail_fast',   Transform::BOOLEAN),
+          Transform::Hash::Key.new('hooks',       PATHNAME_ARRAY),
+          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('matcher',     Matcher::Config::LOADER),
+          Transform::Hash::Key.new('mutation',    Mutation::Config::TRANSFORM),
+          Transform::Hash::Key.new('requires',    Transform::STRING_ARRAY)
+        ],
+        required: []
+      ),
+      Transform::Hash::Symbolize.new
+    ].freeze
+
+    private_constant(:TRANSFORMS)
   end # Config
   # rubocop:enable Metrics/ClassLength
 end # Mutant

data/lib/mutant/env.rb

@@ -137,7 +137,7 @@ module Mutant
   private
 
     def run_mutation_tests(mutation, tests)
-      config.isolation.call(config.mutation_timeout) do
+      config.isolation.call(config.mutation.timeout) do
         hooks.run(:mutation_insert_pre, mutation)
         result = mutation.insert(world.kernel)
         hooks.run(:mutation_insert_post, mutation)

data/lib/mutant/license/subscription/opensource.rb

@@ -18,7 +18,7 @@ module Mutant
           end
 
           def self.parse(input)
-            new(*input.split('/', 2))
+            new(*input.split('/', 2).map(&:downcase))
           end
 
           def self.parse_remote(input)

data/lib/mutant/matcher/method.rb

@@ -99,13 +99,20 @@ module Mutant
           node = matched_node_path.last || return
 
           self.class::SUBJECT_CLASS.new(
-            config:     Subject::Config.parse(ast.comment_associations.fetch(node, [])),
+            config:     subject_config(node),
             context:    context,
             node:       node,
             visibility: visibility
           )
         end
 
+        def subject_config(node)
+          Subject::Config.parse(
+            comments: ast.comment_associations.fetch(node, []),
+            mutation: env.config.mutation
+          )
+        end
+
         def matched_node_path
           AST.find_last_path(ast.node, &method(:match?))
         end

data/lib/mutant/meta/example.rb

@@ -55,7 +55,10 @@ module Mutant
       #
       # @return [Enumerable<Mutant::Mutation>]
       def generated
-        Mutator.mutate(node).map do |node|
+        Mutator::Node.mutate(
+          config: Mutation::Config::DEFAULT,
+          node:   node
+        ).map do |node|
           Mutation::Evil.new(self, node)
         end
       end

data/lib/mutant/mutation/config.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutation
+    class Config
+      include Anima.new(:ignore_patterns, :timeout)
+
+      DEFAULT = new(
+        timeout:         nil,
+        ignore_patterns: []
+      )
+
+      ignore_pattern = Transform::Block.capture('ignore pattern', &AST::Pattern.method(:parse))
+
+      TRANSFORM = Transform::Sequence.new(
+        [
+          Transform::Hash.new(
+            optional: [
+              Transform::Hash::Key.new('ignore_patterns', Transform::Array.new(ignore_pattern)),
+              Transform::Hash::Key.new('timeout',         Transform::FLOAT)
+            ],
+            required: []
+          ),
+          Transform::Hash::Symbolize.new,
+          Transform::Success.new(DEFAULT.method(:with))
+        ]
+      )
+
+      def merge(other)
+        with(
+          timeout: other.timeout || timeout
+        )
+      end
+    end # Config
+  end # Mutation
+end # Mutant

data/lib/mutant/mutator/node/arguments.rb

@@ -50,7 +50,7 @@ module Mutant
 
         def emit_argument_mutations
           children.each_with_index do |child, index|
-            Mutator.mutate(child).each do |mutant|
+            mutate(node: child).each do |mutant|
               next if invalid_argument_replacement?(mutant, index)
               emit_child_update(index, mutant)
             end

data/lib/mutant/mutator/node/begin.rb

@@ -12,8 +12,9 @@ module Mutant
       private
 
         def dispatch
+          ignore_single = children.any?(&method(:ignore?))
           mutate_single_child do |child|
-            emit(child)
+            emit(child) unless ignore_single
           end
         end
       end # Begin

data/lib/mutant/mutator/node/define.rb

@@ -13,8 +13,11 @@ module Mutant
           emit_optarg_body_assignments
           emit_body(N_RAISE)
           emit_body(N_ZSUPER)
-          emit_body(nil)
-          emit_body_mutations if body
+
+          return unless body && !ignore?(body)
+
+          emit_body(nil) unless body.children.any?(&method(:ignore?))
+          emit_body_mutations
         end
 
         def emit_optarg_body_assignments

data/lib/mutant/mutator/node/kwargs.rb

@@ -20,14 +20,14 @@ module Mutant
         end
 
         def emit_argument_presence
-          Util::Array::Presence.call(children).each do |children|
+          Util::Array::Presence.call(input: children, parent: nil).each do |children|
             emit_type(*children) unless children.empty?
           end
         end
 
         def emit_argument_mutations
           children.each_with_index do |child, index|
-            Mutator.mutate(child).each do |mutant|
+            mutate(node: child).each do |mutant|
               unless forbid_argument?(mutant)
                 emit_child_update(index, mutant)
               end

data/lib/mutant/mutator/node/literal/regex.rb

@@ -33,7 +33,7 @@ module Mutant
             # Regular expressions with interpolation are skipped.
             return unless (body_ast = AST::Regexp.expand_regexp_ast(input))
 
-            Mutator.mutate(body_ast).each do |mutation|
+            mutate(node: body_ast).each do |mutation|
               source = AST::Regexp.to_expression(mutation).to_s
               emit_type(s(:str, source), options)
             end

data/lib/mutant/mutator/node/literal/symbol.rb

@@ -15,9 +15,9 @@ module Mutant
 
           def dispatch
             emit_singletons
-            Util::Symbol.call(value).each(&method(:emit_type))
-          end
 
+            Util::Symbol.call(input: value, parent: nil).each(&method(:emit_type))
+          end
         end # Symbol
       end # Literal
     end # Node

data/lib/mutant/mutator/node/named_value/constant_assignment.rb

@@ -26,7 +26,7 @@ module Mutant
           end
 
           def mutate_name
-            Util::Symbol.call(name).each do |name|
+            Util::Symbol.call(input: name, parent: nil).each do |name|
               emit_name(name.upcase)
             end
           end

data/lib/mutant/mutator/node/named_value/variable_assignment.rb

@@ -34,11 +34,11 @@ module Mutant
           def mutate_name
             prefix, regexp = MAP.fetch(node.type)
             stripped = name.to_s.sub(regexp, EMPTY_STRING)
-            Util::Symbol.call(stripped).each do |name|
+
+            Util::Symbol.call(input: stripped, parent: nil).each do |name|
               emit_name(:"#{prefix}#{name}")
             end
           end
-
         end # VariableAssignment
       end # NamedValue
     end # Node

data/lib/mutant/mutator/node/resbody.rb

@@ -15,17 +15,7 @@ module Mutant
         def dispatch
           emit_assignment(nil)
           emit_body_mutations if body
-          mutate_captures
         end
-
-        def mutate_captures
-          return unless captures
-          Util::Array::Element.call(captures.children).each do |matchers|
-            next if matchers.any?(&method(:n_nil?))
-            emit_captures(s(:array, *matchers))
-          end
-        end
-
       end # Resbody
     end # Node
   end # Mutator

data/lib/mutant/mutator/node.rb

@@ -10,8 +10,37 @@ module Mutant
       include AbstractType, Unparser::Constants
       include AST::NamedChildren, AST::NodePredicates, AST::Sexp, AST::Nodes
 
+      include anima.add(:config)
+
       TAUTOLOGY = ->(_input) { true }
 
+      REGISTRY = Registry.new(->(_) { Node::Generic })
+
+      # Lookup and invoke dedicated AST mutator
+      #
+      # @param input [Parser::AST::Node]
+      # @param parent [nil,Mutant::Mutator::Node]
+      #
+      # @return [Set<Parser::AST::Node>]
+      def self.mutate(config:, node:, parent: nil)
+        config.ignore_patterns.each do |pattern|
+          return Set.new if pattern.match?(node)
+        end
+
+        self::REGISTRY.lookup(node.type).call(
+          config: config,
+          input:  node,
+          parent: parent
+        )
+      end
+
+      def self.handle(*types)
+        types.each do |type|
+          self::REGISTRY.register(type, self)
+        end
+      end
+      private_class_method :handle
+
       # Helper to define a named child
       #
       # @param [Parser::AST::Node] node
@@ -37,9 +66,13 @@ module Mutant
       alias_method :node,     :input
       alias_method :dup_node, :dup_input
 
+      def mutate(node:, parent: nil)
+        self.class.mutate(config: config, node: node, parent: parent)
+      end
+
       def mutate_child(index, &block)
         block ||= TAUTOLOGY
-        Mutator.mutate(children.fetch(index), self).each do |mutation|
+        mutate(node: children.fetch(index), parent: self).each do |mutation|
           next unless block.call(mutation)
           emit_child_update(index, mutation)
         end
@@ -96,6 +129,19 @@ module Mutant
         end
       end
 
+      def run(mutator)
+        mutator.call(
+          config: config,
+          input:  input,
+          parent: nil
+        ).each(&method(:emit))
+      end
+
+      def ignore?(node)
+        config.ignore_patterns.any? do |pattern|
+          pattern.match?(node)
+        end
+      end
     end # Node
   end # Mutator
 end # Mutant

data/lib/mutant/mutator/util/array.rb

@@ -21,23 +21,6 @@ module Mutant
           end
 
         end # Presence
-
-        # Array element mutator
-        class Element < Util
-
-        private
-
-          def dispatch
-            input.each_with_index do |element, index|
-              Mutator.mutate(element).each do |mutation|
-                dup = dup_input
-                dup[index] = mutation
-                emit(dup)
-              end
-            end
-          end
-
-        end # Element
       end # Array
     end # Util
   end # Mutator

data/lib/mutant/mutator.rb

@@ -3,33 +3,13 @@
 module Mutant
   # Generator for mutations
   class Mutator
-
-    REGISTRY = Registry.new(->(_) { Node::Generic })
-
     include(
       Adamantium,
-      Concord.new(:input, :parent),
       AbstractType,
+      Anima.new(:input, :parent),
       Procto
     )
 
-    # Lookup and invoke dedicated AST mutator
-    #
-    # @param node [Parser::AST::Node]
-    # @param parent [nil,Mutant::Mutator::Node]
-    #
-    # @return [Set<Parser::AST::Node>]
-    def self.mutate(node, parent = nil)
-      self::REGISTRY.lookup(node.type).call(node, parent)
-    end
-
-    def self.handle(*types)
-      types.each do |type|
-        self::REGISTRY.register(type, self)
-      end
-    end
-    private_class_method :handle
-
     # Return output
     #
     # @return [Set<Parser::AST::Node>]
@@ -39,7 +19,7 @@ module Mutant
 
   private
 
-    def initialize(_input, _parent = nil)
+    def initialize(_attributes)
       super
 
       @output = Set.new
@@ -60,10 +40,6 @@ module Mutant
       output << object
     end
 
-    def run(mutator)
-      mutator.call(input).each(&method(:emit))
-    end
-
     def dup_input
       input.dup
     end

data/lib/mutant/reporter/cli/printer/config.rb

@@ -20,7 +20,7 @@ module Mutant
             info 'Jobs:            %s',    object.jobs || 'auto'
             info 'Includes:        %s',    object.includes
             info 'Requires:        %s',    object.requires
-            info 'MutationTimeout: %0.9g', object.mutation_timeout if object.mutation_timeout
+            info 'MutationTimeout: %0.9g', object.mutation.timeout if object.mutation.timeout
           end
           # rubocop:enable Metrics/AbcSize
 

data/lib/mutant/subject/config.rb

@@ -3,16 +3,17 @@
 module Mutant
   class Subject
     class Config
-      include Adamantium, Anima.new(:inline_disable)
+      include Adamantium, Anima.new(:inline_disable, :mutation)
 
-      DEFAULT = new(inline_disable: false)
+      DEFAULT = new(inline_disable: false, mutation: Mutation::Config::DEFAULT)
 
       DISABLE_REGEXP = /(\s|^)mutant:disable(?:\s|$)/.freeze
       SYNTAX_REGEXP  = /\A(?:#|=begin\n)/.freeze
 
-      def self.parse(comments)
+      def self.parse(comments:, mutation:)
         new(
-          inline_disable: comments.any? { |comment| DISABLE_REGEXP.match?(comment_body(comment)) }
+          inline_disable: comments.any? { |comment| DISABLE_REGEXP.match?(comment_body(comment)) },
+          mutation:       mutation
         )
       end
 

data/lib/mutant/subject.rb

@@ -12,7 +12,10 @@ module Mutant
     # @return [undefined]
     def mutations
       [neutral_mutation].concat(
-        Mutator.mutate(node).map do |mutant|
+        Mutator::Node.mutate(
+          config: config.mutation,
+          node:   node
+        ).map do |mutant|
           Mutation::Evil.new(self, wrap_node(mutant))
         end
       )

data/lib/mutant/transform.rb

@@ -421,6 +421,20 @@ module Mutant
       end
     end # Sequence
 
+    # Always successful transformation
+    class Success < self
+      include Concord.new(:block)
+
+      # Apply transformation to input
+      #
+      # @param [Object]
+      #
+      # @return [Either<Error, Object>]
+      def call(input)
+        success(block.call(input))
+      end
+    end # Sequence
+
     # Generic exception transformer
     class Exception < self
       include Concord.new(:error_class, :block)

data/lib/mutant/version.rb

@@ -2,5 +2,5 @@
 
 module Mutant
   # Current mutant version
-  VERSION = '0.11.11'
+  VERSION = '0.11.12'
 end # Mutant

data/lib/mutant.rb

@@ -93,6 +93,7 @@ require 'mutant/parallel/source'
 require 'mutant/parallel/worker'
 require 'mutant/require_highjack'
 require 'mutant/mutation'
+require 'mutant/mutation/config'
 require 'mutant/mutator'
 require 'mutant/mutator/util'
 require 'mutant/mutator/util/array'
@@ -288,7 +289,7 @@ module Mutant
       isolation:             Mutant::Isolation::Fork.new(WORLD),
       jobs:                  nil,
       matcher:               Matcher::Config::DEFAULT,
-      mutation_timeout:      nil,
+      mutation:              Mutation::Config::DEFAULT,
       reporter:              Reporter::CLI.build(WORLD.stdout),
       requires:              EMPTY_ARRAY,
       zombie:                false

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mutant
 version: !ruby/object:Gem::Version
-  version: 0.11.11
+  version: 0.11.12
 platform: ruby
 authors:
 - Markus Schirp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-20 00:00:00.000000000 Z
+date: 2022-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -249,6 +249,7 @@ files:
 - lib/mutant/meta/example/dsl.rb
 - lib/mutant/meta/example/verification.rb
 - lib/mutant/mutation.rb
+- lib/mutant/mutation/config.rb
 - lib/mutant/mutator.rb
 - lib/mutant/mutator/node.rb
 - lib/mutant/mutator/node/and_asgn.rb