overcommit-jeygeethanmedia 0.53.1

data/lib/overcommit/utils/file_utils.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'overcommit/os'
+require 'overcommit/subprocess'
+
+module Overcommit::Utils
+  # Utility functions for file IO.
+  module FileUtils
+    class << self
+      # When the host OS is Windows, uses the `mklink` command to create an
+      # NTFS symbolic link from `new_name` to `old_name`. Otherwise delegates
+      # to `File.symlink`
+      def symlink(old_name, new_name)
+        return File.symlink(old_name, new_name) unless Overcommit::OS.windows?
+
+        result = win32_mklink_cmd(old_name, new_name)
+        result.status
+      end
+
+      # When the host OS is Windows, uses the `dir` command to check whether
+      # `file_name` is an NTFS symbolic link. Otherwise delegates to
+      # `File.symlink`.
+      def symlink?(file_name)
+        return File.symlink?(file_name) unless Overcommit::OS.windows?
+
+        result = win32_dir_cmd(file_name)
+        win32_symlink?(result.stdout)
+      end
+
+      # When the host OS is Windows, uses the `dir` command to check whether
+      # `link_name` is an NTFS symbolic link. If so, it parses the target from
+      # the command output. Otherwise raises an `ArgumentError`. Delegates to
+      # `File.readlink` if the host OS is not Windows.
+      def readlink(link_name)
+        return File.readlink(link_name) unless Overcommit::OS.windows?
+
+        result = win32_dir_cmd(link_name)
+
+        unless win32_symlink?(result.stdout)
+          raise ArgumentError, "#{link_name} is not a symlink"
+        end
+
+        # Extract symlink target from output, which looks like:
+        #   11/13/2012 12:53 AM <SYMLINK> mysymlink [C:\Windows\Temp\somefile.txt]
+        result.stdout[/\[(.+)\]/, 1]
+      end
+
+      private
+
+      def win32_dir_cmd(file_name)
+        Overcommit::Subprocess.spawn(
+          %W[dir #{win32_fix_pathsep(file_name)}]
+        )
+      end
+
+      def win32_mklink_cmd(old_name, new_name)
+        Overcommit::Subprocess.spawn(
+          %W[mklink #{win32_fix_pathsep(new_name)} #{win32_fix_pathsep(old_name)}]
+        )
+      end
+
+      def win32_fix_pathsep(path)
+        path.tr(File::SEPARATOR, Overcommit::OS::SEPARATOR)
+      end
+
+      def win32_symlink?(dir_output)
+        !(dir_output =~ /<SYMLINK>/).nil?
+      end
+    end
+  end
+end

data/lib/overcommit/utils/messages_utils.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Overcommit::Utils
+  # Utility to process messages
+  module MessagesUtils
+    class << self
+      # 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 [Overcommit::Exceptions::MessageProcessingError] line of output did
+      #   not match regex
+      # @return [Array<Message>]
+      def extract_messages(output_messages, regex, type_categorizer = nil)
+        output_messages.map.with_index do |message, index|
+          unless match = message.match(regex)
+            raise Overcommit::Exceptions::MessageProcessingError,
+                  'Unexpected output: unable to determine line number or type ' \
+                  "of error/warning for output:\n" \
+                  "#{output_messages[index..-1].join("\n")}"
+          end
+
+          file = extract_file(match, message)
+          line = extract_line(match, message) if match.names.include?('line') && match[:line]
+          type = extract_type(match, message, type_categorizer)
+
+          Overcommit::Hook::Message.new(type, file, line, message)
+        end
+      end
+
+      private
+
+      def extract_file(match, message)
+        return unless match.names.include?('file')
+
+        if match[:file].to_s.empty?
+          raise Overcommit::Exceptions::MessageProcessingError,
+                "Unexpected output: no file found in '#{message}'"
+        end
+
+        match[:file]
+      end
+
+      def extract_line(match, message)
+        return unless match.names.include?('line')
+        Integer(match[:line])
+      rescue ArgumentError, TypeError
+        raise Overcommit::Exceptions::MessageProcessingError,
+              "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 Overcommit::Exceptions::MessageProcessingError,
+                  "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
+end

data/lib/overcommit/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Defines the gem version.
+module Overcommit
+  VERSION = '0.53.1'
+end

data/libexec/gerrit-change-id

@@ -0,0 +1,174 @@
+#!/bin/sh
+# From Gerrit Code Review 2.5.1
+#
+# Part of Gerrit Code Review (http://code.google.com/p/gerrit/)
+#
+# Copyright (C) 2009 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+CHANGE_ID_AFTER="Bug|Issue|Story"
+MSG="$1"
+
+# Check for, and add if missing, a unique Change-Id
+#
+add_ChangeId() {
+        clean_message=`sed -e '
+                /^diff --git a\/.*/{
+                        s///
+                        q
+                }
+                /^Signed-off-by:/d
+                /^#/d
+        ' "$MSG" | git stripspace`
+        if test -z "$clean_message"
+        then
+                return
+        fi
+
+        # Does Change-Id: already exist? if so, exit (no change).
+        if grep -i '^Change-Id:' "$MSG" >/dev/null
+        then
+                return
+        fi
+
+        id=`_gen_ChangeId`
+        T="$MSG.tmp.$$"
+        AWK=awk
+        if [ -x /usr/xpg4/bin/awk ]; then
+                # Solaris AWK is just too broken
+                AWK=/usr/xpg4/bin/awk
+        fi
+
+        # How this works:
+        # - parse the commit message as (textLine+ blankLine*)*
+        # - assume textLine+ to be a footer until proven otherwise
+        # - exception: the first block is not footer (as it is the title)
+        # - read textLine+ into a variable
+        # - then count blankLines
+        # - once the next textLine appears, print textLine+ blankLine* as these
+        #   aren't footer
+        # - in END, the last textLine+ block is available for footer parsing
+        $AWK '
+        BEGIN {
+                # while we start with the assumption that textLine+
+                # is a footer, the first block is not.
+                isFooter = 0
+                footerComment = 0
+                blankLines = 0
+        }
+
+        # Skip lines starting with "#" without any spaces before it.
+        /^#/ { next }
+
+        # Skip the line starting with the diff command and everything after it,
+        # up to the end of the file, assuming it is only patch data.
+        # If more than one line before the diff was empty, strip all but one.
+        /^diff --git a/ {
+                blankLines = 0
+                while (getline) { }
+                next
+        }
+
+        # Count blank lines outside footer comments
+        /^$/ && (footerComment == 0) {
+                blankLines++
+                next
+        }
+
+        # Catch footer comment
+        /^\[[a-zA-Z0-9-]+:/ && (isFooter == 1) {
+                footerComment = 1
+        }
+
+        /]$/ && (footerComment == 1) {
+                footerComment = 2
+        }
+
+        # We have a non-blank line after blank lines. Handle this.
+        (blankLines > 0) {
+                print lines
+                for (i = 0; i < blankLines; i++) {
+                        print ""
+                }
+
+                lines = ""
+                blankLines = 0
+                isFooter = 1
+                footerComment = 0
+        }
+
+        # Detect that the current block is not the footer
+        (footerComment == 0) && (!/^\[?[a-zA-Z0-9-]+:/ || /^[a-zA-Z0-9-]+:\/\//) {
+                isFooter = 0
+        }
+
+        {
+                # We need this information about the current last comment line
+                if (footerComment == 2) {
+                        footerComment = 0
+                }
+                if (lines != "") {
+                        lines = lines "\n";
+                }
+                lines = lines $0
+        }
+
+        # Footer handling:
+        # If the last block is considered a footer, splice in the Change-Id at the
+        # right place.
+        # Look for the right place to inject Change-Id by considering
+        # CHANGE_ID_AFTER. Keys listed in it (case insensitive) come first,
+        # then Change-Id, then everything else (eg. Signed-off-by:).
+        #
+        # Otherwise just print the last block, a new line and the Change-Id as a
+        # block of its own.
+        END {
+                unprinted = 1
+                if (isFooter == 0) {
+                        print lines "\n"
+                        lines = ""
+                }
+                changeIdAfter = "^(" tolower("'"$CHANGE_ID_AFTER"'") "):"
+                numlines = split(lines, footer, "\n")
+                for (line = 1; line <= numlines; line++) {
+                        if (unprinted && match(tolower(footer[line]), changeIdAfter) != 1) {
+                                unprinted = 0
+                                print "Change-Id: I'"$id"'"
+                        }
+                        print footer[line]
+                }
+                if (unprinted) {
+                        print "Change-Id: I'"$id"'"
+                }
+        }' "$MSG" > $T && mv $T "$MSG" || rm -f $T
+}
+_gen_ChangeIdInput() {
+        echo "tree `git write-tree`"
+        if parent=`git rev-parse "HEAD^0" 2>/dev/null`
+        then
+                echo "parent $parent"
+        fi
+        echo "author `git var GIT_AUTHOR_IDENT`"
+        echo "committer `git var GIT_COMMITTER_IDENT`"
+        echo
+        printf '%s' "$clean_message"
+}
+_gen_ChangeId() {
+        _gen_ChangeIdInput |
+        git hash-object -t commit --stdin
+}
+
+
+add_ChangeId

data/libexec/index-tags

@@ -0,0 +1,17 @@
+#!/bin/sh
+# Indexes all tags for this repository for easy navigation with Vim, storing the
+# file in <repo>/.git/tags. If you're using Fugitive.vim, you'll automatically
+# have access to the tags file; otherwise you'll have to modify your `tags`
+# option in your vimrc to search the generated file.
+
+set -e
+
+trap "rm -f $GIT_DIR/tags.$$" EXIT
+err_file=$GIT_DIR/ctags.err
+if ctags --tag-relative -Rf$GIT_DIR/tags.$$ --exclude=.git "$@" 2>${err_file}; then
+  mv $GIT_DIR/tags.$$ $GIT_DIR/tags
+  [ -e ${err_file} ] && rm -f ${err_file}
+else
+  # Ignore STDERR unless `ctags` returned a non-zero exit code
+  cat ${err_file}
+fi

data/template-dir/hooks/commit-msg

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Entrypoint for Overcommit hook integration. Installing Overcommit will result
+# in all of your git hooks being copied from this file, allowing the framework
+# to manage your hooks for you.
+
+# Prevent a Ruby stack trace from appearing when we interrupt the hook.
+# Note that this will be overridden when Overcommit is loaded, since the
+# InterruptHandler will redefine the trap at that time.
+Signal.trap('INT') do
+  puts 'Hook run interrupted'
+  exit 130
+end
+
+# Allow hooks to be disabled via environment variable so git commands can be run
+# in scripts without Overcommit running hooks
+if ENV['OVERCOMMIT_DISABLE'].to_i != 0 || ENV['OVERCOMMIT_DISABLED'].to_i != 0
+  exit
+end
+
+hook_type = File.basename($0)
+if hook_type == 'overcommit-hook'
+  puts "Don't run `overcommit-hook` directly; it is intended to be symlinked " \
+       "by each hook in a repository's .git/hooks directory."
+  exit 64 # EX_USAGE
+end
+
+# Check if Overcommit should invoke a Bundler context for loading gems
+require 'yaml'
+# rubocop:disable Style/RescueModifier
+if gemfile = YAML.load_file('.overcommit.yml')['gemfile'] rescue nil
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  require 'bundler'
+
+  begin
+    Bundler.setup
+  rescue Bundler::BundlerError => ex
+    puts "Problem loading '#{gemfile}': #{ex.message}"
+    puts "Try running:\nbundle install --gemfile=#{gemfile}" if ex.is_a?(Bundler::GemNotFound)
+    exit 78 # EX_CONFIG
+  end
+end
+# rubocop:enable Style/RescueModifier
+
+begin
+  require 'overcommit'
+rescue LoadError
+  if gemfile
+    puts 'You have specified the `gemfile` option in your Overcommit ' \
+         'configuration but have not added the `overcommit` gem to ' \
+         "#{gemfile}."
+  else
+    puts 'This repository contains hooks installed by Overcommit, but the ' \
+         "`overcommit` gem is not installed.\n" \
+         'Install it with `gem install overcommit`.'
+  end
+
+  exit 64 # EX_USAGE
+end
+
+begin
+  logger = Overcommit::Logger.new(STDOUT)
+  Overcommit::Utils.log = logger
+
+  # Ensure master hook is up-to-date
+  installer = Overcommit::Installer.new(logger)
+  if installer.run(Overcommit::Utils.repo_root, action: :update)
+    exec($0, *ARGV) # Execute the updated hook with all original arguments
+  end
+
+  config = Overcommit::ConfigurationLoader.new(logger).load_repo_config
+
+  context = Overcommit::HookContext.create(hook_type, config, ARGV, STDIN)
+  config.apply_environment!(context, ENV)
+
+  printer = Overcommit::Printer.new(config, logger, context)
+  runner = Overcommit::HookRunner.new(config, logger, context, printer)
+
+  status = runner.run
+
+  exit(status ? 0 : 65) # 65 = EX_DATAERR
+rescue Overcommit::Exceptions::ConfigurationError => error
+  puts error
+  exit 78 # EX_CONFIG
+rescue Overcommit::Exceptions::HookContextLoadError => error
+  puts error
+  puts 'Are you running an old version of Overcommit?'
+  exit 69 # EX_UNAVAILABLE
+rescue Overcommit::Exceptions::HookLoadError,
+       Overcommit::Exceptions::InvalidHookDefinition => error
+  puts error.message
+  puts error.backtrace
+  exit 78 # EX_CONFIG
+rescue Overcommit::Exceptions::HookSetupFailed,
+       Overcommit::Exceptions::HookCleanupFailed => error
+  puts error.message
+  exit 74 # EX_IOERR
+rescue Overcommit::Exceptions::HookCancelled
+  puts 'You cancelled the hook run'
+  exit 130 # Ctrl-C cancel
+rescue Overcommit::Exceptions::InvalidGitRepo => error
+  puts error
+  exit 64 # EX_USAGE
+rescue Overcommit::Exceptions::ConfigurationSignatureChanged => error
+  puts error
+  puts "For more information, see #{Overcommit::REPO_URL}#security"
+  exit 1
+rescue Overcommit::Exceptions::InvalidHookSignature
+  exit 1
+rescue StandardError => error
+  puts error.message
+  puts error.backtrace
+  puts "Report this bug at #{Overcommit::BUG_REPORT_URL}"
+  exit 70 # EX_SOFTWARE
+end