jawshooah-overcommit 0.22.0

data/lib/overcommit/hook_loader/base.rb

@@ -0,0 +1,36 @@
+module Overcommit::HookLoader
+  # Responsible for loading hooks from a file.
+  class Base
+    # @param config [Overcommit::Configuration]
+    # @param context [Overcommit::HookContext]
+    # @param logger [Overcommit::Logger]
+    def initialize(config, context, logger)
+      @config = config
+      @context = context
+      @log = logger
+    end
+
+    # When implemented in subclasses, loads the hooks for which that subclass is
+    # responsible.
+    #
+    # @return [Array<Hook>]
+    def load_hooks
+      raise NotImplementedError
+    end
+
+    private
+
+    attr_reader :log
+
+    # Load and return a {Hook} from a CamelCase hook name.
+    def create_hook(hook_name)
+      Overcommit::Hook.const_get(@context.hook_class_name).
+                       const_get(hook_name).
+                       new(@config, @context)
+    rescue LoadError, NameError => error
+      raise Overcommit::Exceptions::HookLoadError,
+            "Unable to load hook '#{hook_name}': #{error}",
+            error.backtrace
+    end
+  end
+end

data/lib/overcommit/hook_loader/built_in_hook_loader.rb

@@ -0,0 +1,12 @@
+module Overcommit::HookLoader
+  # Responsible for loading hooks that ship with Overcommit.
+  class BuiltInHookLoader < Base
+    def load_hooks
+      @config.enabled_builtin_hooks(@context).map do |hook_name|
+        underscored_hook_name = Overcommit::Utils.snake_case(hook_name)
+        require "overcommit/hook/#{@context.hook_type_name}/#{underscored_hook_name}"
+        create_hook(hook_name)
+      end
+    end
+  end
+end

data/lib/overcommit/hook_loader/plugin_hook_loader.rb

@@ -0,0 +1,61 @@
+require 'digest'
+
+module Overcommit::HookLoader
+  # Responsible for loading hooks that are specific to the repository Overcommit
+  # is running in.
+  class PluginHookLoader < Base
+    def load_hooks
+      check_for_modified_plugins if @config.verify_plugin_signatures?
+
+      plugin_paths.map do |plugin_path|
+        require plugin_path
+
+        hook_name = Overcommit::Utils.camel_case(File.basename(plugin_path, '.rb'))
+        create_hook(hook_name)
+      end
+    end
+
+    def update_signatures
+      log.success('No plugin signatures have changed') if modified_plugins.empty?
+
+      modified_plugins.each do |plugin|
+        plugin.update_signature!
+        log.warning "Updated signature of plugin #{plugin.hook_name}"
+      end
+    end
+
+    private
+
+    def plugin_paths
+      directory = File.join(@config.plugin_directory, @context.hook_type_name)
+      Dir[File.join(directory, '*.rb')].sort
+    end
+
+    def modified_plugins
+      plugin_paths.
+        map { |path| Overcommit::HookSigner.new(path, @config, @context) }.
+        select(&:signature_changed?)
+    end
+
+    def check_for_modified_plugins
+      return if modified_plugins.empty?
+
+      log.bold_warning "The following #{@context.hook_script_name} plugins " \
+                       'have been added, changed, or had their configuration modified:'
+      log.newline
+
+      modified_plugins.each do |signer|
+        log.warning " * #{signer.hook_name} in #{signer.hook_path}"
+      end
+
+      log.newline
+      log.bold_warning 'You should verify the changes and then run:'
+      log.newline
+      log.warning "overcommit --sign #{@context.hook_script_name}"
+      log.newline
+      log.log "For more information, see #{Overcommit::REPO_URL}#security"
+
+      raise Overcommit::Exceptions::InvalidHookSignature
+    end
+  end
+end

data/lib/overcommit/hook_runner.rb

@@ -0,0 +1,129 @@
+module Overcommit
+  # Responsible for loading the hooks the repository has configured and running
+  # them, collecting and displaying the results.
+  class HookRunner
+    # @param config [Overcommit::Configuration]
+    # @param logger [Overcommit::Logger]
+    # @param context [Overcommit::HookContext]
+    # @param printer [Overcommit::Printer]
+    def initialize(config, logger, context, printer)
+      @config = config
+      @log = logger
+      @context = context
+      @printer = printer
+      @hooks = []
+    end
+
+    # Loads and runs the hooks registered for this {HookRunner}.
+    def run
+      # ASSUMPTION: we assume the setup and cleanup calls will never need to be
+      # interrupted, i.e. they will finish quickly. Should further evidence
+      # suggest this assumption does not hold, we will have to separately wrap
+      # these calls to allow some sort of "are you sure?" double-interrupt
+      # functionality, but until that's deemed necessary let's keep it simple.
+      InterruptHandler.isolate_from_interrupts do
+        @context.setup_environment
+        load_hooks
+        result = run_hooks
+        @context.cleanup_environment
+        result
+      end
+    end
+
+    private
+
+    attr_reader :log
+
+    def run_hooks
+      if @hooks.any?(&:enabled?)
+        @printer.start_run
+
+        interrupted = false
+        run_failed = false
+
+        @hooks.each do |hook|
+          hook_status = run_hook(hook)
+
+          run_failed = true if [:bad, :fail].include?(hook_status)
+
+          if hook_status == :interrupt
+            # Stop running any more hooks and assume a bad result
+            interrupted = true
+            break
+          end
+        end
+
+        print_results(run_failed, interrupted)
+
+        !(run_failed || interrupted)
+      else
+        @printer.nothing_to_run
+        true # Run was successful
+      end
+    end
+
+    def print_results(failed, interrupted)
+      if interrupted
+        @printer.run_interrupted
+      elsif failed
+        @printer.run_failed
+      else
+        @printer.run_succeeded
+      end
+    end
+
+    def run_hook(hook)
+      return if should_skip?(hook)
+
+      @printer.start_hook(hook)
+
+      status, output = nil, nil
+
+      begin
+        # Disable the interrupt handler during individual hook run so that
+        # Ctrl-C actually stops the current hook from being run, but doesn't
+        # halt the entire process.
+        InterruptHandler.disable_until_finished_or_interrupted do
+          status, output = hook.run_and_transform
+        end
+      rescue => ex
+        status = :fail
+        output = "Hook raised unexpected error\n#{ex.message}\n#{ex.backtrace.join("\n")}"
+      rescue Interrupt
+        # At this point, interrupt has been handled and protection is back in
+        # effect thanks to the InterruptHandler.
+        status = :interrupt
+        output = 'Hook was interrupted by Ctrl-C; restoring repo state...'
+      end
+
+      @printer.end_hook(hook, status, output)
+
+      status
+    end
+
+    def should_skip?(hook)
+      return true unless hook.enabled?
+
+      if hook.skip?
+        if hook.required?
+          @printer.required_hook_not_skipped(hook)
+        else
+          # Tell user if hook was skipped only if it actually would have run
+          @printer.hook_skipped(hook) if hook.run?
+          return true
+        end
+      end
+
+      !hook.run?
+    end
+
+    def load_hooks
+      require "overcommit/hook/#{@context.hook_type_name}/base"
+
+      @hooks += HookLoader::BuiltInHookLoader.new(@config, @context, @log).load_hooks
+
+      # Load plugin hooks after so they can subclass existing hooks
+      @hooks += HookLoader::PluginHookLoader.new(@config, @context, @log).load_hooks
+    end
+  end
+end

data/lib/overcommit/hook_signer.rb

@@ -0,0 +1,79 @@
+module Overcommit
+  # Calculates, stores, and retrieves stored signatures of hook plugins.
+  class HookSigner
+    attr_reader :hook_path, :hook_name
+
+    # We don't want to include the skip setting as it is set by Overcommit
+    # itself
+    IGNORED_CONFIG_KEYS = %w[skip]
+
+    # @param hook_path [String] path to the actual hook definition
+    # @param config [Overcommit::Configuration]
+    # @param context [Overcommit::HookContext]
+    def initialize(hook_path, config, context)
+      @hook_path = hook_path
+      @config = config
+      @context = context
+
+      @hook_name = Overcommit::Utils.camel_case(File.basename(@hook_path, '.rb'))
+    end
+
+    # Return whether the signature for this hook has changed since it was last
+    # calculated.
+    #
+    # @return [true,false]
+    def signature_changed?
+      signature != stored_signature
+    end
+
+    # Update the current stored signature for this hook.
+    def update_signature!
+      result = Overcommit::Utils.execute(
+        %w[git config --local] + [signature_config_key, signature]
+      )
+
+      unless result.success?
+        raise Overcommit::Exceptions::GitConfigError,
+              "Unable to write to local repo git config: #{result.stderr}"
+      end
+    end
+
+    private
+
+    # Calculates a hash of a hook using a combination of its configuration and
+    # file contents.
+    #
+    # This way, if either the plugin code changes or its configuration changes,
+    # the hash will change and we can alert the user to this change.
+    def signature
+      hook_config = @config.for_hook(@hook_name, @context.hook_class_name).
+                            dup.
+                            tap { |config| IGNORED_CONFIG_KEYS.each { |k| config.delete(k) } }
+
+      Digest::SHA256.hexdigest(hook_contents + hook_config.to_s)
+    end
+
+    def hook_contents
+      File.open(@hook_path, 'r').read
+    end
+
+    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.#{@context.hook_class_name}.#{@hook_name}.signature"
+    end
+  end
+end

data/lib/overcommit/installer.rb

@@ -0,0 +1,148 @@
+require 'fileutils'
+
+module Overcommit
+  # Manages the installation of Overcommit hooks in a git repository.
+  class Installer # rubocop:disable ClassLength
+    TEMPLATE_DIRECTORY = File.join(OVERCOMMIT_HOME, 'template-dir')
+    MASTER_HOOK = File.join(TEMPLATE_DIRECTORY, 'hooks', 'overcommit-hook')
+
+    def initialize(logger)
+      @log = logger
+    end
+
+    def run(target, options)
+      @target = target
+      @options = options
+      validate_target
+
+      case @options[:action]
+      when :uninstall then uninstall
+      when :update then update
+      else
+        install
+      end
+    end
+
+    private
+
+    attr_reader :log
+
+    def install
+      log.log "Installing hooks into #{@target}"
+
+      ensure_hooks_directory
+      install_master_hook
+      install_hook_symlinks
+      install_starter_config
+
+      log.success "Successfully installed hooks into #{@target}"
+    end
+
+    def uninstall
+      log.log "Removing hooks from #{@target}"
+
+      uninstall_master_hook
+      uninstall_hook_symlinks
+
+      log.success "Successfully removed hooks from #{@target}"
+    end
+
+    # @return [true,false] whether the hooks were updated
+    def update
+      unless FileUtils.compare_file(MASTER_HOOK, master_hook_install_path)
+        install_master_hook
+        install_hook_symlinks
+
+        log.success "Hooks updated to Overcommit version #{Overcommit::VERSION}"
+        true
+      end
+    end
+
+    def hooks_path
+      absolute_target = File.expand_path(@target)
+      File.join(Overcommit::Utils.git_dir(absolute_target), 'hooks')
+    end
+
+    def master_hook_install_path
+      File.join(hooks_path, 'overcommit-hook')
+    end
+
+    def ensure_hooks_directory
+      FileUtils.mkdir_p(hooks_path)
+    end
+
+    def validate_target
+      absolute_target = File.expand_path(@target)
+
+      unless File.directory?(absolute_target)
+        raise Overcommit::Exceptions::InvalidGitRepo, 'is not a directory'
+      end
+
+      git_dir_check = Dir.chdir(absolute_target) do
+        Overcommit::Utils.execute(%w[git rev-parse --git-dir])
+      end
+
+      unless git_dir_check.success?
+        raise Overcommit::Exceptions::InvalidGitRepo, 'does not appear to be a git repository'
+      end
+    end
+
+    def install_master_hook
+      FileUtils.mkdir_p(hooks_path)
+      FileUtils.cp(MASTER_HOOK, master_hook_install_path)
+    end
+
+    def uninstall_master_hook
+      FileUtils.rm_rf(master_hook_install_path)
+    end
+
+    def install_hook_symlinks
+      # Link each hook type (pre-commit, commit-msg, etc.) to the master hook.
+      # We change directories so that the relative symlink paths work regardless
+      # of where the repository is located.
+      Dir.chdir(hooks_path) do
+        Overcommit::Utils.supported_hook_types.each do |hook_type|
+          unless can_replace_file?(hook_type)
+            raise Overcommit::Exceptions::PreExistingHooks,
+                  "Hook '#{File.expand_path(hook_type)}' already exists and " \
+                  'was not installed by Overcommit'
+          end
+          FileUtils.ln_sf('overcommit-hook', hook_type)
+        end
+      end
+    end
+
+    def can_replace_file?(file)
+      @options[:force] ||
+        !File.exist?(file) ||
+        overcommit_hook?(file)
+    end
+
+    def uninstall_hook_symlinks
+      return unless File.directory?(hooks_path)
+
+      Dir.chdir(hooks_path) do
+        Overcommit::Utils.supported_hook_types.each do |hook_type|
+          FileUtils.rm_rf(hook_type) if overcommit_hook?(hook_type)
+        end
+      end
+    end
+
+    def install_starter_config
+      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
+
+    def overcommit_hook?(file)
+      return true if File.read(file) =~ /OVERCOMMIT_DISABLE/
+      # TODO: Remove these checks once we hit version 1.0
+      File.symlink?(file) && File.readlink(file) == 'overcommit-hook'
+    rescue Errno::ENOENT
+      # Some Ruby implementations (e.g. JRuby) raise an error when the file
+      # doesn't exist. Standardize the behavior to return false.
+      false
+    end
+  end
+end