overcommit-jeygeethanmedia 0.53.1

data/lib/overcommit/configuration_loader.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Overcommit
+  # Manages configuration file loading.
+  class ConfigurationLoader
+    DEFAULT_CONFIG_PATH = File.join(Overcommit::HOME, 'config', 'default.yml')
+
+    class << self
+      # Loads and returns the default configuration.
+      #
+      # @return [Overcommit::Configuration]
+      def default_configuration
+        @default_configuration ||= load_from_file(DEFAULT_CONFIG_PATH, default: true, verify: false)
+      end
+
+      # Loads configuration from file.
+      #
+      # @param file [String] path to file
+      # @param options [Hash]
+      # @option default [Boolean] whether this is the default built-in configuration
+      # @option verify [Boolean] whether to verify the signature of the configuration
+      # @option logger [Overcommit::Logger]
+      # @return [Overcommit::Configuration]
+      def load_from_file(file, options = {})
+        hash =
+          if yaml = YAML.load_file(file)
+            yaml.to_hash
+          else
+            {}
+          end
+
+        Overcommit::Configuration.new(hash, options)
+      end
+    end
+
+    # Create a configuration loader which writes warnings/errors to the given
+    # {Overcommit::Logger} instance.
+    #
+    # @param logger [Overcommit::Logger]
+    # @param options [Hash]
+    # @option verify [Boolean] whether to verify signatures
+    def initialize(logger, options = {})
+      @log = logger
+      @options = options
+    end
+
+    # Loads and returns the configuration for the repository we're running in.
+    #
+    # @return [Overcommit::Configuration]
+    def load_repo_config
+      overcommit_yml = File.join(Overcommit::Utils.repo_root,
+                                 Overcommit::CONFIG_FILE_NAME)
+
+      if File.exist?(overcommit_yml)
+        load_file(overcommit_yml)
+      else
+        self.class.default_configuration
+      end
+    end
+
+    # Loads a configuration, ensuring it extends the default configuration.
+    def load_file(file)
+      config = self.class.load_from_file(file, default: false, logger: @log)
+      config = self.class.default_configuration.merge(config)
+
+      if @options.fetch(:verify) { config.verify_signatures? }
+        verify_signatures(config)
+      end
+
+      config
+    rescue Overcommit::Exceptions::ConfigurationSignatureChanged
+      raise
+    rescue StandardError => error
+      raise Overcommit::Exceptions::ConfigurationError,
+            "Unable to load configuration from '#{file}': #{error}",
+            error.backtrace
+    end
+
+    private
+
+    def verify_signatures(config)
+      if !config.previous_signature?
+        raise Overcommit::Exceptions::ConfigurationSignatureChanged,
+              "No previously recorded signature for configuration file.\n" \
+              'Run `overcommit --sign` if you trust the hooks in this repository.'
+
+      elsif config.signature_changed?
+        raise Overcommit::Exceptions::ConfigurationSignatureChanged,
+              "Signature of configuration file has changed!\n" \
+              "Run `overcommit --sign` once you've verified the configuration changes."
+      end
+    end
+  end
+end

data/lib/overcommit/configuration_validator.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/MethodLength
+module Overcommit
+  # Validates and normalizes a configuration.
+  class ConfigurationValidator
+    # Validates hash for any invalid options, normalizing where possible.
+    #
+    # @param config [Overcommit::Configuration]
+    # @param hash [Hash] hash representation of YAML config
+    # @param options[Hash]
+    # @option default [Boolean] whether hash represents the default built-in config
+    # @option logger [Overcommit::Logger] logger to output warnings to
+    # @return [Hash] validated hash (potentially modified)
+    def validate(config, hash, options)
+      @options = options.dup
+      @log = options[:logger]
+
+      hash = convert_nils_to_empty_hashes(hash)
+      ensure_hook_type_sections_exist(hash)
+      check_hook_name_format(hash)
+      check_hook_env(hash)
+      check_for_missing_enabled_option(hash) unless @options[:default]
+      check_for_too_many_processors(config, hash)
+      check_for_verify_plugin_signatures_option(hash)
+
+      hash
+    end
+
+    private
+
+    # Ensures that keys for all supported hook types exist (PreCommit,
+    # CommitMsg, etc.)
+    def ensure_hook_type_sections_exist(hash)
+      Overcommit::Utils.supported_hook_type_classes.each do |hook_type|
+        hash[hook_type] ||= {}
+        hash[hook_type]['ALL'] ||= {}
+      end
+    end
+
+    # Normalizes `nil` values to empty hashes.
+    #
+    # This is useful for when we want to merge two configuration hashes
+    # together, since it's easier to merge two hashes than to have to check if
+    # one of the values is nil.
+    def convert_nils_to_empty_hashes(hash)
+      hash.each_with_object({}) do |(key, value), h|
+        h[key] =
+          case value
+          when nil  then {}
+          when Hash then convert_nils_to_empty_hashes(value)
+          else
+            value
+          end
+      end
+    end
+
+    def check_hook_env(hash)
+      errors = []
+
+      Overcommit::Utils.supported_hook_type_classes.each do |hook_type|
+        hash.fetch(hook_type) { {} }.each do |hook_name, hook_config|
+          hook_env = hook_config.fetch('env') { {} }
+
+          unless hook_env.is_a?(Hash)
+            errors << "#{hook_type}::#{hook_name} has an invalid `env` specified: " \
+                      'must be a hash of environment variable name to string value.'
+            next
+          end
+
+          hook_env.each do |var_name, var_value|
+            if var_name.include?('=')
+              errors << "#{hook_type}::#{hook_name} has an invalid `env` specified: " \
+                        "variable name `#{var_name}` cannot contain `=`."
+            end
+
+            unless var_value.nil? || var_value.is_a?(String)
+              errors << "#{hook_type}::#{hook_name} has an invalid `env` specified: " \
+                        "value of `#{var_name}` must be a string or `nil`, but was " \
+                        "#{var_value.inspect} (#{var_value.class})"
+            end
+          end
+        end
+      end
+
+      if errors.any?
+        if @log
+          @log.error errors.join("\n")
+          @log.newline
+        end
+        raise Overcommit::Exceptions::ConfigurationError,
+              'One or more hooks had an invalid `env` configuration option'
+      end
+    end
+
+    # Prints an error message and raises an exception if a hook has an
+    # invalid name, since this can result in strange errors elsewhere.
+    def check_hook_name_format(hash)
+      errors = []
+
+      Overcommit::Utils.supported_hook_type_classes.each do |hook_type|
+        hash.fetch(hook_type) { {} }.each_key do |hook_name|
+          next if hook_name == 'ALL'
+
+          unless hook_name.match?(/\A[A-Za-z0-9]+\z/)
+            errors << "#{hook_type}::#{hook_name} has an invalid name " \
+                      "#{hook_name}. It must contain only alphanumeric " \
+                      'characters (no underscores or dashes, etc.)'
+          end
+        end
+      end
+
+      if errors.any?
+        if @log
+          @log.error errors.join("\n")
+          @log.newline
+        end
+        raise Overcommit::Exceptions::ConfigurationError,
+              'One or more hooks had invalid names'
+      end
+    end
+
+    # Prints a warning if there are any hooks listed in the configuration
+    # without `enabled` explicitly set.
+    def check_for_missing_enabled_option(hash)
+      return unless @log
+
+      any_warnings = false
+
+      Overcommit::Utils.supported_hook_type_classes.each do |hook_type|
+        hash.fetch(hook_type) { {} }.each do |hook_name, hook_config|
+          next if hook_name == 'ALL'
+
+          if hook_config['enabled'].nil?
+            @log.warning "#{hook_type}::#{hook_name} hook does not explicitly " \
+                         'set `enabled` option in .overcommit.yml'
+            any_warnings = true
+          end
+        end
+      end
+
+      @log.newline if any_warnings
+    end
+
+    # Prints a warning if any hook has a number of processors larger than the
+    # global `concurrency` setting.
+    def check_for_too_many_processors(config, hash)
+      concurrency = config.concurrency
+
+      errors = []
+      Overcommit::Utils.supported_hook_type_classes.each do |hook_type|
+        hash.fetch(hook_type) { {} }.each do |hook_name, hook_config|
+          processors = hook_config.fetch('processors') { 1 }
+          if processors > concurrency
+            errors << "#{hook_type}::#{hook_name} `processors` value " \
+                      "(#{processors}) is larger than the global `concurrency` " \
+                      "option (#{concurrency})"
+          end
+        end
+      end
+
+      if errors.any?
+        if @log
+          @log.error errors.join("\n")
+          @log.newline
+        end
+        raise Overcommit::Exceptions::ConfigurationError,
+              'One or more hooks had invalid `processor` value configured'
+      end
+    end
+
+    # Prints a warning if the `verify_plugin_signatures` option is used instead
+    # of the new `verify_signatures` option.
+    def check_for_verify_plugin_signatures_option(hash)
+      return unless @log
+
+      if hash.key?('verify_plugin_signatures')
+        @log.warning '`verify_plugin_signatures` has been renamed to ' \
+                     '`verify_signatures`. Defaulting to verifying signatures.'
+        @log.warning "See change log at #{REPO_URL}/blob/v0.29.0/CHANGELOG.md for details."
+        @log.newline
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/MethodLength

data/lib/overcommit/constants.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Global application constants.
+module Overcommit
+  HOME = File.expand_path(File.join(File.dirname(__FILE__), '..', '..')).freeze
+  CONFIG_FILE_NAME = '.overcommit.yml'
+
+  HOOK_DIRECTORY = File.join(HOME, 'lib', 'overcommit', 'hook').freeze
+
+  REPO_URL = 'https://github.com/sds/overcommit'
+  BUG_REPORT_URL = "#{REPO_URL}/issues"
+end

data/lib/overcommit/exceptions.rb

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

data/lib/overcommit/git_config.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'overcommit/utils'
+
+module Overcommit
+  # Get configuration options from git
+  module GitConfig
+    module_function
+
+    def comment_character
+      char = `git config --get core.commentchar`.chomp
+      char = '#' if char == ''
+      char
+    end
+
+    def hooks_path
+      path = `git config --get core.hooksPath`.chomp
+      return File.join(Overcommit::Utils.git_dir, 'hooks') if path.empty?
+      File.absolute_path(path, Dir.pwd)
+    end
+  end
+end

data/lib/overcommit/git_repo.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require 'iniparse'
+require 'shellwords'
+
+module Overcommit
+  # Provide a set of utilities for certain interactions with `git`.
+  module GitRepo
+    module_function
+
+    # Regular expression used to extract diff ranges from hunks of diff output.
+    DIFF_HUNK_REGEX = /
+      ^@@\s
+      [^\s]+\s           # Ignore old file range
+      \+(\d+)(?:,(\d+))? # Extract range of hunk containing start line and number of lines
+      \s@@.*$
+    /x
+
+    # Regular expression used to extract information from lines of
+    # `git submodule status` output
+    SUBMODULE_STATUS_REGEX = /
+      ^\s*(?<prefix>[-+U]?)(?<sha1>\w+)
+      \s(?<path>[^\s]+?)
+      (?:\s\((?<describe>.+)\))?$
+    /x
+
+    # Struct encapsulating submodule information extracted from the
+    # output of `git submodule status`
+    SubmoduleStatus = Struct.new(:prefix, :sha1, :path, :describe) do
+      # Returns whether the submodule has not been initialized
+      def uninitialized?
+        prefix == '-'
+      end
+
+      # Returns whether the submodule is out of date with the current
+      # index, i.e. its checked-out commit differs from that stored in
+      # the index of the parent repo
+      def outdated?
+        prefix == '+'
+      end
+
+      # Returns whether the submodule reference has a merge conflict
+      def merge_conflict?
+        prefix == 'U'
+      end
+    end
+
+    # Returns a list of SubmoduleStatus objects, one for each submodule in the
+    # parent repository.
+    #
+    # @option options [Boolean] recursive check submodules recursively
+    # @return [Array<SubmoduleStatus>]
+    def submodule_statuses(options = {})
+      flags = '--recursive' if options[:recursive]
+
+      `git submodule status #{flags}`.
+        scan(SUBMODULE_STATUS_REGEX).
+        map do |prefix, sha1, path, describe|
+          SubmoduleStatus.new(prefix, sha1, path, describe)
+        end
+    end
+
+    # Extract the set of modified lines from a given file.
+    #
+    # @param file_path [String]
+    # @param options [Hash]
+    # @return [Set] line numbers that have been modified in file
+    def extract_modified_lines(file_path, options)
+      lines = Set.new
+
+      flags = '--cached' if options[:staged]
+      refs = options[:refs]
+      subcmd = options[:subcmd] || 'diff'
+
+      `git #{subcmd} --no-color --no-ext-diff -U0 #{flags} #{refs} -- "#{file_path}"`.
+        scan(DIFF_HUNK_REGEX) do |start_line, lines_added|
+        lines_added = (lines_added || 1).to_i # When blank, one line was added
+        cur_line = start_line.to_i
+
+        lines_added.times do
+          lines.add cur_line
+          cur_line += 1
+        end
+      end
+
+      lines
+    end
+
+    # Returns the names of all files that have been modified compared to HEAD.
+    #
+    # @param options [Hash]
+    # @return [Array<String>] list of absolute file paths
+    def modified_files(options)
+      flags = '--cached' if options[:staged]
+      refs = options[:refs]
+      subcmd = options[:subcmd] || 'diff'
+
+      `git #{subcmd} --name-only -z --diff-filter=ACMR --ignore-submodules=all #{flags} #{refs}`.
+        split("\0").
+        map(&:strip).
+        reject(&:empty?).
+        map { |relative_file| File.expand_path(relative_file) }
+    end
+
+    # Returns the names of files in the given paths that are tracked by git.
+    #
+    # @param paths [Array<String>] list of paths to check
+    # @option options [String] ref ('HEAD') Git ref to check
+    # @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/).
+        map { |relative_file| File.expand_path(relative_file) }.
+        reject { |file| File.directory?(file) } # Exclude submodule directories
+    end
+
+    # Returns whether the specified file/path is tracked by this repository.
+    #
+    # @param path [String]
+    # @return [true,false]
+    def tracked?(path)
+      Overcommit::Utils.execute(%W[git ls-files #{path} --error-unmatch]).success?
+    end
+
+    # Returns the names of all files that are tracked by git.
+    #
+    # @return [Array<String>] list of absolute file paths
+    def all_files
+      `git ls-files`.
+        split(/\n/).
+        map { |relative_file| File.expand_path(relative_file) }.
+        reject { |file| File.directory?(file) } # Exclude submodule directories
+    end
+
+    # Returns whether the current git branch is empty (has no commits).
+    # @return [true,false]
+    def initial_commit?
+      !Overcommit::Utils.execute(%w[git rev-parse HEAD]).success?
+    end
+
+    # Store any relevant files that are present when repo is in the middle of a
+    # merge.
+    #
+    # Restored via [#restore_merge_state].
+    def store_merge_state
+      merge_head = `git rev-parse MERGE_HEAD 2> #{File::NULL}`.chomp
+
+      # Store the merge state if we're in the middle of resolving a merge
+      # conflict. This is necessary since stashing removes the merge state.
+      if merge_head != 'MERGE_HEAD'
+        @merge_head = merge_head
+      end
+
+      merge_msg_file = File.expand_path('MERGE_MSG', Overcommit::Utils.git_dir)
+      @merge_msg = File.open(merge_msg_file).read if File.exist?(merge_msg_file)
+    end
+
+    # Store any relevant files that are present when repo is in the middle of a
+    # cherry-pick.
+    #
+    # Restored via [#restore_cherry_pick_state].
+    def store_cherry_pick_state
+      cherry_head = `git rev-parse CHERRY_PICK_HEAD 2> #{File::NULL}`.chomp
+
+      # Store the merge state if we're in the middle of resolving a merge
+      # conflict. This is necessary since stashing removes the merge state.
+      if cherry_head != 'CHERRY_PICK_HEAD'
+        @cherry_head = cherry_head
+      end
+    end
+
+    # Restore any relevant files that were present when repo was in the middle
+    # of a merge.
+    def restore_merge_state
+      if @merge_head
+        FileUtils.touch(File.expand_path('MERGE_MODE', Overcommit::Utils.git_dir))
+
+        File.open(File.expand_path('MERGE_HEAD', Overcommit::Utils.git_dir), 'w') do |f|
+          f.write(@merge_head)
+        end
+        @merge_head = nil
+      end
+
+      if @merge_msg
+        File.open(File.expand_path('MERGE_MSG', Overcommit::Utils.git_dir), 'w') do |f|
+          f.write("#{@merge_msg}\n")
+        end
+        @merge_msg = nil
+      end
+    end
+
+    # Restore any relevant files that were present when repo was in the middle
+    # of a cherry-pick.
+    def restore_cherry_pick_state
+      if @cherry_head
+        File.open(File.expand_path('CHERRY_PICK_HEAD',
+                                   Overcommit::Utils.git_dir), 'w') do |f|
+          f.write(@cherry_head)
+        end
+        @cherry_head = nil
+      end
+    end
+
+    # Contains information about a registered submodule.
+    Submodule = Struct.new(:path, :url)
+
+    # Returns the submodules that have been staged for removal.
+    #
+    # `git` has an unexpected behavior where removing a submodule without
+    # committing (i.e. such that the submodule directory is removed and the
+    # changes to the index are staged) and then doing a hard reset results in
+    # the index being wiped but the empty directory of the once existent
+    # submodule being restored (but with no content).
+    #
+    # This prevents restoration of the stash of the submodule index changes,
+    # which breaks pre-commit hook restorations of the working index.
+    #
+    # Thus we expose this helper so the restoration code can manually delete the
+    # directory.
+    #
+    # @raise [Overcommit::Exceptions::GitSubmoduleError] when
+    def staged_submodule_removals
+      # There were no submodules before, so none could have been removed
+      return [] if `git ls-files .gitmodules`.empty?
+
+      previous = submodules(ref: 'HEAD')
+      current = submodules
+
+      previous - current
+    end
+
+    # Returns the current set of registered submodules.
+    #
+    # @param options [Hash]
+    # @return [Array<Overcommit::GitRepo::Submodule>]
+    def submodules(options = {})
+      ref = options[:ref]
+
+      modules = []
+      IniParse.parse(`git show #{ref}:.gitmodules 2> #{File::NULL}`).each do |section|
+        # git < 1.8.5 does not update the .gitmodules file with submodule
+        # changes, so when we are looking at the current state of the work tree,
+        # we need to check if the submodule actually exists via another method,
+        # since the .gitmodules file we parsed does not represent reality.
+        if ref.nil? && GIT_VERSION < '1.8.5'
+          result = Overcommit::Utils.execute(%W[
+            git submodule status #{section['path']}
+          ])
+          next unless result.success?
+        end
+
+        modules << Submodule.new(section['path'], section['url'])
+      end
+
+      modules
+    rescue IniParse::IniParseError => ex
+      raise Overcommit::Exceptions::GitSubmoduleError,
+            "Unable to read submodule information from #{ref}:.gitmodules file: #{ex.message}"
+    end
+
+    # Returns the names of all branches containing the given commit.
+    #
+    # @param commit_ref [String] git tree ref that resolves to a commit
+    # @return [Array<String>] list of branches containing the given commit
+    def branches_containing_commit(commit_ref)
+      `git branch --column=dense --contains #{commit_ref}`.
+        sub(/\((HEAD )?detached (from|at) .*?\)/, ''). # ignore detached HEAD
+        split(/\s+/).
+        reject { |s| s.empty? || s == '*' }
+    end
+
+    # Returns the name of the currently checked out branch.
+    # @return [String]
+    def current_branch
+      `git symbolic-ref --short -q HEAD`.chomp
+    end
+  end
+end