overcommit-jeygeethanmedia 0.53.1

data/lib/overcommit/installer.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Overcommit
+  # Manages the installation of Overcommit hooks in a git repository.
+  class Installer # rubocop:disable ClassLength
+    TEMPLATE_DIRECTORY = File.join(Overcommit::HOME, 'template-dir')
+    MASTER_HOOK = File.join(TEMPLATE_DIRECTORY, 'hooks', 'overcommit-hook')
+
+    def initialize(logger)
+      @log = logger
+    end
+
+    def run(target, options)
+      @target = target
+      @options = options
+      validate_target
+
+      case @options[:action]
+      when :uninstall then uninstall
+      when :update then update
+      else
+        install
+      end
+    end
+
+    private
+
+    attr_reader :log
+
+    def install
+      log.log "Installing hooks into #{@target}"
+
+      ensure_directory(hooks_path)
+      preserve_old_hooks
+      install_master_hook
+      install_hook_files
+      install_starter_config
+
+      # Auto-sign configuration file on install
+      config(verify: false).update_signature!
+
+      log.success "Successfully installed hooks into #{@target}"
+    end
+
+    def uninstall
+      log.log "Removing hooks from #{@target}"
+
+      uninstall_hook_files
+      uninstall_master_hook
+      restore_old_hooks
+
+      log.success "Successfully removed hooks from #{@target}"
+    end
+
+    # @return [true,false] whether the hooks were updated
+    def update
+      unless FileUtils.compare_file(MASTER_HOOK, master_hook_install_path)
+        preserve_old_hooks
+        install_master_hook
+        install_hook_files
+
+        log.success "Hooks updated to Overcommit version #{Overcommit::VERSION}"
+        true
+      end
+    end
+
+    def hooks_path
+      @hooks_path ||= Dir.chdir(@target) { GitConfig.hooks_path }
+    end
+
+    def old_hooks_path
+      File.join(hooks_path, 'old-hooks')
+    end
+
+    def master_hook_install_path
+      File.join(hooks_path, 'overcommit-hook')
+    end
+
+    def ensure_directory(path)
+      FileUtils.mkdir_p(path)
+    end
+
+    def validate_target
+      absolute_target = File.expand_path(@target)
+
+      unless File.directory?(absolute_target)
+        raise Overcommit::Exceptions::InvalidGitRepo, 'is not a directory'
+      end
+
+      git_dir_check = Dir.chdir(absolute_target) do
+        Overcommit::Utils.execute(%w[git rev-parse --git-dir])
+      end
+
+      unless git_dir_check.success?
+        raise Overcommit::Exceptions::InvalidGitRepo, 'does not appear to be a git repository'
+      end
+    end
+
+    def install_master_hook
+      FileUtils.mkdir_p(hooks_path)
+      FileUtils.cp(MASTER_HOOK, master_hook_install_path)
+    end
+
+    def uninstall_master_hook
+      FileUtils.rm_rf(master_hook_install_path, secure: true)
+    end
+
+    def install_hook_files
+      # Copy each hook type (pre-commit, commit-msg, etc.) from the master hook.
+      Dir.chdir(hooks_path) do
+        Overcommit::Utils.supported_hook_types.each do |hook_type|
+          unless can_replace_file?(hook_type)
+            raise Overcommit::Exceptions::PreExistingHooks,
+                  "Hook '#{File.expand_path(hook_type)}' already exists and " \
+                  'was not installed by Overcommit'
+          end
+          FileUtils.rm_f(hook_type)
+          FileUtils.cp('overcommit-hook', hook_type)
+        end
+      end
+    end
+
+    def can_replace_file?(file)
+      @options[:force] ||
+        !File.exist?(file) ||
+        overcommit_hook?(file)
+    end
+
+    def preserve_old_hooks
+      return unless File.directory?(hooks_path)
+
+      ensure_directory(old_hooks_path)
+      Overcommit::Utils.supported_hook_types.each do |hook_type|
+        hook_file = File.join(hooks_path, hook_type)
+        unless can_replace_file?(hook_file)
+          log.warning "Hook '#{File.expand_path(hook_type)}' already exists and " \
+                      "was not installed by Overcommit. Moving to '#{old_hooks_path}'"
+          FileUtils.mv(hook_file, old_hooks_path)
+        end
+      end
+      # Remove old-hooks directory if empty (i.e. no old hooks were preserved)
+      FileUtils.rmdir(old_hooks_path) if Dir.entries(old_hooks_path).size <= 2
+    end
+
+    def restore_old_hooks
+      return unless File.directory?(old_hooks_path)
+
+      log.log "Restoring old hooks from #{old_hooks_path}"
+
+      Dir.chdir(old_hooks_path) do
+        Overcommit::Utils.supported_hook_types.each do |hook_type|
+          FileUtils.mv(hook_type, hooks_path) if File.exist?(hook_type)
+        end
+      end
+      # Remove old-hooks directory if empty
+      FileUtils.rmdir(old_hooks_path)
+
+      log.success "Successfully restored old hooks from #{old_hooks_path}"
+    end
+
+    def uninstall_hook_files
+      return unless File.directory?(hooks_path)
+
+      Dir.chdir(hooks_path) do
+        Overcommit::Utils.supported_hook_types.each do |hook_type|
+          FileUtils.rm_rf(hook_type, secure: true) if overcommit_hook?(hook_type)
+        end
+      end
+    end
+
+    def install_starter_config
+      repo_config_file = File.join(@target, Overcommit::CONFIG_FILE_NAME)
+
+      return if File.exist?(repo_config_file)
+      FileUtils.cp(File.join(Overcommit::HOME, 'config', 'starter.yml'), repo_config_file)
+    end
+
+    def overcommit_hook?(file)
+      File.read(file) =~ /OVERCOMMIT_DISABLE/
+    rescue Errno::ENOENT
+      # Some Ruby implementations (e.g. JRuby) raise an error when the file
+      # doesn't exist. Standardize the behavior to return false.
+      false
+    end
+
+    # Returns the configuration for this repository.
+    def config(options = {})
+      Overcommit::ConfigurationLoader.new(log, options).load_repo_config
+    end
+  end
+end

data/lib/overcommit/interrupt_handler.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+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
+
+  # Initialize safe interrupt signal handling.
+  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
+
+    # Disable interrupt isolation.
+    def disable!
+      instance.isolate_signals = false
+    end
+
+    # Enable interrupt isolation.
+    def enable!
+      instance.isolate_signals = true
+    end
+
+    # Enable interrupt isolation while executing the provided block.
+    #
+    # @yield block to execute with interrupt isolation
+    def isolate_from_interrupts
+      instance.signal_received = false
+      instance.isolate_signals = true
+      result = yield
+      instance.isolate_signals = false
+      result
+    end
+  end
+end

data/lib/overcommit/logger.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+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(File::NULL, 'w'))
+    end
+
+    # Creates a logger that will write to the given output stream.
+    #
+    # @param out [IO]
+    def initialize(out)
+      @out = out
+      @colorize =
+        if ENV.key?('OVERCOMMIT_COLOR')
+          !%w[0 false no].include?(ENV['OVERCOMMIT_COLOR'])
+        else
+          @out.tty?
+        end
+    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 if debug mode is enabled.
+    def debug(*args)
+      color('35', *args) unless ENV.fetch('OVERCOMMIT_DEBUG') { '' }.empty?
+    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,
+           @colorize ? "\033[#{code}m#{str}\033[0m" : str)
+    end
+  end
+end

data/lib/overcommit/message_processor.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+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:"
+    ERRORS_GENERIC_HEADER = 'Errors:'
+    WARNINGS_GENERIC_HEADER = 'Warnings:'
+
+    # @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_with_line, generic_messages = messages.partition(&:line)
+
+      # Always print generic messages first
+      output = print_messages(
+        generic_messages,
+        ERRORS_GENERIC_HEADER,
+        WARNINGS_GENERIC_HEADER
+      )
+
+      messages_on_modified_lines, messages_on_unmodified_lines =
+        messages_with_line.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, generic_messages + 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)
+      # Message without line number assumed to apply to entire file
+      return true unless message.line
+
+      @hook.modified_lines_in_file(message.file).include?(message.line)
+    end
+  end
+end