overcommit-jeygeethanmedia 0.53.1.2 → 0.58.0

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,79 @@
+# 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,144 @@
+# 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])
+        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/post_commit.rb

@@ -27,6 +27,7 @@ module Overcommit::HookContext
     # @return [true,false]
     def initial_commit?
       return @initial_commit unless @initial_commit.nil?
+
       @initial_commit = !Overcommit::Utils.execute(%w[git rev-parse HEAD~]).success?
     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/hook_context/pre_push.rb

@@ -76,6 +76,7 @@ module Overcommit::HookContext
 
       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")

data/lib/overcommit/hook_context/run_all.rb

@@ -36,6 +36,7 @@ module Overcommit::HookContext
 
     def initial_commit?
       return @initial_commit unless @initial_commit.nil?
+
       @initial_commit = Overcommit::GitRepo.initial_commit?
     end
 

data/lib/overcommit/hook_context.rb

@@ -9,11 +9,11 @@ module Overcommit::HookContext
     require "overcommit/hook_context/#{underscored_hook_type}"
 
     Overcommit::HookContext.const_get(hook_type_class).new(config, args, input)
-  rescue LoadError, NameError => error
+  rescue LoadError, NameError => e
     # Could happen when a symlink was created for a hook type Overcommit does
     # not yet support.
     raise Overcommit::Exceptions::HookContextLoadError,
-          "Unable to load '#{hook_type}' hook context: '#{error}'",
-          error.backtrace
+          "Unable to load '#{hook_type}' hook context: '#{e}'",
+          e.backtrace
   end
 end

data/lib/overcommit/hook_loader/base.rb

@@ -38,10 +38,10 @@ module Overcommit::HookLoader
         Overcommit::Hook.const_get(@context.hook_class_name).
                          const_get(hook_name).
                          new(@config, @context)
-      rescue LoadError, NameError => error
+      rescue LoadError, NameError => e
         raise Overcommit::Exceptions::HookLoadError,
-              "Unable to load hook '#{hook_name}': #{error}",
-              error.backtrace
+              "Unable to load hook '#{hook_name}': #{e}",
+              e.backtrace
       end
     end
   end

data/lib/overcommit/hook_loader/plugin_hook_loader.rb

@@ -93,10 +93,10 @@ module Overcommit::HookLoader
       end
 
       hook_module.const_set(hook_name, hook_class).new(@config, @context)
-    rescue LoadError, NameError => error
+    rescue LoadError, NameError => e
       raise Overcommit::Exceptions::HookLoadError,
-            "Unable to load hook '#{hook_name}': #{error}",
-            error.backtrace
+            "Unable to load hook '#{hook_name}': #{e}",
+            e.backtrace
     end
   end
 end

data/lib/overcommit/hook_runner.rb

@@ -94,6 +94,7 @@ module Overcommit
       loop do
         hook = @lock.synchronize { @hooks_left.pop }
         break unless hook
+
         run_hook(hook)
       end
     end
@@ -159,12 +160,12 @@ module Overcommit
         return if should_skip?(hook)
 
         status, output = hook.run_and_transform
-      rescue Overcommit::Exceptions::MessageProcessingError => ex
+      rescue Overcommit::Exceptions::MessageProcessingError => e
         status = :fail
-        output = ex.message
-      rescue StandardError => ex
+        output = e.message
+      rescue StandardError => e
         status = :fail
-        output = "Hook raised unexpected error\n#{ex.message}\n#{ex.backtrace.join("\n")}"
+        output = "Hook raised unexpected error\n#{e.message}\n#{e.backtrace.join("\n")}"
       end
 
       @failed = true if status == :fail
@@ -202,7 +203,7 @@ module Overcommit
 
       # Load plugin hooks after so they can subclass existing hooks
       @hooks += HookLoader::PluginHookLoader.new(@config, @context, @log).load_hooks
-    rescue LoadError => ex
+    rescue LoadError => e
       # Include a more helpful message that will probably save some confusion
       message = 'A load error occurred. ' +
         if @config['gemfile']
@@ -212,8 +213,8 @@ module Overcommit
         end
 
       raise Overcommit::Exceptions::HookLoadError,
-            "#{message}\n#{ex.message}",
-            ex.backtrace
+            "#{message}\n#{e.message}",
+            e.backtrace
     end
   end
 end

data/lib/overcommit/hook_signer.rb

@@ -52,6 +52,7 @@ module Overcommit
 
     def signable_file?(file)
       return unless file
+
       sep = Overcommit::OS.windows? ? '\\' : File::SEPARATOR
       file.start_with?(".#{sep}") ||
         file.start_with?(Overcommit::Utils.repo_root)

data/lib/overcommit/installer.rb

@@ -4,7 +4,7 @@ require 'fileutils'
 
 module Overcommit
   # Manages the installation of Overcommit hooks in a git repository.
-  class Installer # rubocop:disable ClassLength
+  class Installer # rubocop:disable Metrics/ClassLength
     TEMPLATE_DIRECTORY = File.join(Overcommit::HOME, 'template-dir')
     MASTER_HOOK = File.join(TEMPLATE_DIRECTORY, 'hooks', 'overcommit-hook')
 
@@ -174,6 +174,7 @@ module Overcommit
       repo_config_file = File.join(@target, Overcommit::CONFIG_FILE_NAME)
 
       return if File.exist?(repo_config_file)
+
       FileUtils.cp(File.join(Overcommit::HOME, 'config', 'starter.yml'), repo_config_file)
     end
 

data/lib/overcommit/subprocess.rb

@@ -2,6 +2,7 @@
 
 require 'childprocess'
 require 'tempfile'
+require 'overcommit/os'
 
 module Overcommit
   # Manages execution of a child process, collecting the exit status and
@@ -38,7 +39,7 @@ module Overcommit
         if options[:input]
           begin
             process.io.stdin.puts(options[:input])
-          rescue StandardError # rubocop:disable Lint/HandleExceptions
+          rescue StandardError
             # Silently ignore if the standard input stream of the spawned
             # process is closed before we get a chance to write to it. This
             # happens on JRuby a lot.
@@ -51,7 +52,7 @@ module Overcommit
         err.rewind
         out.rewind
 
-        Result.new(process.exit_code, out.read, err.read)
+        Result.new(process.exit_code, to_utf8(out.read), to_utf8(err.read))
       end
 
       # Spawns a new process in the background using the given array of
@@ -83,6 +84,27 @@ module Overcommit
         %w[cmd.exe /c] + [args.join(' ')]
       end
 
+      # Convert string from current locale to utf-8
+      #
+      # When running commands under windows the command output is using
+      # current system locale (depends on system lanuage) not UTF-8
+      #
+      # @param process [String]
+      # @return [String]
+      def to_utf8(string)
+        # Our encoding code doesn't work on the GitHub Actions Windows
+        # environment for unknown reasons, so just skip it in CI.
+        return string if OS.windows? && ENV['GITHUB_ACTIONS']
+
+        if Encoding.locale_charmap == 'UTF-8'
+          return string
+        end
+
+        ec = Encoding::Converter.new(Encoding.locale_charmap, 'UTF-8')
+        # Convert encoding, alternatively simple: string.scrub will suffice
+        ec.convert(string)
+      end
+
       # @param process [ChildProcess]
       # @return [Array<IO>]
       def assign_output_streams(process)

data/lib/overcommit/utils/messages_utils.rb

@@ -52,6 +52,7 @@ module Overcommit::Utils
 
       def extract_line(match, message)
         return unless match.names.include?('line')
+
         Integer(match[:line])
       rescue ArgumentError, TypeError
         raise Overcommit::Exceptions::MessageProcessingError,

data/lib/overcommit/version.rb

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