mutant 0.11.20 → 0.11.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28479ac15f5cf3d79de8ffd27e87601db35a642c09a9d717df6d34bfb41bc0c0
-  data.tar.gz: 1aa5fc440f828ab7a3b21fbb65534899be91281bfd238e86cf3e7e7098f3c4ba
+  metadata.gz: bf5fb7800ce81d8fa90585c0dbd00ef9e2f2d21fa1ffbb788cbb59bb9323f677
+  data.tar.gz: 206c2db89f0cfca28b088059a68b0715974dffee6062a8825dd27c703ecbb245
 SHA512:
-  metadata.gz: 9a7bb108c85e012d4ba53444e612ff955f6ceafbac159f1d4a1561c62f8f693279d1673e2cde0899ef2356ac42bad99143405d2ab482c35215553548c734e662
-  data.tar.gz: 143cc0c327d18f4203a6769606ceb976aaf0fb748168680d80bc0d4d2099d203a4271cf2a3644307050421c841a9019441947250c21fdefaf7883c198f0887b8
+  metadata.gz: 3923e0d8c6927da2c7f6ca9915fd84c98e032708bb41b9c10c91cca92503226a1d04d09b20970ffad44b06e0ca7ff20215609d385f927ea0880a8b60bafcad93
+  data.tar.gz: 43834f9ec8af1dd4a65b307cf43af4acaffcb839c3c76fe52069dedb2201d80c7a81e313c6e4742fd9d28f81229f36f72bbfb5f4a7c119d13a001705648993b8

data/lib/mutant/ast/meta/send.rb

@@ -33,8 +33,7 @@ module Mutant
         #
         # @return [Boolean]
         def attribute_assignment?
-          !Types::METHOD_OPERATORS.include?(selector) &&
-          selector.to_s.end_with?(ATTRIBUTE_ASSIGNMENT_SELECTOR_SUFFIX)
+          !Types::METHOD_OPERATORS.include?(selector) && selector.end_with?(ATTRIBUTE_ASSIGNMENT_SELECTOR_SUFFIX)
         end
 
         # Test for binary operator implemented as method

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

@@ -28,18 +28,8 @@ module Mutant
           env = Env.empty(world, @config)
 
           env
-            .record(:config) { Config.load_config_file(env).fmap(&method(:expand)) }
-            .bind { Bootstrap.call(env.with(config: @config)) }
-        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)
+            .record(:config) { Config.load(cli_config: @config, world: world) }
+            .bind { |config| Bootstrap.call(env.with(config: config)) }
         end
 
         def parse_remaining_arguments(arguments)
@@ -87,9 +77,22 @@ module Mutant
         def add_integration_options(parser)
           parser.separator('Integration:')
 
-          parser.on('--use INTEGRATION', 'Use INTEGRATION to kill mutations') do |name|
-            set(integration: name)
-          end
+          parser.on('--use INTEGRATION', 'deprecated alias for --integration', &method(:assign_integration_name))
+          parser.on('--integration NAME', 'Use test integration with NAME', &method(:assign_integration_name))
+
+          parser.on(
+            '--integration-argument ARGUMENT', 'Pass ARGUMENT to integration',
+            &method(:add_integration_argument)
+          )
+        end
+
+        def add_integration_argument(value)
+          config = @config.integration
+          set(integration: config.with(arguments: config.arguments + [value]))
+        end
+
+        def assign_integration_name(name)
+          set(integration: @config.integration.with(name: name))
         end
 
         def add_matcher_options(parser)

data/lib/mutant/config.rb

@@ -52,6 +52,20 @@ module Mutant
       ```
     MESSAGE
 
+    INTEGRATION_DEPRECATION = <<~'MESSAGE'
+      Deprecated configuration toplevel string key `integration` found.
+
+      This key will be removed in the next major version.
+      Instead place your integration configuration under the `integration.name` key
+      like this:
+
+      ```
+      # mutant.yml
+      integration:
+        name: your_integration # typically rspec or minitest
+      ```
+    MESSAGE
+
     private_constant(*constants(false))
 
     # Merge with other config
@@ -69,7 +83,7 @@ module Mutant
         fail_fast:             fail_fast || other.fail_fast,
         hooks:                 hooks + other.hooks,
         includes:              includes + other.includes,
-        integration:           other.integration || integration,
+        integration:           integration.merge(other.integration),
         jobs:                  other.jobs || jobs,
         matcher:               matcher.merge(other.matcher),
         mutation:              mutation.merge(other.mutation),
@@ -79,30 +93,41 @@ module Mutant
     # rubocop:enable Metrics/AbcSize
     # rubocop:enable Metrics/MethodLength
 
+    # Load the configuration
+    def self.load(cli_config:, world:)
+      load_config_file(reporter: cli_config.reporter, world: world).fmap do |file_config|
+        DEFAULT.with(
+          jobs:     Etc.nprocessors,
+          mutation: Mutation::Config::DEFAULT
+        ).merge(file_config.merge(cli_config))
+      end
+    end
+
     # Load config file
     #
     # @param [Env] env
     #
     # @return [Either<String,Config>]
-    def self.load_config_file(env)
+    def self.load_config_file(reporter:, world:)
       files = CANDIDATES
-        .map(&env.world.pathname.public_method(:new))
+        .map(&world.pathname.public_method(:new))
         .select(&:readable?)
 
       if files.one?
-        load_contents(env, files.first).fmap(&DEFAULT.public_method(:with))
+        load_contents(reporter: reporter, path: files.first).fmap(&DEFAULT.public_method(:with))
       elsif files.empty?
         Either::Right.new(DEFAULT)
       else
         Either::Left.new(MORE_THAN_ONE_CONFIG_FILE % files.join(', '))
       end
     end
+    private_class_method :load_config_file
 
-    def self.load_contents(env, path)
+    def self.load_contents(reporter:, path:)
       Transform::Named
         .new(
           name:      path.to_s,
-          transform: sequence(env.config.reporter)
+          transform: sequence(reporter)
         )
         .call(path)
         .lmap(&:compact_message)
@@ -122,13 +147,6 @@ module Mutant
     end
     private_class_method :sequence
 
-    # The configuration from the environment
-    #
-    # @return [Config]
-    def self.env
-      DEFAULT.with(jobs: Etc.nprocessors)
-    end
-
     PATHNAME_ARRAY = Transform::Array.new(
       transform: Transform::Sequence.new(
         steps: [
@@ -158,14 +176,29 @@ module Mutant
     end
 
     def self.deprecations(reporter, hash)
-      if hash.key?('mutation_timeout')
-        reporter.warn(MUTATION_TIMEOUT_DEPRECATION)
-
-        (hash['mutation'] ||= {})['timeout'] ||= hash.delete('mutation_timeout')
-      end
+      mutation_timeout_deprecation(reporter, hash)
+      integration_deprecation(reporter, hash)
 
       hash
     end
+    private_class_method :deprecations
+
+    def self.mutation_timeout_deprecation(reporter, hash)
+      return unless hash.key?('mutation_timeout')
+      reporter.warn(MUTATION_TIMEOUT_DEPRECATION)
+
+      (hash['mutation'] ||= {})['timeout'] ||= hash.delete('mutation_timeout')
+    end
+    private_class_method :mutation_timeout_deprecation
+
+    def self.integration_deprecation(reporter, hash)
+      value = hash['integration']
+      return unless value.instance_of?(String)
+      reporter.warn(INTEGRATION_DEPRECATION)
+
+      hash['integration'] = { 'name' => value }
+    end
+    private_class_method :integration_deprecation
 
     TRANSFORMS = [
       Transform::Hash.new(
@@ -196,7 +229,7 @@ module Mutant
             value:     'includes'
           ),
           Transform::Hash::Key.new(
-            transform: Transform::STRING,
+            transform: ->(value) { Integration::Config::TRANSFORM.call(value) },
             value:     'integration'
           ),
           Transform::Hash::Key.new(

data/lib/mutant/env.rb

@@ -2,6 +2,7 @@
 
 module Mutant
   # Mutation testing execution environment
+  # rubocop:disable Metrics/ClassLength
   class Env
     include Adamantium, Anima.new(
       :config,
@@ -32,6 +33,7 @@ module Mutant
         config:           config,
         hooks:            Hooks.empty,
         integration:      Integration::Null.new(
+          arguments:         EMPTY_ARRAY,
           expression_parser: config.expression_parser,
           world:             world
         ),
@@ -175,4 +177,5 @@ module Mutant
     end
 
   end # Env
+  # rubocop:enable Metrics/ClassLength
 end # Mutant

data/lib/mutant/integration.rb

@@ -4,7 +4,7 @@ module Mutant
 
   # Abstract base class mutant test framework integrations
   class Integration
-    include AbstractType, Adamantium, Anima.new(:expression_parser, :world)
+    include AbstractType, Adamantium, Anima.new(:arguments, :expression_parser, :world)
 
     LOAD_MESSAGE = <<~'MESSAGE'
       Unable to load integration mutant-%<integration_name>s:
@@ -26,18 +26,47 @@ module Mutant
 
     private_constant(*constants(false))
 
+    class Config
+      include Adamantium, Anima.new(:name, :arguments)
+
+      DEFAULT = new(arguments: EMPTY_ARRAY, name: nil)
+
+      TRANSFORM = Transform::Sequence.new(
+        steps: [
+          Transform::Primitive.new(primitive: Hash),
+          Transform::Hash.new(
+            optional: [
+              Transform::Hash::Key.new(transform: Transform::STRING,       value: 'name'),
+              Transform::Hash::Key.new(transform: Transform::STRING_ARRAY, value: 'arguments')
+            ],
+            required: []
+          ),
+          Transform::Hash::Symbolize.new,
+          Transform::Success.new(block: DEFAULT.method(:with))
+        ]
+      )
+
+      def merge(other)
+        self.class.new(
+          name:      other.name || name,
+          arguments: arguments + other.arguments
+        )
+      end
+    end # Config
+
     # Setup integration
     #
     # @param env [Bootstrap]
     #
     # @return [Either<String, Integration>]
     def self.setup(env)
-      unless env.config.integration
-        return Either::Left.new(INTEGRATION_MISSING)
-      end
+      integration_config = env.config.integration
+
+      return Either::Left.new(INTEGRATION_MISSING) unless integration_config.name
 
       attempt_require(env).bind { attempt_const_get(env) }.fmap do |klass|
         klass.new(
+          arguments:         integration_config.arguments,
           expression_parser: env.config.expression_parser,
           world:             env.world
         ).setup
@@ -46,7 +75,7 @@ module Mutant
 
     # rubocop:disable Style/MultilineBlockChain
     def self.attempt_require(env)
-      integration_name = env.config.integration
+      integration_name = env.config.integration.name
 
       Either.wrap_error(LoadError) do
         env.world.kernel.require("mutant/integration/#{integration_name}")
@@ -61,7 +90,7 @@ module Mutant
     # rubocop:enable Style/MultilineBlockChain
 
     def self.attempt_const_get(env)
-      integration_name = env.config.integration
+      integration_name = env.config.integration.name
       constant_name    = integration_name.capitalize
 
       Either.wrap_error(NameError) { const_get(constant_name) }.lmap do |exception|

data/lib/mutant/isolation/fork.rb

@@ -205,10 +205,6 @@ module Mutant
           _pid, status = world.process.wait2(@pid, Process::WNOHANG)
           status
         end
-
-        def add_result(result)
-          @result = defined?(@result) ? @result.add_error(result) : result
-        end
       end # Parent
       # rubocop:enable Metrics/ClassLength
 

data/lib/mutant/matcher/config.rb

@@ -78,9 +78,11 @@ module Mutant
       #
       # @return [Config]
       def merge(other)
-        self.class.new(
-          to_h
-            .to_h { |name, value| [name, value + other.public_send(name)] }
+        with(
+          ignore:            ignore + other.ignore,
+          start_expressions: start_expressions + other.start_expressions,
+          subjects:          other.subjects.any? ? other.subjects : subjects,
+          diffs:             diffs + other.diffs
         )
       end
 

data/lib/mutant/matcher/filter.rb

@@ -12,9 +12,7 @@ module Mutant
       #
       # @return [Enumerable<Subject>]
       def call(env)
-        matcher
-          .call(env)
-          .select(&predicate.method(:call))
+        matcher.call(env).select(&predicate)
       end
 
     end # Filter

data/lib/mutant/meta/example/dsl.rb

@@ -11,25 +11,26 @@ module Mutant
         #
         # @param [Thread::Backtrace::Location] location
         # @param [Set<Symbol>] types
+        # @param [Mutation::Operators] operators
         #
         # @return [Example]
-        def self.call(location, types, block)
-          instance = new(location, types)
+        #
+        def self.call(location:, types:, operators:, block:) # rubocop:disable Metrics/ParameterLists
+          instance = new(location, types, operators)
           instance.instance_eval(&block)
           instance.example
         end
-
         private_class_method :new
 
         # Initialize object
         #
         # @return [undefined]
-        def initialize(location, types)
-          @expected    = []
-          @location    = location
-          @lvars       = []
-          @source      = nil
-          @types       = types
+        def initialize(location, types, operators)
+          @expected  = []
+          @location  = location
+          @lvars     = []
+          @operators = operators
+          @types     = types
         end
 
         # Example captured by DSL
@@ -46,6 +47,7 @@ module Mutant
             location:        @location,
             lvars:           @lvars,
             node:            @node,
+            operators:       @operators,
             original_source: @source,
             types:           @types
           )

data/lib/mutant/meta/example/verification.rb

@@ -54,7 +54,7 @@ module Mutant
 
         def original
           [
-            'Original:',
+            "Original: (operators: #{example.operators.class.operators_name})",
             example.node,
             example.original_source
           ]

data/lib/mutant/meta/example.rb

@@ -10,6 +10,7 @@ module Mutant
         :location,
         :lvars,
         :node,
+        :operators,
         :original_source,
         :types
       )
@@ -56,7 +57,7 @@ module Mutant
       # @return [Enumerable<Mutant::Mutation>]
       def generated
         Mutator::Node.mutate(
-          config: Mutation::Config::DEFAULT,
+          config: Mutation::Config::DEFAULT.with(operators: operators),
           node:   node
         ).map do |node|
           Mutation::Evil.new(subject: self, node: node)

data/lib/mutant/meta.rb

@@ -16,8 +16,13 @@ module Mutant
       # Add example
       #
       # @return [undefined]
-      def self.add(*types, &block)
-        ALL << DSL.call(caller_locations(1).first, Set.new(types), block)
+      def self.add(*types, operators: :full, &block)
+        ALL << DSL.call(
+          block:     block,
+          location:  caller_locations(1).first,
+          operators: Mutation::Operators.parse(operators.to_s).from_right,
+          types:     Set.new(types)
+        )
       end
 
       Pathname.glob(Pathname.new(__dir__).parent.parent.join('meta', '*.rb'))

data/lib/mutant/mutation/config.rb

@@ -3,11 +3,22 @@
 module Mutant
   class Mutation
     class Config
-      include Anima.new(:ignore_patterns, :timeout)
+      include Anima.new(
+        :ignore_patterns,
+        :operators,
+        :timeout
+      )
+
+      EMPTY = new(
+        ignore_patterns: [],
+        operators:       nil,
+        timeout:         nil
+      )
 
       DEFAULT = new(
-        timeout:         nil,
-        ignore_patterns: []
+        ignore_patterns: [],
+        operators:       Mutation::Operators::Light.new,
+        timeout:         nil
       )
 
       ignore_pattern = Transform::Block.capture('ignore pattern', &AST::Pattern.method(:parse))
@@ -20,6 +31,10 @@ module Mutant
                 transform: Transform::Array.new(transform: ignore_pattern),
                 value:     'ignore_patterns'
               ),
+              Transform::Hash::Key.new(
+                transform: Operators::TRANSFORM,
+                value:     'operators'
+              ),
               Transform::Hash::Key.new(
                 transform: Transform::FLOAT,
                 value:     'timeout'
@@ -28,13 +43,14 @@ module Mutant
             required: []
           ),
           Transform::Hash::Symbolize.new,
-          Transform::Success.new(block: DEFAULT.method(:with))
+          Transform::Success.new(block: EMPTY.method(:with))
         ]
       )
 
       def merge(other)
         with(
           ignore_patterns: other.ignore_patterns,
+          operators:       other.operators || operators,
           timeout:         other.timeout || timeout
         )
       end

data/lib/mutant/mutation/operators.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Mutant
+  # Represent a mutated node with its subject
+  class Mutation
+    class Operators
+      include Equalizer.new
+
+      class Full < self
+        NAME = :full
+
+        SELECTOR_REPLACEMENTS = {
+          :< =>          %i[== eql? equal?],
+          :<= =>         %i[< == eql? equal?],
+          :== =>         %i[eql? equal?],
+          :=== =>        %i[is_a?],
+          :=~ =>         %i[match?],
+          :> =>          %i[== eql? equal?],
+          :>= =>         %i[> == eql? equal?],
+          __send__:      %i[public_send],
+          all?:          %i[any?],
+          any?:          %i[all?],
+          at:            %i[fetch key?],
+          fetch:         %i[key?],
+          flat_map:      %i[map],
+          gsub:          %i[sub],
+          is_a?:         %i[instance_of?],
+          kind_of?:      %i[instance_of?],
+          map:           %i[each],
+          match:         %i[match?],
+          method:        %i[public_method],
+          reverse_each:  %i[each],
+          reverse_map:   %i[map each],
+          reverse_merge: %i[merge],
+          send:          %i[public_send __send__],
+          to_a:          %i[to_ary],
+          to_h:          %i[to_hash],
+          to_i:          %i[to_int],
+          to_s:          %i[to_str],
+          values_at:     %i[fetch_values]
+        }.freeze.tap { |hash| hash.values(&:freeze) }
+      end
+
+      class Light < self
+        NAME = :light
+
+        SELECTOR_REPLACEMENTS = Full::SELECTOR_REPLACEMENTS
+          .dup
+          .tap do |replacements|
+            replacements.delete(:==)
+            replacements.delete(:eql?)
+          end
+          .freeze
+      end
+
+      def self.operators_name
+        self::NAME
+      end
+
+      def selector_replacements
+        self.class::SELECTOR_REPLACEMENTS
+      end
+
+      def self.parse(value)
+        klass = [Light, Full].detect { |candidate| candidate.operators_name.to_s.eql?(value) }
+
+        if klass
+          Either::Right.new(klass.new)
+        else
+          Either::Left.new("Unknown operators: #{value}")
+        end
+      end
+
+      TRANSFORM =
+        Transform::Sequence.new(
+          steps: [
+            Transform::STRING,
+            Transform::Block.capture('parse operator', &method(:parse))
+          ]
+        )
+    end # Operators
+  end # Mutation
+end # Mutant

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

@@ -20,9 +20,12 @@ module Mutant
         def emit_symbol_to_proc_mutations
           return unless n_sym?(argument)
 
-          Send::SELECTOR_REPLACEMENTS.fetch(*argument, EMPTY_ARRAY).each do |method|
-            emit_argument(s(:sym, method))
-          end
+          config
+            .operators
+            .selector_replacements
+            .fetch(*argument, EMPTY_ARRAY).each do |method|
+              emit_argument(s(:sym, method))
+            end
         end
       end # Block
     end # Node

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

@@ -13,37 +13,6 @@ module Mutant
 
         children :receiver, :selector
 
-        SELECTOR_REPLACEMENTS = {
-          :< =>          %i[== eql? equal?],
-          :<= =>         %i[< == eql? equal?],
-          :== =>         %i[eql? equal?],
-          :=== =>        %i[is_a?],
-          :=~ =>         %i[match?],
-          :> =>          %i[== eql? equal?],
-          :>= =>         %i[> == eql? equal?],
-          __send__:      %i[public_send],
-          all?:          %i[any?],
-          any?:          %i[all?],
-          at:            %i[fetch key?],
-          fetch:         %i[key?],
-          flat_map:      %i[map],
-          gsub:          %i[sub],
-          is_a?:         %i[instance_of?],
-          kind_of?:      %i[instance_of?],
-          map:           %i[each],
-          match:         %i[match?],
-          method:        %i[public_method],
-          reverse_each:  %i[each],
-          reverse_map:   %i[map each],
-          reverse_merge: %i[merge],
-          send:          %i[public_send __send__],
-          to_a:          %i[to_ary],
-          to_h:          %i[to_hash],
-          to_i:          %i[to_int],
-          to_s:          %i[to_str],
-          values_at:     %i[fetch_values]
-        }.freeze.tap { |hash| hash.values(&:freeze) }
-
         RECEIVER_SELECTOR_REPLACEMENTS = {
           Date: {
             parse: %i[jd civil strptime iso8601 rfc3339 xmlschema rfc2822 rfc822 httpdate jisx0301]
@@ -227,7 +196,10 @@ module Mutant
         end
 
         def emit_selector_replacement
-          SELECTOR_REPLACEMENTS.fetch(selector, EMPTY_ARRAY).each(&method(:emit_selector))
+          config
+            .operators
+            .selector_replacements
+            .fetch(selector, EMPTY_ARRAY).each(&public_method(:emit_selector))
         end
 
         def emit_naked_receiver

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

@@ -16,10 +16,11 @@ module Mutant
           # rubocop:disable Metrics/AbcSize
           def run
             info 'Matcher:         %s',    object.matcher.inspect
-            info 'Integration:     %s',    object.integration || 'null'
+            info 'Integration:     %s',    object.integration.name || 'null'
             info 'Jobs:            %s',    object.jobs || 'auto'
             info 'Includes:        %s',    object.includes
             info 'Requires:        %s',    object.requires
+            info 'Operators:       %s',    object.mutation.operators.class.operators_name
             info 'MutationTimeout: %0.9g', object.mutation.timeout if object.mutation.timeout
           end
           # rubocop:enable Metrics/AbcSize

data/lib/mutant/version.rb

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

data/lib/mutant.rb

@@ -107,6 +107,7 @@ module Mutant
     require 'mutant/parallel/worker'
     require 'mutant/require_highjack'
     require 'mutant/mutation'
+    require 'mutant/mutation/operators'
     require 'mutant/mutation/config'
     require 'mutant/mutator'
     require 'mutant/mutator/util'
@@ -346,11 +347,11 @@ module Mutant
       fail_fast:             false,
       hooks:                 EMPTY_ARRAY,
       includes:              EMPTY_ARRAY,
-      integration:           nil,
+      integration:           Integration::Config::DEFAULT,
       isolation:             Mutant::Isolation::Fork.new(world: WORLD),
       jobs:                  nil,
       matcher:               Matcher::Config::DEFAULT,
-      mutation:              Mutation::Config::DEFAULT,
+      mutation:              Mutation::Config::EMPTY,
       reporter:              Reporter::CLI.build(WORLD.stdout),
       requires:              EMPTY_ARRAY
     )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mutant
 version: !ruby/object:Gem::Version
-  version: 0.11.20
+  version: 0.11.22
 platform: ruby
 authors:
 - Markus Schirp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-22 00:00:00.000000000 Z
+date: 2023-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.7
+        version: 0.6.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.7
+        version: 0.6.8
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
@@ -235,6 +235,7 @@ files:
 - lib/mutant/meta/example/verification.rb
 - lib/mutant/mutation.rb
 - lib/mutant/mutation/config.rb
+- lib/mutant/mutation/operators.rb
 - lib/mutant/mutation/runner.rb
 - lib/mutant/mutation/runner/sink.rb
 - lib/mutant/mutator.rb