overcommit 0.52.1 → 0.56.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d754f1b3cae9fb7a74e38645a47a52e84337692b53ac32be7079296ef6f0c4ef
-  data.tar.gz: 1065cb959d9285aca1541fc5ed6523e7c237dfc5f0fb6acbd129c1edc4c772c4
+  metadata.gz: d6ecbb7e4b390f8d17c9058da38464b73f7cec50a87e494430e9c15a9c40ecff
+  data.tar.gz: f90974df2fe0b918ff8711a228608ad1b312a730abd9ad7c45b02ee512daa496
 SHA512:
-  metadata.gz: dee7031b48c46a3b42f27701dd922d63468340498f3745d11a1c5bbe2a573e408a2d1fe266b96313d319dc3e43eb8401d4624cf4e94d835df850b25efea859dd
-  data.tar.gz: 69389da703ab37e63f35d7267b70a6a1a8fb3c7afd80cdadbe6f2ff32fe27428c45276b34b2286dd01930e0a9c78f5d2bc44f707c5980f501460897a79aebcf3
+  metadata.gz: a8b55f73d42ca1791bbd6a01281a0adbbe1f57385721d9ec4905e98dd9217480ae5b10ff8e9083048953974d40c97d104f126ca9b514fb05359ba6c402b4bf7b
+  data.tar.gz: b9263d9c65fbbeaa4cf7a38d5b7c2bb4af6d6ec7abf5e3ee22209a455a3b7529718b6eb9adbc14161539861420242093c7b4c3564e248ce84bc663cfb354899f

data/config/default.yml

@@ -338,7 +338,7 @@ PreCommit:
     keywords: ['FContext','FDescribe','FIt','FMeasure','FSpecify','FWhen']
 
   GoFmt:
-    enabled: true
+    enabled: false
     description: 'Fix with go fmt'
     required_executable: 'go'
     command: ['go', 'fmt']
@@ -885,7 +885,7 @@ PreCommit:
     enabled: false
     description: 'Analyze with YAMLlint'
     required_executable: 'yamllint'
-    flags: ['--format=parsable']
+    flags: ['--format=parsable', '--strict']
     install_command: 'pip install yamllint'
     include:
       - '**/*.yaml'
@@ -1237,9 +1237,14 @@ PrepareCommitMsg:
   ReplaceBranch:
     enabled: false
     description: 'Prepends the commit message with text based on the branch name'
-    branch_pattern: '\A.*\w+[-_](\d+).*\z'
+    branch_pattern: '\A(\d+)-(\w+).*\z'
     replacement_text: '[#\1]'
-    skipped_commit_types: ['message', 'template', 'merge', 'squash']
+    skipped_commit_types:
+     - 'message'  # if message is given via `-m`, `-F`
+     - 'template' # if `-t` is given or `commit.template` is set
+     - 'commit'   # if `-c`, `-C`, or `--amend` is given
+     - 'merge'    # if merging
+     - 'squash'   # if squashing
     on_fail: warn
 
 # Hooks that run during `git push`, after remote refs have been updated but
@@ -1297,6 +1302,13 @@ PrePush:
     flags: ['--bootstrap', 'vendor/autoload.php', 'tests']
     install_command: 'composer require --dev phpunit/phpunit'
 
+  Pronto:
+    enabled: false
+    description: 'Analyzing with pronto'
+    required_executable: 'pronto'
+    install_command: 'gem install pronto'
+    flags: ['run', '--exit-code']
+
   ProtectedBranches:
     enabled: false
     description: 'Check for illegal pushes to protected branches'

data/lib/overcommit/exceptions.rb

@@ -1,52 +1,55 @@
 # frozen_string_literal: true
 
 module Overcommit::Exceptions
+  # Base error class.
+  class Error < StandardError; end
+
   # Raised when a {Configuration} could not be loaded from a file.
-  class ConfigurationError < StandardError; end
+  class ConfigurationError < Error; end
 
   # Raised when the Overcommit configuration file signature has changed.
-  class ConfigurationSignatureChanged < StandardError; end
+  class ConfigurationSignatureChanged < Error; end
 
   # Raised when trying to read/write to/from the local repo git config fails.
-  class GitConfigError < StandardError; end
+  class GitConfigError < Error; end
 
   # Raised when there was a problem reading submodule information for a repo.
-  class GitSubmoduleError < StandardError; end
+  class GitSubmoduleError < Error; end
 
   # Raised when there was a problem reading git revision information with `rev-list`.
-  class GitRevListError < StandardError; end
+  class GitRevListError < Error; end
 
   # Raised when a {HookContext} is unable to setup the environment before a run.
-  class HookSetupFailed < StandardError; end
+  class HookSetupFailed < Error; end
 
   # Raised when a {HookContext} is unable to clean the environment after a run.
-  class HookCleanupFailed < StandardError; end
+  class HookCleanupFailed < Error; end
 
   # Raised when a hook run was cancelled by the user.
-  class HookCancelled < StandardError; end
+  class HookCancelled < Error; end
 
   # Raised when a hook could not be loaded by a {HookRunner}.
-  class HookLoadError < StandardError; end
+  class HookLoadError < Error; end
 
   # Raised when a {HookRunner} could not be loaded.
-  class HookContextLoadError < StandardError; end
+  class HookContextLoadError < Error; end
 
   # Raised when a pipe character is used in the `execute` helper, as this was
   # likely used in error.
-  class InvalidCommandArgs < StandardError; end
+  class InvalidCommandArgs < Error; end
 
   # Raised when an installation target is not a valid git repository.
-  class InvalidGitRepo < StandardError; end
+  class InvalidGitRepo < Error; end
 
   # Raised when a hook was defined incorrectly.
-  class InvalidHookDefinition < StandardError; end
+  class InvalidHookDefinition < Error; end
 
   # Raised when one or more hook plugin signatures have changed.
-  class InvalidHookSignature < StandardError; end
+  class InvalidHookSignature < Error; end
 
   # Raised when there is a problem processing output into {Hook::Messages}s.
-  class MessageProcessingError < StandardError; end
+  class MessageProcessingError < Error; end
 
   # Raised when an installation target already contains non-Overcommit hooks.
-  class PreExistingHooks < StandardError; end
+  class PreExistingHooks < Error; end
 end

data/lib/overcommit/git_repo.rb

@@ -109,15 +109,16 @@ module Overcommit
     # @return [Array<String>] list of absolute file paths
     def list_files(paths = [], options = {})
       ref = options[:ref] || 'HEAD'
-      path_list =
-        if OS.windows?
-          paths = paths.map { |path| path.gsub('"', '""') }
-          paths.empty? ? '' : "\"#{paths.join('" "')}\""
-        else
-          paths.shelljoin
-        end
-      `git ls-tree --name-only #{ref} #{path_list}`.
-        split(/\n/).
+
+      result = Overcommit::Utils.execute(%W[git ls-tree --name-only #{ref}], args: paths)
+      unless result.success?
+        raise Overcommit::Exceptions::Error,
+              "Error listing files. EXIT STATUS(es): #{result.statuses}.\n" \
+              "STDOUT(s): #{result.stdouts}.\n" \
+              "STDERR(s): #{result.stderrs}."
+      end
+
+      result.stdout.split(/\n/).
         map { |relative_file| File.expand_path(relative_file) }.
         reject { |file| File.directory?(file) } # Exclude submodule directories
     end

data/lib/overcommit/hook/base.rb

@@ -84,7 +84,8 @@ module Overcommit::Hook
     end
 
     def skip?
-      @config['skip']
+      @config['skip'] ||
+        (@config['skip_if'] ? execute(@config['skip_if']).success? : false)
     end
 
     def run?

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

@@ -12,9 +12,9 @@ module Overcommit::Hook::PreCommit
           result.stdout.chomp
         end
 
-      unless name.split(' ').count >= 2
+      if name.empty?
         return :fail,
-               "Author must have at least first and last name, but was: #{name}.\n" \
+               "Author name must be non-0 in length.\n" \
                'Set your name with `git config --global user.name "Your Name"` ' \
                'or via the GIT_AUTHOR_NAME environment variable'
       end

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

@@ -12,21 +12,14 @@ module Overcommit::Hook::PreCommit
     def run
       messages = []
 
-      applicable_files.each do |file|
-        result = execute(command, args: [file])
-        if result.status
-          rows = result.stdout.split("\n")
-
-          # Discard the csv header
-          rows.shift
-
-          # Push each of the errors in the particular file into the array
-          rows.map do |row|
-            messages << row
-          end
-        end
+      result = execute(command, args: applicable_files)
+      if result.status
+        messages = result.stdout.split("\n")
+        # Discard the csv header
+        messages.shift
       end
 
+      return :fail if messages.empty? && !result.success?
       return :pass if messages.empty?
 
       parse_messages(messages)

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

@@ -1,23 +1,12 @@
 # frozen_string_literal: true
 
+require 'overcommit/hook/shared/pronto'
+
 module Overcommit::Hook::PreCommit
   # Runs `pronto`
   #
   # @see https://github.com/mmozuras/pronto
   class Pronto < Base
-    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
-      type.include?('E') ? :error : :warning
-    end
-
-    def run
-      result = execute(command)
-      return :pass if result.success?
-
-      extract_messages(
-        result.stdout.split("\n"),
-        /^(?<file>(?:\w:)?[^:]+):(?<line>\d+) (?<type>[^ ]+)/,
-        MESSAGE_TYPE_CATEGORIZER,
-      )
-    end
+    include Overcommit::Hook::Shared::Pronto
   end
 end

data/lib/overcommit/hook/pre_push/base.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'forwardable'
+require 'overcommit/utils/messages_utils'
 
 module Overcommit::Hook::PrePush
   # Functionality common to all pre-push hooks.
@@ -17,6 +18,10 @@ module Overcommit::Hook::PrePush
 
     private
 
+    def extract_messages(*args)
+      Overcommit::Utils::MessagesUtils.extract_messages(*args)
+    end
+
     def exclude_remotes
       @config['exclude_remotes'] || []
     end

data/lib/overcommit/hook/pre_push/pronto.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'overcommit/hook/shared/pronto'
+
+module Overcommit::Hook::PrePush
+  # Runs `pronto`
+  #
+  # @see https://github.com/mmozuras/pronto
+  class Pronto < Base
+    include Overcommit::Hook::Shared::Pronto
+  end
+end

data/lib/overcommit/hook/prepare_commit_msg/replace_branch.rb

@@ -2,11 +2,37 @@
 
 module Overcommit::Hook::PrepareCommitMsg
   # Prepends the commit message with a message based on the branch name.
+  #
+  # === What to prepend
+  #
   # It's possible to reference parts of the branch name through the captures in
   # the `branch_pattern` regex.
+  #
+  # For instance, if your current branch is `123-topic` then this config
+  #
+  #    branch_pattern: '(\d+)-(\w+)'
+  #    replacement_text: '[#\1]'
+  #
+  # would make this hook prepend commit messages with `[#123]`.
+  #
+  # Similarly, a replacement text of `[\1][\2]` would result in `[123][topic]`.
+  #
+  # == When to run this hook
+  #
+  # You can configure this to run only for specific types of commits by setting
+  # the `skipped_commit_types`. The allowed types are
+  #
+  # - 'message'  - if message is given via `-m`, `-F`
+  # - 'template' - if `-t` is given or `commit.template` is set
+  # - 'commit'   - if `-c`, `-C`, or `--amend` is given
+  # - 'merge'    - if merging
+  # - 'squash'   - if squashing
+  #
   class ReplaceBranch < Base
+    DEFAULT_BRANCH_PATTERN = /\A(\d+)-(\w+).*\z/
+
     def run
-      return :pass if skipped_commit_types.include? commit_message_source
+      return :pass if skip?
 
       Overcommit::Utils.log.debug(
         "Checking if '#{Overcommit::GitRepo.current_branch}' matches #{branch_pattern}"
@@ -17,21 +43,25 @@ module Overcommit::Hook::PrepareCommitMsg
       Overcommit::Utils.log.debug("Writing #{commit_message_filename} with #{new_template}")
 
       modify_commit_message do |old_contents|
-        "#{new_template}\n#{old_contents}"
+        "#{new_template}#{old_contents}"
       end
 
       :pass
     end
 
     def new_template
-      @new_template ||= Overcommit::GitRepo.current_branch.gsub(branch_pattern, replacement_text)
+      @new_template ||=
+        begin
+          curr_branch = Overcommit::GitRepo.current_branch
+          curr_branch.gsub(branch_pattern, replacement_text).strip
+        end
     end
 
     def branch_pattern
       @branch_pattern ||=
         begin
           pattern = config['branch_pattern']
-          Regexp.new((pattern || '').empty? ? '\A.*\w+[-_](\d+).*\z' : pattern)
+          Regexp.new((pattern || '').empty? ? DEFAULT_BRANCH_PATTERN : pattern)
         end
     end
 
@@ -53,5 +83,9 @@ module Overcommit::Hook::PrepareCommitMsg
     def skipped_commit_types
       @skipped_commit_types ||= config['skipped_commit_types'].map(&:to_sym)
     end
+
+    def skip?
+      skipped_commit_types.include?(commit_message_source)
+    end
   end
 end

data/lib/overcommit/hook/shared/pronto.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::Shared
+  # Shared code used by all Pronto hooks. Runs pronto linter.
+  module Pronto
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('E') ? :error : :warning
+    end
+
+    def run
+      result = execute(command)
+      return :pass if result.success?
+
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>(?:\w:)?[^:]+):(?<line>\d+) (?<type>[^ ]+)/,
+        MESSAGE_TYPE_CATEGORIZER,
+      )
+    end
+  end
+end

data/lib/overcommit/hook_context/commit_msg.rb

@@ -1,8 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'pre_commit'
+require_relative 'helpers/stash_unstaged_changes'
+require_relative 'helpers/file_modifications'
+
 module Overcommit::HookContext
   # Contains helpers related to contextual information used by commit-msg hooks.
   class CommitMsg < Base
+    include Overcommit::HookContext::Helpers::StashUnstagedChanges
+    include Overcommit::HookContext::Helpers::FileModifications
+
     def empty_message?
       commit_message.strip.empty?
     end

data/lib/overcommit/hook_context/helpers/file_modifications.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Overcommit::HookContext
+  module Helpers
+    # This module contains methods for determining what files were changed and on what unique line
+    # numbers did the change occur.
+    module FileModifications
+      # Returns whether this hook run was triggered by `git commit --amend`
+      def amendment?
+        return @amendment unless @amendment.nil?
+
+        cmd = Overcommit::Utils.parent_command
+        return unless cmd
+        amend_pattern = 'commit(\s.*)?\s--amend(\s|$)'
+
+        # Since the ps command can return invalid byte sequences for commands
+        # containing unicode characters, we replace the offending characters,
+        # since the pattern we're looking for will consist of ASCII characters
+        unless cmd.valid_encoding?
+          cmd = Overcommit::Utils.
+            parent_command.
+            encode('UTF-16be', invalid: :replace, replace: '?').
+            encode('UTF-8')
+        end
+
+        return @amendment if
+          # True if the command is a commit with the --amend flag
+          @amendment = !(/\s#{amend_pattern}/ =~ cmd).nil?
+
+        # Check for git aliases that call `commit --amend`
+        `git config --get-regexp "^alias\\." "#{amend_pattern}"`.
+          scan(/alias\.([-\w]+)/). # Extract the alias
+          each do |match|
+            return @amendment if
+              # True if the command uses a git alias for `commit --amend`
+              @amendment = !(/git(\.exe)?\s+#{match[0]}/ =~ cmd).nil?
+          end
+
+        @amendment
+      end
+
+      # Get a list of added, copied, or modified files that have been staged.
+      # Renames and deletions are ignored, since there should be nothing to check.
+      def modified_files
+        unless @modified_files
+          currently_staged = Overcommit::GitRepo.modified_files(staged: true)
+          @modified_files = currently_staged
+
+          # Include files modified in last commit if amending
+          if amendment?
+            subcmd = 'show --format=%n'
+            previously_modified = Overcommit::GitRepo.modified_files(subcmd: subcmd)
+            @modified_files |= filter_modified_files(previously_modified)
+          end
+        end
+        @modified_files
+      end
+
+      # Returns the set of line numbers corresponding to the lines that were
+      # changed in a specified file.
+      def modified_lines_in_file(file)
+        @modified_lines ||= {}
+        unless @modified_lines[file]
+          @modified_lines[file] =
+            Overcommit::GitRepo.extract_modified_lines(file, staged: true)
+
+          # Include lines modified in last commit if amending
+          if amendment?
+            subcmd = 'show --format=%n'
+            @modified_lines[file] +=
+              Overcommit::GitRepo.extract_modified_lines(file, subcmd: subcmd)
+          end
+        end
+        @modified_lines[file]
+      end
+    end
+  end
+end

data/lib/overcommit/hook_context/helpers/stash_unstaged_changes.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Overcommit::HookContext
+  module Helpers
+    # This module contains behavior for stashing unstaged changes before hooks are ran and restoring
+    # them afterwards
+    module StashUnstagedChanges
+      # Stash unstaged contents of files so hooks don't see changes that aren't
+      # about to be committed.
+      def setup_environment
+        store_modified_times
+        Overcommit::GitRepo.store_merge_state
+        Overcommit::GitRepo.store_cherry_pick_state
+
+        # Don't attempt to stash changes if all changes are staged, as this
+        # prevents us from modifying files at all, which plays better with
+        # editors/tools which watch for file changes.
+        if !initial_commit? && unstaged_changes?
+          stash_changes
+
+          # While running hooks make it appear as if nothing changed
+          restore_modified_times
+        end
+      end
+
+      # Returns whether the current git branch is empty (has no commits).
+      def initial_commit?
+        return @initial_commit unless @initial_commit.nil?
+        @initial_commit = Overcommit::GitRepo.initial_commit?
+      end
+
+      # Restore unstaged changes and reset file modification times so it appears
+      # as if nothing ever changed.
+      #
+      # We want to restore the modification times for each of the files after
+      # every step to ensure as little time as possible has passed while the
+      # modification time on the file was newer. This helps us play more nicely
+      # with file watchers.
+      def cleanup_environment
+        if @changes_stashed
+          clear_working_tree
+          restore_working_tree
+          restore_modified_times
+        end
+
+        Overcommit::GitRepo.restore_merge_state
+        Overcommit::GitRepo.restore_cherry_pick_state
+      end
+
+      private
+
+      # Stores the modification times for all modified files to make it appear like
+      # they never changed.
+      #
+      # This prevents (some) editors from complaining about files changing when we
+      # stash changes before running the hooks.
+      def store_modified_times
+        @modified_times = {}
+
+        staged_files = modified_files
+        unstaged_files = Overcommit::GitRepo.modified_files(staged: false)
+
+        (staged_files + unstaged_files).each do |file|
+          next if Overcommit::Utils.broken_symlink?(file)
+          next unless File.exist?(file) # Ignore renamed files (old file no longer exists)
+          @modified_times[file] = File.mtime(file)
+        end
+      end
+
+      # Returns whether there are any changes to tracked files which have not yet
+      # been staged.
+      def unstaged_changes?
+        result = Overcommit::Utils.execute(%w[git --no-pager diff --quiet])
+        !result.success?
+      end
+
+      def stash_changes
+        @stash_attempted = true
+
+        stash_message = "Overcommit: Stash of repo state before hook run at #{Time.now}"
+        result = Overcommit::Utils.with_environment('GIT_LITERAL_PATHSPECS' => '0') do
+          Overcommit::Utils.execute(
+            %w[git -c commit.gpgsign=false stash save --keep-index --quiet] + [stash_message]
+          )
+        end
+
+        unless result.success?
+          # Failure to stash in this case is likely due to a configuration
+          # issue (e.g. author/email not set or GPG signing key incorrect)
+          raise Overcommit::Exceptions::HookSetupFailed,
+                "Unable to setup environment for #{hook_script_name} hook run:" \
+                "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+        end
+
+        @changes_stashed = `git stash list -1`.include?(stash_message)
+      end
+
+      # Restores the file modification times for all modified files to make it
+      # appear like they never changed.
+      def restore_modified_times
+        @modified_times.each do |file, time|
+          next if Overcommit::Utils.broken_symlink?(file)
+          next unless File.exist?(file)
+          File.utime(time, time, file)
+        end
+      end
+
+      # Clears the working tree so that the stash can be applied.
+      def clear_working_tree
+        removed_submodules = Overcommit::GitRepo.staged_submodule_removals
+
+        result = Overcommit::Utils.execute(%w[git reset --hard])
+        unless result.success?
+          raise Overcommit::Exceptions::HookCleanupFailed,
+                "Unable to cleanup working tree after #{hook_script_name} hooks run:" \
+                "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+        end
+
+        # Hard-resetting a staged submodule removal results in the index being
+        # reset but the submodule being restored as an empty directory. This empty
+        # directory prevents us from stashing on a subsequent run if a hook fails.
+        #
+        # Work around this by removing these empty submodule directories as there
+        # doesn't appear any reason to keep them around.
+        removed_submodules.each do |submodule|
+          FileUtils.rmdir(submodule.path)
+        end
+      end
+
+      # Applies the stash to the working tree to restore the user's state.
+      def restore_working_tree
+        result = Overcommit::Utils.execute(%w[git stash pop --index --quiet])
+        unless result.success?
+          raise Overcommit::Exceptions::HookCleanupFailed,
+                "Unable to restore working tree after #{hook_script_name} hooks run:" \
+                "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+        end
+      end
+    end
+  end
+end

data/lib/overcommit/hook_context/pre_commit.rb

@@ -2,6 +2,8 @@
 
 require 'fileutils'
 require 'set'
+require_relative 'helpers/stash_unstaged_changes'
+require_relative 'helpers/file_modifications'
 
 module Overcommit::HookContext
   # Contains helpers related to contextual information used by pre-commit hooks.
@@ -9,204 +11,8 @@ module Overcommit::HookContext
   # This includes staged files, which lines of those files have been modified,
   # etc. It is also responsible for saving/restoring the state of the repo so
   # hooks only inspect staged changes.
-  class PreCommit < Base # rubocop:disable ClassLength
-    # Returns whether this hook run was triggered by `git commit --amend`
-    def amendment?
-      return @amendment unless @amendment.nil?
-
-      cmd = Overcommit::Utils.parent_command
-      return unless cmd
-      amend_pattern = 'commit(\s.*)?\s--amend(\s|$)'
-
-      # Since the ps command can return invalid byte sequences for commands
-      # containing unicode characters, we replace the offending characters,
-      # since the pattern we're looking for will consist of ASCII characters
-      unless cmd.valid_encoding?
-        cmd = Overcommit::Utils.parent_command.encode('UTF-16be', invalid: :replace, replace: '?').
-                                               encode('UTF-8')
-      end
-
-      return @amendment if
-        # True if the command is a commit with the --amend flag
-        @amendment = !(/\s#{amend_pattern}/ =~ cmd).nil?
-
-      # Check for git aliases that call `commit --amend`
-      `git config --get-regexp "^alias\\." "#{amend_pattern}"`.
-        scan(/alias\.([-\w]+)/). # Extract the alias
-        each do |match|
-          return @amendment if
-            # True if the command uses a git alias for `commit --amend`
-            @amendment = !(/git(\.exe)?\s+#{match[0]}/ =~ cmd).nil?
-        end
-
-      @amendment
-    end
-
-    # Stash unstaged contents of files so hooks don't see changes that aren't
-    # about to be committed.
-    def setup_environment
-      store_modified_times
-      Overcommit::GitRepo.store_merge_state
-      Overcommit::GitRepo.store_cherry_pick_state
-
-      # Don't attempt to stash changes if all changes are staged, as this
-      # prevents us from modifying files at all, which plays better with
-      # editors/tools which watch for file changes.
-      if !initial_commit? && unstaged_changes?
-        stash_changes
-
-        # While running hooks make it appear as if nothing changed
-        restore_modified_times
-      end
-    end
-
-    # Restore unstaged changes and reset file modification times so it appears
-    # as if nothing ever changed.
-    #
-    # We want to restore the modification times for each of the files after
-    # every step to ensure as little time as possible has passed while the
-    # modification time on the file was newer. This helps us play more nicely
-    # with file watchers.
-    def cleanup_environment
-      if @changes_stashed
-        clear_working_tree
-        restore_working_tree
-        restore_modified_times
-      end
-
-      Overcommit::GitRepo.restore_merge_state
-      Overcommit::GitRepo.restore_cherry_pick_state
-    end
-
-    # Get a list of added, copied, or modified files that have been staged.
-    # Renames and deletions are ignored, since there should be nothing to check.
-    def modified_files
-      unless @modified_files
-        currently_staged = Overcommit::GitRepo.modified_files(staged: true)
-        @modified_files = currently_staged
-
-        # Include files modified in last commit if amending
-        if amendment?
-          subcmd = 'show --format=%n'
-          previously_modified = Overcommit::GitRepo.modified_files(subcmd: subcmd)
-          @modified_files |= filter_modified_files(previously_modified)
-        end
-      end
-      @modified_files
-    end
-
-    # Returns the set of line numbers corresponding to the lines that were
-    # changed in a specified file.
-    def modified_lines_in_file(file)
-      @modified_lines ||= {}
-      unless @modified_lines[file]
-        @modified_lines[file] =
-          Overcommit::GitRepo.extract_modified_lines(file, staged: true)
-
-        # Include lines modified in last commit if amending
-        if amendment?
-          subcmd = 'show --format=%n'
-          @modified_lines[file] +=
-            Overcommit::GitRepo.extract_modified_lines(file, subcmd: subcmd)
-        end
-      end
-      @modified_lines[file]
-    end
-
-    # Returns whether the current git branch is empty (has no commits).
-    def initial_commit?
-      return @initial_commit unless @initial_commit.nil?
-      @initial_commit = Overcommit::GitRepo.initial_commit?
-    end
-
-    private
-
-    def stash_changes
-      @stash_attempted = true
-
-      stash_message = "Overcommit: Stash of repo state before hook run at #{Time.now}"
-      result = Overcommit::Utils.with_environment('GIT_LITERAL_PATHSPECS' => '0') do
-        Overcommit::Utils.execute(
-          %w[git -c commit.gpgsign=false stash save --keep-index --quiet] + [stash_message]
-        )
-      end
-
-      unless result.success?
-        # Failure to stash in this case is likely due to a configuration
-        # issue (e.g. author/email not set or GPG signing key incorrect)
-        raise Overcommit::Exceptions::HookSetupFailed,
-              "Unable to setup environment for #{hook_script_name} hook run:" \
-              "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
-      end
-
-      @changes_stashed = `git stash list -1`.include?(stash_message)
-    end
-
-    # Clears the working tree so that the stash can be applied.
-    def clear_working_tree
-      removed_submodules = Overcommit::GitRepo.staged_submodule_removals
-
-      result = Overcommit::Utils.execute(%w[git reset --hard])
-      unless result.success?
-        raise Overcommit::Exceptions::HookCleanupFailed,
-              "Unable to cleanup working tree after #{hook_script_name} hooks run:" \
-              "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
-      end
-
-      # Hard-resetting a staged submodule removal results in the index being
-      # reset but the submodule being restored as an empty directory. This empty
-      # directory prevents us from stashing on a subsequent run if a hook fails.
-      #
-      # Work around this by removing these empty submodule directories as there
-      # doesn't appear any reason to keep them around.
-      removed_submodules.each do |submodule|
-        FileUtils.rmdir(submodule.path)
-      end
-    end
-
-    # Applies the stash to the working tree to restore the user's state.
-    def restore_working_tree
-      result = Overcommit::Utils.execute(%w[git stash pop --index --quiet])
-      unless result.success?
-        raise Overcommit::Exceptions::HookCleanupFailed,
-              "Unable to restore working tree after #{hook_script_name} hooks run:" \
-              "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
-      end
-    end
-
-    # Returns whether there are any changes to tracked files which have not yet
-    # been staged.
-    def unstaged_changes?
-      result = Overcommit::Utils.execute(%w[git --no-pager diff --quiet])
-      !result.success?
-    end
-
-    # Stores the modification times for all modified files to make it appear like
-    # they never changed.
-    #
-    # This prevents (some) editors from complaining about files changing when we
-    # stash changes before running the hooks.
-    def store_modified_times
-      @modified_times = {}
-
-      staged_files = modified_files
-      unstaged_files = Overcommit::GitRepo.modified_files(staged: false)
-
-      (staged_files + unstaged_files).each do |file|
-        next if Overcommit::Utils.broken_symlink?(file)
-        next unless File.exist?(file) # Ignore renamed files (old file no longer exists)
-        @modified_times[file] = File.mtime(file)
-      end
-    end
-
-    # Restores the file modification times for all modified files to make it
-    # appear like they never changed.
-    def restore_modified_times
-      @modified_times.each do |file, time|
-        next if Overcommit::Utils.broken_symlink?(file)
-        next unless File.exist?(file)
-        File.utime(time, time, file)
-      end
-    end
+  class PreCommit < Base
+    include Overcommit::HookContext::Helpers::StashUnstagedChanges
+    include Overcommit::HookContext::Helpers::FileModifications
   end
 end

data/lib/overcommit/printer.rb

@@ -51,6 +51,7 @@ module Overcommit
     def run_interrupted
       log.newline
       log.warning '⚠  Hook run interrupted by user'
+      log.warning '⚠  If files appear modified/missing, check your stash to recover them'
       log.newline
     end
 

data/lib/overcommit/version.rb

@@ -2,5 +2,5 @@
 
 # Defines the gem version.
 module Overcommit
-  VERSION = '0.52.1'
+  VERSION = '0.56.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: overcommit
 version: !ruby/object:Gem::Version
-  version: 0.52.1
+  version: 0.56.0
 platform: ruby
 authors:
 - Shane da Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-04 00:00:00.000000000 Z
+date: 2020-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: childprocess
@@ -19,7 +19,7 @@ dependencies:
         version: 0.6.3
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: 0.6.3
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: iniparse
   requirement: !ruby/object:Gem::Requirement
@@ -216,6 +216,7 @@ files:
 - lib/overcommit/hook/pre_push/golangci_lint.rb
 - lib/overcommit/hook/pre_push/minitest.rb
 - lib/overcommit/hook/pre_push/php_unit.rb
+- lib/overcommit/hook/pre_push/pronto.rb
 - lib/overcommit/hook/pre_push/protected_branches.rb
 - lib/overcommit/hook/pre_push/pytest.rb
 - lib/overcommit/hook/pre_push/python_nose.rb
@@ -231,12 +232,15 @@ files:
 - lib/overcommit/hook/shared/composer_install.rb
 - lib/overcommit/hook/shared/index_tags.rb
 - lib/overcommit/hook/shared/npm_install.rb
+- lib/overcommit/hook/shared/pronto.rb
 - lib/overcommit/hook/shared/rake_target.rb
 - lib/overcommit/hook/shared/submodule_status.rb
 - lib/overcommit/hook/shared/yarn_install.rb
 - lib/overcommit/hook_context.rb
 - lib/overcommit/hook_context/base.rb
 - lib/overcommit/hook_context/commit_msg.rb
+- lib/overcommit/hook_context/helpers/file_modifications.rb
+- lib/overcommit/hook_context/helpers/stash_unstaged_changes.rb
 - lib/overcommit/hook_context/post_checkout.rb
 - lib/overcommit/hook_context/post_commit.rb
 - lib/overcommit/hook_context/post_merge.rb