mutest 0.0.1 → 0.0.2

data/lib/mutest/parallel/source.rb

@@ -0,0 +1,57 @@
+module Mutest
+  module Parallel
+    # Job source for parallel execution
+    class Source
+      include AbstractType
+
+      NoJobError = Class.new(RuntimeError)
+
+      # Next job
+      #
+      # @return [Object]
+      #
+      # @raise [NoJobError]
+      #   when no next job is available
+      abstract_method :next
+
+      # Test if next job is available
+      #
+      # @return [Boolean]
+      abstract_method :next?
+
+      # Job source backed by a finite array
+      class Array
+        include Concord.new(:jobs)
+
+        # Initialize objecto
+        #
+        # @return [undefined]
+        def initialize(*)
+          super
+
+          @next_index = 0
+        end
+
+        # Test if next job is available
+        #
+        # @return [Boolean]
+        def next?
+          @next_index < jobs.length
+        end
+
+        # Next job
+        #
+        # @return [Object]
+        #
+        # @raise [NoJobError]
+        #   when no next job is available
+        def next
+          fail NoJobError unless next?
+          jobs.fetch(@next_index).tap do
+            @next_index += 1
+          end
+        end
+      end # Array
+    end # Source
+  end # Parallel
+end # Mutest

data/lib/mutest/parallel/worker.rb

@@ -0,0 +1,76 @@
+module Mutest
+  module Parallel
+    # Parallel execution worker
+    class Worker
+      include Adamantium::Flat, Anima.new(
+        :mailbox,
+        :parent,
+        :processor
+      )
+
+      # Run worker
+      #
+      # @param [Hash<Symbol, Object] attributes
+      #
+      # @return [self]
+      def self.run(attributes)
+        new(attributes).run
+        self
+      end
+
+      private_class_method :new
+
+      # Worker loop
+      #
+      # @return [self]
+      #
+      # rubocop:disable Lint/Loop
+      def run
+        begin
+          parent.call(Actor::Message.new(:ready, mailbox.sender))
+        end until handle(mailbox.receiver.call)
+      end
+
+      private
+
+      # Handle job
+      #
+      # @param [Message] message
+      #
+      # @return [Boolean]
+      def handle(message) # rubocop:disable Metrics/MethodLength
+        type    = message.type
+        payload = message.payload
+
+        case message.type
+        when :job
+          handle_job(payload)
+          nil
+        when :stop
+          true
+        else
+          fail Actor::ProtocolError, "Unknown command: #{type.inspect}"
+        end
+      end
+
+      # Handle mutation
+      #
+      # @param [Job] job
+      #
+      # @return [undefined]
+      def handle_job(job)
+        result = processor.call(job.payload)
+
+        parent.call(
+          Actor::Message.new(
+            :result,
+            JobResult.new(
+              job:     job,
+              payload: result
+            )
+          )
+        )
+      end
+    end # Worker
+  end # Parallel
+end # Mutest

data/lib/mutest/parser.rb

@@ -0,0 +1,22 @@
+module Mutest
+  # An AST Parser
+  class Parser
+    include Adamantium::Mutable, Equalizer.new
+
+    # Initialize object
+    #
+    # @return [undefined]
+    def initialize
+      @cache = {}
+    end
+
+    # Parse path into AST
+    #
+    # @param [Pathname] path
+    #
+    # @return [AST::Node]
+    def open(path)
+      @cache[path] ||= SourceFile.read(path)
+    end
+  end # Parser
+end # Mutest

data/lib/mutest/registry.rb

@@ -0,0 +1,43 @@
+module Mutest
+  # Registry for mapping AST types to classes
+  class Registry
+    include Concord.new(:contents)
+
+    # Initialize object
+    #
+    # @return [undefined]
+    def initialize
+      super({})
+    end
+
+    # Raised when the type is an invalid type
+    RegistryError = Class.new(TypeError)
+
+    # Register class for AST node class
+    #
+    # @param [Symbol] type
+    # @param [Class] class
+    #
+    # @return [self]
+    def register(type, klass)
+      fail RegistryError, "Invalid type registration: #{type.inspect}" unless AST::Types::ALL.include?(type)
+      fail RegistryError, "Duplicate type registration: #{type.inspect}" if contents.key?(type)
+      contents[type] = klass
+      self
+    end
+
+    # Lookup class for node
+    #
+    # @param [Symbol] type
+    #
+    # @return [Class]
+    #
+    # @raise [ArgumentError]
+    #   raises argument error when class cannot be found
+    def lookup(type)
+      contents.fetch(type) do
+        fail RegistryError, "No entry for: #{type.inspect}"
+      end
+    end
+  end # Registry
+end # Mutest

data/lib/mutest/reporter.rb

@@ -0,0 +1,39 @@
+module Mutest
+  # Abstract base class for reporters
+  class Reporter
+    include AbstractType
+
+    # Write warning message
+    #
+    # @param [String] message
+    #
+    # @return [self]
+    abstract_method :warn
+
+    # Report start
+    #
+    # @param [Env] env
+    #
+    # @return [self]
+    abstract_method :start
+
+    # Report collector state
+    #
+    # @param [Runner::Collector] collector
+    #
+    # @return [self]
+    abstract_method :report
+
+    # Report progress on object
+    #
+    # @param [Object] object
+    #
+    # @return [self]
+    abstract_method :progress
+
+    # The reporter delay
+    #
+    # @return [Float]
+    abstract_method :delay
+  end # Reporter
+end # Mutest

data/lib/mutest/reporter/cli.rb

@@ -0,0 +1,87 @@
+module Mutest
+  class Reporter
+    # Reporter that reports in human readable format
+    class CLI < self
+      include Concord.new(:output, :format)
+
+      # Build reporter
+      #
+      # @param [IO] output
+      #
+      # @return [Reporter::CLI]
+      #
+      # :reek:ManualDispatch
+      def self.build(output)
+        tput = Tput.detect
+        tty = output.respond_to?(:tty?) && output.tty?
+        format =
+          if !Mutest.ci? && tty && tput
+            Format::Framed.new(tty:  tty, tput: tput)
+          else
+            Format::Progressive.new(tty: tty)
+          end
+        new(output, format)
+      end
+
+      # Report start
+      #
+      # @param [Env::Bootstrap] env
+      #
+      # @return [self]
+      def start(env)
+        write(format.start(env))
+        self
+      end
+
+      # Report progress object
+      #
+      # @param [Parallel::Status] status
+      #
+      # @return [self]
+      def progress(status)
+        write(format.progress(status))
+        self
+      end
+
+      # Report delay in seconds
+      #
+      # TODO: Move this to a callback registration
+      #
+      # @return [Float]
+      def delay
+        format.delay
+      end
+
+      # Report warning
+      #
+      # @param [String] message
+      #
+      # @return [self]
+      def warn(message)
+        output.puts(message)
+        self
+      end
+
+      # Report env
+      #
+      # @param [Result::Env] env
+      #
+      # @return [self]
+      def report(env)
+        Printer::EnvResult.call(output, env)
+        self
+      end
+
+      private
+
+      # Write output frame
+      #
+      # @param [String] frame
+      #
+      # @return [undefined]
+      def write(frame)
+        output.write(frame)
+      end
+    end # CLI
+  end # Reporter
+end # Mutest

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

@@ -0,0 +1,135 @@
+module Mutest
+  class Reporter
+    class CLI
+      # CLI output format
+      #
+      class Format
+        include AbstractType, Anima.new(:tty)
+
+        # Start representation
+        #
+        # @param [Env::Bootstrap] env
+        #
+        # @return [String]
+        abstract_method :start
+
+        # Progress representation
+        #
+        # @param [Runner::Status] status
+        #
+        # @return [String]
+        abstract_method :progress
+
+        # Report delay in seconds
+        #
+        # @return [Float]
+        def delay
+          self.class::REPORT_DELAY
+        end
+
+        # Output abstraction to decouple tty? from buffer
+        class Output
+          include Concord.new(:tty, :buffer)
+
+          # Test if output is a tty
+          #
+          # @return [Boolean]
+          alias_method :tty?, :tty
+          public :tty?
+
+          %i[puts write].each do |name|
+            define_method(name) do |*args, &block|
+              buffer.public_send(name, *args, &block)
+            end
+          end
+        end # Output
+
+        private
+
+        # Format object with printer
+        #
+        # @param [Class:Printer] printer
+        # @param [Object] object
+        #
+        # @return [String]
+        def format(printer, object)
+          buffer = new_buffer
+          printer.call(Output.new(tty, buffer), object)
+          buffer.rewind
+          buffer.read
+        end
+
+        # Format for progressive non rewindable output
+        class Progressive < self
+          REPORT_FREQUENCY = 1.0
+          REPORT_DELAY     = 1 / REPORT_FREQUENCY
+
+          # Start representation
+          #
+          # @return [String]
+          def start(env)
+            format(Printer::Config, env.config)
+          end
+
+          # Progress representation
+          #
+          # @return [String]
+          def progress(status)
+            format(Printer::StatusProgressive, status)
+          end
+
+          private
+
+          # New buffer
+          #
+          # @return [StringIO]
+          def new_buffer
+            StringIO.new
+          end
+        end # Progressive
+
+        # Format for framed rewindable output
+        class Framed < self
+          include anima.add(:tput)
+
+          BUFFER_FLAGS = 'a+'.freeze
+
+          REPORT_FREQUENCY = 20.0
+          REPORT_DELAY     = 1 / REPORT_FREQUENCY
+
+          # Format start
+          #
+          # @param [Env::Bootstrap] env
+          #
+          # @return [String]
+          def start(_env)
+            tput.prepare
+          end
+
+          # Format progress
+          #
+          # @param [Runner::Status] status
+          #
+          # @return [String]
+          def progress(status)
+            format(Printer::Status, status)
+          end
+
+          private
+
+          # New buffer
+          #
+          # @return [StringIO]
+          def new_buffer
+            # For some reason this raises an Errno::EACCESS error:
+            #
+            #  StringIO.new(Tput::INSTANCE.restore, BUFFER_FLAGS)
+            #
+            buffer = StringIO.new
+            buffer << tput.restore
+          end
+        end # Framed
+      end # Format
+    end # CLI
+  end # Reporter
+end # Mutest