overcommit 0.19.0 → 0.20.0

data/lib/overcommit/hook_context/run_all.rb

@@ -0,0 +1,39 @@
+require 'set'
+
+module Overcommit::HookContext
+  # Simulates a pre-commit context pretending that all files have been changed.
+  #
+  # This results in pre-commit hooks running against the entire repository,
+  # which is useful for automated CI scripts.
+  class RunAll < Base
+    EMPTY_SET = Set.new
+
+    def modified_files
+      all_files
+    end
+
+    # Return an empty set since in this context the user didn't actually touch
+    # any lines.
+    def modified_lines_in_file(_file)
+      EMPTY_SET
+    end
+
+    def hook_class_name
+      'PreCommit'
+    end
+
+    def hook_type_name
+      'pre_commit'
+    end
+
+    def hook_script_name
+      'pre-commit'
+    end
+
+    private
+
+    def all_files
+      @all_files ||= Overcommit::GitRepo.all_files
+    end
+  end
+end

data/lib/overcommit/hook_context.rb

@@ -1,12 +1,12 @@
 # Utility module which manages the creation of {HookContext}s.
 module Overcommit::HookContext
-  def self.create(hook_type, config, args, input)
+  def self.create(hook_type, config, args)
     hook_type_class = Overcommit::Utils.camel_case(hook_type)
     underscored_hook_type = Overcommit::Utils.snake_case(hook_type)
 
     require "overcommit/hook_context/#{underscored_hook_type}"
 
-    Overcommit::HookContext.const_get(hook_type_class).new(config, args, input)
+    Overcommit::HookContext.const_get(hook_type_class).new(config, args)
   rescue LoadError, NameError => error
     # Could happen when a symlink was created for a hook type Overcommit does
     # not yet support.

data/lib/overcommit/hook_loader/base.rb

@@ -4,12 +4,10 @@ module Overcommit::HookLoader
     # @param config [Overcommit::Configuration]
     # @param context [Overcommit::HookContext]
     # @param logger [Overcommit::Logger]
-    # @param input [Overcommit::UserInput]
-    def initialize(config, context, logger, input)
+    def initialize(config, context, logger)
       @config = config
       @context = context
       @log = logger
-      @input = input
     end
 
     # When implemented in subclasses, loads the hooks for which that subclass is

data/lib/overcommit/hook_loader/plugin_hook_loader.rb

@@ -5,10 +5,7 @@ module Overcommit::HookLoader
   # is running in.
   class PluginHookLoader < Base
     def load_hooks
-      directory = File.join(@config.plugin_directory, @context.hook_type_name)
-      plugin_paths = Dir[File.join(directory, '*.rb')].sort
-
-      check_for_modified_plugins(plugin_paths) if @config.verify_plugin_signatures?
+      check_for_modified_plugins if @config.verify_plugin_signatures?
 
       plugin_paths.map do |plugin_path|
         require plugin_path
@@ -18,34 +15,47 @@ module Overcommit::HookLoader
       end
     end
 
+    def update_signatures
+      log.success('No plugin signatures have changed') if modified_plugins.empty?
+
+      modified_plugins.each do |plugin|
+        plugin.update_signature!
+        log.warning "Updated signature of plugin #{plugin.hook_name}"
+      end
+    end
+
     private
 
-    def check_for_modified_plugins(plugin_paths)
-      modified_plugins = plugin_paths.
+    def plugin_paths
+      directory = File.join(@config.plugin_directory, @context.hook_type_name)
+      Dir[File.join(directory, '*.rb')].sort
+    end
+
+    def modified_plugins
+      plugin_paths.
         map { |path| Overcommit::HookSigner.new(path, @config, @context) }.
         select(&:signature_changed?)
+    end
 
+    def check_for_modified_plugins
       return if modified_plugins.empty?
 
       log.bold_warning "The following #{@context.hook_script_name} plugins " \
                        'have been added, changed, or had their configuration modified:'
-      log.log
+      log.newline
 
       modified_plugins.each do |signer|
         log.warning " * #{signer.hook_name} in #{signer.hook_path}"
       end
 
-      log.log
-      log.bold_warning 'You should verify the changes before continuing'
+      log.newline
+      log.bold_warning 'You should verify the changes and then run:'
+      log.newline
+      log.warning "overcommit --sign #{@context.hook_script_name}"
+      log.newline
       log.log "For more information, see #{Overcommit::REPO_URL}#security"
-      log.log
-      log.partial 'Continue? (y/n) '
-
-      unless (answer = @input.get) && answer.strip.downcase.start_with?('y')
-        raise Overcommit::Exceptions::HookCancelled
-      end
 
-      modified_plugins.each(&:update_signature!)
+      raise Overcommit::Exceptions::InvalidHookSignature
     end
   end
 end

data/lib/overcommit/hook_runner.rb

@@ -5,12 +5,11 @@ module Overcommit
     # @param config [Overcommit::Configuration]
     # @param logger [Overcommit::Logger]
     # @param context [Overcommit::HookContext]
-    # @param input [Overcommit::UserInput]
-    def initialize(config, logger, context, input, printer)
+    # @param printer [Overcommit::Printer]
+    def initialize(config, logger, context, printer)
       @config = config
       @log = logger
       @context = context
-      @input = input
       @printer = printer
       @hooks = []
     end
@@ -36,7 +35,7 @@ module Overcommit
     attr_reader :log
 
     def run_hooks
-      if @hooks.any? { |hook| hook.run? || hook.skip? }
+      if @hooks.any?(&:enabled?)
         @printer.start_run
 
         interrupted = false
@@ -54,7 +53,7 @@ module Overcommit
           end
         end
 
-        @printer.end_run(run_failed, interrupted)
+        print_results(run_failed, interrupted)
 
         !(run_failed || interrupted)
       else
@@ -63,6 +62,16 @@ module Overcommit
       end
     end
 
+    def print_results(failed, interrupted)
+      if interrupted
+        @printer.run_interrupted
+      elsif failed
+        @printer.run_failed
+      else
+        @printer.run_succeeded
+      end
+    end
+
     def run_hook(hook)
       return if should_skip?(hook)
 
@@ -79,7 +88,7 @@ module Overcommit
         end
       rescue => ex
         status = :fail
-        output = "Hook raised unexpected error\n#{ex.message}"
+        output = "Hook raised unexpected error\n#{ex.message}\n#{ex.backtrace.join("\n")}"
       rescue Interrupt
         # At this point, interrupt has been handled and protection is back in
         # effect thanks to the InterruptHandler.
@@ -99,7 +108,8 @@ module Overcommit
         if hook.required?
           @printer.required_hook_not_skipped(hook)
         else
-          @printer.hook_skipped(hook)
+          # Tell user if hook was skipped only if it actually would have run
+          @printer.hook_skipped(hook) if hook.run?
           return true
         end
       end
@@ -110,10 +120,10 @@ module Overcommit
     def load_hooks
       require "overcommit/hook/#{@context.hook_type_name}/base"
 
-      @hooks += HookLoader::BuiltInHookLoader.new(@config, @context, @log, @input).load_hooks
+      @hooks += HookLoader::BuiltInHookLoader.new(@config, @context, @log).load_hooks
 
       # Load plugin hooks after so they can subclass existing hooks
-      @hooks += HookLoader::PluginHookLoader.new(@config, @context, @log, @input).load_hooks
+      @hooks += HookLoader::PluginHookLoader.new(@config, @context, @log).load_hooks
     end
   end
 end

data/lib/overcommit/installer.rb

@@ -3,8 +3,8 @@ require 'fileutils'
 module Overcommit
   # Manages the installation of Overcommit hooks in a git repository.
   class Installer # rubocop:disable ClassLength
-    MASTER_HOOK =
-      File.join(OVERCOMMIT_HOME, 'template-dir', 'hooks', 'overcommit-hook')
+    TEMPLATE_DIRECTORY = File.join(OVERCOMMIT_HOME, 'template-dir')
+    MASTER_HOOK = File.join(TEMPLATE_DIRECTORY, 'hooks', 'overcommit-hook')
 
     def initialize(logger)
       @log = logger
@@ -115,13 +115,15 @@ module Overcommit
     def can_replace_file?(file)
       @options[:force] ||
         !File.exist?(file) ||
-        overcommit_symlink?(file)
+        overcommit_hook?(file)
     end
 
     def uninstall_hook_symlinks
+      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) if overcommit_symlink?(hook_type)
+          FileUtils.rm_rf(hook_type) if overcommit_hook?(hook_type)
         end
       end
     end
@@ -133,7 +135,9 @@ module Overcommit
       FileUtils.cp(File.join(OVERCOMMIT_HOME, 'config', 'starter.yml'), repo_config_file)
     end
 
-    def overcommit_symlink?(file)
+    def overcommit_hook?(file)
+      return true if File.read(file) =~ /OVERCOMMIT_DISABLE/
+      # TODO: Remove these checks once we hit version 1.0
       File.symlink?(file) && File.readlink(file) == 'overcommit-hook'
     rescue Errno::ENOENT
       # Some Ruby implementations (e.g. JRuby) raise an error when the file

data/lib/overcommit/logger.rb

@@ -6,44 +6,71 @@ module Overcommit
       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)

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

@@ -20,21 +20,6 @@ module Overcommit
       log.success "✓ No applicable #{hook_script_name} hooks to run"
     end
 
-    # Executed at the very end of running the collection of hooks.
-    def end_run(run_failed, interrupted)
-      log.log # Newline
-
-      if interrupted
-        log.warning '⚠  Hook run interrupted by user'
-      elsif run_failed
-        log.error "✗ One or more #{hook_script_name} hooks failed"
-      else
-        log.success "✓ All #{hook_script_name} hooks passed"
-      end
-
-      log.log # Newline
-    end
-
     # Executed at the start of an individual hook run.
     def start_hook(hook)
       unless hook.quiet?
@@ -59,6 +44,27 @@ module Overcommit
       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)
@@ -103,18 +109,6 @@ module Overcommit
       log.send(format, output) unless output.nil? || output.empty?
     end
 
-    def run_interrupted
-      log.warning '⚠  Hook run interrupted by user'
-    end
-
-    def run_failed
-      log.error "✗ One or more #{hook_script_name} hooks failed"
-    end
-
-    def run_succeeded
-      log.success "✓ All #{hook_script_name} hooks passed"
-    end
-
     def hook_script_name
       @context.hook_script_name
     end

data/lib/overcommit/subprocess.rb

@@ -6,32 +6,41 @@ module Overcommit
   # standard out/error output.
   class Subprocess
     # Encapsulates the result of a process.
-    Result = Struct.new(:status, :stderr, :stdout) do
+    Result = Struct.new(:status, :stdout, :stderr) do
       def success?
         status == 0
       end
     end
 
-    # Spawns a new process using the given array of arguments (the first
-    # element is the command).
-    def self.spawn(args)
-      process = ChildProcess.build(*args)
+    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)
 
-      err = ::Tempfile.new('err')
-      err.sync = true
-      out = ::Tempfile.new('out')
-      out.sync = true
+        out, err = assign_output_streams(process)
 
-      process.io.stderr = err
-      process.io.stdout = out
+        process.start
+        process.wait
 
-      process.start
-      process.wait
+        err.rewind
+        out.rewind
 
-      err.rewind
-      out.rewind
+        Result.new(process.exit_code, out.read, err.read)
+      end
+
+      private
 
-      Result.new(process.exit_code, err.read, out.read)
+      # @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

data/lib/overcommit/utils.rb

@@ -132,6 +132,26 @@ module Overcommit
         # symlinks, so we need use File.size?
         File.symlink?(file) && File.size?(file).nil?
       end
+
+      # Convert a glob pattern to an absolute path glob pattern rooted from the
+      # repository root directory.
+      #
+      # @param glob [String]
+      # @return [String]
+      def convert_glob_to_absolute(glob)
+        File.join(repo_root, glob)
+      end
+
+      # Return whether a pattern matches the given path.
+      #
+      # @param pattern [String]
+      # @param path [String]
+      def matches_path?(pattern, path)
+        File.fnmatch?(pattern, path,
+                      File::FNM_PATHNAME | # Wildcard doesn't match separator
+                      File::FNM_DOTMATCH   # Wildcards match dotfiles
+        )
+      end
     end
   end
 end

data/lib/overcommit/version.rb

@@ -1,4 +1,4 @@
 # Defines the gem version.
 module Overcommit
-  VERSION = '0.19.0'
+  VERSION = '0.20.0'
 end

data/lib/overcommit.rb

@@ -6,7 +6,6 @@ require 'overcommit/configuration_loader'
 require 'overcommit/hook/base'
 require 'overcommit/hook_context/base'
 require 'overcommit/hook_context'
-require 'overcommit/user_input'
 require 'overcommit/git_repo'
 require 'overcommit/hook_signer'
 require 'overcommit/hook_loader/base'