jawshooah-overcommit 0.22.0

data/lib/overcommit/hook/pre_commit/rubocop.rb

@@ -0,0 +1,19 @@
+module Overcommit::Hook::PreCommit
+  # Runs `rubocop` against any modified Ruby files.
+  class Rubocop < Base
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('W') ? :warning : :error
+    end
+
+    def run
+      result = execute(%W[#{executable} --format=emacs --force-exclusion] + applicable_files)
+      return :pass if result.success?
+
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>[^:]+):(?<line>\d+):[^ ]+ (?<type>[^ ]+)/,
+        MESSAGE_TYPE_CATEGORIZER,
+      )
+    end
+  end
+end

data/lib/overcommit/hook/pre_commit/scss_lint.rb

@@ -0,0 +1,19 @@
+module Overcommit::Hook::PreCommit
+  # Runs `scss-lint` against any modified SCSS files.
+  class ScssLint < Base
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('W') ? :warning : :error
+    end
+
+    def run
+      result = execute([executable] + applicable_files)
+      return :pass if result.success?
+
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>[^:]+):(?<line>\d+)[^ ]* (?<type>[^ ]+)/,
+        MESSAGE_TYPE_CATEGORIZER,
+      )
+    end
+  end
+end

data/lib/overcommit/hook/pre_commit/shell_check.rb

@@ -0,0 +1,19 @@
+module Overcommit::Hook::PreCommit
+  # Runs `shellcheck` against any modified shell script files.
+  class ShellCheck < Base
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('note') ? :warning : :error
+    end
+
+    def run
+      result = execute(%W[#{executable} --format=gcc] + applicable_files)
+      return :pass if result.success?
+
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>[^:]+):(?<line>\d+):[^ ]+ (?<type>[^ ]+)/,
+        MESSAGE_TYPE_CATEGORIZER,
+      )
+    end
+  end
+end

data/lib/overcommit/hook/pre_commit/trailing_whitespace.rb

@@ -0,0 +1,13 @@
+module Overcommit::Hook::PreCommit
+  # Checks for trailing whitespace in files.
+  class TrailingWhitespace < Base
+    def run
+      result = execute(%w[grep -IHn \s$] + applicable_files)
+      unless result.stdout.empty?
+        return :fail, "Trailing whitespace detected:\n#{result.stdout}"
+      end
+
+      :pass
+    end
+  end
+end

data/lib/overcommit/hook/pre_commit/travis_lint.rb

@@ -0,0 +1,11 @@
+module Overcommit::Hook::PreCommit
+  # Runs `travis-lint` against any modified Travis CI files.
+  class TravisLint < Base
+    def run
+      result = execute([executable, 'lint'] + applicable_files)
+      return :pass if result.success?
+
+      [:fail, (result.stdout + result.stderr).strip]
+    end
+  end
+end

data/lib/overcommit/hook/pre_commit/yaml_syntax.rb

@@ -0,0 +1,22 @@
+require 'yaml'
+
+module Overcommit::Hook::PreCommit
+  # Checks the syntax of any modified YAML files.
+  class YamlSyntax < Base
+    def run
+      output = []
+
+      applicable_files.each do |file|
+        begin
+          YAML.load_file(file)
+        rescue ArgumentError => e
+          output << "#{e.message} parsing #{file}"
+        end
+      end
+
+      return :pass if output.empty?
+
+      [:fail, output]
+    end
+  end
+end

data/lib/overcommit/hook_context.rb

@@ -0,0 +1,17 @@
+# Utility module which manages the creation of {HookContext}s.
+module Overcommit::HookContext
+  def self.create(hook_type, config, args)
+    hook_type_class = Overcommit::Utils.camel_case(hook_type)
+    underscored_hook_type = Overcommit::Utils.snake_case(hook_type)
+
+    require "overcommit/hook_context/#{underscored_hook_type}"
+
+    Overcommit::HookContext.const_get(hook_type_class).new(config, args)
+  rescue LoadError, NameError => error
+    # Could happen when a symlink was created for a hook type Overcommit does
+    # not yet support.
+    raise Overcommit::Exceptions::HookContextLoadError,
+          "Unable to load '#{hook_type}' hook context: '#{error}'",
+          error.backtrace
+  end
+end

data/lib/overcommit/hook_context/base.rb

@@ -0,0 +1,69 @@
+require 'set'
+
+module Overcommit::HookContext
+  # Contains helpers related to the context with which a hook is being run.
+  #
+  # It acts as an adapter to the arguments passed to the hook, as well as
+  # context-specific information such as staged files, providing a single source
+  # of truth for this context.
+  #
+  # This is also important to house in a separate object so that any
+  # calculations can be memoized across all hooks in a single object, which
+  # helps with performance.
+  class Base
+    # @param config [Overcommit::Configuration]
+    # @param args [Array<String>]
+    def initialize(config, args)
+      @config = config
+      @args = args
+    end
+
+    # Returns the camel-cased type of this hook (e.g. PreCommit)
+    def hook_class_name
+      self.class.name.split('::').last
+    end
+
+    # Returns the snake-cased type of this hook (e.g. pre_commit)
+    def hook_type_name
+      Overcommit::Utils.snake_case(hook_class_name)
+    end
+
+    # Returns the actual name of the hook script being run (e.g. pre-commit).
+    def hook_script_name
+      hook_type_name.gsub('_', '-')
+    end
+
+    # Initializes anything related to the environment.
+    #
+    # This is called before the hooks are run by the [HookRunner]. Different
+    # hook types can perform different setup.
+    def setup_environment
+      # Implemented by subclass
+    end
+
+    # Resets the environment to an appropriate state.
+    #
+    # This is called after the hooks have been run by the [HookRunner].
+    # Different hook types can perform different cleanup operations, which are
+    # intended to "undo" the results of the call to {#setup_environment}.
+    def cleanup_environment
+      # Implemented by subclass
+    end
+
+    # Returns a list of files that have been modified.
+    #
+    # By default, this returns an empty list. Subclasses should implement if
+    # there is a concept of files changing for the type of hook being run.
+    def modified_files
+      []
+    end
+
+    # Returns a set of lines that have been modified for a file.
+    #
+    # By default, this returns an empty set. Subclasses should implement if
+    # there is a concept of files changing for the type of hook being run.
+    def modified_lines(_file)
+      Set.new
+    end
+  end
+end

data/lib/overcommit/hook_context/commit_msg.rb

@@ -0,0 +1,32 @@
+module Overcommit::HookContext
+  # Contains helpers related to contextual information used by commit-msg hooks.
+  class CommitMsg < Base
+    # User commit message stripped of comments and diff (from verbose output).
+    def commit_message
+      commit_message_lines.join
+    end
+
+    # Updates the commit message to the specified text.
+    def update_commit_message(message)
+      ::File.open(commit_message_file, 'w') do |file|
+        file.write(message)
+      end
+    end
+
+    def commit_message_lines
+      raw_commit_message_lines.
+        reject     { |line| line =~ /^#/ }.
+        take_while { |line| !line.start_with?('diff --git') }
+    end
+
+    def commit_message_file
+      @args[0]
+    end
+
+    private
+
+    def raw_commit_message_lines
+      ::IO.readlines(commit_message_file)
+    end
+  end
+end

data/lib/overcommit/hook_context/post_checkout.rb

@@ -0,0 +1,26 @@
+module Overcommit::HookContext
+  # Contains helpers related to contextual information used by post-checkout
+  # hooks.
+  class PostCheckout < Base
+    # Returns the ref of the HEAD that we transitioned from.
+    def previous_head
+      @args[0]
+    end
+
+    # Returns the ref of the new current HEAD.
+    def new_head
+      @args[1]
+    end
+
+    # Returns whether this checkout was the result of changing/updating a
+    # branch.
+    def branch_checkout?
+      @args[2].to_i == 1
+    end
+
+    # Returns whether this checkout was for a single file.
+    def file_checkout?
+      !branch_checkout?
+    end
+  end
+end

data/lib/overcommit/hook_context/post_commit.rb

@@ -0,0 +1,19 @@
+module Overcommit::HookContext
+  # Contains helpers related to contextual information used by post-commit
+  # hooks.
+  class PostCommit < Base
+    # Get a list of added, copied, or modified files that have been staged.
+    # Renames and deletions are ignored, since there should be nothing to check.
+    def modified_files_last_commit
+      @modified_files_last_commit ||= Overcommit::GitRepo.modified_files_last_commit
+    end
+
+    # Returns the set of line numbers corresponding to the lines that were
+    # changed in a specified file.
+    def modified_lines_in_file_last_commit(file)
+      @modified_lines_last_commit ||= {}
+      @modified_lines_last_commit[file] ||=
+        Overcommit::GitRepo.extract_modified_lines_last_commit(file)
+    end
+  end
+end

data/lib/overcommit/hook_context/pre_commit.rb

@@ -0,0 +1,148 @@
+require 'fileutils'
+require 'set'
+
+module Overcommit::HookContext
+  # Contains helpers related to contextual information used by pre-commit hooks.
+  #
+  # This includes staged files, which lines of those files have been modified,
+  # etc. It is also responsible for saving/restoring the state of the repo so
+  # hooks only inspect staged changes.
+  class PreCommit < Base
+    # Stash unstaged contents of files so hooks don't see changes that aren't
+    # about to be committed.
+    def setup_environment
+      store_modified_times
+      Overcommit::GitRepo.store_merge_state
+      Overcommit::GitRepo.store_cherry_pick_state
+
+      if !initial_commit? && any_changes?
+        @stash_attempted = true
+
+        result = Overcommit::Utils.execute(
+          %w[git stash save --keep-index --quiet] +
+          ["Overcommit: Stash of repo state before hook run at #{Time.now}"]
+        )
+
+        unless result.success?
+          # Failure to stash in this case is likely due to a configuration
+          # issue (e.g. author/email not set or GPG signing key incorrect)
+          raise Overcommit::Exceptions::HookSetupFailed,
+                "Unable to setup environment for #{hook_script_name} hook run:" \
+                "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+        end
+
+        @changes_stashed = true
+      end
+
+      # While running the hooks make it appear as if nothing changed
+      restore_modified_times
+    end
+
+    # Restore unstaged changes and reset file modification times so it appears
+    # as if nothing ever changed.
+    #
+    # We want to restore the modification times for each of the files after
+    # every step to ensure as little time as possible has passed while the
+    # modification time on the file was newer. This helps us play more nicely
+    # with file watchers.
+    def cleanup_environment
+      unless initial_commit? || (@stash_attempted && !@changes_stashed)
+        clear_working_tree # Ensure working tree is clean before restoring it
+        restore_modified_times
+      end
+
+      if @changes_stashed
+        restore_working_tree
+        restore_modified_times
+      end
+
+      Overcommit::GitRepo.restore_merge_state
+      Overcommit::GitRepo.restore_cherry_pick_state
+      restore_modified_times
+    end
+
+    # Get a list of added, copied, or modified files that have been staged.
+    # Renames and deletions are ignored, since there should be nothing to check.
+    def modified_files
+      @modified_files ||= Overcommit::GitRepo.modified_files(staged: true)
+    end
+
+    # @deprecated
+    # TODO: Remove this once we've moved all existing hooks to stop using this
+    # endpoint
+    def modified_lines(file)
+      modified_lines_in_file(file)
+    end
+
+    # Returns the set of line numbers corresponding to the lines that were
+    # changed in a specified file.
+    def modified_lines_in_file(file)
+      @modified_lines ||= {}
+      @modified_lines[file] ||=
+        Overcommit::GitRepo.extract_modified_lines(file, staged: true)
+    end
+
+    private
+
+    # Clears the working tree so that the stash can be applied.
+    def clear_working_tree
+      result = Overcommit::Utils.execute(%w[git reset --hard])
+      unless result.success?
+        raise Overcommit::Exceptions::HookCleanupFailed,
+              "Unable to cleanup working tree after #{hook_script_name} hooks run:" \
+              "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+      end
+    end
+
+    # Applies the stash to the working tree to restore the user's state.
+    def restore_working_tree
+      result = Overcommit::Utils.execute(%w[git stash pop --index --quiet])
+      unless result.success?
+        raise Overcommit::Exceptions::HookCleanupFailed,
+              "Unable to restore working tree after #{hook_script_name} hooks run:" \
+              "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+      end
+    end
+
+    # Returns whether there are any changes to the working tree, staged or
+    # otherwise.
+    def any_changes?
+      modified_files = `git status -z --untracked-files=no`.
+        split("\0").
+        map { |line| line.gsub(/[^\s]+\s+(.+)/, '\\1') }
+
+      modified_files.any?
+    end
+
+    # Returns whether the current git branch is empty (has no commits).
+    def initial_commit?
+      return @initial_commit unless @initial_commit.nil?
+      @initial_commit = Overcommit::GitRepo.initial_commit?
+    end
+
+    # Stores the modification times for all modified files to make it appear like
+    # they never changed.
+    #
+    # This prevents (some) editors from complaining about files changing when we
+    # stash changes before running the hooks.
+    def store_modified_times
+      @modified_times = {}
+
+      modified_files.each do |file|
+        next if Overcommit::Utils.broken_symlink?(file)
+        @modified_times[file] = File.mtime(file)
+      end
+    end
+
+    # Restores the file modification times for all modified files to make it
+    # appear like they never changed.
+    def restore_modified_times
+      modified_files.each do |file|
+        next if Overcommit::Utils.broken_symlink?(file)
+        next unless File.exist?(file)
+        time = @modified_times[file]
+        File.utime(time, time, file)
+      end
+    end
+  end
+end

data/lib/overcommit/hook_context/run_all.rb

@@ -0,0 +1,39 @@
+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
+    EMPTY_SET = Set.new
+
+    def modified_files
+      all_files
+    end
+
+    # Return an empty set since in this context the user didn't actually touch
+    # any lines.
+    def modified_lines_in_file(_file)
+      EMPTY_SET
+    end
+
+    def hook_class_name
+      'PreCommit'
+    end
+
+    def hook_type_name
+      'pre_commit'
+    end
+
+    def hook_script_name
+      'pre-commit'
+    end
+
+    private
+
+    def all_files
+      @all_files ||= Overcommit::GitRepo.all_files
+    end
+  end
+end