mutant 0.11.21 → 0.11.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47d87c7b5cf12da4906d170d892be1d5121b4f65b86b39365db2d6424f1487c6
-  data.tar.gz: e8d9007fc9633eea5343b83282d331fab5e59aaf6f880aa9b52cb525b2f6db81
+  metadata.gz: bf5fb7800ce81d8fa90585c0dbd00ef9e2f2d21fa1ffbb788cbb59bb9323f677
+  data.tar.gz: 206c2db89f0cfca28b088059a68b0715974dffee6062a8825dd27c703ecbb245
 SHA512:
-  metadata.gz: 04e36404f3a210cfa4a7045e244a72509e69332dbf736e81f5069a7d632680931747b761fd5f61e2ba915e94a0f9545506c3db2369a44f62a21b7a0254264db6
-  data.tar.gz: 2e0db7e6d2ada9525ec054a197f8004e223a31c093ab7b603704044f92f8e1f4305048851b8a583172f3904a028a25a304a605e3e84d5a5e708eccabb6842e9c
+  metadata.gz: 3923e0d8c6927da2c7f6ca9915fd84c98e032708bb41b9c10c91cca92503226a1d04d09b20970ffad44b06e0ca7ff20215609d385f927ea0880a8b60bafcad93
+  data.tar.gz: 43834f9ec8af1dd4a65b307cf43af4acaffcb839c3c76fe52069dedb2201d80c7a81e313c6e4742fd9d28f81229f36f72bbfb5f4a7c119d13a001705648993b8

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

@@ -3,7 +3,6 @@
 module Mutant
   module CLI
     class Command
-      # rubocop:disable Metrics/ClassLength
       class Environment < self
         NAME              = 'environment'
         SHORT_DESCRIPTION = 'Environment subcommands'
@@ -29,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)

data/lib/mutant/config.rb

@@ -93,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)
@@ -136,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: [

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/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

@@ -20,6 +20,7 @@ module Mutant
             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.21'
+  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'
@@ -350,7 +351,7 @@ module Mutant
       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.21
+  version: 0.11.22
 platform: ruby
 authors:
 - Markus Schirp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-15 00:00:00.000000000 Z
+date: 2023-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -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