jawshooah-overcommit 0.22.0

data/lib/overcommit/configuration.rb

@@ -0,0 +1,183 @@
+module Overcommit
+  # Stores configuration for Overcommit and the hooks it runs.
+  class Configuration # rubocop:disable ClassLength
+    # Creates a configuration from the given hash.
+    def initialize(hash)
+      @hash = ConfigurationValidator.new.validate(hash)
+    end
+
+    def ==(other)
+      super || @hash == other.hash
+    end
+    alias_method :eql?, :==
+
+    # 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'] || '.githooks')
+    end
+
+    def verify_plugin_signatures?
+      @hash['verify_plugin_signatures'] != false
+    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.gsub('-', '_'))
+        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.
+        select { |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 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(/[:, ]/)
+      hook_type = hook_context.hook_class_name
+
+      if skipped_hooks.include?('all') || skipped_hooks.include?('ALL')
+        @hash[hook_type]['ALL']['skip'] = true
+      else
+        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
+    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
+
+    protected
+
+    attr_reader :hash
+
+    private
+
+    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)
+    end
+
+    def hook_enabled?(hook_context_or_type, hook_name)
+      hook_type = hook_context_or_type.is_a?(String) ? hook_context_or_type :
+                                                       hook_context_or_type.hook_class_name
+
+      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?
+
+      true
+    end
+
+    def smart_merge(parent, child)
+      parent.merge(child) do |_key, old, new|
+        case old
+        when Array
+          old + Array(new)
+        when Hash
+          smart_merge(old, new)
+        else
+          new
+        end
+      end
+    end
+  end
+end

data/lib/overcommit/configuration_loader.rb

@@ -0,0 +1,49 @@
+require 'yaml'
+
+module Overcommit
+  # Manages configuration file loading.
+  class ConfigurationLoader
+    DEFAULT_CONFIG_PATH = File.join(OVERCOMMIT_HOME, 'config', 'default.yml')
+
+    class << self
+      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
+          default_configuration
+        end
+      end
+
+      def default_configuration
+        @default_config ||= load_from_file(DEFAULT_CONFIG_PATH)
+      end
+
+      private
+
+      # Loads a configuration, ensuring it extends the default configuration.
+      def load_file(file)
+        config = load_from_file(file)
+
+        default_configuration.merge(config)
+      rescue => error
+        raise Overcommit::Exceptions::ConfigurationError,
+              "Unable to load configuration from '#{file}': #{error}",
+              error.backtrace
+      end
+
+      def load_from_file(file)
+        hash =
+          if yaml = YAML.load_file(file)
+            yaml.to_hash
+          else
+            {}
+          end
+
+        Overcommit::Configuration.new(hash)
+      end
+    end
+  end
+end

data/lib/overcommit/configuration_validator.rb

@@ -0,0 +1,40 @@
+module Overcommit
+  # Validates and normalizes a configuration.
+  class ConfigurationValidator
+    # Validates hash for any invalid options, normalizing where possible.
+    def validate(hash)
+      hash = convert_nils_to_empty_hashes(hash)
+      ensure_hook_type_sections_exist(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
+  end
+end

data/lib/overcommit/constants.rb

@@ -0,0 +1,8 @@
+# Global application constants.
+module Overcommit
+  OVERCOMMIT_HOME = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+  OVERCOMMIT_CONFIG_FILE_NAME = '.overcommit.yml'
+
+  REPO_URL = 'https://github.com/causes/overcommit'
+  BUG_REPORT_URL = "#{REPO_URL}/issues"
+end

data/lib/overcommit/exceptions.rb

@@ -0,0 +1,35 @@
+module Overcommit::Exceptions
+  # Raised when a {Configuration} could not be loaded from a file.
+  class ConfigurationError < StandardError; end
+
+  # Raised when trying to read/write to/from the local repo git config fails.
+  class GitConfigError < 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 one or more hook plugin signatures have changed.
+  class InvalidHookSignature < StandardError; end
+
+  # Raised when an installation target already contains non-Overcommit hooks.
+  class PreExistingHooks < StandardError; end
+end

data/lib/overcommit/git_repo.rb

@@ -0,0 +1,147 @@
+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
+
+    # 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  = 'HEAD~ HEAD' if options[:last_commit]
+
+      `git diff --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
+
+    # 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_last_commit(file_path)
+      extract_modified_lines(file_path, last_commit: true)
+    end
+
+    # Returns the names of all files that have been modified from compared to
+    # HEAD.
+    #
+    # @param options [Hash]
+    # @return [Array<String>] list of absolute file paths
+    def modified_files(options)
+      flags = '--cached' if options[:staged]
+      refs  = 'HEAD~ HEAD' if options[:last_commit]
+
+      `git diff --name-only -z --diff-filter=ACM --ignore-submodules=all #{flags} #{refs}`.
+        split("\0").
+        map { |relative_file| File.expand_path(relative_file) }
+    end
+
+    # Returns the names of all files that were modified in the last commit.
+    #
+    # @return [Array<String>] lsit of absolute file paths
+    def modified_files_last_commit
+      modified_files(last_commit: true)
+    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) }
+    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> /dev/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> /dev/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}\n")
+        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}\n")
+        end
+        @cherry_head = nil
+      end
+    end
+  end
+end