mutest 0.0.1 → 0.0.2

data/lib/mutest/mutator/node/send/conditional.rb

@@ -0,0 +1,21 @@
+module Mutest
+  class Mutator
+    class Node
+      class Send
+        class Conditional < self
+          handle(:csend)
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            super()
+            emit(s(:send, *children))
+          end
+        end # Conditional
+      end # Send
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/send/index.rb

@@ -0,0 +1,47 @@
+module Mutest
+  class Mutator
+    class Node
+      class Send
+        # Base mutator for index operations
+        class Index < self
+          # Mutator for index assignments
+          class Assign < self
+            define_named_child(:value, -1)
+
+            INDEX_RANGE = (2..-2).freeze
+
+            private
+
+            # Emit mutations
+            #
+            # @return [undefined]
+            def dispatch
+              emit_naked_receiver
+              emit_value_mutations
+              emit_index_read
+              emit(value)
+              mutate_indices
+            end
+
+            # Mutate indices
+            #
+            # @return [undefined]
+            def mutate_indices
+              children_indices(INDEX_RANGE).each do |index|
+                delete_child(index)
+                mutate_child(index)
+              end
+            end
+
+            # Emit index read
+            #
+            # @return [undefined]
+            def emit_index_read
+              emit_type(receiver, :[], *children[INDEX_RANGE])
+            end
+          end # Assign
+        end # Index
+      end # Send
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/splat.rb

@@ -0,0 +1,23 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for splat nodes
+      class Splat < self
+        handle :splat
+
+        children :expression
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit_expression_mutations
+          emit(expression)
+        end
+      end # Splat
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/super.rb

@@ -0,0 +1,24 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for super with parentheses
+      class Super < self
+        handle(:super)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit(N_EMPTY_SUPER)
+          children.each_index do |index|
+            mutate_child(index)
+            delete_child(index)
+          end
+        end
+      end # Super
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/when.rb

@@ -0,0 +1,60 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for when nodes
+      class When < self
+        handle(:when)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          if body
+            mutate_body
+          else
+            emit_child_update(body_index, N_RAISE)
+          end
+          mutate_conditions
+        end
+
+        # Emit condition mutations
+        #
+        # @return [undefined]
+        def mutate_conditions
+          conditions = children.length - 1
+          children[0..-2].each_index do |index|
+            delete_child(index) if conditions > 1
+            mutate_child(index)
+          end
+        end
+
+        # Emit body mutations
+        #
+        # @return [undefined]
+        def mutate_body
+          mutate_child(body_index)
+        end
+
+        # Body node
+        #
+        # @return [Parser::AST::Node]
+        #   if body is present
+        #
+        # @return [nil]
+        #   otherwise
+        def body
+          children.fetch(body_index)
+        end
+
+        # Index of body node
+        #
+        # @return [Fixnum]
+        def body_index
+          children.length - 1
+        end
+      end # When
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/yield.rb

@@ -0,0 +1,21 @@
+module Mutest
+  class Mutator
+    class Node
+      # Yield mutator
+      class Yield < Generic
+        handle(:yield)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          super()
+          emit_singletons
+          children.each_index(&method(:delete_child))
+        end
+      end # Yield
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/zsuper.rb

@@ -0,0 +1,20 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for super without parentheses
+      class ZSuper < self
+        handle(:zsuper)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit(N_EMPTY_SUPER)
+        end
+      end # ZSuper
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/util.rb

@@ -0,0 +1,11 @@
+module Mutest
+  class Mutator
+    # Namespace for utility mutators
+    class Util < self
+      private
+
+      def disabled?
+      end
+    end # Util
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/util/array.rb

@@ -0,0 +1,42 @@
+module Mutest
+  class Mutator
+    class Util
+      # Mutators that mutates an array of inputs
+      class Array < self
+        # Element presence mutator
+        class Presence < Util
+          private
+
+          # Emit element presence mutations
+          #
+          # @return [undefined]
+          def dispatch
+            input.each_index do |index|
+              dup = dup_input
+              dup.delete_at(index)
+              emit(dup)
+            end
+          end
+        end # Presence
+
+        # Array element mutator
+        class Element < Util
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            input.each_with_index do |element, index|
+              mutate(element).each do |mutation|
+                dup = dup_input
+                dup[index] = mutation
+                emit(dup)
+              end
+            end
+          end
+        end # Element
+      end # Array
+    end # Util
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/util/symbol.rb

@@ -0,0 +1,19 @@
+module Mutest
+  class Mutator
+    class Util
+      # Utility symbol mutator
+      class Symbol < self
+        POSTFIX = '__mutest__'.freeze
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit((input.to_s + POSTFIX).to_sym)
+        end
+      end # Symbol
+    end # Util
+  end # Mutator
+end # Mutest

data/lib/mutest/parallel.rb

@@ -0,0 +1,89 @@
+module Mutest
+  # Parallel execution engine of arbitrary payloads
+  module Parallel
+    # Driver for parallelized execution
+    class Driver
+      include Concord.new(:binding)
+
+      # Scheduler status
+      #
+      # @return [Object]
+      def status
+        binding.call(__method__)
+      end
+
+      # Stop master gracefully
+      #
+      # @return [self]
+      def stop
+        binding.call(__method__)
+        self
+      end
+    end # Driver
+
+    # Run async computation returning driver
+    #
+    # @return [Driver]
+    def self.async(config)
+      Driver.new(config.env.new_mailbox.bind(Master.call(config)))
+    end
+
+    # Job result sink
+    class Sink
+      include AbstractType
+
+      # Process job result
+      #
+      # @param [Object]
+      #
+      # @return [self]
+      abstract_method :result
+
+      # Sink status
+      #
+      # @return [Object]
+      abstract_method :status
+
+      # Test if processing should stop
+      #
+      # @return [Boolean]
+      abstract_method :stop?
+    end # Sink
+
+    # Job to push to workers
+    class Job
+      include Adamantium::Flat, Anima.new(
+        :index,
+        :payload
+      )
+    end # Job
+
+    # Job result object received from workers
+    class JobResult
+      include Adamantium::Flat, Anima.new(
+        :job,
+        :payload
+      )
+    end # JobResult
+
+    # Parallel run configuration
+    class Config
+      include Adamantium::Flat, Anima.new(
+        :env,
+        :jobs,
+        :processor,
+        :sink,
+        :source
+      )
+    end # Config
+
+    # Parallel execution status
+    class Status
+      include Adamantium::Flat, Anima.new(
+        :active_jobs,
+        :done,
+        :payload
+      )
+    end # Status
+  end # Parallel
+end # Mutest

data/lib/mutest/parallel/master.rb

@@ -0,0 +1,181 @@
+module Mutest
+  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    = message.type
+        payload = 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 # Mutest