overcommit 0.55.0 → 0.56.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a524e83e8f2a0a620f84817c6001626f7c9ddebcc9e539371b1efbab310d7493
-  data.tar.gz: 7ab2d3ac91f72a49dc5d549c7ae0e801d03db8898a1927e59d61b1bb34cae540
+  metadata.gz: d6ecbb7e4b390f8d17c9058da38464b73f7cec50a87e494430e9c15a9c40ecff
+  data.tar.gz: f90974df2fe0b918ff8711a228608ad1b312a730abd9ad7c45b02ee512daa496
 SHA512:
-  metadata.gz: e4f16534e0c4173f388aecf99d35a16cc5672cbac25f3e3abf524bd1a3c581c9afa3dd391995d70d122fc85bf5b7488ec414413be9b93f8ea35dc83967335eab
-  data.tar.gz: a41eca8c55b8643cd248a1cebd619ad6984d7c257bd3477932e72506b436866b8ccdb7123b8e45bc7ebdef4d5a7618bf9239fb4162ca0bb3d804c29a4a867685
+  metadata.gz: a8b55f73d42ca1791bbd6a01281a0adbbe1f57385721d9ec4905e98dd9217480ae5b10ff8e9083048953974d40c97d104f126ca9b514fb05359ba6c402b4bf7b
+  data.tar.gz: b9263d9c65fbbeaa4cf7a38d5b7c2bb4af6d6ec7abf5e3ee22209a455a3b7529718b6eb9adbc14161539861420242093c7b4c3564e248ce84bc663cfb354899f

data/config/default.yml

@@ -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

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.55.0'
+  VERSION = '0.56.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: overcommit
 version: !ruby/object:Gem::Version
-  version: 0.55.0
+  version: 0.56.0
 platform: ruby
 authors:
 - Shane da Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-15 00:00:00.000000000 Z
+date: 2020-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: childprocess
@@ -239,6 +239,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