overcommit 0.23.0 → 0.24.0

data/lib/overcommit/hook_context/pre_push.rb

@@ -0,0 +1,44 @@
+module Overcommit::HookContext
+  # Contains helpers related to contextual information used by pre-push hooks.
+  class PrePush < Base
+    attr_accessor :args
+
+    def remote_name
+      @args[0]
+    end
+
+    def remote_url
+      @args[1]
+    end
+
+    def pushed_refs
+      input_lines.map do |line|
+        PushedRef.new(*line.split(' '))
+      end
+    end
+
+    PushedRef = Struct.new(:local_ref, :local_sha1, :remote_ref, :remote_sha1) do
+      def forced?
+        !(created? || deleted? || overwritten_commits.empty?)
+      end
+
+      def created?
+        remote_sha1 == '0' * 40
+      end
+
+      def deleted?
+        local_sha1 == '0' * 40
+      end
+
+      def to_s
+        "#{local_ref} #{local_sha1} #{remote_ref} #{remote_sha1}"
+      end
+
+      private
+
+      def overwritten_commits
+        `git rev-list #{remote_sha1} ^#{local_sha1}`.split("\n")
+      end
+    end
+  end
+end

data/lib/overcommit/hook_context/pre_rebase.rb

@@ -0,0 +1,36 @@
+module Overcommit::HookContext
+  # Contains helpers related to contextual information used by pre-rebase
+  # hooks.
+  class PreRebase < Base
+    # Returns the name of the branch we are rebasing onto.
+    def upstream_branch
+      @args[0]
+    end
+
+    # Returns the name of the branch being rebased. Empty if rebasing a
+    # detached HEAD.
+    def rebased_branch
+      @rebased_branch ||=
+        @args[1] || `git symbolic-ref --short --quiet HEAD`.chomp
+    end
+
+    # Returns whether we are rebasing a detached HEAD rather than a branch
+    def detached_head?
+      rebased_branch.empty?
+    end
+
+    # Returns whether this rebase is a fast-forward
+    def fast_forward?
+      rebased_commits.empty?
+    end
+
+    # Returns the SHA1-sums of the series of commits to be rebased
+    # in reverse topological order.
+    def rebased_commits
+      rebased_ref = detached_head? ? 'HEAD' : rebased_branch
+      @rebased_commits ||=
+        `git rev-list --topo-order --reverse #{upstream_branch}..#{rebased_ref}`.
+          split("\n")
+    end
+  end
+end

data/lib/overcommit/hook_runner.rb

@@ -22,11 +22,24 @@ module Overcommit
       # these calls to allow some sort of "are you sure?" double-interrupt
       # functionality, but until that's deemed necessary let's keep it simple.
       InterruptHandler.isolate_from_interrupts do
-        @context.setup_environment
+        # Load hooks before setting up the environment so that the repository
+        # has not been touched yet. This way any load errors at this point don't
+        # result in Overcommit leaving the repository in a bad state.
         load_hooks
-        result = run_hooks
-        @context.cleanup_environment
-        result
+
+        # Setup the environment without automatically calling
+        # `cleanup_environment` on an error. This is because it's possible that
+        # the `setup_environment` code did not fully complete, so there's no
+        # guarantee that `cleanup_environment` will be able to accomplish
+        # anything of value. The safest thing to do is therefore nothing in the
+        # unlikely case of failure.
+        @context.setup_environment
+
+        begin
+          run_hooks
+        ensure
+          @context.cleanup_environment
+        end
       end
     end
 
@@ -40,11 +53,13 @@ module Overcommit
 
         interrupted = false
         run_failed = false
+        run_warned = false
 
         @hooks.each do |hook|
           hook_status = run_hook(hook)
 
-          run_failed = true if [:bad, :fail].include?(hook_status)
+          run_failed = true if hook_status == :fail
+          run_warned = true if hook_status == :warn
 
           if hook_status == :interrupt
             # Stop running any more hooks and assume a bad result
@@ -53,7 +68,7 @@ module Overcommit
           end
         end
 
-        print_results(run_failed, interrupted)
+        print_results(run_failed, run_warned, interrupted)
 
         !(run_failed || interrupted)
       else
@@ -62,11 +77,16 @@ module Overcommit
       end
     end
 
-    def print_results(failed, interrupted)
+    # @param failed [Boolean]
+    # @param warned [Boolean]
+    # @param interrupted [Boolean]
+    def print_results(failed, warned, interrupted)
       if interrupted
         @printer.run_interrupted
       elsif failed
         @printer.run_failed
+      elsif warned
+        @printer.run_warned
       else
         @printer.run_succeeded
       end

data/lib/overcommit/installer.rb

@@ -3,7 +3,7 @@ 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')
+    TEMPLATE_DIRECTORY = File.join(Overcommit::HOME, 'template-dir')
     MASTER_HOOK = File.join(TEMPLATE_DIRECTORY, 'hooks', 'overcommit-hook')
 
     def initialize(logger)
@@ -30,7 +30,8 @@ module Overcommit
     def install
       log.log "Installing hooks into #{@target}"
 
-      ensure_hooks_directory
+      ensure_directory(hooks_path)
+      preserve_old_hooks
       install_master_hook
       install_hook_symlinks
       install_starter_config
@@ -41,8 +42,9 @@ module Overcommit
     def uninstall
       log.log "Removing hooks from #{@target}"
 
-      uninstall_master_hook
       uninstall_hook_symlinks
+      uninstall_master_hook
+      restore_old_hooks
 
       log.success "Successfully removed hooks from #{@target}"
     end
@@ -50,6 +52,7 @@ module Overcommit
     # @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_symlinks
 
@@ -63,12 +66,16 @@ module Overcommit
       File.join(Overcommit::Utils.git_dir(absolute_target), 'hooks')
     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_hooks_directory
-      FileUtils.mkdir_p(hooks_path)
+    def ensure_directory(path)
+      FileUtils.mkdir_p(path)
     end
 
     def validate_target
@@ -118,6 +125,38 @@ module Overcommit
         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
+      FileUtils.rmdir(old_hooks_path)
+    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_symlinks
       return unless File.directory?(hooks_path)
 
@@ -129,10 +168,10 @@ module Overcommit
     end
 
     def install_starter_config
-      repo_config_file = File.join(@target, OVERCOMMIT_CONFIG_FILE_NAME)
+      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)
+      FileUtils.cp(File.join(Overcommit::HOME, 'config', 'starter.yml'), repo_config_file)
     end
 
     def overcommit_hook?(file)

data/lib/overcommit/message_processor.rb

@@ -126,6 +126,9 @@ module Overcommit
     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

data/lib/overcommit/printer.rb

@@ -39,7 +39,7 @@ module Overcommit
     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_header(hook) if hook.quiet? && status != :pass
 
       print_result(hook, status, output)
     end
@@ -58,6 +58,13 @@ module Overcommit
       log.newline
     end
 
+    # Executed when no hooks failed by the end of the run, but some warned.
+    def run_warned
+      log.newline
+      log.warning "⚠ All #{hook_script_name} hooks passed, but with warnings"
+      log.newline
+    end
+
     # Executed when no hooks failed by the end of the run.
     def run_succeeded
       log.newline
@@ -78,20 +85,9 @@ module Overcommit
       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)

data/lib/overcommit/subprocess.rb

@@ -29,6 +29,17 @@ module Overcommit
         Result.new(process.exit_code, out.read, err.read)
       end
 
+      # Spawns a new process in the background using the given array of
+      # arguments (the first element is the command).
+      def spawn_detached(args)
+        process = ChildProcess.build(*args)
+        process.detach = true
+
+        assign_output_streams(process)
+
+        process.start
+      end
+
       private
 
       # @param process [ChildProcess]

data/lib/overcommit/utils.rb

@@ -4,9 +4,27 @@ require 'overcommit/subprocess'
 module Overcommit
   # Utility functions for general use.
   module Utils
+    # Helper class for doing quick constraint validations on version numbers.
+    #
+    # This allows us to execute code based on the git version.
+    class Version < Gem::Version
+      # Overload comparison operators so we can conveniently compare this
+      # version directly to a string in code.
+      %w[< <= > >= == !=].each do |operator|
+        define_method operator do |version|
+          case version
+          when String
+            super(Gem::Version.new(version))
+          else
+            super(version)
+          end
+        end
+      end
+    end
+
     class << self
       def script_path(script)
-        File.join(OVERCOMMIT_HOME, 'libexec', script)
+        File.join(Overcommit::HOME, 'libexec', script)
       end
 
       # Returns an absolute path to the root of the repository.
@@ -71,9 +89,9 @@ module Overcommit
 
       # Returns a list of supported hook types (pre-commit, commit-msg, etc.)
       def supported_hook_types
-        Dir[File.join(OVERCOMMIT_HOME, 'lib', 'overcommit', 'hook', '*')].
+        Dir[File.join(HOOK_DIRECTORY, '*')].
           select { |file| File.directory?(file) }.
-          map { |file| File.basename(file, '.rb').gsub('_', '-') }
+          map { |file| File.basename(file).gsub('_', '-') }
       end
 
       # Returns a list of supported hook classes (PreCommit, CommitMsg, etc.)
@@ -101,6 +119,11 @@ module Overcommit
         false
       end
 
+      # Return the parent command that triggered this hook run
+      def parent_command
+        `ps -ocommand= -p #{Process.ppid}`.chomp
+      end
+
       # Execute a command in a subprocess, capturing exit status and output from
       # both standard and error streams.
       #
@@ -124,15 +147,14 @@ module Overcommit
       # which we do not need to know the result.
       #
       # @param args [Array<String>]
-      # @return [Thread] thread watching the resulting child process
+      # @return [ChildProcess] detached process spawned in the background
       def execute_in_background(args)
         if args.include?('|')
           raise Overcommit::Exceptions::InvalidCommandArgs,
                 'Cannot pipe commands with the `execute_in_background` helper'
         end
 
-        # Dissociate process from parent's input/output streams
-        Process.detach(Process.spawn({}, *args, [:in, :out, :err] => '/dev/null'))
+        Subprocess.spawn_detached(args)
       end
 
       # Calls a block of code with a modified set of environment variables,

data/lib/overcommit/version.rb

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

data/template-dir/hooks/commit-msg

@@ -43,9 +43,9 @@ begin
     exec($0, *ARGV) # Execute the updated hook with all original arguments
   end
 
-  config = Overcommit::ConfigurationLoader.load_repo_config
+  config = Overcommit::ConfigurationLoader.new(logger).load_repo_config
 
-  context = Overcommit::HookContext.create(hook_type, config, ARGV)
+  context = Overcommit::HookContext.create(hook_type, config, ARGV, STDIN)
   config.apply_environment!(context, ENV)
 
   printer = Overcommit::Printer.new(logger, context)

data/template-dir/hooks/overcommit-hook

@@ -43,9 +43,9 @@ begin
     exec($0, *ARGV) # Execute the updated hook with all original arguments
   end
 
-  config = Overcommit::ConfigurationLoader.load_repo_config
+  config = Overcommit::ConfigurationLoader.new(logger).load_repo_config
 
-  context = Overcommit::HookContext.create(hook_type, config, ARGV)
+  context = Overcommit::HookContext.create(hook_type, config, ARGV, STDIN)
   config.apply_environment!(context, ENV)
 
   printer = Overcommit::Printer.new(logger, context)

data/template-dir/hooks/post-checkout

@@ -43,9 +43,9 @@ begin
     exec($0, *ARGV) # Execute the updated hook with all original arguments
   end
 
-  config = Overcommit::ConfigurationLoader.load_repo_config
+  config = Overcommit::ConfigurationLoader.new(logger).load_repo_config
 
-  context = Overcommit::HookContext.create(hook_type, config, ARGV)
+  context = Overcommit::HookContext.create(hook_type, config, ARGV, STDIN)
   config.apply_environment!(context, ENV)
 
   printer = Overcommit::Printer.new(logger, context)