overcommit-jeygeethanmedia 0.53.1

data/lib/overcommit/hook_context/post_merge.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Overcommit::HookContext
+  # Contains helpers related to contextual information used by post-merge
+  # hooks.
+  class PostMerge < Base
+    attr_accessor :args
+    # Get a list of files that were added, copied, or modified in the merge
+    # commit. Renames and deletions are ignored, since there should be nothing
+    # to check.
+    def modified_files
+      staged = squash?
+      refs = 'HEAD^ HEAD' if merge_commit?
+      @modified_files ||= Overcommit::GitRepo.modified_files(staged: staged, refs: refs)
+    end
+
+    # Returns the set of line numbers corresponding to the lines that were
+    # changed in a specified file.
+    def modified_lines_in_file(file)
+      staged = squash?
+      refs = 'HEAD^ HEAD' if merge_commit?
+      @modified_lines ||= {}
+      @modified_lines[file] ||=
+        Overcommit::GitRepo.extract_modified_lines(file, staged: staged, refs: refs)
+    end
+
+    # Returns whether this merge was made using --squash
+    def squash?
+      @args[0].to_i == 1
+    end
+
+    # Returns whether this merge was made without --squash
+    def merge_commit?
+      !squash?
+    end
+  end
+end

data/lib/overcommit/hook_context/post_rewrite.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Overcommit::HookContext
+  # Contains helpers for contextual information used by post-rewrite hooks.
+  class PostRewrite < Base
+    # Returns whether this post-rewrite was triggered by `git commit --amend`.
+    #
+    # @return [true,false]
+    def amend?
+      @args[0] == 'amend'
+    end
+
+    # Returns whether this post-rewrite was triggered by `git rebase`.
+    #
+    # @return [true,false]
+    def rebase?
+      @args[0] == 'rebase'
+    end
+
+    # Returns the list of commits rewritten by the action that triggered this
+    # hook run.
+    #
+    # @return [Array<RewrittenCommit>]
+    def rewritten_commits
+      @rewritten_commits ||= input_lines.map do |line|
+        RewrittenCommit.new(*line.split(' '))
+      end
+    end
+
+    # Get a list of files that have been added or modified as part of a
+    # rewritten commit. Renames and deletions are ignored, since there should be
+    # nothing to check.
+    def modified_files
+      @modified_files ||= begin
+        @modified_files = []
+
+        rewritten_commits.each do |rewritten_commit|
+          refs = "#{rewritten_commit.old_hash} #{rewritten_commit.new_hash}"
+          @modified_files |= Overcommit::GitRepo.modified_files(refs: refs)
+        end
+
+        filter_modified_files(@modified_files)
+      end
+    end
+
+    # Struct encapsulating the old and new SHA1 hashes of a rewritten commit
+    RewrittenCommit = Struct.new(:old_hash, :new_hash)
+  end
+end

data/lib/overcommit/hook_context/pre_commit.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'set'
+
+module Overcommit::HookContext
+  # Contains helpers related to contextual information used by pre-commit hooks.
+  #
+  # 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
+  end
+end

data/lib/overcommit/hook_context/pre_push.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+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 remote_ref_deletion?
+      return @remote_ref_deletion if defined?(@remote_ref_deletion)
+
+      @remote_ref_deletion ||= input_lines.
+                               first&.
+                               split(' ')&.
+                               first == '(deleted)'
+    end
+
+    def pushed_refs
+      input_lines.map do |line|
+        PushedRef.new(*line.split(' '))
+      end
+    end
+
+    def modified_files
+      @modified_files ||= pushed_refs.map(&:modified_files).flatten.uniq
+    end
+
+    def modified_lines_in_file(file)
+      @modified_lines ||= {}
+      @modified_lines[file] = pushed_refs.each_with_object(Set.new) do |pushed_ref, set|
+        set.merge(pushed_ref.modified_lines_in_file(file))
+      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 destructive?
+        deleted? || forced?
+      end
+
+      def modified_files
+        Overcommit::GitRepo.modified_files(refs: ref_range)
+      end
+
+      def modified_lines_in_file(file)
+        Overcommit::GitRepo.extract_modified_lines(file, refs: ref_range)
+      end
+
+      def to_s
+        "#{local_ref} #{local_sha1} #{remote_ref} #{remote_sha1}"
+      end
+
+      private
+
+      def ref_range
+        "#{remote_sha1}..#{local_sha1}"
+      end
+
+      def overwritten_commits
+        return @overwritten_commits if defined? @overwritten_commits
+        result = Overcommit::Subprocess.spawn(%W[git rev-list #{remote_sha1} ^#{local_sha1}])
+        if result.success?
+          result.stdout.split("\n")
+        else
+          raise Overcommit::Exceptions::GitRevListError,
+                "Unable to check if commits on the remote ref will be overwritten: #{result.stderr}"
+        end
+      end
+    end
+  end
+end

data/lib/overcommit/hook_context/pre_rebase.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+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_context/prepare_commit_msg.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Overcommit::HookContext
+  # Contains helpers related to contextual information used by prepare-commit-msg
+  # hooks.
+  class PrepareCommitMsg < Base
+    # Returns the name of the file that contains the commit log message
+    def commit_message_filename
+      @args[0]
+    end
+
+    # Returns the source of the commit message, and can be: message (if a -m or
+    # -F option was given); template (if a -t option was given or the
+    # configuration option commit.template is set); merge (if the commit is a
+    # merge or a .git/MERGE_MSG file exists); squash (if a .git/SQUASH_MSG file
+    # exists); or commit, followed by a commit SHA-1 (if a -c, -C or --amend
+    # option was given)
+    def commit_message_source
+      @args[1]&.to_sym
+    end
+
+    # Returns the commit's SHA-1.
+    # If commit_message_source is :commit, it's passed through the command-line.
+    def commit_message_source_ref
+      @args[2] || `git rev-parse HEAD`
+    end
+
+    # Lock for the pre_commit_message file. Should be shared by all
+    # prepare-commit-message hooks
+    def lock
+      @lock ||= Monitor.new
+    end
+  end
+end