mutest 0.0.1 → 0.0.2

data/lib/mutest/reporter/cli/printer/status_progressive.rb

@@ -0,0 +1,46 @@
+module Mutest
+  class Reporter
+    class CLI
+      class Printer
+        # Reporter for progressive output format on scheduler Status objects
+        class StatusProgressive < self
+          FORMAT = '(%02d/%02d) %3d%% - killtime: %0.02fs runtime: %0.02fs overhead: %0.02fs'.freeze
+
+          delegate(
+            :coverage,
+            :runtime,
+            :amount_mutations_killed,
+            :amount_mutations,
+            :amount_mutation_results,
+            :killtime,
+            :overhead
+          )
+
+          # Run printer
+          #
+          # @return [undefined]
+          def run
+            status(
+              FORMAT,
+              amount_mutations_killed,
+              amount_mutations,
+              coverage * 100,
+              killtime,
+              runtime,
+              overhead
+            )
+          end
+
+          private
+
+          # Object being printed
+          #
+          # @return [Result::Env]
+          def object
+            super().payload
+          end
+        end # StatusProgressive
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutest

data/lib/mutest/reporter/cli/printer/subject_progress.rb

@@ -0,0 +1,65 @@
+module Mutest
+  class Reporter
+    class CLI
+      class Printer
+        # Reporter for subject progress
+        class SubjectProgress < self
+          FORMAT = '(%02d/%02d) %3d%% - killtime: %0.02fs runtime: %0.02fs overhead: %0.02fs'.freeze
+
+          delegate(
+            :tests,
+            :subject,
+            :coverage,
+            :runtime,
+            :amount_mutations_killed,
+            :amount_mutations,
+            :amount_mutation_results,
+            :killtime,
+            :overhead
+          )
+
+          # Run printer
+          #
+          # @return [undefined]
+          def run
+            puts("#{subject.identification} mutations: #{amount_mutations}")
+            print_mutation_results
+            print_progress_bar_finish
+            print_stats
+          end
+
+          private
+
+          # Print stats
+          #
+          # @return [undefined]
+          def print_stats
+            status(
+              FORMAT,
+              amount_mutations_killed,
+              amount_mutations,
+              coverage * 100,
+              killtime,
+              runtime,
+              overhead
+            )
+          end
+
+          # Print progress bar finish
+          #
+          # @return [undefined]
+          def print_progress_bar_finish
+            puts(nil) unless amount_mutation_results.zero?
+          end
+
+          # Print mutation results
+          #
+          # @return [undefined]
+          def print_mutation_results
+            visit_collection(MutationProgressResult, object.mutation_results)
+          end
+        end # SubjectProgress
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutest

data/lib/mutest/reporter/cli/printer/subject_result.rb

@@ -0,0 +1,23 @@
+module Mutest
+  class Reporter
+    class CLI
+      class Printer
+        # Subject result printer
+        class SubjectResult < self
+          delegate :subject, :alive_mutation_results, :tests
+
+          # Run report printer
+          #
+          # @return [undefined]
+          def run
+            status(subject.identification)
+            tests.each do |test|
+              puts("- #{test.identification}")
+            end
+            visit_collection(MutationResult, alive_mutation_results)
+          end
+        end # SubjectResult
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutest

data/lib/mutest/reporter/cli/printer/test_result.rb

@@ -0,0 +1,28 @@
+module Mutest
+  class Reporter
+    class CLI
+      class Printer
+        # Test result reporter
+        class TestResult < self
+          delegate :tests, :runtime
+
+          STATUS_FORMAT = '- %d @ runtime: %s'.freeze
+          OUTPUT_HEADER = 'Test Output:'.freeze
+          TEST_FORMAT   = '  - %s'.freeze
+
+          # Run test result reporter
+          #
+          # @return [undefined]
+          def run
+            info(STATUS_FORMAT, tests.length, runtime)
+            tests.each do |test|
+              info(TEST_FORMAT, test.identification)
+            end
+            puts(OUTPUT_HEADER)
+            puts(object.output)
+          end
+        end # TestResult
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutest

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

@@ -0,0 +1,43 @@
+module Mutest
+  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 # Mutest

data/lib/mutest/reporter/null.rb

@@ -0,0 +1,14 @@
+module Mutest
+  class Reporter
+    # Null reporter
+    class Null < self
+      include Equalizer.new
+
+      %w[warn report start progress].each do |name|
+        define_method name do |_object|
+          self
+        end
+      end
+    end # Null
+  end # Reporter
+end # Mutest

data/lib/mutest/reporter/sequence.rb

@@ -0,0 +1,24 @@
+module Mutest
+  class Reporter
+    class Sequence < self
+      include Concord.new(:reporters)
+
+      %i[warn progress report start].each do |name|
+        define_method(name) do |value|
+          reporters.each do |reporter|
+            reporter.public_send(name, value)
+          end
+
+          self
+        end
+      end
+
+      # Minimum reporter delay
+      #
+      # @return [Float]
+      def delay
+        reporters.map(&:delay).min
+      end
+    end # Sequence
+  end # Reporter
+end # Mutest

data/lib/mutest/repository.rb

@@ -0,0 +1,80 @@
+module Mutest
+  module Repository
+    # Error raised on repository interaction problems
+    RepositoryError = Class.new(RuntimeError)
+
+    # Subject filter based on repository diff
+    class SubjectFilter
+      include Adamantium, Concord.new(:diff)
+
+      # Test if subject was touched in diff
+      #
+      # @param [Subject] subject
+      #
+      # @return [Boolean]
+      def call(subject)
+        diff.touches?(subject.source_path, subject.source_lines)
+      end
+    end # SubjectFilter
+
+    # Diff between two objects in repository
+    class Diff
+      include Adamantium, Anima.new(:config, :from, :to)
+
+      HEAD = 'HEAD'.freeze
+
+      # Test if diff changes file at line range
+      #
+      # @param [Pathname] path
+      # @param [Range<Fixnum>] line_range
+      #
+      # @return [Boolean]
+      #
+      # @raise [RepositoryError]
+      #   when git command failed
+      def touches?(path, line_range)
+        return false unless within_working_directory?(path) && tracks?(path)
+
+        command = %W[
+          git log
+          #{from}...#{to}
+          -L #{line_range.begin},#{line_range.end}:#{path}
+        ]
+
+        stdout, status = config.open3.capture2(*command, binmode: true)
+
+        fail RepositoryError, "Command #{command} failed!" unless status.success?
+
+        !stdout.empty?
+      end
+
+      private
+
+      # Test if path is tracked in repository
+      #
+      # FIXME: Cache results, to avoid spending time on producing redundant results.
+      #
+      # @param [Pathname] path
+      #
+      # @return [Boolean]
+      def tracks?(path)
+        command = %W[git ls-files --error-unmatch -- #{path}]
+        config.kernel.system(
+          *command,
+          out: File::NULL,
+          err: File::NULL
+        )
+      end
+
+      # Test if the path is within the current working directory
+      #
+      # @param [Pathname] path
+      #
+      # @return [TrueClass, nil]
+      def within_working_directory?(path)
+        working_directory = config.pathname.pwd
+        path.ascend { |parent| return true if working_directory.eql?(parent) }
+      end
+    end # Diff
+  end # Repository
+end # Mutest

data/lib/mutest/require_highjack.rb

@@ -0,0 +1,24 @@
+module Mutest
+  # Require highjack
+  module RequireHighjack
+    # Install require callback
+    #
+    # @param [Module] target
+    # @param [#call] callback
+    #
+    # @return [#call]
+    #   the original implementation on singleton
+    def self.call(target, callback)
+      target.public_method(:require).tap do
+        target.module_eval do
+          undef_method(:require)
+          define_method(:require, &callback)
+          class << self
+            undef_method(:require)
+          end
+          define_singleton_method(:require, &callback)
+        end
+      end
+    end
+  end # RequireHighjack
+end # Mutest

data/lib/mutest/result.rb

@@ -0,0 +1,212 @@
+module Mutest
+  # Namespace and mixin module for results
+  module Result
+    # Coverage mixin
+    module Coverage
+      FULL_COVERAGE = Rational(1).freeze
+      private_constant(*constants(false))
+
+      # Observed coverage
+      #
+      # @return [Rational]
+      def coverage
+        if amount_mutation_results.zero?
+          FULL_COVERAGE
+        else
+          Rational(amount_mutations_killed, amount_mutation_results)
+        end
+      end
+    end # Coverage
+
+    # Class level mixin
+    module ClassMethods
+      # Generate a sum method from name and collection
+      #
+      # @param [Symbol] name
+      #   the attribute name on collection item and method name to use
+      #
+      # @param [Symbol] collection
+      #   the attribute name used to receive collection
+      #
+      # @return [undefined]
+      def sum(name, collection)
+        define_method(name) do
+          public_send(collection).map(&name).reduce(0, :+)
+        end
+        memoize(name)
+      end
+    end # ClassMethods
+
+    private_constant(*constants(false))
+
+    # Mutest overhead running mutatet tests
+    #
+    # This is NOT the overhead of mutation testing, just an engine specific
+    # measurement for the efficiency of the parallelization engine, kill
+    # isolation etc.
+    #
+    # @return [Float]
+    def overhead
+      runtime - killtime
+    end
+
+    # Hook called when module gets included
+    #
+    # @param [Class, Module] host
+    #
+    # @return [undefined]
+    def self.included(host)
+      host.class_eval do
+        include Adamantium
+        extend ClassMethods
+      end
+    end
+
+    # Env result object
+    class Env
+      include Coverage, Result, Anima.new(
+        :env,
+        :runtime,
+        :subject_results
+      )
+
+      # Test if run is successful
+      #
+      # @return [Boolean]
+      def success?
+        coverage.eql?(Rational(1))
+      end
+      memoize :success?
+
+      # Failed subject results
+      #
+      # @return [Array<Result::Subject>]
+      def failed_subject_results
+        subject_results.reject(&:success?)
+      end
+
+      sum :amount_mutation_results, :subject_results
+      sum :amount_mutations_alive,  :subject_results
+      sum :amount_mutations_killed, :subject_results
+      sum :killtime,                :subject_results
+
+      # Amount of mutations
+      #
+      # @return [Fixnum]
+      def amount_mutations
+        env.mutations.length
+      end
+
+      # Amount of subjects
+      #
+      # @return [Fixnum]
+      def amount_subjects
+        env.subjects.length
+      end
+    end # Env
+
+    # Test result
+    class Test
+      include Result, Anima.new(
+        :output,
+        :passed,
+        :runtime,
+        :tests
+      )
+    end # Test
+
+    # Subject result
+    class Subject
+      include Coverage, Result, Anima.new(
+        :mutation_results,
+        :subject,
+        :tests
+      )
+
+      sum :killtime, :mutation_results
+      sum :runtime,  :mutation_results
+
+      # Test if subject was processed successful
+      #
+      # @return [Boolean]
+      def success?
+        alive_mutation_results.empty?
+      end
+
+      # Alive mutations
+      #
+      # @return [Array<Result::Mutation>]
+      def alive_mutation_results
+        mutation_results.reject(&:success?)
+      end
+      memoize :alive_mutation_results
+
+      # Amount of mutations
+      #
+      # @return [Fixnum]
+      def amount_mutation_results
+        mutation_results.length
+      end
+
+      # Amount of mutations
+      #
+      # @return [Fixnum]
+      def amount_mutations
+        subject.mutations.length
+      end
+
+      # Number of killed mutations
+      #
+      # @return [Fixnum]
+      def amount_mutations_killed
+        killed_mutation_results.length
+      end
+
+      # Number of alive mutations
+      #
+      # @return [Fixnum]
+      def amount_mutations_alive
+        alive_mutation_results.length
+      end
+
+      private
+
+      # Killed mutation results
+      #
+      # @return [Array<Result::Mutation>]
+      def killed_mutation_results
+        mutation_results.select(&:success?)
+      end
+      memoize :killed_mutation_results
+    end # Subject
+
+    # Mutation result
+    class Mutation
+      include Result, Anima.new(
+        :mutation,
+        :test_result
+      )
+
+      # The runtime
+      #
+      # @return [Float]
+      def runtime
+        test_result.runtime
+      end
+
+      # The time spent on killing
+      #
+      # @return [Float]
+      #
+      # @api private
+      alias_method :killtime, :runtime
+
+      # Test if mutation was handled successfully
+      #
+      # @return [Boolean]
+      def success?
+        mutation.class.success?(test_result)
+      end
+    end # Mutation
+  end # Result
+end # Mutest