mutant 0.10.20 → 0.10.25

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/config.rb

@@ -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/env.rb

@@ -43,19 +43,21 @@ module Mutant
     end
     # rubocop:enable Metrics/MethodLength
 
-    # Kill mutation
+    # Cover mutation with specific index
     #
-    # @param [Mutation] mutation
+    # @param [Integer] mutation_index
     #
-    # @return [Result::Mutation]
-    def kill(mutation)
+    # @return [Result::MutationIndex]
+    def cover_index(mutation_index)
+      mutation = mutations.fetch(mutation_index)
+
       start = timer.now
 
       tests = selections.fetch(mutation.subject)
 
-      Result::Mutation.new(
+      Result::MutationIndex.new(
         isolation_result: run_mutation_tests(mutation, tests),
-        mutation:         mutation,
+        mutation_index:   mutation_index,
         runtime:          timer.now - start
       )
     end

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/namespace.rb

@@ -17,7 +17,7 @@ module Mutant
         def initialize(*)
           super
 
-          @syntax = "#{scope_name}*"
+          @syntax = "#{scope_name}*".freeze # rubocop:disable Style/RedundantFreeze
 
           @recursion_pattern = Regexp.union(
             /\A#{scope_name}\z/,

data/lib/mutant/isolation/fork.rb

@@ -230,7 +230,7 @@ module Mutant
 
       end # Child
 
-      private_constant(*(constants(false) - %i[ChildError ForkError]))
+      private_constant(*constants(false))
 
       # Call block in isolation
       #

data/lib/mutant/loader.rb

@@ -18,7 +18,7 @@ module Mutant
 
       # Vale returned on MRI detecting void value expressions
       class VoidValue < self
-      end # voidValue
+      end # VoidValue
     end # Result
 
     # Call loader

data/lib/mutant/matcher.rb

@@ -20,7 +20,7 @@ module Mutant
     # @return [Matcher]
     def self.from_config(config)
       Filter.new(
-        Chain.new(config.match_expressions.map(&:matcher)),
+        Chain.new(config.subjects.map(&:matcher)),
         method(:allowed_subject?).curry.call(config)
       )
     end
@@ -42,7 +42,7 @@ module Mutant
     #
     # @return [Boolean]
     def self.ignore_subject?(config, subject)
-      config.ignore_expressions.any? do |expression|
+      config.ignore.any? do |expression|
         expression.prefix?(subject.expression)
       end
     end

data/lib/mutant/matcher/config.rb

@@ -5,8 +5,8 @@ module Mutant
     # Subject matcher configuration
     class Config
       include Adamantium, Anima.new(
-        :ignore_expressions,
-        :match_expressions,
+        :ignore,
+        :subjects,
         :start_expressions,
         :subject_filters
       )
@@ -17,15 +17,36 @@ module Mutant
       ENUM_DELIMITER      = ','
       EMPTY_ATTRIBUTES    = 'empty'
       PRESENTATIONS       = IceNine.deep_freeze(
-        ignore_expressions: :syntax,
-        match_expressions:  :syntax,
-        start_expressions:  :syntax,
-        subject_filters:    :inspect
+        ignore:            :syntax,
+        start_expressions: :syntax,
+        subject_filters:   :inspect,
+        subjects:          :syntax
       )
       private_constant(*constants(false))
 
       DEFAULT = new(Hash[anima.attribute_names.map { |name| [name, []] }])
 
+      expression = Transform::Block.capture(:expression) do |input|
+        Mutant::Config::DEFAULT.expression_parser.call(input)
+      end
+
+      expression_array = Transform::Array.new(expression)
+
+      LOADER =
+        Transform::Sequence.new(
+          [
+            Transform::Hash.new(
+              optional: [
+                Transform::Hash::Key.new('subjects', expression_array),
+                Transform::Hash::Key.new('ignore', expression_array)
+              ],
+              required: []
+            ),
+            Transform::Hash::Symbolize.new,
+            ->(attributes) { Either::Right.new(DEFAULT.with(attributes)) }
+          ]
+        )
+
       # Inspection string
       #
       # @return [String]

data/lib/mutant/matcher/method.rb

@@ -87,9 +87,8 @@ module Mutant
           node = matched_node_path.last || return
 
           self.class::SUBJECT_CLASS.new(
-            context:  context,
-            node:     node,
-            warnings: env.world.warnings
+            context: context,
+            node:    node
           )
         end
         memoize :subject

data/lib/mutant/matcher/method/metaclass.rb

@@ -80,7 +80,7 @@ module Mutant
         end # Evaluator
 
         private_constant(*constants(false))
-      end # Singleton
+      end # Metaclass
     end # Method
   end # Matcher
 end # Mutant

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

@@ -37,7 +37,7 @@ module Mutant
         # @return [Example]
         #
         # @raise [RuntimeError]
-        #   in case example cannot be build
+        #   in case the example cannot be built
         def example
           fail 'source not defined' unless @source
 
@@ -82,6 +82,11 @@ module Mutant
           mutation('self')
         end
 
+        def regexp_mutations
+          mutation('//')
+          mutation('/nomatch\A/')
+        end
+
         def node(input)
           case input
           when String

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

@@ -8,8 +8,6 @@ module Mutant
 
         handle(:args)
 
-        PROCARG = %i[restarg mlhs].freeze
-
       private
 
         def dispatch

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

@@ -21,7 +21,7 @@ module Mutant
         end
 
         def mutate_body
-          emit_body(nil)
+          emit_body(nil) unless unconditional_loop?
           emit_body(N_RAISE)
 
           return unless body
@@ -31,6 +31,10 @@ module Mutant
           mutate_body_receiver
         end
 
+        def unconditional_loop?
+          send.eql?(s(:send, nil, :loop))
+        end
+
         def body_has_control?
           AST.find_last_path(body) do |node|
             n_break?(node) || n_next?(node)

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

@@ -18,7 +18,7 @@ module Mutant
           end
         end
 
-      end # Dstr
+      end # DynamicLiteral
     end # Node
   end # Mutator
 end # Mutant

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      # Mutator for kwargs node
+      class Kwargs < self
+
+        DISALLOW = %i[nil self].freeze
+
+        private_constant(*constants(false))
+
+        handle(:kwargs)
+
+      private
+
+        def dispatch
+          emit_argument_presence
+          emit_argument_mutations
+        end
+
+        def emit_argument_presence
+          Util::Array::Presence.call(children).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|
+              unless forbid_argument?(mutant)
+                emit_child_update(index, mutant)
+              end
+            end
+          end
+        end
+
+        def forbid_argument?(node)
+          n_pair?(node) && DISALLOW.include?(node.children.first.type)
+        end
+      end # Kwargs
+    end # Node
+  end # Mutator
+end # Mutant