jawshooah-overcommit 0.22.0

data/lib/overcommit/interrupt_handler.rb

@@ -0,0 +1,87 @@
+require 'singleton'
+
+# Provides a handler for interrupt signals (SIGINT), allowing the application to
+# finish what it's currently working on.
+class InterruptHandler
+  include Singleton
+
+  attr_accessor :isolate_signals, :signal_received, :reenable_on_interrupt
+
+  def initialize
+    self.isolate_signals = false
+    self.signal_received = false
+    self.reenable_on_interrupt = false
+
+    Signal.trap('INT') do
+      if isolate_signals
+        self.signal_received = true
+      else
+        if reenable_on_interrupt
+          self.reenable_on_interrupt = false
+          self.isolate_signals = true
+        end
+
+        raise Interrupt # Allow interrupt to propagate to code
+      end
+    end
+  end
+
+  class << self
+    # Provide a way to allow a single Ctrl-C interrupt to happen and atomically
+    # re-enable interrupt protections once that interrupt is propagated.
+    #
+    # This prevents a race condition where code like the following:
+    #
+    #  begin
+    #    InterruptHandler.disable!
+    #    ... do stuff ...
+    #  rescue Interrupt
+    #    ... handle it ...
+    #  ensure
+    #    InterruptHandler.enable!
+    #  end
+    #
+    # ...could have the `enable!` call to the interrupt handler not called in
+    # the event another interrupt was received in between the interrupt being
+    # handled and the `ensure` block being entered.
+    #
+    # Thus you should always write:
+    #
+    #  begin
+    #    InterruptHandler.disable_until_finished_or_interrupted do
+    #      ... do stuff ...
+    #    end
+    #  rescue Interrupt
+    #    ... handle it ...
+    #  rescue
+    #    ... handle any other exceptions ...
+    #  end
+    def disable_until_finished_or_interrupted
+      instance.reenable_on_interrupt = true
+      instance.isolate_signals = false
+      yield
+    ensure
+      instance.isolate_signals = true
+    end
+
+    def disable!
+      instance.isolate_signals = false
+    end
+
+    def enable!
+      instance.isolate_signals = true
+    end
+
+    def isolate_from_interrupts
+      instance.signal_received = false
+      instance.isolate_signals = true
+      result = yield
+      instance.isolate_signals = false
+      result
+    end
+
+    def signal_received?
+      instance.signal_received
+    end
+  end
+end

data/lib/overcommit/logger.rb

@@ -0,0 +1,79 @@
+module Overcommit
+  # Encapsulates all communication to an output source.
+  class Logger
+    # Helper for creating a logger which outputs nothing.
+    def self.silent
+      new(File.open('/dev/null', 'w'))
+    end
+
+    # Creates a logger that will write to the given output stream.
+    #
+    # @param out [IO]
+    def initialize(out)
+      @out = out
+    end
+
+    # Write output without a trailing newline.
+    def partial(*args)
+      @out.print(*args)
+    end
+
+    # Prints a newline character (alias for readability).
+    def newline
+      log
+    end
+
+    # Write a line of output.
+    #
+    # A newline character will always be appended.
+    def log(*args)
+      @out.puts(*args)
+    end
+
+    # Write a line of output that is intended to be emphasized.
+    def bold(*args)
+      color('1', *args)
+    end
+
+    # Write a line of output indicating a problem or error.
+    def error(*args)
+      color(31, *args)
+    end
+
+    # Write a line of output indicating a problem or error which is emphasized
+    # over a regular problem or error.
+    def bold_error(*args)
+      color('1;31', *args)
+    end
+
+    # Write a line of output indicating a successful or noteworthy event.
+    def success(*args)
+      color(32, *args)
+    end
+
+    # Write a line of output indicating a potential cause for concern, but not
+    # an actual error.
+    def warning(*args)
+      color(33, *args)
+    end
+
+    # Write a line of output indicating a potential cause for concern, but with
+    # greater emphasize compared to other warnings.
+    def bold_warning(*args)
+      color('1;33', *args)
+    end
+
+    private
+
+    # Outputs text wrapped in ANSI escape code necessary to produce a given
+    # color/text display.
+    #
+    # @param code [String] ANSI escape code, e.g. '1;33' for "bold yellow"
+    # @param str [String] string to wrap
+    # @param partial [true,false] whether to omit a newline
+    def color(code, str, partial = false)
+      send(partial ? :partial : :log,
+           @out.tty? ? "\033[#{code}m#{str}\033[0m" : str)
+    end
+  end
+end

data/lib/overcommit/message_processor.rb

@@ -0,0 +1,132 @@
+module Overcommit
+  # Utility class that encapsulates the handling of hook messages and whether
+  # they affect lines the user has modified or not.
+  #
+  # This class exposes an endpoint that extracts an appropriate hook/status
+  # output tuple from an array of {Overcommit::Hook::Message}s, respecting the
+  # configuration settings for the given hook.
+  class MessageProcessor
+    ERRORS_MODIFIED_HEADER = 'Errors on modified lines:'
+    WARNINGS_MODIFIED_HEADER = 'Warnings on modified lines:'
+    ERRORS_UNMODIFIED_HEADER = "Errors on lines you didn't modify:"
+    WARNINGS_UNMODIFIED_HEADER = "Warnings on lines you didn't modify:"
+
+    # @param hook [Overcommit::Hook::Base]
+    # @param unmodified_lines_setting [String] how to treat messages on
+    #   unmodified lines
+    def initialize(hook, unmodified_lines_setting)
+      @hook = hook
+      @setting = unmodified_lines_setting
+    end
+
+    # Returns a hook status/output tuple from the messages this processor was
+    # initialized with.
+    #
+    # @return [Array<Symbol,String>]
+    def hook_result(messages)
+      status, output = basic_status_and_output(messages)
+
+      # Nothing to do if there are no problems to begin with
+      return [status, output] if status == :pass
+
+      # Return as-is if this type of hook doesn't have the concept of modified lines
+      return [status, output] unless @hook.respond_to?(:modified_lines_in_file)
+
+      handle_modified_lines(messages, status)
+    end
+
+    private
+
+    def handle_modified_lines(messages, status)
+      messages = remove_ignored_messages(messages)
+
+      messages_on_modified_lines, messages_on_unmodified_lines =
+        messages.partition { |message| message_on_modified_line?(message) }
+
+      output = print_messages(
+        messages_on_modified_lines,
+        ERRORS_MODIFIED_HEADER,
+        WARNINGS_MODIFIED_HEADER
+      )
+      output += print_messages(
+        messages_on_unmodified_lines,
+        ERRORS_UNMODIFIED_HEADER,
+        WARNINGS_UNMODIFIED_HEADER
+      )
+
+      [transform_status(status, messages_on_modified_lines), output]
+    end
+
+    def transform_status(status, messages_on_modified_lines)
+      # `report` indicates user wants the original status
+      return status if @setting == 'report'
+
+      error_messages, warning_messages =
+        messages_on_modified_lines.partition { |msg| msg.type == :error }
+
+      if can_upgrade_to_warning?(status, error_messages)
+        status = :warn
+      end
+
+      if can_upgrade_to_passing?(status, warning_messages)
+        status = :pass
+      end
+
+      status
+    end
+
+    def can_upgrade_to_warning?(status, error_messages)
+      status == :fail && error_messages.empty?
+    end
+
+    def can_upgrade_to_passing?(status, warning_messages)
+      status == :warn && @setting == 'ignore' && warning_messages.empty?
+    end
+
+    # Returns status and output for messages assuming no special treatment of
+    # messages occurring on unmodified lines.
+    def basic_status_and_output(messages)
+      status =
+        if messages.any? { |message| message.type == :error }
+          :fail
+        elsif messages.any? { |message| message.type == :warning }
+          :warn
+        else
+          :pass
+        end
+
+      output = ''
+      if messages.any?
+        output += messages.join("\n") + "\n"
+      end
+
+      [status, output]
+    end
+
+    def print_messages(messages, error_heading, warning_heading)
+      output = ''
+      errors, warnings = messages.partition { |msg| msg.type == :error }
+
+      if errors.any?
+        output += "#{error_heading}\n#{errors.join("\n")}\n"
+      end
+
+      if warnings.any?
+        output += "#{warning_heading}\n#{warnings.join("\n")}\n"
+      end
+
+      output
+    end
+
+    def remove_ignored_messages(messages)
+      # If user wants to ignore messages on unmodified lines, simply remove them
+      return messages unless @setting == 'ignore'
+
+      messages.select { |message| message_on_modified_line?(message) }
+    end
+
+    def message_on_modified_line?(message)
+      @hook.modified_lines_in_file(message.file).include?(message.line)
+    end
+  end
+end

data/lib/overcommit/printer.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+module Overcommit
+  # Provide a set of callbacks which can be executed as events occur during the
+  # course of {HookRunner#run}.
+  class Printer
+    attr_reader :log
+
+    def initialize(logger, context)
+      @log = logger
+      @context = context
+    end
+
+    # Executed at the very beginning of running the collection of hooks.
+    def start_run
+      log.bold "Running #{hook_script_name} hooks"
+    end
+
+    def nothing_to_run
+      log.success "✓ No applicable #{hook_script_name} hooks to run"
+    end
+
+    # Executed at the start of an individual hook run.
+    def start_hook(hook)
+      unless hook.quiet?
+        print_header(hook)
+      end
+    end
+
+    def hook_skipped(hook)
+      log.warning "Skipping #{hook.name}"
+    end
+
+    def required_hook_not_skipped(hook)
+      log.warning "Cannot skip #{hook.name} since it is required"
+    end
+
+    # Executed at the end of an individual hook run.
+    def end_hook(hook, status, output)
+      # Want to print the header for quiet hooks only if the result wasn't good
+      # so that the user knows what failed
+      print_header(hook) if hook.quiet? && ![:good, :pass].include?(status)
+
+      print_result(hook, status, output)
+    end
+
+    # Executed when a hook run was interrupted/cancelled by user.
+    def run_interrupted
+      log.newline
+      log.warning '⚠  Hook run interrupted by user'
+      log.newline
+    end
+
+    # Executed when one or more hooks by the end of the run.
+    def run_failed
+      log.newline
+      log.error "✗ One or more #{hook_script_name} hooks failed"
+      log.newline
+    end
+
+    # Executed when no hooks failed by the end of the run.
+    def run_succeeded
+      log.newline
+      log.success "✓ All #{hook_script_name} hooks passed"
+      log.newline
+    end
+
+    private
+
+    def print_header(hook)
+      hook_name = "[#{hook.name}] "
+      log.partial hook.description
+      log.partial '.' * [70 - hook.description.length - hook_name.length, 0].max
+      log.partial hook_name
+    end
+
+    def print_result(hook, status, output) # rubocop:disable CyclomaticComplexity, MethodLength
+      case status
+      when :pass
+        log.success 'OK' unless hook.quiet?
+      when :good
+        log.success 'OK'
+        log.bold_error 'Hook returned a status of `:good`. This is deprecated ' \
+                       'in favor of `:pass` and will be removed in a future ' \
+                       'version of Overcommit'
+      when :warn
+        log.warning 'WARNING'
+        print_report(output, :bold_warning)
+      when :bad
+        log.error 'FAILED'
+        log.bold_error 'Hook returned a status of `:bad`. This is deprecated ' \
+                       'in favor of `:fail` and will be removed in a future ' \
+                       'version of Overcommit'
+        print_report(output, :bold_error)
+      when :fail
+        log.error 'FAILED'
+        print_report(output, :bold_error)
+      when :interrupt
+        log.error 'INTERRUPTED'
+        print_report(output, :bold_error)
+      else
+        log.error '???'
+        print_report("Hook returned unknown status `#{status.inspect}` -- ignoring.",
+                     :bold_error)
+      end
+    end
+
+    def print_report(output, format = :log)
+      log.send(format, output) unless output.nil? || output.empty?
+    end
+
+    def hook_script_name
+      @context.hook_script_name
+    end
+  end
+end

data/lib/overcommit/subprocess.rb

@@ -0,0 +1,46 @@
+require 'childprocess'
+require 'tempfile'
+
+module Overcommit
+  # Manages execution of a child process, collecting the exit status and
+  # standard out/error output.
+  class Subprocess
+    # Encapsulates the result of a process.
+    Result = Struct.new(:status, :stdout, :stderr) do
+      def success?
+        status == 0
+      end
+    end
+
+    class << self
+      # Spawns a new process using the given array of arguments (the first
+      # element is the command).
+      def spawn(args)
+        process = ChildProcess.build(*args)
+
+        out, err = assign_output_streams(process)
+
+        process.start
+        process.wait
+
+        err.rewind
+        out.rewind
+
+        Result.new(process.exit_code, out.read, err.read)
+      end
+
+      private
+
+      # @param process [ChildProcess]
+      # @return [Array<IO>]
+      def assign_output_streams(process)
+        %w[out err].map do |stream_name|
+          ::Tempfile.new(stream_name).tap do |stream|
+            stream.sync = true
+            process.io.send("std#{stream_name}=", stream)
+          end
+        end
+      end
+    end
+  end
+end