jawshooah-overcommit 0.22.0

data/lib/overcommit/hook/base.rb

@@ -0,0 +1,174 @@
+require 'forwardable'
+require 'overcommit/message_processor'
+
+# Container for top-level hook-related classes and constants.
+module Overcommit::Hook
+  # Helper containing metadata about error/warning messages returned by hooks.
+  Message = Struct.new(:type, :file, :line, :content) do
+    def to_s
+      content
+    end
+  end
+
+  # Possible types of messages.
+  MESSAGE_TYPES = [:error, :warning]
+
+  # Functionality common to all hooks.
+  class Base
+    extend Forwardable
+
+    def_delegators :@context, :modified_files
+    attr_reader :config
+
+    # @param config [Overcommit::Configuration]
+    # @param context [Overcommit::HookContext]
+    def initialize(config, context)
+      @config = config.for_hook(self)
+      @context = context
+    end
+
+    # Runs the hook.
+    def run
+      raise NotImplementedError, 'Hook must define `run`'
+    end
+
+    # Runs the hook and transforms the status returned based on the hook's
+    # configuration.
+    #
+    # Poorly named because we already have a bunch of hooks in the wild that
+    # implement `#run`, and we needed a wrapper step to transform the status
+    # based on any custom configuration.
+    def run_and_transform
+      if output = check_for_executable
+        status = :fail
+      else
+        status, output = process_hook_return_value(run)
+      end
+
+      [transform_status(status), output]
+    end
+
+    # Converts the hook's return value into a canonical form of a tuple
+    # containing status (pass/warn/fail) and output.
+    #
+    # This is intended to support various shortcuts for writing hooks so that
+    # hook authors don't need to work with {Overcommit::Hook::Message} objects
+    # for simple pass/fail hooks. It also saves you from needing to manually
+    # encode logic like "if there are errors, fail; if there are warnings, warn,
+    # otherwise pass." by simply returning an array of
+    # {Overcommit::Hook::Message} objects.
+    #
+    # @param hook_return_value [Symbol, Array<Symbol,String>, Array<Message>]
+    # @return [Array<Symbol,String>] tuple of status and output
+    def process_hook_return_value(hook_return_value)
+      if hook_return_value.is_a?(Array) &&
+         hook_return_value.first.is_a?(Message)
+        # Process messages into a status and output
+        Overcommit::MessageProcessor.new(
+          self,
+          @config['problem_on_unmodified_line'],
+        ).hook_result(hook_return_value)
+      else
+        # Otherwise return as-is
+        hook_return_value
+      end
+    end
+
+    def name
+      self.class.name.split('::').last
+    end
+
+    def description
+      @config['description'] || "Running #{name}"
+    end
+
+    def required?
+      @config['required']
+    end
+
+    def quiet?
+      @config['quiet']
+    end
+
+    def enabled?
+      @config['enabled'] != false
+    end
+
+    def skip?
+      @config['skip']
+    end
+
+    def run?
+      enabled? &&
+        !(@config['requires_files'] && applicable_files.empty?)
+    end
+
+    def in_path?(cmd)
+      Overcommit::Utils.in_path?(cmd)
+    end
+
+    def execute(cmd)
+      Overcommit::Utils.execute(cmd)
+    end
+
+    def executable
+      @config['required_executable']
+    end
+
+    # Gets a list of staged files that apply to this hook based on its
+    # configured `include` and `exclude` lists.
+    def applicable_files
+      @applicable_files ||= modified_files.select { |file| applicable_file?(file) }
+    end
+
+    private
+
+    def applicable_file?(file)
+      includes = Array(@config['include']).map do |glob|
+        Overcommit::Utils.convert_glob_to_absolute(glob)
+      end
+
+      included = includes.empty? || includes.any? do |glob|
+        Overcommit::Utils.matches_path?(glob, file)
+      end
+
+      excludes = Array(@config['exclude']).map do |glob|
+        Overcommit::Utils.convert_glob_to_absolute(glob)
+      end
+
+      excluded = excludes.any? do |glob|
+        Overcommit::Utils.matches_path?(glob, file)
+      end
+
+      included && !excluded
+    end
+
+    # If the hook defines a required executable, check if it's in the path and
+    # display the install command if one exists.
+    def check_for_executable
+      return unless executable && !in_path?(executable)
+
+      output = "'#{executable}' is not installed (or is not in your PATH)"
+
+      if install_command = @config['install_command']
+        output += "\nInstall it by running: #{install_command}"
+      end
+
+      output
+    end
+
+    # Transforms the hook's status based on custom configuration.
+    #
+    # This allows users to change failures into warnings, or vice versa.
+    def transform_status(status)
+      case status
+      when :fail, :bad
+        @config.fetch('on_fail', :fail).to_sym
+      when :warn
+        @config.fetch('on_warn', :warn).to_sym
+      else
+        status
+      end
+    end
+  end
+end

data/lib/overcommit/hook/commit_msg/base.rb

@@ -0,0 +1,11 @@
+require 'forwardable'
+
+module Overcommit::Hook::CommitMsg
+  # Functionality common to all commit-msg hooks.
+  class Base < Overcommit::Hook::Base
+    extend Forwardable
+
+    def_delegators :@context, :commit_message, :update_commit_message,
+                   :commit_message_lines, :commit_message_file
+  end
+end

data/lib/overcommit/hook/commit_msg/gerrit_change_id.rb

@@ -0,0 +1,18 @@
+module Overcommit::Hook::CommitMsg
+  # Ensures a Gerrit Change-Id line is included in the commit message.
+  #
+  # It may seem odd to do this here instead of in a prepare-commit-msg hook, but
+  # the reality is that if you want to _ensure_ the Change-Id is included then
+  # you need to do it in a commit-msg hook. This is because the user could still
+  # edit the message after a prepare-commit-msg hook was run.
+  class GerritChangeId < Base
+    SCRIPT_LOCATION = Overcommit::Utils.script_path('gerrit-change-id')
+
+    def run
+      result = execute([SCRIPT_LOCATION, commit_message_file])
+      return :pass if result.success?
+
+      [:fail, result.stdout]
+    end
+  end
+end

data/lib/overcommit/hook/commit_msg/hard_tabs.rb

@@ -0,0 +1,13 @@
+module Overcommit::Hook::CommitMsg
+  # Checks for hard tabs in commit messages.
+  class HardTabs < Base
+    def run
+      # Catches hard tabs entered by the user (not auto-generated)
+      if commit_message.index(/\t/)
+        return :warn, "Don't use hard tabs in commit messages"
+      end
+
+      :pass
+    end
+  end
+end

data/lib/overcommit/hook/commit_msg/russian_novel.rb

@@ -0,0 +1,14 @@
+module Overcommit::Hook::CommitMsg
+  # Checks for long commit messages (not good or bad--just fun to point out)
+  class RussianNovel < Base
+    RUSSIAN_NOVEL_LENGTH = 30
+
+    def run
+      if commit_message_lines.length >= RUSSIAN_NOVEL_LENGTH
+        return :warn, 'You seem to have authored a Russian novel; congratulations!'
+      end
+
+      :pass
+    end
+  end
+end

data/lib/overcommit/hook/commit_msg/single_line_subject.rb

@@ -0,0 +1,12 @@
+module Overcommit::Hook::CommitMsg
+  # Ensures commit message subject lines are followed by a blank line.
+  class SingleLineSubject < Base
+    def run
+      unless commit_message_lines[1].to_s.strip.empty?
+        return :warn, 'Subject should be one line and followed by a blank line'
+      end
+
+      :pass
+    end
+  end
+end

data/lib/overcommit/hook/commit_msg/text_width.rb

@@ -0,0 +1,38 @@
+module Overcommit::Hook::CommitMsg
+  # Ensures the number of columns the subject and commit message lines occupy is
+  # under the preferred limits.
+  class TextWidth < Base
+    def run
+      @errors = []
+
+      find_errors_in_subject(commit_message_lines.first)
+      find_errors_in_body(commit_message_lines)
+
+      return :warn, @errors.join("\n") if @errors.any?
+
+      :pass
+    end
+
+    private
+
+    def find_errors_in_subject(subject)
+      max_subject_width = config['max_subject_width']
+      return unless subject.length > max_subject_width
+
+      @errors << "Please keep the subject <= #{max_subject_width} characters"
+    end
+
+    def find_errors_in_body(lines)
+      return unless lines.count > 2
+
+      max_body_width = config['max_body_width']
+
+      lines[2..-1].each_with_index do |line, index|
+        if line.chomp.size > max_body_width
+          @errors << "Line #{index + 3} of commit message has > " \
+                    "#{max_body_width} characters"
+        end
+      end
+    end
+  end
+end

data/lib/overcommit/hook/commit_msg/trailing_period.rb

@@ -0,0 +1,12 @@
+module Overcommit::Hook::CommitMsg
+  # Ensures commit message subject lines do not have a trailing period
+  class TrailingPeriod < Base
+    def run
+      if commit_message_lines.first.rstrip.end_with?('.')
+        return :warn, 'Please omit trailing period from commit message subject'
+      end
+
+      :pass
+    end
+  end
+end

data/lib/overcommit/hook/post_checkout/base.rb

@@ -0,0 +1,11 @@
+require 'forwardable'
+
+module Overcommit::Hook::PostCheckout
+  # Functionality common to all post-checkout hooks.
+  class Base < Overcommit::Hook::Base
+    extend Forwardable
+
+    def_delegators :@context,
+                   :previous_head, :new_head, :branch_checkout?, :file_checkout?
+  end
+end

data/lib/overcommit/hook/post_checkout/index_tags.rb

@@ -0,0 +1,26 @@
+module Overcommit::Hook::PostCheckout
+  # Scans source code each time HEAD changes to generate an up-to-date index of
+  # all function/variable definitions, etc.
+  class IndexTags < Base
+    def run
+      unless in_path?('ctags')
+        return :pass # Silently ignore
+      end
+
+      index_tags_in_background
+
+      :pass
+    end
+
+    private
+
+    SCRIPT_LOCATION = Overcommit::Utils.script_path('index-tags')
+
+    def index_tags_in_background
+      ctags_args = config['ctags_arguments']
+
+      # TODO: come up with Ruby 1.8-friendly way to do this
+      Process.detach(Process.spawn("#{SCRIPT_LOCATION} #{ctags_args}"))
+    end
+  end
+end

data/lib/overcommit/hook/post_commit/base.rb

@@ -0,0 +1,11 @@
+require 'forwardable'
+
+module Overcommit::Hook::PostCommit
+  # Functionality common to all post-commit hooks.
+  class Base < Overcommit::Hook::Base
+    extend Forwardable
+
+    def_delegators :@context, :modified_files_last_commit,
+                   :modified_lines_in_file_last_commit
+  end
+end

data/lib/overcommit/hook/post_commit/git_guilt.rb

@@ -0,0 +1,9 @@
+module Overcommit::Hook::PostCommit
+  # Calculates the change in blame since the last revision.
+  class GitGuilt < Base
+    def run
+      execute(%w[git guilt HEAD~1 HEAD])
+      :pass
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Overcommit::Hook::PreCommit
+  # Checks the format of an author's email address.
+  class AuthorEmail < Base
+    def run
+      result = execute(%w[git config --get user.email])
+      email = result.stdout.chomp
+
+      unless email =~ /#{config['pattern']}/
+        return :fail,
+               "Author has an invalid email address: '#{email}'\n" \
+               'Set your email with ' \
+               '`git config --global user.email your_email@example.com`'
+      end
+
+      :pass
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Overcommit::Hook::PreCommit
+  # Ensures that a commit author has a name with at least first and last names.
+  class AuthorName < Base
+    def run
+      result = execute(%w[git config --get user.name])
+      name = result.stdout.chomp
+
+      unless name.split(' ').count >= 2
+        return :fail,
+               "Author must have at least first and last name, but was: #{name}." \
+               "\nSet your name with `git config --global user.name 'Your Name'`"
+      end
+
+      :pass
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'forwardable'
+
+module Overcommit::Hook::PreCommit
+  # Functionality common to all pre-commit hooks.
+  class Base < Overcommit::Hook::Base
+    extend Forwardable
+
+    def_delegators :@context, :modified_lines_in_file
+
+    private
+
+    # Extract file, line number, and type of message from an error/warning
+    # messages in output.
+    #
+    # Assumes each element of `output` is a separate error/warning with all
+    # information necessary to identify it.
+    #
+    # @param output_messages [Array<String>] unprocessed error/warning messages
+    # @param regex [Regexp] regular expression defining `file`, `line` and
+    #   `type` capture groups used to extract file locations and error/warning
+    #   type from each line of output
+    # @param type_categorizer [Proc] function executed against the `type`
+    #   capture group to convert it to a `:warning` or `:error` symbol. Assumes
+    #   `:error` if `nil`.
+    # @raise [RuntimeError] line of output did not match regex
+    # @return [Array<Message>]
+    def extract_messages(output_messages, regex, type_categorizer = nil)
+      output_messages.map do |message|
+        unless match = message.match(regex)
+          raise 'Unexpected output: unable to determine line number or type ' \
+                "of error/warning for message '#{message}'"
+        end
+
+        file = extract_file(match, message)
+        line = extract_line(match, message)
+        type = extract_type(match, message, type_categorizer)
+
+        Overcommit::Hook::Message.new(type, file, line, message)
+      end
+    end
+
+    def extract_file(match, message)
+      if match[:file].nil? || match[:file].empty?
+        raise "Unexpected output: no file found in '#{message}'"
+      end
+
+      match[:file]
+    end
+
+    def extract_line(match, message)
+      Integer(match[:line])
+    rescue ArgumentError, TypeError
+      raise "Unexpected output: invalid line number found in '#{message}'"
+    end
+
+    def extract_type(match, message, type_categorizer)
+      if type_categorizer
+        type_match = match.names.include?('type') ? match[:type] : nil
+        type = type_categorizer.call(type_match)
+        unless Overcommit::Hook::MESSAGE_TYPES.include?(type)
+          raise "Invalid message type '#{type}' for '#{message}': must " \
+                "be one of #{Overcommit::Hook::MESSAGE_TYPES.inspect}"
+        end
+        type
+      else
+        :error # Assume error since no categorizer was defined
+      end
+    end
+  end
+end