overcommit-jeygeethanmedia 0.53.1

data/lib/overcommit/hook_context/run_all.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Overcommit::HookContext
+  # Simulates a pre-commit context pretending that all files have been changed.
+  #
+  # This results in pre-commit hooks running against the entire repository,
+  # which is useful for automated CI scripts.
+  class RunAll < Base
+    def modified_files
+      @modified_files ||= all_files
+    end
+
+    # Returns all lines in the file since in this context the entire repo is
+    # being scrutinized.
+    #
+    # @param file [String]
+    # @return [Set]
+    def modified_lines_in_file(file)
+      @modified_lines_in_file ||= {}
+      @modified_lines_in_file[file] ||= Set.new(1..count_lines(file))
+    end
+
+    def hook_class_name
+      'PreCommit'
+    end
+
+    def hook_type_name
+      'pre_commit'
+    end
+
+    def hook_script_name
+      'pre-commit'
+    end
+
+    def initial_commit?
+      return @initial_commit unless @initial_commit.nil?
+      @initial_commit = Overcommit::GitRepo.initial_commit?
+    end
+
+    private
+
+    def count_lines(file)
+      File.foreach(file).count
+    end
+  end
+end

data/lib/overcommit/hook_loader/base.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+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)
+      hook_type_class = Overcommit::Hook.const_get(@context.hook_class_name)
+      hook_base_class = hook_type_class.const_get(:Base)
+      hook_class = hook_type_class.const_get(hook_name)
+      unless hook_class < hook_base_class
+        raise Overcommit::Exceptions::HookLoadError,
+              "Class #{hook_name} is not a subclass of #{hook_base_class}."
+      end
+
+      begin
+        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
+end

data/lib/overcommit/hook_loader/built_in_hook_loader.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+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,102 @@
+# frozen_string_literal: true
+
+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_signatures?
+
+      hooks = 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
+
+      hooks + ad_hoc_hook_names.map do |hook_name|
+        create_ad_hoc_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 plugin_hook_names
+      plugin_paths.map do |path|
+        Overcommit::Utils.camel_case(File.basename(path, '.rb'))
+      end
+    end
+
+    def ad_hoc_hook_names
+      @config.enabled_ad_hoc_hooks(@context)
+    end
+
+    def modified_plugins
+      (plugin_hook_names + ad_hoc_hook_names).
+        map { |hook_name| Overcommit::HookSigner.new(hook_name, @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
+
+    def create_ad_hoc_hook(hook_name)
+      hook_module = Overcommit::Hook.const_get(@context.hook_class_name)
+      hook_base = hook_module.const_get('Base')
+
+      # Implement a simple class that executes the command and returns pass/fail
+      # based on the exit status
+      hook_class = Class.new(hook_base) do
+        def run
+          result = @context.execute_hook(command)
+
+          if result.success?
+            :pass
+          else
+            [:fail, result.stdout + result.stderr]
+          end
+        end
+      end
+
+      hook_module.const_set(hook_name, hook_class).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_runner.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Overcommit
+  # Responsible for loading the hooks the repository has configured and running
+  # them, collecting and displaying the results.
+  class HookRunner # rubocop:disable Metrics/ClassLength
+    # @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 = []
+
+      @lock = Mutex.new
+      @resource = ConditionVariable.new
+      @slots_available = @config.concurrency
+    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
+        # Load hooks before setting up the environment so that the repository
+        # has not been touched yet. This way any load errors at this point don't
+        # result in Overcommit leaving the repository in a bad state.
+        load_hooks
+
+        # Setup the environment without automatically calling
+        # `cleanup_environment` on an error. This is because it's possible that
+        # the `setup_environment` code did not fully complete, so there's no
+        # guarantee that `cleanup_environment` will be able to accomplish
+        # anything of value. The safest thing to do is therefore nothing in the
+        # unlikely case of failure.
+        @context.setup_environment
+
+        begin
+          run_hooks
+        ensure
+          @context.cleanup_environment
+        end
+      end
+    end
+
+    private
+
+    attr_reader :log
+
+    def run_hooks # rubocop:disable Metrics/MethodLength
+      if @hooks.any?(&:enabled?)
+        @printer.start_run
+
+        # Sort so hooks requiring fewer processors get queued first. This
+        # ensures we make better use of our available processors
+        @hooks_left = @hooks.sort_by { |hook| processors_for_hook(hook) }
+        @threads = Array.new(@config.concurrency) { Thread.new(&method(:consume)) }
+
+        begin
+          InterruptHandler.disable_until_finished_or_interrupted do
+            @threads.each(&:join)
+          end
+        rescue Interrupt
+          @printer.interrupt_triggered
+          # We received an interrupt on the main thread, so alert the
+          # remaining workers that an exception occurred
+          @interrupted = true
+          @threads.each { |thread| thread.raise Interrupt }
+        end
+
+        print_results
+
+        hook_failed = @failed || @interrupted
+
+        if hook_failed
+          message = @context.post_fail_message
+          @printer.hook_run_failed(message) unless message.nil?
+        end
+
+        !hook_failed
+      else
+        @printer.nothing_to_run
+        true # Run was successful
+      end
+    end
+
+    def consume
+      loop do
+        hook = @lock.synchronize { @hooks_left.pop }
+        break unless hook
+        run_hook(hook)
+      end
+    end
+
+    def wait_for_slot(hook)
+      @lock.synchronize do
+        slots_needed = processors_for_hook(hook)
+
+        loop do
+          if @slots_available >= slots_needed
+            @slots_available -= slots_needed
+
+            # Give another thread a chance since there are still slots available
+            @resource.signal if @slots_available > 0
+            break
+          elsif @slots_available > 0
+            # It's possible that another hook that requires fewer slots can be
+            # served, so give another a chance
+            @resource.signal
+
+            # Wait for a signal from another thread to try again
+            @resource.wait(@lock)
+          else
+            # Otherwise there are not slots left, so just wait for signal
+            @resource.wait(@lock)
+          end
+        end
+      end
+    end
+
+    def release_slot(hook)
+      @lock.synchronize do
+        slots_released = processors_for_hook(hook)
+        @slots_available += slots_released
+
+        # Signal every time in case there are threads that are already waiting for
+        # these slots to be released
+        @resource.signal
+      end
+    end
+
+    def processors_for_hook(hook)
+      hook.parallelize? ? hook.processors : @config.concurrency
+    end
+
+    def print_results
+      if @interrupted
+        @printer.run_interrupted
+      elsif @failed
+        @printer.run_failed
+      elsif @warned
+        @printer.run_warned
+      else
+        @printer.run_succeeded
+      end
+    end
+
+    def run_hook(hook) # rubocop:disable Metrics/CyclomaticComplexity
+      status, output = nil, nil
+
+      begin
+        wait_for_slot(hook)
+        return if should_skip?(hook)
+
+        status, output = hook.run_and_transform
+      rescue Overcommit::Exceptions::MessageProcessingError => ex
+        status = :fail
+        output = ex.message
+      rescue StandardError => ex
+        status = :fail
+        output = "Hook raised unexpected error\n#{ex.message}\n#{ex.backtrace.join("\n")}"
+      end
+
+      @failed = true if status == :fail
+      @warned = true if status == :warn
+
+      @printer.end_hook(hook, status, output) unless @interrupted
+
+      status
+    rescue Interrupt
+      @interrupted = true
+    ensure
+      release_slot(hook)
+    end
+
+    def should_skip?(hook)
+      return true if @interrupted || !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
+    rescue LoadError => ex
+      # Include a more helpful message that will probably save some confusion
+      message = 'A load error occurred. ' +
+        if @config['gemfile']
+          "Did you forget to specify a gem in your `#{@config['gemfile']}`?"
+        else
+          'Did you forget to install a gem?'
+        end
+
+      raise Overcommit::Exceptions::HookLoadError,
+            "#{message}\n#{ex.message}",
+            ex.backtrace
+    end
+  end
+end

data/lib/overcommit/hook_signer.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Overcommit
+  # Calculates, stores, and retrieves stored signatures of hook plugins.
+  class HookSigner
+    attr_reader :hook_name
+
+    # We don't want to include the skip setting as it is set by Overcommit
+    # itself
+    IGNORED_CONFIG_KEYS = %w[skip].freeze
+
+    # @param hook_name [String] name of the hook
+    # @param config [Overcommit::Configuration]
+    # @param context [Overcommit::HookContext]
+    def initialize(hook_name, config, context)
+      @hook_name = hook_name
+      @config = config
+      @context = context
+    end
+
+    # Returns the path of the file that should be incorporated into this hooks
+    # signature.
+    #
+    # @return [String]
+    def hook_path
+      @hook_path ||= begin
+        plugin_path = File.join(@config.plugin_directory,
+                                @context.hook_type_name,
+                                "#{Overcommit::Utils.snake_case(@hook_name)}.rb")
+
+        if File.exist?(plugin_path)
+          plugin_path
+        else
+          # Otherwise this is an ad hoc hook using an existing hook script
+          hook_config = @config.for_hook(@hook_name, @context.hook_class_name)
+
+          command = Array(hook_config['command'] || hook_config['required_executable'])
+
+          if @config.verify_signatures? &&
+            signable_file?(command.first) &&
+            !Overcommit::GitRepo.tracked?(command.first)
+            raise Overcommit::Exceptions::InvalidHookDefinition,
+                  'Hook specified a `required_executable` or `command` that ' \
+                  'is a path relative to the root of the repository, and so ' \
+                  'must be tracked by Git in order to be signed'
+          end
+
+          File.join(Overcommit::Utils.repo_root, command.first.to_s)
+        end
+      end
+    end
+
+    def signable_file?(file)
+      return unless file
+      sep = Overcommit::OS.windows? ? '\\' : File::SEPARATOR
+      file.start_with?(".#{sep}") ||
+        file.start_with?(Overcommit::Utils.repo_root)
+    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) } }
+
+      content_to_sign =
+        if signable_file?(hook_path) && Overcommit::GitRepo.tracked?(hook_path)
+          hook_contents
+        end
+
+      Digest::SHA256.hexdigest(content_to_sign.to_s + hook_config.to_s)
+    end
+
+    def hook_contents
+      File.read(hook_path)
+    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