overcommit 0.26.0 → 0.27.0

data/lib/overcommit/hook/pre_commit/merge_conflicts.rb

@@ -2,7 +2,7 @@ module Overcommit::Hook::PreCommit
   # Checks for unresolved merge conflicts
   class MergeConflicts < Base
     def run
-      result = execute(command + applicable_files)
+      result = execute(command, args: applicable_files)
 
       unless result.stdout.empty?
         return :fail, "Merge conflict markers detected:\n#{result.stdout}"

data/lib/overcommit/hook/pre_commit/semi_standard.rb

@@ -5,14 +5,14 @@ module Overcommit::Hook::PreCommit
   class SemiStandard < Base
     def run
       result = execute(command + applicable_files)
-      output = result.stderr.chomp
+      output = result.stdout.chomp
       return :pass if result.success? && output.empty?
 
       # example message:
       #   path/to/file.js:1:1: Error message (ruleName)
       extract_messages(
         output.split("\n")[1..-1], # ignore header line
-        /^(?<file>[^:]+):(?<line>\d+)/
+        /^\s*(?<file>[^:]+):(?<line>\d+)/
       )
     end
   end

data/lib/overcommit/hook/pre_commit/standard.rb

@@ -5,14 +5,14 @@ module Overcommit::Hook::PreCommit
   class Standard < Base
     def run
       result = execute(command + applicable_files)
-      output = result.stderr.chomp
+      output = result.stdout.chomp
       return :pass if result.success? && output.empty?
 
       # example message:
       #   path/to/file.js:1:1: Error message (ruleName)
       extract_messages(
         output.split("\n")[1..-1], # ignore header line
-        /^(?<file>[^:]+):(?<line>\d+)/
+        /^\s*(?<file>[^:]+):(?<line>\d+)/
       )
     end
   end

data/lib/overcommit/hook/pre_commit/trailing_whitespace.rb

@@ -2,7 +2,7 @@ module Overcommit::Hook::PreCommit
   # Checks for trailing whitespace in files.
   class TrailingWhitespace < Base
     def run
-      result = execute(command + applicable_files)
+      result = execute(command, args: applicable_files)
 
       extract_messages(
         result.stdout.split("\n"),

data/lib/overcommit/hook_context/base.rb

@@ -22,6 +22,15 @@ module Overcommit::HookContext
       @input = input
     end
 
+    # Executes a command as if it were a regular git hook, passing all
+    # command-line arguments and the standard input stream.
+    #
+    # This is intended to be used by ad hoc hooks so developers can link up
+    # their existing git hooks with Overcommit.
+    def execute_hook(command)
+      Overcommit::Utils.execute(command, args: @args, input: input_string)
+    end
+
     # Returns the camel-cased type of this hook (e.g. PreCommit)
     #
     # @return [String]
@@ -70,12 +79,45 @@ module Overcommit::HookContext
       []
     end
 
+    # Returns the contents of the entire standard input stream that were passed
+    # to the hook.
+    #
+    # @return [String]
+    def input_string
+      @input_string ||= @input.read
+    end
+
     # Returns an array of lines passed to the hook via the standard input
     # stream.
     #
     # @return [Array<String>]
     def input_lines
-      @input_lines ||= @input.read.split("\n")
+      @input_lines ||= input_string.split("\n")
+    end
+
+    private
+
+    def filter_modified_files(modified_files)
+      filter_directories(filter_nonexistent(modified_files))
+    end
+
+    # Filter out non-existent files (unless it's a broken symlink, in which case
+    # it's a file that points to a non-existent file). This could happen if a
+    # file was renamed as part of an amendment, leading to the old file no
+    # longer existing.
+    def filter_nonexistent(modified_files)
+      modified_files.select do |file|
+        File.exist?(file) || Overcommit::Utils.broken_symlink?(file)
+      end
+    end
+
+    # Filter out directories. This could happen when changing a symlink to a
+    # directory as part of an amendment, since the symlink will still appear as
+    # a file, but the actual working tree will have a directory.
+    def filter_directories(modified_files)
+      modified_files.reject do |file|
+        File.directory?(file) && !File.symlink?(file)
+      end
     end
   end
 end

data/lib/overcommit/hook_context/commit_msg.rb

@@ -19,8 +19,8 @@ module Overcommit::HookContext
 
     def commit_message_lines
       raw_commit_message_lines.
-        reject     { |line| line =~ /^#/ }.
-        take_while { |line| !line.start_with?('diff --git') }
+        take_while { |line| !line.start_with?('diff --git') }.
+        reject     { |line| line =~ /^#/ }
     end
 
     def commit_message_file

data/lib/overcommit/hook_context/post_checkout.rb

@@ -22,5 +22,13 @@ module Overcommit::HookContext
     def file_checkout?
       !branch_checkout?
     end
+
+    # Get a list of files that have been added or modified between
+    # `previous_head` and `new_head`. Renames and deletions are ignored, since
+    # there should be nothing to check.
+    def modified_files
+      @modified_files ||=
+        Overcommit::GitRepo.modified_files(refs: "#{previous_head} #{new_head}")
+    end
   end
 end

data/lib/overcommit/hook_context/post_rewrite.rb

@@ -14,5 +14,34 @@ module Overcommit::HookContext
     def rebase?
       @args[0] == 'rebase'
     end
+
+    # Returns the list of commits rewritten by the action that triggered this
+    # hook run.
+    #
+    # @return [Array<RewrittenCommit>]
+    def rewritten_commits
+      @rewritten_commits ||= input_lines.map do |line|
+        RewrittenCommit.new(*line.split(' '))
+      end
+    end
+
+    # Get a list of files that have been added or modified as part of a
+    # rewritten commit. Renames and deletions are ignored, since there should be
+    # nothing to check.
+    def modified_files
+      @modified_files ||= begin
+        @modified_files = []
+
+        rewritten_commits.each do |rewritten_commit|
+          refs = "#{rewritten_commit.old_hash} #{rewritten_commit.new_hash}"
+          @modified_files |= Overcommit::GitRepo.modified_files(refs: refs)
+        end
+
+        filter_modified_files(@modified_files)
+      end
+    end
+
+    # Struct encapsulating the old and new SHA1 hashes of a rewritten commit
+    RewrittenCommit = Struct.new(:old_hash, :new_hash)
   end
 end

data/lib/overcommit/hook_context/pre_commit.rb

@@ -95,20 +95,7 @@ module Overcommit::HookContext
         if amendment?
           subcmd = 'show --format=%n'
           previously_modified = Overcommit::GitRepo.modified_files(subcmd: subcmd)
-
-          # Filter out non-existent files. This could happen if a file was
-          # renamed as part of the amendment, leading to the old file no longer
-          # existing.
-          previously_modified.select! { |file| File.exist?(file) }
-
-          # Filter out directories. This could happen when changing a symlink to
-          # a directory as part of an amendment, since the symlink will still
-          # appear as a file, but the actual working tree will have a directory.
-          previously_modified.reject! do |file|
-            File.directory?(file) && !File.symlink?(file)
-          end
-
-          @modified_files |= previously_modified
+          @modified_files |= filter_modified_files(previously_modified)
         end
       end
       @modified_files

data/lib/overcommit/hook_loader/plugin_hook_loader.rb

@@ -7,12 +7,16 @@ module Overcommit::HookLoader
     def load_hooks
       check_for_modified_plugins if @config.verify_plugin_signatures?
 
-      plugin_paths.map do |plugin_path|
+      hooks = plugin_paths.map do |plugin_path|
         require plugin_path
 
         hook_name = Overcommit::Utils.camel_case(File.basename(plugin_path, '.rb'))
         create_hook(hook_name)
       end
+
+      hooks + ad_hoc_hook_names.map do |hook_name|
+        create_ad_hoc_hook(hook_name)
+      end
     end
 
     def update_signatures
@@ -31,9 +35,19 @@ module Overcommit::HookLoader
       Dir[File.join(directory, '*.rb')].sort
     end
 
+    def plugin_hook_names
+      plugin_paths.map do |path|
+        Overcommit::Utils.camel_case(File.basename(path, '.rb'))
+      end
+    end
+
+    def ad_hoc_hook_names
+      @config.enabled_ad_hoc_hooks(@context)
+    end
+
     def modified_plugins
-      plugin_paths.
-        map { |path| Overcommit::HookSigner.new(path, @config, @context) }.
+      (plugin_hook_names + ad_hoc_hook_names).
+        map { |hook_name| Overcommit::HookSigner.new(hook_name, @config, @context) }.
         select(&:signature_changed?)
     end
 
@@ -57,5 +71,30 @@ module Overcommit::HookLoader
 
       raise Overcommit::Exceptions::InvalidHookSignature
     end
+
+    def create_ad_hoc_hook(hook_name)
+      hook_module = Overcommit::Hook.const_get(@context.hook_class_name)
+      hook_base = hook_module.const_get('Base')
+
+      # Implement a simple class that executes the command and returns pass/fail
+      # based on the exit status
+      hook_class = Class.new(hook_base) do
+        def run # rubocop:disable Lint/NestedMethodDefinition
+          result = @context.execute_hook(command)
+
+          if result.success?
+            :pass
+          else
+            [:fail, result.stdout + result.stderr]
+          end
+        end
+      end
+
+      hook_module.const_set(hook_name, hook_class).new(@config, @context)
+    rescue LoadError, NameError => error
+      raise Overcommit::Exceptions::HookLoadError,
+            "Unable to load hook '#{hook_name}': #{error}",
+            error.backtrace
+    end
   end
 end

data/lib/overcommit/hook_runner.rb

@@ -144,6 +144,18 @@ module Overcommit
 
       # Load plugin hooks after so they can subclass existing hooks
       @hooks += HookLoader::PluginHookLoader.new(@config, @context, @log).load_hooks
+    rescue LoadError => ex
+      # Include a more helpful message that will probably save some confusion
+      message = 'A load error occurred. ' +
+        if @config['gemfile']
+          "Did you forget to specify a gem in your `#{@config['gemfile']}`?"
+        else
+          'Did you forget to install a gem?'
+        end
+
+      raise Overcommit::Exceptions::HookLoadError,
+            "#{message}\n#{ex.message}",
+            ex.backtrace
     end
   end
 end

data/lib/overcommit/hook_signer.rb

@@ -1,21 +1,56 @@
 module Overcommit
   # Calculates, stores, and retrieves stored signatures of hook plugins.
   class HookSigner
-    attr_reader :hook_path, :hook_name
+    attr_reader :hook_name
 
     # We don't want to include the skip setting as it is set by Overcommit
     # itself
     IGNORED_CONFIG_KEYS = %w[skip]
 
-    # @param hook_path [String] path to the actual hook definition
+    # @param hook_name [String] name of the hook
     # @param config [Overcommit::Configuration]
     # @param context [Overcommit::HookContext]
-    def initialize(hook_path, config, context)
-      @hook_path = hook_path
+    def initialize(hook_name, config, context)
+      @hook_name = hook_name
       @config = config
       @context = context
+    end
+
+    # Returns the path of the file that should be incorporated into this hooks
+    # signature.
+    #
+    # @return [String]
+    def hook_path
+      @hook_path ||= begin
+        plugin_path = File.join(@config.plugin_directory,
+                                @context.hook_type_name,
+                                "#{Overcommit::Utils.snake_case(@hook_name)}.rb")
+
+        if File.exist?(plugin_path)
+          plugin_path
+        else
+          # Otherwise this is an ad hoc hook using an existing hook script
+          hook_config = @config.for_hook(@hook_name, @context.hook_class_name)
+
+          command = Array(hook_config['command'] ||
+                          hook_config['required_executable'])
+
+          unless !@config.verify_plugin_signatures? ||
+                 signable_file?(command.first)
+            raise Overcommit::Exceptions::InvalidHookDefinition,
+                  'Hook must specify a `required_executable` or `command` that ' \
+                  'is tracked by git (i.e. is a path relative to the root ' \
+                  'of the repository) so that it can be signed'
+          end
+
+          File.join(Overcommit::Utils.repo_root, command.first)
+        end
+      end
+    end
 
-      @hook_name = Overcommit::Utils.camel_case(File.basename(@hook_path, '.rb'))
+    def signable_file?(file)
+      file.start_with?(".#{File::SEPARATOR}") &&
+        Overcommit::GitRepo.tracked?(file)
     end
 
     # Return whether the signature for this hook has changed since it was last
@@ -54,7 +89,7 @@ module Overcommit
     end
 
     def hook_contents
-      File.open(@hook_path, 'r').read
+      File.read(hook_path)
     end
 
     def stored_signature

data/lib/overcommit/logger.rb

@@ -30,6 +30,11 @@ module Overcommit
       @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)

data/lib/overcommit/printer.rb

@@ -17,7 +17,7 @@ module Overcommit
     end
 
     def nothing_to_run
-      log.success "✓ No applicable #{hook_script_name} hooks to run"
+      log.debug "✓ No applicable #{hook_script_name} hooks to run"
     end
 
     # Executed at the start of an individual hook run.

data/lib/overcommit/subprocess.rb

@@ -6,6 +6,10 @@ module Overcommit
   # standard out/error output.
   class Subprocess
     # Encapsulates the result of a process.
+    #
+    # @attr_reader status [Integer] exit status code returned by process
+    # @attr_reader stdout [String] standard output stream output
+    # @attr_reader stderr [String] standard error stream output
     Result = Struct.new(:status, :stdout, :stderr) do
       def success?
         status == 0
@@ -15,12 +19,29 @@ module Overcommit
     class << self
       # Spawns a new process using the given array of arguments (the first
       # element is the command).
-      def spawn(args)
+      #
+      # @param args [Array<String>]
+      # @param options [Hash]
+      # @option options [String] input string to pass via standard input stream
+      # @return [Result]
+      def spawn(args, options = {})
         process = ChildProcess.build(*args)
 
         out, err = assign_output_streams(process)
 
+        process.duplex = true if options[:input] # Make stdin available if needed
         process.start
+        if options[:input]
+          begin
+            process.io.stdin.puts(options[:input])
+          rescue
+            # Silently ignore if the standard input stream of the spawned
+            # process is closed before we get a chance to write to it. This
+            # happens on JRuby a lot.
+          ensure
+            process.io.stdin.close
+          end
+        end
         process.wait
 
         err.rewind

data/lib/overcommit/utils.rb

@@ -1,5 +1,7 @@
 require 'pathname'
 require 'overcommit/subprocess'
+require 'overcommit/command_splitter'
+require 'tempfile'
 
 module Overcommit
   # Utility functions for general use.
@@ -23,6 +25,9 @@ module Overcommit
     end
 
     class << self
+      # @return [Overcommit::Logger] logger with which to send debug output
+      attr_accessor :log
+
       def script_path(script)
         File.join(Overcommit::HOME, 'libexec', script)
       end
@@ -72,6 +77,16 @@ module Overcommit
           end
       end
 
+      # Remove ANSI escape sequences from a string.
+      #
+      # This is useful for stripping colorized output from external tools.
+      #
+      # @param text [String]
+      # @return [String]
+      def strip_color_codes(text)
+        text.gsub(/\e\[(\d+)(;\d+)*m/, '')
+      end
+
       # Shamelessly stolen from:
       # stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
       def snake_case(str)
@@ -131,15 +146,40 @@ module Overcommit
       # This is intended to provide a centralized place to perform any checks or
       # filtering of the command before executing it.
       #
-      # @param args [Array<String>]
+      # The `args` option provides a convenient way of splitting up long
+      # argument lists which would otherwise exceed the maximum command line
+      # length of the OS. It will break up the list into chunks and run the
+      # command with the same prefix `initial_args`, finally combining the
+      # output together at the end.
+      #
+      # This requires that the external command you are running can have its
+      # work split up in this way and still produce the same resultant output
+      # when outputs of the individual commands are concatenated back together.
+      #
+      # @param initial_args [Array<String>]
+      # @param options [Hash]
+      # @option options [Array<String>] :args long list of arguments to split up
       # @return [Overcommit::Subprocess::Result] status, stdout, and stderr
-      def execute(args)
-        if args.include?('|')
+      def execute(initial_args, options = {})
+        if initial_args.include?('|')
           raise Overcommit::Exceptions::InvalidCommandArgs,
                 'Cannot pipe commands with the `execute` helper'
         end
 
-        Subprocess.spawn(args)
+        result =
+          if (splittable_args = options.fetch(:args, [])).any?
+            debug(initial_args.join(' ') + " ... (#{splittable_args.length} splittable args)")
+            Overcommit::CommandSplitter.execute(initial_args, options)
+          else
+            debug(initial_args.join(' '))
+            Overcommit::Subprocess.spawn(initial_args, options)
+          end
+
+        debug("EXIT STATUS: #{result.status}")
+        debug("STDOUT: #{result.stdout.inspect}")
+        debug("STDERR: #{result.stderr.inspect}")
+
+        result
       end
 
       # Execute a command in a subprocess, returning immediately.
@@ -155,6 +195,7 @@ module Overcommit
                 'Cannot pipe commands with the `execute_in_background` helper'
         end
 
+        debug("Spawning background task: #{args.join(' ')}")
         Subprocess.spawn_detached(args)
       end
 
@@ -200,6 +241,19 @@ module Overcommit
                       File::FNM_DOTMATCH   # Wildcards match dotfiles
         )
       end
+
+      private
+
+      # Log debug output.
+      #
+      # This is necessary since some specs indirectly call utility functions but
+      # don't explicitly set the logger for the Utils class, so we do a quick
+      # check here to see if it's set before we attempt to log.
+      #
+      # @param args [Array<String>]
+      def debug(*args)
+        log.debug(*args) if log
+      end
     end
   end
 end