mutant 0.11.16 → 0.11.18

data/lib/mutant/mutator/regexp.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Regexp < self
+      def self.regexp_body(node)
+        *body, _options = node.children
+
+        body.map do |child|
+          return unless child.type.equal?(:str)
+          child.children
+        end.join
+      end
+
+      class Registry
+        include Concord.new(:contents)
+
+        def initialize
+          super({})
+        end
+
+        def register(expression_class, mutator_class)
+          (contents[expression_class] ||= []) << mutator_class
+          self
+        end
+
+        def lookup(expression_class)
+          contents.fetch(expression_class, []).push(Quantifier)
+        end
+      end # Registry
+
+      REGISTRY = Registry.new
+
+      # mutant:disable - boot time code
+      def self.handle(*types)
+        types.each do |type|
+          self::REGISTRY.register(type, self)
+        end
+      end
+
+      private_class_method :handle
+
+      def self.mutate(expression)
+        REGISTRY
+          .lookup(expression.class)
+          .map { |mutator| mutator.call(input: expression, parent: nil) }
+          .reduce(&:merge)
+      end
+
+   private
+
+      def subexpressions
+        input.expressions
+      end
+
+      def mk_dup
+        Marshal.load(Marshal.dump(input))
+      end
+
+      def emit_expression(klass:, text:)
+        emit(
+          klass.construct(text: text).tap do |new|
+            subexpressions.each do |expression|
+              new << Marshal.load(Marshal.dump(expression))
+            end
+          end
+        )
+      end
+
+      def emit_passive_group
+        emit_expression(
+          klass: ::Regexp::Expression::Group::Passive,
+          text:  '(?:'
+        )
+      end
+
+      class Alternation < self
+        handle(::Regexp::Expression::Alternation)
+
+        def dispatch
+          subexpressions.each_index do |index|
+            emit(mk_dup.tap { |new| new.expressions.delete_at(index) })
+          end
+        end
+      end
+
+      class Quantifier < self
+        MAP = {
+          '*'  => '+',
+          '*+' => '++',
+          '*?' => '+?'
+        }.freeze
+
+        def dispatch
+          return unless input.quantifier
+
+          emit_removal
+          emit_replacement
+        end
+
+        def emit_removal
+          emit(mk_dup.tap { |new| new.quantifier = nil })
+        end
+
+        def emit_replacement
+          new_text = MAP[input.quantifier.text]
+
+          emit(mk_dup.tap { |new| new.quantifier.text = new_text })
+        end
+      end
+
+      class Replacement < self
+        ns = ::Regexp::Expression
+
+        dual_table =
+          [
+            [ns::Anchor::WordBoundary,            '\\b', ns::Anchor::NonWordBoundary,  '\\B'],
+            [ns::CharacterType::Digit,            '\\d', ns::CharacterType::NonDigit,  '\\D'],
+            [ns::CharacterType::ExtendedGrapheme, '\\X', ns::CharacterType::Linebreak, '\\R'],
+            [ns::CharacterType::Hex,              '\\h', ns::CharacterType::NonHex,    '\\H'],
+            [ns::CharacterType::Space,            '\\s', ns::CharacterType::NonSpace,  '\\S'],
+            [ns::CharacterType::Word,             '\\w', ns::CharacterType::NonWord,   '\\W']
+          ]
+
+        MAP = dual_table.flat_map do |(left_key, left_text, right_key, right_text)|
+          [
+            [left_key,  [right_key, right_text]],
+            [right_key, [left_key,  left_text]]
+          ]
+        end.to_h
+
+        MAP[ns::Anchor::BeginningOfLine]              = [ns::Anchor::BeginningOfString, '\\A']
+        MAP[ns::Anchor::EndOfLine]                    = [ns::Anchor::EndOfString, '\\z']
+        MAP[ns::Anchor::EndOfStringOrBeforeEndOfLine] = [ns::Anchor::EndOfString, '\\z']
+
+        MAP.freeze
+
+        handle(*MAP.keys)
+
+        def dispatch
+          klass, text = MAP.fetch(input.class)
+
+          emit(klass.construct(text: text).tap { |new| new.quantifier = input.quantifier })
+        end
+      end
+
+      class GroupCapturePositional < self
+        handle(::Regexp::Expression::Group::Capture)
+
+      private
+
+        def dispatch
+          emit_passive_group unless subexpressions.empty?
+        end
+      end
+
+      class GroupCaptureNamed < self
+        handle(::Regexp::Expression::Group::Named)
+
+      private
+
+        def dispatch
+          return if input.name.start_with?('_') || subexpressions.empty?
+
+          emit_passive_group
+
+          emit_expression(
+            klass: ::Regexp::Expression::Group::Named,
+            text:  "(?<_#{input.name}>"
+          )
+        end
+      end
+
+      class Recurse < self
+        ns = ::Regexp::Expression
+
+        # This list of nodes with subexessions is not yet complete.
+        handle(ns::Assertion::Base)
+        handle(ns::Assertion::Lookahead)
+        handle(ns::Assertion::Lookbehind)
+        handle(ns::Assertion::NegativeLookahead)
+        handle(ns::Assertion::NegativeLookbehind)
+        handle(ns::Alternative)
+        handle(ns::Alternation)
+        handle(ns::Sequence)
+        handle(ns::CharacterSet)
+        handle(ns::CharacterSet::Range)
+        handle(ns::Conditional::Branch)
+        handle(ns::Conditional::Expression)
+        handle(ns::Group::Absence)
+        handle(ns::Group::Atomic)
+        handle(ns::Group::Capture)
+        handle(ns::Group::Comment)
+        handle(ns::Group::Named)
+        handle(ns::Group::Options)
+        handle(ns::Group::Passive)
+        handle(ns::Root)
+
+      private
+
+        def dispatch
+          subexpressions.each_with_index do |expression, index|
+            self.class.mutate(expression).each do |new_expression|
+              emit(mk_dup.tap { |new| new.expressions[index] = new_expression })
+            end
+          end
+        end
+      end
+    end # Regexp
+  end # Mutator
+end # Mutant

data/lib/mutant/parallel/driver.rb

@@ -49,6 +49,7 @@ module Mutant
       def finalize(status)
         status.tap do
           if status.done?
+            workers.each(&:signal)
             workers.each(&:join)
             threads.each(&:join)
           end

data/lib/mutant/parallel/worker.rb

@@ -77,8 +77,12 @@ module Mutant
         self
       end
 
-      def join
+      def signal
         process.kill('TERM', pid)
+        self
+      end
+
+      def join
         process.wait(pid)
         self
       end

data/lib/mutant/runner.rb

@@ -15,15 +15,17 @@ module Mutant
     def self.run_mutation_analysis(env)
       reporter = reporter(env)
 
-      run_driver(
-        reporter,
-        Parallel.async(env.world, mutation_test_config(env))
-      ).tap do |result|
-        reporter.report(result)
-      end
+      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

data/lib/mutant/segment/recorder.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Segment
+    class Recorder
+      include Anima.new(
+        :gen_id,
+        :parent_id,
+        :recording_start,
+        :root_id,
+        :segments,
+        :timer
+      )
+
+      private(*anima.attribute_names)
+
+      # rubocop:disable Metrics/MethodLength
+      def record(name)
+        start     = timer.now
+        parent_id = parent_id()
+
+        @parent_id = id = gen_id.call
+
+        yield.tap do
+          segments << Segment.new(
+            id:              id,
+            name:            name,
+            parent_id:       parent_id,
+            timestamp_end:   timer.now,
+            timestamp_start: start
+          )
+        end
+      ensure
+        @parent_id = parent_id
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def print_profile(io)
+        print_node(io, tree, 0)
+      end
+
+    private
+
+      class Node
+        include Adamantium, Anima.new(:value, :children)
+      end
+      private_constant :Node
+
+      def tree
+        id_index     = {}
+        parent_index = {}
+
+        final_segments.each do |segment|
+          id_index[segment.id] = segment
+
+          (parent_index[segment.parent_id] ||= []) << segment
+        end
+
+        build_node(
+          value:        id_index.fetch(root_id),
+          parent_index: parent_index
+        )
+      end
+
+      def final_segments
+        timestamp_end = timer.now
+
+        segments.map do |segment|
+          if segment.timestamp_end
+            segment
+          else
+            segment.with(timestamp_end: timestamp_end)
+          end
+        end
+      end
+
+      def build_node(value:, parent_index:)
+        Node.new(
+          value:    value,
+          children: build_children(
+            parent_id:    value.id,
+            parent_index: parent_index
+          )
+        )
+      end
+
+      def build_children(parent_id:, parent_index:)
+        parent_index
+          .fetch(parent_id, EMPTY_ARRAY)
+          .map { |value| build_node(value: value, parent_index: parent_index) }
+      end
+
+      def print_node(io, node, indent)
+        segment = node.value
+
+        indent_str = '  ' * indent
+
+        print_line(io, :offset_start, segment, indent_str)
+
+        return unless node.children.any?
+
+        node.children.each do |child|
+          print_node(io, child, indent.succ)
+        end
+        print_line(io, :offset_end, segment, indent_str)
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable Style/FormatStringToken
+      def print_line(io, offset, segment, indent_str)
+        io.puts(
+          '%4.4f: (%4.4fs) %s %s' % [
+            segment.public_send(offset, recording_start),
+            segment.elapsed,
+            indent_str,
+            segment.name
+          ]
+        )
+      end
+      # rubocop:enable Metrics/ParameterLists
+      # rubocop:enable Style/FormatStringToken
+    end # Recorder
+  end # Segment
+end # Mutant

data/lib/mutant/segment.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Segment
+    include Adamantium, Anima.new(
+      :id,
+      :name,
+      :parent_id,
+      :timestamp_end,
+      :timestamp_start
+    )
+
+    def elapsed
+      timestamp_end - timestamp_start
+    end
+
+    def offset_start(recording_start)
+      timestamp_start - recording_start
+    end
+
+    def offset_end(recording_start)
+      timestamp_end - recording_start
+    end
+  end # Segment
+end # Mutant

data/lib/mutant/version.rb

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

data/lib/mutant/world.rb

@@ -19,6 +19,7 @@ module Mutant
       :pathname,
       :process,
       :random,
+      :recorder,
       :stderr,
       :stdout,
       :thread,
@@ -77,5 +78,9 @@ module Mutant
         Timer::Deadline::None.new
       end
     end
+
+    def record(name, &block)
+      recorder.record(name, &block)
+    end
   end # World
 end # Mutant