mutant 0.11.18 → 0.11.19

data/lib/mutant/matcher/namespace.rb

@@ -4,7 +4,7 @@ module Mutant
   class Matcher
     # Matcher for specific namespace
     class Namespace < self
-      include Concord::Public.new(:expression)
+      include Anima.new(:expression)
 
       # Enumerate subjects
       #
@@ -13,7 +13,7 @@ module Mutant
       # @return [Enumerable<Subject>]
       def call(env)
         Chain.new(
-          matched_scopes(env).map { |scope| Scope.new(scope.raw) }
+          matchers: matched_scopes(env).map { |scope| Scope.new(scope: scope.raw) }
         ).call(env)
       end
 

data/lib/mutant/matcher/scope.rb

@@ -9,7 +9,7 @@ module Mutant
     # to hook in custom matchers. In that case the scope matchers to expand
     # should be passed as arguments to the constructor.
     class Scope < self
-      include Concord.new(:scope)
+      include Anima.new(:scope)
 
       MATCHERS = [
         Matcher::Methods::Singleton,
@@ -25,13 +25,13 @@ module Mutant
       #
       # @return [Enumerable<Subject>]
       def call(env)
-        Chain.new(effective_matchers).call(env)
+        Chain.new(matchers: effective_matchers).call(env)
       end
 
     private
 
       def effective_matchers
-        MATCHERS.map { |matcher| matcher.new(scope) }
+        MATCHERS.map { |matcher| matcher.new(scope: scope) }
       end
 
     end # Scope

data/lib/mutant/matcher/static.rb

@@ -4,7 +4,7 @@ module Mutant
   class Matcher
     # Matcher returning subjects already known at its creation time
     class Static
-      include Concord.new(:subjects)
+      include Anima.new(:subjects)
 
       # Call matcher
       #

data/lib/mutant/matcher.rb

@@ -20,8 +20,8 @@ module Mutant
     # @return [Matcher]
     def self.from_config(config)
       Filter.new(
-        Chain.new(config.subjects.map(&:matcher)),
-        method(:allowed_subject?).curry.call(config)
+        matcher:   Chain.new(matchers: config.subjects.map(&:matcher)),
+        predicate: method(:allowed_subject?).curry.call(config)
       )
     end
 

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

@@ -5,7 +5,7 @@ module Mutant
     class Example
       # Example verification
       class Verification
-        include Adamantium, Concord.new(:example, :mutations)
+        include Adamantium, Anima.new(:example, :mutations)
 
         # Test if mutation was verified successfully
         #
@@ -94,7 +94,7 @@ module Mutant
 
         def missing
           (example.expected.map(&:node) - mutations.map(&:node)).map do |node|
-            Mutation::Evil.new(example, node)
+            Mutation::Evil.new(subject: example, node: node)
           end
         end
         memoize :missing

data/lib/mutant/meta/example.rb

@@ -22,7 +22,7 @@ module Mutant
       #
       # @return [Verification]
       def verification
-        Verification.new(self, generated)
+        Verification.new(example: self, mutations: generated)
       end
       memoize :verification
 
@@ -38,8 +38,8 @@ module Mutant
       # @return [Context]
       def context
         Context.new(
-          Object,
-          location.path
+          scope:       Object,
+          source_path: location.path
         )
       end
 
@@ -59,7 +59,7 @@ module Mutant
           config: Mutation::Config::DEFAULT,
           node:   node
         ).map do |node|
-          Mutation::Evil.new(self, node)
+          Mutation::Evil.new(subject: self, node: node)
         end
       end
       memoize :generated

data/lib/mutant/mutation/config.rb

@@ -13,16 +13,22 @@ module Mutant
       ignore_pattern = Transform::Block.capture('ignore pattern', &AST::Pattern.method(:parse))
 
       TRANSFORM = Transform::Sequence.new(
-        [
+        steps: [
           Transform::Hash.new(
             optional: [
-              Transform::Hash::Key.new('ignore_patterns', Transform::Array.new(ignore_pattern)),
-              Transform::Hash::Key.new('timeout',         Transform::FLOAT)
+              Transform::Hash::Key.new(
+                transform: Transform::Array.new(transform: ignore_pattern),
+                value:     'ignore_patterns'
+              ),
+              Transform::Hash::Key.new(
+                transform: Transform::FLOAT,
+                value:     'timeout'
+              )
             ],
             required: []
           ),
           Transform::Hash::Symbolize.new,
-          Transform::Success.new(DEFAULT.method(:with))
+          Transform::Success.new(block: DEFAULT.method(:with))
         ]
       )
 

data/lib/mutant/mutation/runner/sink.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutation
+    module Runner
+      class Sink
+        include Anima.new(:env)
+
+        # Initialize object
+        #
+        # @return [undefined]
+        def initialize(*)
+          super
+          @start           = env.world.timer.now
+          @subject_results = {}
+        end
+
+        # Runner status
+        #
+        # @return [Result::Env]
+        def status
+          Result::Env.new(
+            env:             env,
+            runtime:         env.world.timer.now - @start,
+            subject_results: @subject_results.values
+          )
+        end
+
+        # Test if scheduling stopped
+        #
+        # @return [Boolean]
+        def stop?
+          status.stop?
+        end
+
+        # Handle mutation finish
+        #
+        # @param [Result::MutationIndex] mutation_index_result
+        #
+        # @return [self]
+        def result(mutation_index_result)
+          mutation_result = mutation_result(mutation_index_result)
+
+          subject = mutation_result.mutation.subject
+
+          @subject_results[subject] = Result::Subject.new(
+            subject:          subject,
+            coverage_results: previous_coverage_results(subject).dup << coverage_result(mutation_result),
+            tests:            env.selections.fetch(subject)
+          )
+
+          self
+        end
+
+      private
+
+        def coverage_result(mutation_result)
+          Result::Coverage.new(
+            mutation_result: mutation_result,
+            criteria_result: mutation_result.criteria_result(env.config.coverage_criteria)
+          )
+        end
+
+        def mutation_result(mutation_index_result)
+          Result::Mutation.new(
+            isolation_result: mutation_index_result.isolation_result,
+            mutation:         env.mutations.fetch(mutation_index_result.mutation_index),
+            runtime:          mutation_index_result.runtime
+          )
+        end
+
+        def previous_coverage_results(subject)
+          subject_result = @subject_results.fetch(subject) { return EMPTY_ARRAY }
+          subject_result.coverage_results
+        end
+
+      end # Sink
+    end # Runner
+  end # Mutation
+end # Mutant

data/lib/mutant/mutation/runner.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutation
+    module Runner
+      # Run against env
+      #
+      # @return [Either<String, Result>]
+      def self.call(env)
+        reporter(env).start(env)
+
+        Either::Right.new(run_mutation_analysis(env))
+      end
+
+      def self.run_mutation_analysis(env)
+        reporter = reporter(env)
+
+        env
+          .record(:analysis) { run_driver(reporter, async_driver(env)) }
+          .tap { |result| env.record(:report) { reporter.report(result) } }
+      end
+      private_class_method :run_mutation_analysis
+
+      def self.async_driver(env)
+        Parallel.async(env.world, mutation_test_config(env))
+      end
+      private_class_method :async_driver
+
+      def self.run_driver(reporter, driver)
+        Signal.trap('INT') do
+          driver.stop
+        end
+
+        loop do
+          status = driver.wait_timeout(reporter.delay)
+          break status.payload if status.done?
+          reporter.progress(status)
+        end
+      end
+      private_class_method :run_driver
+
+      def self.mutation_test_config(env)
+        Parallel::Config.new(
+          block:        env.method(:cover_index),
+          jobs:         env.config.jobs,
+          process_name: 'mutant-worker-process',
+          sink:         Sink.new(env: env),
+          source:       Parallel::Source::Array.new(jobs: env.mutations.each_index.to_a),
+          thread_name:  'mutant-worker-thread'
+        )
+      end
+      private_class_method :mutation_test_config
+
+      def self.reporter(env)
+        env.config.reporter
+      end
+      private_class_method :reporter
+
+    end # Runner
+  end # Mutation
+end # Mutant

data/lib/mutant/mutation.rb

@@ -4,7 +4,7 @@ module Mutant
   # Represent a mutated node with its subject
   class Mutation
     include AbstractType, Adamantium
-    include Concord::Public.new(:subject, :node)
+    include Anima.new(:subject, :node)
 
     CODE_DELIMITER = "\0"
     CODE_RANGE     = (..4).freeze

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

@@ -48,7 +48,7 @@ module Mutant
         def mutate_body_receiver
           return if n_lambda?(send) || !n_send?(body)
 
-          body_meta = AST::Meta::Send.new(body)
+          body_meta = AST::Meta::Send.new(node: body)
 
           emit(s(:send, send, body_meta.selector, *body_meta.arguments))
         end
@@ -56,7 +56,7 @@ module Mutant
         def valid_send_mutation?(node)
           return unless n_send?(node)
 
-          last = AST::Meta::Send.new(node).arguments.last
+          last = AST::Meta::Send.new(node: node).arguments.last
 
           !last&.type.equal?(:block_pass)
         end

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

@@ -23,7 +23,7 @@ module Mutant
 
         def emit_optarg_body_assignments
           arguments.children.each do |argument|
-            next unless n_optarg?(argument) && AST::Meta::Optarg.new(argument).used?
+            next unless n_optarg?(argument) && AST::Meta::Optarg.new(node: argument).used?
 
             emit_body_prepend(s(:lvasgn, *argument))
           end

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

@@ -5,6 +5,7 @@ module Mutant
     class Node
       # Mutator for if nodes
       class If < self
+        FLOW_MODIFIER = %i[return next break].to_set.freeze
 
         handle(:if)
 
@@ -43,6 +44,14 @@ module Mutant
           emit_type(condition, nil, else_branch)
         end
 
+        def emit_type(_condition, if_branch, else_branch)
+          super unless ternary? && (if_branch.nil? || else_branch.nil?)
+        end
+
+        def ternary?
+          parent && FLOW_MODIFIER.include?(parent.node.type)
+        end
+
       end # If
     end # Node
   end # Mutator

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

@@ -25,7 +25,7 @@ module Mutant
         def mutate_rescue_bodies
           children_indices(RESCUE_INDICES).each do |index|
             mutate_child(index)
-            resbody_body = AST::Meta::Resbody.new(children.fetch(index)).body
+            resbody_body = AST::Meta::Resbody.new(node: children.fetch(index)).body
             emit_concat(resbody_body) if resbody_body
           end
         end

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

@@ -79,7 +79,7 @@ module Mutant
         end
 
         def meta
-          AST::Meta::Send.new(node)
+          AST::Meta::Send.new(node: node)
         end
         memoize :meta
 
@@ -173,7 +173,7 @@ module Mutant
 
           return unless dynamic_selector && n_sym?(dynamic_selector)
 
-          method_name = AST::Meta::Symbol.new(dynamic_selector).name
+          method_name = AST::Meta::Symbol.new(node: dynamic_selector).name
 
           emit(s(node.type, receiver, method_name, *actual_arguments))
         end
@@ -194,7 +194,7 @@ module Mutant
         def emit_double_negation_mutation
           return unless selector.equal?(:!) && n_send?(receiver)
 
-          negated = AST::Meta::Send.new(meta.receiver)
+          negated = AST::Meta::Send.new(node: receiver)
           emit(negated.receiver) if negated.selector.equal?(:!)
         end
 
@@ -223,7 +223,7 @@ module Mutant
         def emit_const_get_mutation
           return unless selector.equal?(:const_get) && n_sym?(arguments.first)
 
-          emit(s(:const, receiver, AST::Meta::Symbol.new(arguments.first).name))
+          emit(s(:const, receiver, AST::Meta::Symbol.new(node: arguments.first).name))
         end
 
         def emit_selector_replacement

data/lib/mutant/mutator/regexp.rb

@@ -13,10 +13,10 @@ module Mutant
       end
 
       class Registry
-        include Concord.new(:contents)
+        include Anima.new(:contents)
 
         def initialize
-          super({})
+          super(contents: {})
         end
 
         def register(expression_class, mutator_class)

data/lib/mutant/parallel/source.rb

@@ -27,7 +27,7 @@ module Mutant
 
       # Job source backed by a finite array
       class Array
-        include Concord.new(:jobs)
+        include Anima.new(:jobs)
 
         # Initialize objecto
         #

data/lib/mutant/pipe.rb

@@ -41,7 +41,7 @@ module Mutant
       Error = Class.new(RuntimeError)
 
       class Frame
-        include Concord.new(:io)
+        include Anima.new(:io)
 
         HEADER_FORMAT = 'N'
         MAX_BYTES     = (2**32).pred
@@ -87,8 +87,8 @@ module Mutant
       def self.from_pipes(marshal:, reader:, writer:)
         new(
           marshal: marshal,
-          reader:  Frame.new(reader.to_reader),
-          writer:  Frame.new(writer.to_writer)
+          reader:  Frame.new(io: reader.to_reader),
+          writer:  Frame.new(io: writer.to_writer)
         )
       end
     end

data/lib/mutant/registry.rb

@@ -3,13 +3,13 @@
 module Mutant
   # Registry for mapping AST types to classes
   class Registry
-    include Concord.new(:contents, :default)
+    include Anima.new(:contents, :default)
 
     # Initialize object
     #
     # @return [undefined]
     def initialize(default)
-      super({}, default)
+      super(contents: {}, default: default)
     end
 
     # Raised when the type is an invalid type

data/lib/mutant/reporter/cli/format.rb

@@ -7,7 +7,7 @@ module Mutant
       #
       # rubocop:disable Style/FormatString
       class Format
-        include AbstractType, Concord.new(:tty)
+        include AbstractType, Anima.new(:tty)
 
         # Start representation
         #
@@ -32,7 +32,7 @@ module Mutant
 
         # Output abstraction to decouple tty? from buffer
         class Output
-          include Concord.new(:tty, :buffer)
+          include Anima.new(:tty, :buffer)
 
           # Test if output is a tty
           #
@@ -51,7 +51,7 @@ module Mutant
 
         def format(printer, object)
           buffer = new_buffer
-          printer.call(Output.new(tty, buffer), object)
+          printer.call(output: Output.new(tty: tty, buffer: buffer), object: object)
           buffer.rewind
           buffer.read
         end

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

@@ -8,7 +8,7 @@ module Mutant
         include(
           AbstractType,
           Adamantium,
-          Concord.new(:output, :object),
+          Anima.new(:output, :object),
           Procto
         )
 
@@ -61,7 +61,7 @@ module Mutant
         end
 
         def visit(printer, object)
-          printer.call(output, object)
+          printer.call(output: output, object: object)
         end
 
         def info(string, *arguments)

data/lib/mutant/reporter/cli.rb

@@ -4,7 +4,7 @@ module Mutant
   class Reporter
     # Reporter that reports in human readable format
     class CLI < self
-      include Concord.new(:output, :format)
+      include Anima.new(:output, :format)
 
       # Build reporter
       #
@@ -13,8 +13,8 @@ module Mutant
       # @return [Reporter::CLI]
       def self.build(output)
         new(
-          output,
-          Format::Progressive.new(output.respond_to?(:tty?) && output.tty?)
+          format: Format::Progressive.new(tty: output.respond_to?(:tty?) && output.tty?),
+          output: output
         )
       end
 
@@ -61,7 +61,7 @@ module Mutant
       #
       # @return [self]
       def report(env)
-        Printer::EnvResult.call(output, env)
+        Printer::EnvResult.call(output: output, object: env)
         self
       end
 

data/lib/mutant/reporter/sequence.rb

@@ -3,7 +3,7 @@
 module Mutant
   class Reporter
     class Sequence < self
-      include Concord.new(:reporters)
+      include Anima.new(:reporters)
 
       %i[warn progress report start].each do |name|
         define_method(name) do |value|

data/lib/mutant/repository.rb

@@ -4,7 +4,7 @@ module Mutant
   module Repository
     # Subject filter based on repository diff
     class SubjectFilter
-      include Adamantium, Concord.new(:diff)
+      include Adamantium, Anima.new(:diff)
 
       # Test if subject was touched in diff
       #

data/lib/mutant/result.rb

@@ -132,7 +132,7 @@ module Mutant
         def initialize
           super(
             passed:  false,
-            runtime: 0.0,
+            runtime: 0.0
           )
         end
       end # VoidValue

data/lib/mutant/scope.rb

@@ -3,6 +3,6 @@
 module Mutant
   # Class or Module bound to an exact expression
   class Scope
-    include Concord::Public.new(:raw, :expression)
+    include Anima.new(:raw, :expression)
   end # Scope
 end # Mutant

data/lib/mutant/selector/expression.rb

@@ -4,7 +4,7 @@ module Mutant
   class Selector
     # Expression based test selector
     class Expression < self
-      include Concord.new(:integration)
+      include Anima.new(:integration)
 
       # Tests for subject
       #

data/lib/mutant/subject.rb

@@ -16,7 +16,7 @@ module Mutant
           config: config.mutation,
           node:   node
         ).map do |mutant|
-          Mutation::Evil.new(self, wrap_node(mutant))
+          Mutation::Evil.new(subject: self, node: wrap_node(mutant))
         end
       )
     end
@@ -92,7 +92,7 @@ module Mutant
   private
 
     def neutral_mutation
-      Mutation::Neutral.new(self, wrap_node(node))
+      Mutation::Neutral.new(subject: self, node: wrap_node(node))
     end
 
     def wrap_node(node)

data/lib/mutant/timer.rb

@@ -2,7 +2,7 @@
 
 module Mutant
   class Timer
-    include Concord.new(:process)
+    include Anima.new(:process)
 
     # The now monotonic time
     #
@@ -28,7 +28,7 @@ module Mutant
 
       # Deadline status snapshot
       class Status
-        include Concord::Public.new(:time_left)
+        include Anima.new(:time_left)
 
         # Test if deadline is not yet expired
         def ok?
@@ -40,7 +40,7 @@ module Mutant
       #
       # @return [Status]
       def status
-        Status.new(time_left)
+        Status.new(time_left: time_left)
       end
 
       # Probe the time left