overcommit-jeygeethanmedia 0.53.1

data/config/starter.yml

@@ -0,0 +1,33 @@
+# Use this file to configure the Overcommit hooks you wish to use. This will
+# extend the default configuration defined in:
+# https://github.com/sds/overcommit/blob/master/config/default.yml
+#
+# At the topmost level of this YAML file is a key representing type of hook
+# being run (e.g. pre-commit, commit-msg, etc.). Within each type you can
+# customize each hook, such as whether to only run it on certain files (via
+# `include`), whether to only display output if it fails (via `quiet`), etc.
+#
+# For a complete list of hooks, see:
+# https://github.com/sds/overcommit/tree/master/lib/overcommit/hook
+#
+# For a complete list of options that you can use to customize hooks, see:
+# https://github.com/sds/overcommit#configuration
+#
+# Uncomment the following lines to make the configuration take effect.
+
+#PreCommit:
+#  RuboCop:
+#    enabled: true
+#    on_warn: fail # Treat all warnings as failures
+#
+#  TrailingWhitespace:
+#    enabled: true
+#    exclude:
+#      - '**/db/structure.sql' # Ignore trailing whitespace in generated files
+#
+#PostCheckout:
+#  ALL: # Special hook name that customizes all hooks of this type
+#    quiet: true # Change all post-checkout hooks to only display output on failure
+#
+#  IndexTags:
+#    enabled: true # Generate a tags file with `ctags` each time HEAD changes

data/lib/overcommit.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'overcommit/os'
+require 'overcommit/constants'
+require 'overcommit/exceptions'
+require 'overcommit/utils/file_utils'
+require 'overcommit/utils'
+require 'overcommit/git_version'
+require 'overcommit/configuration_validator'
+require 'overcommit/configuration'
+require 'overcommit/configuration_loader'
+require 'overcommit/hook/base'
+require 'overcommit/hook_context/base'
+require 'overcommit/hook_context'
+require 'overcommit/git_config'
+require 'overcommit/git_repo'
+require 'overcommit/hook_signer'
+require 'overcommit/hook_loader/base'
+require 'overcommit/hook_loader/built_in_hook_loader'
+require 'overcommit/hook_loader/plugin_hook_loader'
+require 'overcommit/interrupt_handler'
+require 'overcommit/printer'
+require 'overcommit/hook_runner'
+require 'overcommit/installer'
+require 'overcommit/logger'
+require 'overcommit/version'

data/lib/overcommit/cli.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require 'overcommit'
+require 'optparse'
+
+module Overcommit
+  # Responsible for parsing command-line options and executing appropriate
+  # application logic based on those options.
+  class CLI # rubocop:disable ClassLength
+    def initialize(arguments, input, logger)
+      @arguments = arguments
+      @input     = input
+      @log       = logger
+      @options   = {}
+
+      Overcommit::Utils.log = logger
+    end
+
+    def run
+      parse_arguments
+
+      case @options[:action]
+      when :install, :uninstall
+        install_or_uninstall
+      when :template_dir
+        print_template_directory_path
+      when :sign
+        sign
+      when :run_all
+        run_all
+      end
+    rescue Overcommit::Exceptions::ConfigurationSignatureChanged => ex
+      puts ex
+      exit 78 # EX_CONFIG
+    rescue Overcommit::Exceptions::HookContextLoadError => ex
+      puts ex
+      exit 64 # EX_USAGE
+    end
+
+    private
+
+    attr_reader :log
+
+    def parse_arguments
+      @parser = create_option_parser
+
+      begin
+        @parser.parse!(@arguments)
+
+        # Default action is to install
+        @options[:action] ||= :install
+
+        # Unconsumed arguments are our targets
+        @options[:targets] = @arguments
+      rescue OptionParser::InvalidOption => ex
+        print_help @parser.help, ex
+      end
+    end
+
+    def create_option_parser
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{opts.program_name} [options] [target-repo]"
+
+        add_information_options(opts)
+        add_installation_options(opts)
+        add_other_options(opts)
+      end
+    end
+
+    def add_information_options(opts)
+      opts.on_tail('-h', '--help', 'Show this message') do
+        print_help opts.help
+      end
+
+      opts.on_tail('-v', '--version', 'Show version') do
+        print_version(opts.program_name)
+      end
+
+      opts.on_tail('-l', '--list-hooks', 'List installed hooks') do
+        print_installed_hooks
+      end
+    end
+
+    def add_installation_options(opts)
+      opts.on('-u', '--uninstall', 'Remove Overcommit hooks from a repository') do
+        @options[:action] = :uninstall
+      end
+
+      opts.on('-i', '--install', 'Install Overcommit hooks in a repository') do
+        @options[:action] = :install
+      end
+
+      opts.on('-f', '--force', 'Overwrite any previously installed hooks') do
+        @options[:force] = true
+      end
+
+      opts.on('-r', '--run', 'Run pre-commit hook against all git tracked files') do
+        @options[:action] = :run_all
+      end
+    end
+
+    def add_other_options(opts)
+      opts.on('-s', '--sign [hook]', 'Update hook signatures', String) do |hook_to_sign|
+        @options[:hook_to_sign] = hook_to_sign if hook_to_sign.is_a?(String)
+        @options[:action] = :sign
+      end
+
+      opts.on('-t', '--template-dir', 'Print location of template directory') do
+        @options[:action] = :template_dir
+      end
+    end
+
+    def install_or_uninstall
+      if Array(@options[:targets]).empty?
+        @options[:targets] = [Overcommit::Utils.repo_root].compact
+      end
+
+      if @options[:targets].empty?
+        log.warning 'You are not in a git repository.'
+        log.log 'You must either specify the path to a repository or ' \
+                'change your current directory to a repository.'
+        halt 64 # EX_USAGE
+      end
+
+      @options[:targets].each do |target|
+        begin
+          Installer.new(log).run(target, @options)
+        rescue Overcommit::Exceptions::InvalidGitRepo => error
+          log.warning "Invalid repo #{target}: #{error}"
+          halt 69 # EX_UNAVAILABLE
+        rescue Overcommit::Exceptions::PreExistingHooks => error
+          log.warning "Unable to install into #{target}: #{error}"
+          halt 73 # EX_CANTCREAT
+        end
+      end
+    end
+
+    def print_template_directory_path
+      puts File.join(Overcommit::HOME, 'template-dir')
+      halt
+    end
+
+    def print_help(message, error = nil)
+      log.error "#{error}\n" if error
+      log.log message
+      halt(error ? 64 : 0) # 64 = EX_USAGE
+    end
+
+    def print_version(program_name)
+      log.log "#{program_name} #{Overcommit::VERSION}"
+      halt
+    end
+
+    # Prints the hooks available in the current repo and whether they're
+    # enabled/disabled.
+    def print_installed_hooks
+      config.all_hook_configs.each do |hook_type, hook_configs|
+        print_hooks_for_hook_type(config, hook_configs, hook_type)
+      end
+
+      halt
+    end
+
+    def print_hooks_for_hook_type(repo_config, hook_configs, hook_type)
+      log.log "#{hook_type}:"
+      hook_configs.each do |hook_name, config|
+        log.partial "  #{hook_name}: "
+
+        if config['enabled']
+          log.success('enabled', true)
+        else
+          log.error('disabled', true)
+        end
+
+        if repo_config.plugin_hook?(hook_type, hook_name)
+          log.warning(' (plugin)')
+        else
+          log.newline
+        end
+      end
+    end
+
+    def sign
+      if @options[:hook_to_sign]
+        context = Overcommit::HookContext.create(@options[:hook_to_sign],
+                                                 config,
+                                                 @arguments,
+                                                 @input)
+        Overcommit::HookLoader::PluginHookLoader.new(config,
+                                                     context,
+                                                     log).update_signatures
+      else
+        log.log 'Updating signature for configuration file...'
+        config(verify: false).update_signature!
+      end
+
+      halt
+    end
+
+    def run_all
+      empty_stdin = File.open(File::NULL) # pre-commit hooks don't take input
+      context = Overcommit::HookContext.create('run-all', config, @arguments, empty_stdin)
+      config.apply_environment!(context, ENV)
+
+      printer = Overcommit::Printer.new(config, log, context)
+      runner  = Overcommit::HookRunner.new(config, log, context, printer)
+
+      status = runner.run
+
+      halt(status ? 0 : 65)
+    end
+
+    # Used for ease of stubbing in tests
+    def halt(status = 0)
+      exit status
+    end
+
+    # Returns the configuration for this repository.
+    def config(options = {})
+      @config ||= Overcommit::ConfigurationLoader.new(log, options).load_repo_config
+    end
+  end
+end

data/lib/overcommit/command_splitter.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Overcommit
+  # Distributes a list of arguments over multiple invocations of a command.
+  #
+  # This accomplishes the same functionality provided by `xargs` but in a
+  # cross-platform way that does not require any pre-existing tools.
+  #
+  # One of the tradeoffs with this approach is that we no longer deal with a
+  # single exit status from a command, but multiple (one for each invocation).
+  #
+  # This will return a struct similar to `Subprocess::Result` but with
+  # additional `statuses`, `stdouts`, and `stderrs` fields so hook authors can
+  # actually see the results of each invocation. If they don't care, the
+  # standard `status`, `stdout`, and `stderr` will still work but be a
+  # aggregation/concatenation of all statuses/outputs.
+  class CommandSplitter
+    # Encapsulates the result of a split argument run.
+    #
+    # @attr_reader statuses [Array<Integer>] status codes for invocations
+    # @attr_reader stdouts [Array<String>] standard outputs from invocations
+    # @attr_reader stderrs [Array<String>] standard error outputs from invocations
+    Result = Struct.new(:statuses, :stdouts, :stderrs) do
+      # Returns whether all invocations were successful.
+      #
+      # @return [true,false]
+      def success?
+        status == 0
+      end
+
+      # Returns `0` if all invocations returned `0`; `1` otherwise.
+      #
+      # @return [true,false]
+      def status
+        statuses.all? { |code| code == 0 } ? 0 : 1
+      end
+
+      # Returns concatenated standard output streams of all invocations in the
+      # order they were executed.
+      #
+      # @return [String]
+      def stdout
+        stdouts.join
+      end
+
+      # Returns concatenated standard error streams of all invocations in the
+      # order they were executed.
+      #
+      # @return [String]
+      def stderr
+        stderrs.join
+      end
+    end
+
+    class << self
+      def execute(initial_args, options)
+        options = options.dup
+
+        if (splittable_args = (options.delete(:args) { [] })).empty?
+          raise Overcommit::Exceptions::InvalidCommandArgs,
+                'Must specify list of arguments to split on'
+        end
+
+        # Execute each chunk of arguments in serial. We don't parallelize (yet)
+        # since in theory we want to support parallelization at the hook level
+        # and not within individual hooks.
+        results = extract_argument_lists(initial_args, splittable_args).map do |arg_list|
+          Overcommit::Subprocess.spawn(arg_list, options)
+        end
+
+        Result.new(results.map(&:status), results.map(&:stdout), results.map(&:stderr))
+      end
+
+      private
+
+      # Given a list of prefix arguments and suffix arguments that can be split,
+      # returns a list of argument lists that are executable on the current OS
+      # without exceeding command line limitations.
+      def extract_argument_lists(args, splittable_args)
+        # Total number of bytes needed to contain the prefix command
+        # (including byte separators between each argument)
+        prefix_bytes = (args.size - 1) + args.reduce(0) { |sum, arg| sum + arg.bytesize }
+
+        if prefix_bytes >= max_command_length
+          raise Overcommit::Exceptions::InvalidCommandArgs,
+                "Command `#{args.take(5).join(' ')} ...` is longer than the " \
+                'maximum number of bytes allowed by the operating system ' \
+                "(#{max_command_length})"
+        end
+
+        arg_lists = []
+        index = 0
+        while index <= splittable_args.length - 1
+          arg_list, index = arguments_under_limit(splittable_args,
+                                                  index,
+                                                  max_command_length - prefix_bytes)
+          arg_lists << args + arg_list
+        end
+
+        arg_lists
+      end
+
+      # @return [Array<Array<String>, Integer>] tuple of arguments and new index
+      def arguments_under_limit(splittable_args, start_index, byte_limit)
+        index = start_index
+        total_bytes = 0
+
+        loop do
+          break if index > splittable_args.length - 1
+          total_bytes += splittable_args[index].bytesize
+          break if total_bytes > byte_limit # Not enough room
+          index += 1
+        end
+
+        if index == start_index
+          # No argument was consumed; perhaps a really long argument?
+          raise Overcommit::Exceptions::InvalidCommandArgs,
+                "Argument `#{splittable_args[index][0..5]}...` exceeds the " \
+                'maximum command length when appended to command prefix and ' \
+                "can't be split further"
+        end
+
+        [splittable_args[start_index...index], index]
+      end
+
+      # Returns the maximum number of arguments allowed in a single command on
+      # this system.
+      #
+      # @return [Integer]
+      def max_command_length
+        @max_command_length ||=
+          if Gem.win_platform?
+            # Windows is limited to 2048 since that is a worst-case scenario.
+            # http://blogs.msdn.com/b/oldnewthing/archive/2003/12/10/56028.aspx
+            2048
+          else
+            # We fudge factor this by halving the buffer size since *nix systems
+            # usually have pretty large limits, and the actual limit changes
+            # depending on how much of your stack is environment variables.
+            # Definitely erring on the side of overly cautious.
+            `getconf ARG_MAX`.to_i / 2
+          end
+      end
+    end
+  end
+end

data/lib/overcommit/configuration.rb

@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+
+module Overcommit
+  # Stores configuration for Overcommit and the hooks it runs.
+  class Configuration # rubocop:disable ClassLength
+    # Creates a configuration from the given hash.
+    #
+    # @param hash [Hash] loaded YAML config file as a hash
+    # @param options [Hash]
+    # @option default [Boolean] whether this is the default built-in configuration
+    # @option logger [Overcommit::Logger]
+    def initialize(hash, options = {})
+      @options = options.dup
+      @options[:logger] ||= Overcommit::Logger.silent
+      @hash = hash # Assign so validator can read original values
+      unless options[:validate] == false
+        @hash = Overcommit::ConfigurationValidator.new.validate(self, hash, options)
+      end
+    end
+
+    def ==(other)
+      super || @hash == other.hash
+    end
+
+    # Access the configuration as if it were a hash.
+    #
+    # @param key [String]
+    # @return [Array,Hash,Number,String]
+    def [](key)
+      @hash[key]
+    end
+
+    # Returns absolute path to the directory that external hook plugins should
+    # be loaded from.
+    def plugin_directory
+      File.join(Overcommit::Utils.repo_root, @hash['plugin_directory'] || '.git-hooks')
+    end
+
+    def concurrency
+      @concurrency ||=
+        begin
+          cores = Overcommit::Utils.processor_count
+          content = @hash.fetch('concurrency') { '%<processors>d' }
+          if content.is_a?(String)
+            concurrency_expr = content % { processors: cores }
+
+            a, op, b = concurrency_expr.scan(%r{(\d+)\s*([+\-*\/])\s*(\d+)})[0]
+            if a
+              a.to_i.send(op, b.to_i)
+            else
+              concurrency_expr.to_i
+            end
+          else
+            content.to_i
+          end
+        end
+    end
+
+    # Returns configuration for all hooks in each hook type.
+    #
+    # @return [Hash]
+    def all_hook_configs
+      smart_merge(all_builtin_hook_configs, all_plugin_hook_configs)
+    end
+
+    # Returns configuration for all built-in hooks in each hook type.
+    #
+    # @return [Hash]
+    def all_builtin_hook_configs
+      hook_configs = {}
+
+      Overcommit::Utils.supported_hook_type_classes.each do |hook_type|
+        hook_names = @hash[hook_type].keys.reject { |name| name == 'ALL' }
+
+        hook_configs[hook_type] = Hash[
+          hook_names.map do |hook_name|
+            [hook_name, for_hook(hook_name, hook_type)]
+          end
+        ]
+      end
+
+      hook_configs
+    end
+
+    # Returns configuration for all plugin hooks in each hook type.
+    #
+    # @return [Hash]
+    def all_plugin_hook_configs
+      hook_configs = {}
+
+      Overcommit::Utils.supported_hook_types.each do |hook_type|
+        hook_type_class_name = Overcommit::Utils.camel_case(hook_type)
+
+        directory = File.join(plugin_directory, hook_type.tr('-', '_'))
+        plugin_paths = Dir[File.join(directory, '*.rb')].sort
+
+        hook_names = plugin_paths.map do |path|
+          Overcommit::Utils.camel_case(File.basename(path, '.rb'))
+        end
+
+        hook_configs[hook_type_class_name] = Hash[
+          hook_names.map do |hook_name|
+            [hook_name, for_hook(hook_name, Overcommit::Utils.camel_case(hook_type))]
+          end
+        ]
+      end
+
+      hook_configs
+    end
+
+    # Returns the built-in hooks that have been enabled for a hook type.
+    def enabled_builtin_hooks(hook_context)
+      @hash[hook_context.hook_class_name].keys.
+        reject { |hook_name| hook_name == 'ALL' }.
+        select { |hook_name| built_in_hook?(hook_context, hook_name) }.
+        select { |hook_name| hook_enabled?(hook_context, hook_name) }
+    end
+
+    # Returns the ad hoc hooks that have been enabled for a hook type.
+    def enabled_ad_hoc_hooks(hook_context)
+      @hash[hook_context.hook_class_name].keys.
+        reject { |hook_name| hook_name == 'ALL' }.
+        select { |hook_name| ad_hoc_hook?(hook_context, hook_name) }.
+        select { |hook_name| hook_enabled?(hook_context, hook_name) }
+    end
+
+    # Returns a non-modifiable configuration for a hook.
+    def for_hook(hook, hook_type = nil)
+      unless hook_type
+        components = hook.class.name.split('::')
+        hook = components.last
+        hook_type = components[-2]
+      end
+
+      # Merge hook configuration with special 'ALL' config
+      hook_config = smart_merge(@hash[hook_type]['ALL'], @hash[hook_type][hook] || {})
+
+      # Need to specially handle `enabled` option since not setting it does not
+      # necessarily mean the hook is disabled
+      hook_config['enabled'] = hook_enabled?(hook_type, hook)
+
+      hook_config.freeze
+    end
+
+    # Merges the given configuration with this one, returning a new
+    # {Configuration}. The provided configuration will either add to or replace
+    # any options defined in this configuration.
+    def merge(config)
+      self.class.new(smart_merge(@hash, config.hash))
+    end
+
+    # Applies additional configuration settings based on the provided
+    # environment variables.
+    def apply_environment!(hook_context, env)
+      skipped_hooks = "#{env['SKIP']} #{env['SKIP_CHECKS']} #{env['SKIP_HOOKS']}".split(/[:, ]/)
+      only_hooks = env.fetch('ONLY') { '' }.split(/[:, ]/)
+      hook_type = hook_context.hook_class_name
+
+      if only_hooks.any? || skipped_hooks.include?('all') || skipped_hooks.include?('ALL')
+        @hash[hook_type]['ALL']['skip'] = true
+      end
+
+      only_hooks.select { |hook_name| hook_exists?(hook_context, hook_name) }.
+                 map { |hook_name| Overcommit::Utils.camel_case(hook_name) }.
+                 each do |hook_name|
+        @hash[hook_type][hook_name] ||= {}
+        @hash[hook_type][hook_name]['skip'] = false
+      end
+
+      skipped_hooks.select { |hook_name| hook_exists?(hook_context, hook_name) }.
+                    map { |hook_name| Overcommit::Utils.camel_case(hook_name) }.
+                    each do |hook_name|
+        @hash[hook_type][hook_name] ||= {}
+        @hash[hook_type][hook_name]['skip'] = true
+      end
+    end
+
+    def plugin_hook?(hook_context_or_type, hook_name)
+      hook_type_name =
+        if hook_context_or_type.is_a?(String)
+          Overcommit::Utils.snake_case(hook_context_or_type)
+        else
+          hook_context_or_type.hook_type_name
+        end
+      hook_name = Overcommit::Utils.snake_case(hook_name)
+
+      File.exist?(File.join(plugin_directory, hook_type_name, "#{hook_name}.rb"))
+    end
+
+    # Return whether the signature for this configuration has changed since it
+    # was last calculated.
+    #
+    # @return [true,false]
+    def signature_changed?
+      signature != stored_signature
+    end
+
+    # Return whether a previous signature has been recorded for this
+    # configuration.
+    #
+    # @return [true,false]
+    def previous_signature?
+      !stored_signature.empty?
+    end
+
+    # Returns whether this configuration should verify itself by checking the
+    # stored configuration for the repo.
+    #
+    # @return [true,false]
+    def verify_signatures?
+      return false if ENV['OVERCOMMIT_NO_VERIFY']
+      return true if @hash['verify_signatures'] != false
+
+      result = Overcommit::Utils.execute(
+        %W[git config --local --get #{verify_signature_config_key}]
+      )
+
+      if result.status == 1 # Key doesn't exist
+        return true
+      elsif result.status != 0
+        raise Overcommit::Exceptions::GitConfigError,
+              "Unable to read from local repo git config: #{result.stderr}"
+      end
+
+      # We don't cast since we want to allow anything to count as "true" except
+      # a literal zero
+      result.stdout.strip != '0'
+    end
+
+    # Update the currently stored signature for this hook.
+    def update_signature!
+      result = Overcommit::Utils.execute(
+        %w[git config --local] + [signature_config_key, signature]
+      )
+
+      verify_signature_value = @hash['verify_signatures'] ? 1 : 0
+      result &&= Overcommit::Utils.execute(
+        %W[git config --local #{verify_signature_config_key} #{verify_signature_value}]
+      )
+
+      unless result.success?
+        raise Overcommit::Exceptions::GitConfigError,
+              "Unable to write to local repo git config: #{result.stderr}"
+      end
+    end
+
+    protected
+
+    attr_reader :hash
+
+    private
+
+    def ad_hoc_hook?(hook_context, hook_name)
+      ad_hoc_conf = @hash.fetch(hook_context.hook_class_name) { {} }.fetch(hook_name) { {} }
+
+      # Ad hoc hooks are neither built-in nor have a plugin file written but
+      # still have a `command` specified to be run
+      !built_in_hook?(hook_context, hook_name) &&
+        !plugin_hook?(hook_context, hook_name) &&
+        (ad_hoc_conf['command'] || ad_hoc_conf['required_executable'])
+    end
+
+    def built_in_hook?(hook_context, hook_name)
+      hook_name = Overcommit::Utils.snake_case(hook_name)
+
+      File.exist?(File.join(Overcommit::HOME, 'lib', 'overcommit', 'hook',
+                            hook_context.hook_type_name, "#{hook_name}.rb"))
+    end
+
+    def hook_exists?(hook_context, hook_name)
+      built_in_hook?(hook_context, hook_name) ||
+        plugin_hook?(hook_context, hook_name) ||
+        ad_hoc_hook?(hook_context, hook_name)
+    end
+
+    def hook_enabled?(hook_context_or_type, hook_name)
+      hook_type =
+        if hook_context_or_type.is_a?(String)
+          hook_context_or_type
+        else
+          hook_context_or_type.hook_class_name
+        end
+
+      individual_enabled = @hash[hook_type].fetch(hook_name) { {} }['enabled']
+      return individual_enabled unless individual_enabled.nil?
+
+      all_enabled = @hash[hook_type]['ALL']['enabled']
+      return all_enabled unless all_enabled.nil?
+
+      false
+    end
+
+    def smart_merge(parent, child)
+      # Treat the ALL hook specially so that it overrides any configuration
+      # specified by the default configuration.
+      child_all = child['ALL']
+      unless child_all.nil?
+        parent = Hash[parent.collect { |k, v| [k, smart_merge(v, child_all)] }]
+      end
+
+      parent.merge(child) do |_key, old, new|
+        case old
+        when Hash
+          smart_merge(old, new)
+        else
+          new
+        end
+      end
+    end
+
+    # Returns the unique signature of this configuration.
+    #
+    # @return [String]
+    def signature
+      Digest::SHA256.hexdigest(@hash.to_json)
+    end
+
+    # Returns the stored signature of this repo's Overcommit configuration.
+    #
+    # This is intended to be compared against the current signature of this
+    # configuration object.
+    #
+    # @return [String]
+    def stored_signature
+      result = Overcommit::Utils.execute(
+        %w[git config --local --get] + [signature_config_key]
+      )
+
+      if result.status == 1 # Key doesn't exist
+        return ''
+      elsif result.status != 0
+        raise Overcommit::Exceptions::GitConfigError,
+              "Unable to read from local repo git config: #{result.stderr}"
+      end
+
+      result.stdout.chomp
+    end
+
+    def signature_config_key
+      'overcommit.configuration.signature'
+    end
+
+    def verify_signature_config_key
+      'overcommit.configuration.verifysignatures'
+    end
+  end
+end