overcommit 0.53.0 → 0.57.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f21bd45048df18d59d884ff63d79c3d3304116125497e788e1127b53c449c52
-  data.tar.gz: 5e7c92a6e7c241b4f3f0498fe42347fde0863317f4e7097adb89e6ebd44fb0b4
+  metadata.gz: b5c35b43073b67da5cd0f8218c5ffd914b0601f1aac6d5ac9263ec3945893259
+  data.tar.gz: 9c08bf2a7153993c48e3d15f30dee2c846edbb5f8500f89a41e027ec80ffb767
 SHA512:
-  metadata.gz: 3c7182368533a88cbccabcf3dfdee1df57bbdc37b5a865a4f3bc37d30eb128d5af5ac655932141a68687a3fb56500dbe443e56f26b82fa43d10e12cc0ee8cf44
-  data.tar.gz: 8ef215e68656618666eebe1a48369a924731e909674a27cc42172427ace29104ba67d0cdaafa72c22b8693deb9baaf81d41c6355653111d5775d6a81f5f1260b
+  metadata.gz: 6cdcab7f4b31feed71b3f584f1e025a930d9b767e4e9acf00562ed57fac38442381454f57758bd967a657c9f966842f44212b53e2b482fe50613723590383d02
+  data.tar.gz: 6d763e1d1eca286dd9c8861ee265bd8b3ed29e740d10d430e82c461ae64b313ef2057b11db654c0f694c21dcefcf187b8e7ea27bfbf1a16eba3d6f47776b4772

data/config/default.yml

@@ -275,6 +275,13 @@ PreCommit:
       - '**/*.ex'
       - '**/*.exs'
 
+  ErbLint:
+    enabled: false
+    description: 'Analyze with ERB Lint'
+    required_executable: 'erblint'
+    install_command: 'bundle install erb_lint'
+    include: '**/*.html.erb'
+
   EsLint:
     enabled: false
     description: 'Analyze with ESLint'
@@ -338,7 +345,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 +892,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 +1244,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

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/commit_msg/base.rb

@@ -9,6 +9,6 @@ module Overcommit::Hook::CommitMsg
 
     def_delegators :@context, :empty_message?, :commit_message,
                    :update_commit_message, :commit_message_lines,
-                   :commit_message_file
+                   :commit_message_file, :modified_lines_in_file
   end
 end

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/erb_lint.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `erblint` against any modified ERB files.
+  #
+  # @see https://github.com/Shopify/erb-lint
+  class ErbLint < Base
+    MESSAGE_REGEX = /(?<message>.+)\nIn file: (?<file>.+):(?<line>\d+)/
+
+    def run
+      result = execute(command, args: applicable_files)
+      return :pass if result.success?
+
+      extract_messages(
+        result.stdout.split("\n\n")[1..-1],
+        MESSAGE_REGEX
+      )
+    end
+  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} #{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_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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: overcommit
 version: !ruby/object:Gem::Version
-  version: 0.53.0
+  version: 0.57.0
 platform: ruby
 authors:
 - Shane da Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-24 00:00:00.000000000 Z
+date: 2020-10-03 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
@@ -130,6 +130,7 @@ files:
 - lib/overcommit/hook/pre_commit/credo.rb
 - lib/overcommit/hook/pre_commit/css_lint.rb
 - lib/overcommit/hook/pre_commit/dogma.rb
+- lib/overcommit/hook/pre_commit/erb_lint.rb
 - lib/overcommit/hook/pre_commit/es_lint.rb
 - lib/overcommit/hook/pre_commit/execute_permissions.rb
 - lib/overcommit/hook/pre_commit/fasterer.rb
@@ -239,6 +240,8 @@ files:
 - 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