loupe 0.1.5

data/lib/loupe/paged_reporter.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module Loupe
+  # Pager
+  #
+  # This class is responsible for paginating the test failures,
+  # and implementing an interface for interacting with them.
+  class PagedReporter < Reporter # rubocop:disable Metrics/ClassLength
+    # @return [void]
+    def print_summary
+      @current_page = 0
+      @console = IO.console
+      @runtime = Time.now - @start_time
+      @running = true
+      page
+    end
+
+    private
+
+    # Main loop of the pager
+    # Allow users to navigate through pages of test failures
+    # and interact with them.
+    # @return [void]
+    def page
+      while @running
+        @current_failure = @failures[@current_page]
+        @mid_width = @console.winsize[1] / 2
+        header
+
+        if @failures.empty?
+          puts "All tests fixed"
+          @running = false
+        else
+          file_preview
+          menu
+          handle_raw_command
+        end
+      end
+    end
+
+    # Read a raw command from the console and match it
+    #
+    # @return [void]
+    def handle_raw_command # rubocop:disable Metrics/CyclomaticComplexity
+      case @console.raw { |c| c.read(1) }
+      when "j"
+        @current_page += 1 unless @current_page == @failures.length - 1
+      when "k"
+        @current_page -= 1 unless @current_page.zero?
+      when "o"
+        open_editor
+      when "f"
+        @failures.delete_at(@current_page)
+        @failure_count -= 1
+        @success_count += 1
+        @current_page -= 1 unless @current_page.zero?
+      when "r"
+        rerun_failure
+      when "q"
+        @running = false
+      end
+    end
+
+    # Print the summary at the top of the screen.
+    # This string has to be updated every time, since the statistics
+    # might change if the user has marked tests as fixed
+    # return [String]
+    def summary
+      <<~SUMMARY
+        Tests: #{@test_count} Expectations: #{@expectation_count}
+        Passed: #{@success_count} Failures: #{@failure_count}
+
+        Finished in #{@runtime} seconds
+      SUMMARY
+    end
+
+    # Prints a bar at the top with the summary of the test run
+    # including totals failures and expectations
+    # @return [void]
+    def header
+      @console.erase_screen(2)
+      @console.cursor = [0, 0]
+      bar = "=" * @console.winsize[1]
+      puts "#{bar}\n#{summary}\n#{bar}\n"
+    end
+
+    # Print the preview of the file where a failure occurred
+    # add a line indicating where exactly it broke
+    # @return [void]
+    def file_preview
+      lines = File.readlines(@current_failure.file_name)
+
+      lines.insert(
+        @current_failure.line_number + 1,
+        "#{indentation_on_failure_line(lines)}^^^ #{@current_failure.message.gsub(/(\[\d;\d{2}m|\[0m)/, '')}"
+      )
+
+      content = lines[@current_failure.line_number - 5..@current_failure.line_number + 5].join("\n")
+      puts content
+    end
+
+    # The indentation on the line where the failure happened
+    # so that the error message can be inserted at the right level
+    # @param lines [Array<String>]
+    # return [String]
+    def indentation_on_failure_line(lines)
+      " " * (lines[@current_failure.line_number].chars.index { |c| c != " " })
+    end
+
+    # @return [void]
+    def menu
+      location, message = @current_failure.location_and_message
+
+      print_on_right_side(7, @status)
+      print_on_right_side(9, location)
+      print_on_right_side(10, message)
+
+      print_on_right_side(12, "Commands")
+      print_on_right_side(14, "j (next)")
+      print_on_right_side(15, "k (previous)")
+      print_on_right_side(16, "o (open in editor)")
+      print_on_right_side(17, "f (mark as fixed)")
+      print_on_right_side(18, "r (rerun selected test)")
+      print_on_right_side(19, "q (quit)")
+
+      @status = nil
+    end
+
+    # The first half of the screen is the file preview.
+    # This helper method assists in printing things on the
+    # other side of the screen.
+    #
+    # Always clear coloring afterwards
+    #
+    # return [void]
+    def print_on_right_side(row, message)
+      @console.cursor = [row, @mid_width + 1]
+      available_length = @console.winsize[1] - @mid_width + 1
+      print message.to_s[0, available_length]
+      print "\033[0m"
+    end
+
+    # Open the editor selected by options (or defined by $EDITOR) with the current
+    # failure being viewed.
+    # @return [void]
+    def open_editor
+      editor = @options[:editor] || ENV["EDITOR"]
+      executable = editor_executable(editor)
+
+      case editor
+      when "vim", "nvim"
+        spawn "#{executable} +#{@current_failure.line_number} #{@current_failure.file_name}"
+      when "code"
+        spawn "#{executable} -g #{@current_failure.file_name}:#{@current_failure.line_number}"
+      else
+        spawn "#{executable} #{@current_failure.file_name}"
+      end
+    end
+
+    # Attempt to find the editor's executable within
+    # the given PATHs
+    # @param editor [String]
+    # @return [String]
+    def editor_executable(editor)
+      ENV["PATH"].split(":").each do |p|
+        path = File.join(p, editor)
+        return path if File.exist?(path)
+      end
+    end
+
+    # Rerun the current failure
+    #
+    # Since the developer is changing the test file to fix it,
+    # we need to unload it from LOADED_FEATURES and require it again.
+    # Otherwise, we would just be re-running the same test loaded in memory
+    # and it would never pass.
+    #
+    # @return void
+    def rerun_failure
+      $LOADED_FEATURES.delete(@current_failure.file_name)
+      require @current_failure.file_name
+
+      reporter = @current_failure.klass.run(@current_failure.test_name, @options)
+
+      if reporter.failures.empty?
+        @status = "#{@color.p('Fixed', :green)}. Click f to remove from list"
+      else
+        @failures[@current_page] = reporter.failures.first
+        @status = @color.p("Still failing", :red)
+      end
+    end
+  end
+end

data/lib/loupe/plain_reporter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Loupe
+  # PlainReporter
+  #
+  # A simple reporter that just prints dots and Fs to
+  # the terminal
+  class PlainReporter < Reporter
+    # @return [void]
+    def print_summary
+      if @failures.empty?
+        report = ""
+      else
+        report = +"\n\n"
+        report << @failures.map!(&:to_s).join("\n")
+      end
+
+      print "\n\n"
+      print <<~SUMMARY
+        Tests: #{@test_count} Expectations: #{@expectation_count}
+        Passed: #{@success_count} Failures: #{@failure_count}#{report}
+
+        Finished in #{Time.now - @start_time} seconds
+      SUMMARY
+    end
+  end
+end

data/lib/loupe/process_executor.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "drb/drb"
+
+module Loupe
+  # ProcessExecutor
+  #
+  # This class is responsible for executing tests in process mode.
+  class ProcessExecutor < Executor
+    # Create a new ProcessExecutor
+    #
+    # This will create a new server object that will be shared
+    # with child processes using DRb
+    # @param options [Hash<Symbol, BasicObject>]
+    # @return [Loupe::Executor]
+    def initialize(options)
+      super
+
+      @server = QueueServer.new(populate_queue, @reporter)
+      @url = DRb.start_service("drbunix:", @server).uri
+    end
+
+    # run
+    #
+    # Fork each one of the process workers and connect with the server
+    # object coming from DRb. Run until the queue is clear
+    # @return [Integer]
+    def run
+      @workers = (0...[Etc.nprocessors, @server.length].min).map do
+        fork do
+          DRb.start_service
+          server = DRbObject.new_with_uri(@url)
+
+          until server.empty?
+            klass, method_name = server.pop
+            server.add_reporter(klass.run(method_name, @options)) if klass && method_name
+          end
+        end
+      end
+
+      shutdown
+      @reporter.print_summary
+      @reporter.exit_status
+    end
+
+    private
+
+    # Wait until all child processes finish executing tests
+    # and then stop the DRb service
+    # return [void]
+    def shutdown
+      @workers.each { |pid| Process.waitpid(pid) }
+      DRb.stop_service
+    end
+  end
+end

data/lib/loupe/queue_server.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Loupe
+  # Server
+  #
+  # This object is the one passed to DRb in order to
+  # communicate between worker and server processes and coordinate
+  # both the queue and the reporting results
+  class QueueServer
+    # The two operations we need to synchronize between the
+    # main process and its children is the queue and the reporter.
+    # We need to share the queue, so that workers can pop the tests from it
+    # and we need to share the reporter, so that workers can update the results
+    #
+    # @param queue [Array<Array<Class, Symbol>>]
+    # @param reporter [Loupe::Reporter]
+    # @return [Loupe::Server]
+    def initialize(queue, reporter)
+      @queue = queue
+      @reporter = reporter
+    end
+
+    # add_reporter
+    #
+    # Adds a temporary reporter from a child process into
+    # the main reporter to aggregate results
+    #
+    # @param other [Loupe::Reporter]
+    # @return [void]
+    def add_reporter(other)
+      @reporter << other
+    end
+
+    # @return [Array<Class, Symbol>]
+    def pop
+      @queue.pop
+    end
+
+    # @return [Integer]
+    def length
+      @queue.length
+    end
+
+    # @return [Boolean]
+    def empty?
+      @queue.empty?
+    end
+  end
+end

data/lib/loupe/ractor_executor.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Loupe
+  # RactorExecutor
+  #
+  # This class is responsible for the execution flow. It populates
+  # the queue of tests to be executed, instantiates the workers,
+  # creates an accumulator reporter and delegates tests to workers
+  # until the queue is empty.
+  class RactorExecutor < Executor
+    # @param options [Hash<Symbol, BasicObject>]
+    # @return [Loupe::Executor]
+    def initialize(options)
+      super
+      @workers = (0...[Etc.nprocessors, @queue.length].min).map do
+        Ractor.new(options) do |opts|
+          loop do
+            klass, method_name = Ractor.receive
+            Ractor.yield klass.run(method_name, opts)
+          end
+        end
+      end
+    end
+
+    # Run the main process for executing tests
+    #
+    # Send the first tests to all workers from the queue and
+    # then keep selecting the idle Ractor until the queue is empty.
+    # Acumulate the reporters as tests are finalized.
+    # The last set of results are obtained outside the loop using `take`,
+    # since once the queue is empty `select` will no longer accumulate the result.
+    #
+    # @return [Integer]
+    def run
+      @workers.each do |r|
+        item = @queue.pop
+        r.send(item) unless item.nil?
+      end
+
+      until @queue.empty?
+        idle_worker, tmp_reporter = Ractor.select(*@workers)
+        @reporter << tmp_reporter
+        idle_worker.send(@queue.pop)
+      end
+
+      @workers.each { |w| @reporter << w.take }
+
+      @reporter.print_summary
+      @reporter.exit_status
+    end
+  end
+end

data/lib/loupe/rake_task.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "loupe"
+require "rake"
+require "rake/tasklib"
+
+module Loupe
+  # Loupe's test rake task
+  #
+  # Define a rake task so that we can hook into `rake test`
+  # an run the suite using Loupe. To hook it up, add this to the Rakefile
+  #
+  # require "loupe/rake_task"
+  #
+  # Loupe::RakeTask.new do |options|
+  #   options << "--plain"
+  #   options << "--ractor"
+  # end
+  #
+  # Then run with `bundle exec rake test`
+  #
+  class RakeTask < Rake::TaskLib
+    attr_accessor :name, :description, :libs
+
+    # @return [Loupe::RakeTask]
+    def initialize
+      super
+
+      @name = "test"
+      @description = "Run tests using Loupe"
+      @libs = %w[lib test]
+      @options = []
+      ARGV.shift if ARGV.first == "test"
+      yield(@options)
+      define
+    end
+
+    private
+
+    # @return [Loupe::RakeTask]
+    def define
+      desc @description
+      task(@name) { Loupe::Cli.new(@options) }
+      self
+    end
+  end
+end

data/lib/loupe/reporter.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Loupe's reporter structure is heavily inspired by or adapted from Minitest. The
+# originals license can be found below.
+#
+# Minitest https://github.com/seattlerb/minitest
+#
+# (The MIT License)
+#
+# Copyright © Ryan Davis, seattle.rb
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the 'Software'), to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+# to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+# the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+# THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+module Loupe
+  # Reporter
+  #
+  # Class that handles reporting test results
+  # and progress.
+  class Reporter
+    # @return [Integer]
+    attr_reader :test_count
+
+    # @return [Integer]
+    attr_reader :expectation_count
+
+    # @return [Integer]
+    attr_reader :success_count
+
+    # @return [Integer]
+    attr_reader :failure_count
+
+    # @return [Array<Loupe::Failure>]
+    attr_reader :failures
+
+    # @param options [Hash<Symbol, BasicObject>]
+    # @return [Loupe::Reporter]
+    def initialize(options = {})
+      @options = options
+      @color = Color.new(options[:color])
+      @options = options
+      @test_count = 0
+      @expectation_count = 0
+      @success_count = 0
+      @failure_count = 0
+      @failures = []
+      @start_time = Time.now
+    end
+
+    # @return [void]
+    def increment_test_count
+      @test_count += 1
+    end
+
+    # @return [void]
+    def increment_expectation_count
+      @expectation_count += 1
+    end
+
+    # @return [void]
+    def increment_success_count
+      print(@color.p(".", :green))
+      @success_count += 1
+    end
+
+    # @param test [Loupe::Test]
+    # @return [void]
+    def increment_failure_count(test, message)
+      print(@color.p("F", :red))
+      @failures << Failure.new(test, message)
+      @failure_count += 1
+    end
+
+    # @param other [Loupe::Reporter]
+    # @return [Loupe::Reporter]
+    def <<(other)
+      @test_count += other.test_count
+      @expectation_count += other.expectation_count
+      @success_count += other.success_count
+      @failure_count += other.failure_count
+      @failures.concat(other.failures)
+      self
+    end
+
+    # @return [Integer]
+    def exit_status
+      @failure_count.zero? ? 0 : 1
+    end
+
+    # @return [void]
+    def print_summary
+      raise NotImplementedError, "Print must be implemented in the inheriting reporter class"
+    end
+  end
+end