mutant 0.8.24 → 0.9.0

data/lib/mutant/mutator/node/regexp/greedy_zero_or_more.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for greedy zero-or-more quantifier, `*`
-        class GreedyZeroOrMore < Node
-          handle(:regexp_greedy_zero_or_more)
-
-          children :min, :max, :subject
-
-          # Emit mutations
-          #
-          # Replace `/a*/` with `/a+/`
-          #
-          # @return [undefined]
-          def dispatch
-            emit(s(:regexp_greedy_one_or_more, *children))
-            emit_subject_mutations
-            emit(subject)
-          end
-        end # GreedyZeroOrMore
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

data/lib/mutant/parallel/master.rb

@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  module Parallel
-    # Master parallel worker
-    class Master
-      include Concord.new(:config, :mailbox)
-
-      private_class_method :new
-
-      # Run master
-      #
-      # @param [Config] config
-      #
-      # @return [Actor::Sender]
-      def self.call(config)
-        config.env.spawn do |mailbox|
-          new(config, mailbox).__send__(:run)
-        end
-      end
-
-      # Initialize object
-      #
-      # @return [undefined]
-      def initialize(*)
-        super
-
-        @stop        = false
-        @workers     = 0
-        @active_jobs = Set.new
-        @index       = 0
-      end
-
-    private
-
-      # Run work loop
-      #
-      # rubocop:disable MethodLength
-      #
-      # @return [undefined]
-      def run
-        config.jobs.times do
-          @workers += 1
-          config.env.spawn do |worker_mailbox|
-            Worker.run(
-              mailbox:   worker_mailbox,
-              processor: config.processor,
-              parent:    mailbox.sender
-            )
-          end
-        end
-
-        receive_loop
-      end
-
-      MAP = IceNine.deep_freeze(
-        ready:  :handle_ready,
-        status: :handle_status,
-        result: :handle_result,
-        stop:   :handle_stop
-      )
-
-      # Handle messages
-      #
-      # @param [Actor::Message] message
-      #
-      # @return [undefined]
-      def handle(message)
-        type, payload = message.type, message.payload
-        method = MAP.fetch(type) do
-          fail Actor::ProtocolError, "Unexpected message: #{type.inspect}"
-        end
-        __send__(method, payload)
-      end
-
-      # Run receive loop
-      #
-      # @return [undefined]
-      def receive_loop
-        handle(mailbox.receiver.call) until @workers.zero? && @stop
-      end
-
-      # Handle status
-      #
-      # @param [Actor::Sender] sender
-      #
-      # @return [undefined]
-      def handle_status(sender)
-        status = Status.new(
-          payload:     sink.status,
-          done:        sink.stop? || @workers.zero?,
-          active_jobs: @active_jobs.dup.freeze
-        )
-        sender.call(Actor::Message.new(:status, status))
-      end
-
-      # Handle result
-      #
-      # @param [JobResult] job_result
-      #
-      # @return [undefined]
-      def handle_result(job_result)
-        @active_jobs.delete(job_result.job)
-        sink.result(job_result.payload)
-      end
-
-      # Handle stop
-      #
-      # @param [Actor::Sender] sender
-      #
-      # @return [undefined]
-      def handle_stop(sender)
-        @stop = true
-        receive_loop
-        sender.call(Actor::Message.new(:stop))
-      end
-
-      # Handle ready worker
-      #
-      # @param [Actor::Sender] sender
-      #
-      # @return [undefined]
-      def handle_ready(sender)
-        if stop_work?
-          stop_worker(sender)
-          return
-        end
-
-        sender.call(Actor::Message.new(:job, next_job))
-      end
-
-      # Next job if any
-      #
-      # @return [Job]
-      #   if next job is available
-      #
-      # @return [nil]
-      def next_job
-        Job.new(
-          index:   @index,
-          payload: source.next
-        ).tap do |job|
-          @index += 1
-          @active_jobs << job
-        end
-      end
-
-      # Stop worker
-      #
-      # @param [Actor::Sender] sender
-      #
-      # @return [undefined]
-      def stop_worker(sender)
-        @workers -= 1
-        sender.call(Actor::Message.new(:stop))
-      end
-
-      # Test if scheduling stopped
-      #
-      # @return [Boolean]
-      def stop_work?
-        @stop || !source.next? || sink.stop?
-      end
-
-      # Job source
-      #
-      # @return [Source]
-      def source
-        config.source
-      end
-
-      # Job result sink
-      #
-      # @return [Sink]
-      def sink
-        config.sink
-      end
-
-    end # Master
-  end # Parallel
-end # Mutant

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Reporter
-    class CLI
-      class Printer
-        # Printer for runner status
-        class Status < self
-
-          delegate(:active_jobs, :payload)
-
-          ACTIVE_JOB_HEADER = 'Active Jobs:'
-          ACTIVE_JOB_FORMAT = '%d: %s'
-
-          # Print progress for collector
-          #
-          # @return [undefined]
-          def run
-            visit(EnvProgress, payload)
-            job_status
-            info('Active subjects: %d', active_subject_results.length)
-            visit_collection(SubjectProgress, active_subject_results)
-          end
-
-        private
-
-          # Print worker status
-          #
-          # @return [undefined]
-          def job_status
-            return if active_jobs.empty?
-            info(ACTIVE_JOB_HEADER)
-            active_jobs.sort_by(&:index).each do |job|
-              info(ACTIVE_JOB_FORMAT, job.index, job.payload.identification)
-            end
-          end
-
-          # Active subject results
-          #
-          # @return [Array<Result::Subject>]
-          def active_subject_results
-            active_subjects = active_jobs.map(&:payload).flat_map(&:subject)
-
-            payload.subject_results.select do |subject_result|
-              active_subjects.include?(subject_result.subject)
-            end
-          end
-
-        end # Status
-      end # Printer
-    end # CLI
-  end # Reporter
-end # Mutant

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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Reporter
-    class CLI
-      # Interface to the optionally present tput binary
-      class Tput
-        include Adamantium, Concord::Public.new(:prepare, :restore)
-
-        private_class_method :new
-
-        # Detected tput support
-        #
-        # @return [Tput]
-        #   if tput support is present
-        #
-        # @return [nil]
-        #   otherwise
-        def self.detect
-          reset   = capture('tput reset')
-          save    = capture('tput sc') if reset
-          restore = capture('tput rc') if save
-          clean   = capture('tput ed') || capture('tput cd') if restore
-          new(reset + save, restore + clean) if clean
-        end
-
-        # Capture output
-        #
-        # @param [String] command
-        #   command to run
-        #
-        # @return [String]
-        #   stdout of command on success
-        #
-        # @return [nil]
-        #   otherwise
-        def self.capture(command)
-          stdout, _stderr, exitstatus = Open3.capture3(command)
-          stdout if exitstatus.success?
-        end
-        private_class_method :capture
-
-      end # Tput
-    end # CLI
-  end # Reporter
-end # Mutant

data/lib/mutant/warning_filter.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  # Stream filter for warnings
-  class WarningFilter
-    include Equalizer.new(:target)
-
-    WARNING_PATTERN = /\A(?:.+):(?:\d+): warning: (?:.+)\n\z/.freeze
-
-    # Initialize object
-    #
-    # @param [#write] target
-    #
-    # @return [undefined]
-    def initialize(target)
-      @target   = target
-      @warnings = []
-    end
-
-    # Warnings captured by filter
-    #
-    # @return [Array<String>]
-    attr_reader :warnings
-
-    # Target stream to capture warnings on
-    #
-    # @return [#write] target
-    #
-    # @return [undefined]
-    attr_reader :target
-    protected :target
-
-    # Write message to target filtering warnings
-    #
-    # @param [String] message
-    #
-    # @return [self]
-    def write(message)
-      if WARNING_PATTERN.match?(message)
-        warnings << message
-      else
-        target.write(message)
-      end
-
-      self
-    end
-
-    # Use warning filter during block execution
-    #
-    # @return [Array<String>]
-    def self.use
-      original = $stderr
-      $stderr = filter = new(original)
-      yield
-      filter.warnings
-    ensure
-      $stderr = original
-    end
-
-  end # WarningFilter
-end # Mutant

data/meta/regexp/character_types.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-mutations = {
-  [:regexp_digit_type,           '/\d/'] => [:regexp_nondigit_type,           '/\D/'],
-  [:regexp_hex_type,             '/\h/'] => [:regexp_nonhex_type,             '/\H/'],
-  [:regexp_space_type,           '/\s/'] => [:regexp_nonspace_type,           '/\S/'],
-  [:regexp_word_boundary_anchor, '/\b/'] => [:regexp_nonword_boundary_anchor, '/\B/'],
-  [:regexp_word_type,            '/\w/'] => [:regexp_nonword_type,            '/\W/'],
-  [:regexp_xgrapheme_type,       '/\X/'] => [:regexp_linebreak_type,          '/\R/']
-}
-
-mutations = mutations.merge(mutations.invert)
-
-mutations.each do |(source_type, source_mutation), (_, regexp_mutation)|
-  Mutant::Meta::Example.add :regexp, source_type do
-    source(source_mutation)
-
-    singleton_mutations
-    regexp_mutations
-
-    mutation(regexp_mutation)
-  end
-end

data/meta/regexp/regexp_alternation_meta.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :regexp_alternation_meta do
-  source '/\A(foo|bar|baz)\z/'
-
-  singleton_mutations
-  regexp_mutations
-
-  mutation '/\A(foo|bar)\z/'
-  mutation '/\A(foo|baz)\z/'
-  mutation '/\A(bar|baz)\z/'
-  mutation '/\A(?:foo|bar|baz)\z/'
-end

data/meta/regexp/regexp_bol_anchor.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :regexp_bol_anchor do
-  source '/^/'
-
-  singleton_mutations
-  regexp_mutations
-
-  mutation '/\\A/'
-end

data/meta/regexp/regexp_bos_anchor.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :regexp_bos_anchor do
-  source '/\A/'
-
-  singleton_mutations
-  regexp_mutations
-end
-
-Mutant::Meta::Example.add :regexp_bos_anchor do
-  source '/^#{a}/'
-
-  singleton_mutations
-  regexp_mutations
-
-  mutation '/^#{nil}/'
-  mutation '/^#{self}/'
-end

data/meta/regexp/regexp_capture_group.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :regexp_capture_group do
-  source '/()/'
-
-  singleton_mutations
-  regexp_mutations
-end
-
-Mutant::Meta::Example.add :regexp_capture_group do
-  source '/(foo|bar)/'
-
-  singleton_mutations
-  regexp_mutations
-
-  mutation '/(?:foo|bar)/'
-  mutation '/(foo)/'
-  mutation '/(bar)/'
-end