overcommit-jeygeethanmedia 0.53.1

data/lib/overcommit/os.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+module Overcommit
+  # Methods relating to the current operating system
+  module OS
+    class << self
+      def windows?
+        !(/mswin|msys|mingw|bccwin|wince|emc/ =~ host_os).nil?
+      end
+
+      def cygwin?
+        !(/cygwin/ =~ host_os).nil?
+      end
+
+      def mac?
+        !(/darwin|mac os/ =~ host_os).nil?
+      end
+
+      def unix?
+        !windows?
+      end
+
+      def linux?
+        unix? && !mac? && !cygwin?
+      end
+
+      private
+
+      def host_os
+        @host_os ||= ::RbConfig::CONFIG['host_os'].freeze
+      end
+    end
+
+    SEPARATOR = (windows? ? '\\' : File::SEPARATOR).freeze
+  end
+end

data/lib/overcommit/printer.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'monitor'
+
+module Overcommit
+  # Provide a set of callbacks which can be executed as events occur during the
+  # course of {HookRunner#run}.
+  class Printer
+    attr_reader :log
+
+    def initialize(config, logger, context)
+      @config = config
+      @log = logger
+      @context = context
+      @lock = Monitor.new # Need to use monitor so we can have re-entrant locks
+      synchronize_all_methods
+    end
+
+    # Executed at the very beginning of running the collection of hooks.
+    def start_run
+      log.bold "Running #{hook_script_name} hooks" unless @config['quiet']
+    end
+
+    def nothing_to_run
+      log.debug "✓ No applicable #{hook_script_name} hooks to run"
+    end
+
+    def hook_skipped(hook)
+      log.warning "Skipping #{hook.name}"
+    end
+
+    def required_hook_not_skipped(hook)
+      log.warning "Cannot skip #{hook.name} since it is required"
+    end
+
+    # Executed at the end of an individual hook run.
+    def end_hook(hook, status, output)
+      # Want to print the header for quiet hooks only if the result wasn't good
+      # so that the user knows what failed
+      print_header(hook) if (!hook.quiet? && !@config['quiet']) || status != :pass
+
+      print_result(hook, status, output)
+    end
+
+    def interrupt_triggered
+      log.newline
+      log.error 'Interrupt signal received. Stopping hooks...'
+    end
+
+    # Executed when a hook run was interrupted/cancelled by user.
+    def run_interrupted
+      log.newline
+      log.warning '⚠  Hook run interrupted by user'
+      log.warning '⚠  If files appear modified/missing, check your stash to recover them'
+      log.newline
+    end
+
+    # Executed when one or more hooks by the end of the run.
+    def run_failed
+      log.newline
+      log.error "✗ One or more #{hook_script_name} hooks failed"
+      log.newline
+    end
+
+    # Executed when no hooks failed by the end of the run, but some warned.
+    def run_warned
+      log.newline
+      log.warning "⚠ All #{hook_script_name} hooks passed, but with warnings"
+      log.newline
+    end
+
+    # Executed when no hooks failed by the end of the run.
+    def run_succeeded
+      unless @config['quiet']
+        log.newline
+        log.success "✓ All #{hook_script_name} hooks passed"
+        log.newline
+      end
+    end
+
+    def hook_run_failed(message)
+      log.newline
+      log.log message
+      log.newline
+    end
+
+    private
+
+    def print_header(hook)
+      hook_name = "[#{hook.name}] "
+      log.partial hook.description
+      log.partial '.' * [70 - hook.description.length - hook_name.length, 0].max
+      log.partial hook_name
+    end
+
+    def print_result(hook, status, output) # rubocop:disable Metrics/CyclomaticComplexity
+      case status
+      when :pass
+        log.success 'OK' unless @config['quiet'] || hook.quiet?
+        print_report(output)
+      when :warn
+        log.warning 'WARNING'
+        print_report(output, :bold_warning)
+      when :fail
+        log.error 'FAILED'
+        print_report(output, :bold_error)
+      when :interrupt
+        log.error 'INTERRUPTED'
+        print_report(output, :bold_error)
+      else
+        log.error '???'
+        print_report("Hook returned unknown status `#{status.inspect}` -- ignoring.",
+                     :bold_error)
+      end
+    end
+
+    def print_report(output, format = :log)
+      log.send(format, output) unless output.nil? || output.empty?
+    end
+
+    def hook_script_name
+      @context.hook_script_name
+    end
+
+    # Get all public methods that were defined on this class and wrap them with
+    # synchronization locks so we ensure the output isn't interleaved amongst
+    # the various threads.
+    def synchronize_all_methods
+      methods = self.class.instance_methods - self.class.superclass.instance_methods
+
+      methods.each do |method_name|
+        old_method = :"old_#{method_name}"
+        new_method = :"synchronized_#{method_name}"
+
+        self.class.__send__(:alias_method, old_method, method_name)
+
+        self.class.send(:define_method, new_method) do |*args|
+          @lock.synchronize { __send__(old_method, *args) }
+        end
+
+        self.class.__send__(:alias_method, method_name, new_method)
+      end
+    end
+  end
+end

data/lib/overcommit/subprocess.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'childprocess'
+require 'tempfile'
+
+module Overcommit
+  # Manages execution of a child process, collecting the exit status and
+  # standard out/error output.
+  class Subprocess
+    # Encapsulates the result of a process.
+    #
+    # @attr_reader status [Integer] exit status code returned by process
+    # @attr_reader stdout [String] standard output stream output
+    # @attr_reader stderr [String] standard error stream output
+    Result = Struct.new(:status, :stdout, :stderr) do
+      def success?
+        status == 0
+      end
+    end
+
+    class << self
+      # Spawns a new process using the given array of arguments (the first
+      # element is the command).
+      #
+      # @param args [Array<String>]
+      # @param options [Hash]
+      # @option options [String] input string to pass via standard input stream
+      # @return [Result]
+      def spawn(args, options = {})
+        args = win32_prepare_args(args) if OS.windows?
+
+        process = ChildProcess.build(*args)
+
+        out, err = assign_output_streams(process)
+
+        process.duplex = true if options[:input] # Make stdin available if needed
+        process.start
+        if options[:input]
+          begin
+            process.io.stdin.puts(options[:input])
+          rescue StandardError # rubocop:disable Lint/HandleExceptions
+            # Silently ignore if the standard input stream of the spawned
+            # process is closed before we get a chance to write to it. This
+            # happens on JRuby a lot.
+          ensure
+            process.io.stdin.close
+          end
+        end
+        process.wait
+
+        err.rewind
+        out.rewind
+
+        Result.new(process.exit_code, out.read, err.read)
+      end
+
+      # Spawns a new process in the background using the given array of
+      # arguments (the first element is the command).
+      def spawn_detached(args)
+        args = win32_prepare_args(args) if OS.windows?
+
+        process = ChildProcess.build(*args)
+        process.detach = true
+
+        assign_output_streams(process)
+
+        process.start
+      end
+
+      private
+
+      # Necessary to run commands in the cmd.exe context.
+      # Args are joined to properly handle quotes and special characters.
+      def win32_prepare_args(args)
+        args = args.map do |arg|
+          # Quote args that contain whitespace
+          arg = "\"#{arg}\"" if arg =~ /\s/
+
+          # Escape cmd.exe metacharacters
+          arg.gsub(/[()%!^"<>&|]/, '^\0')
+        end
+
+        %w[cmd.exe /c] + [args.join(' ')]
+      end
+
+      # @param process [ChildProcess]
+      # @return [Array<IO>]
+      def assign_output_streams(process)
+        %w[out err].map do |stream_name|
+          ::Tempfile.new(stream_name).tap do |stream|
+            stream.sync = true
+            process.io.send("std#{stream_name}=", stream)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/overcommit/utils.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'overcommit/os'
+require 'overcommit/subprocess'
+require 'overcommit/command_splitter'
+require 'tempfile'
+
+module Overcommit
+  # Utility functions for general use.
+  module Utils
+    # Helper class for doing quick constraint validations on version numbers.
+    #
+    # This allows us to execute code based on the git version.
+    class Version < Gem::Version
+      # Overload comparison operators so we can conveniently compare this
+      # version directly to a string in code.
+      %w[< <= > >= == !=].each do |operator|
+        define_method operator do |version|
+          case version
+          when String
+            super(Gem::Version.new(version))
+          else
+            super(version)
+          end
+        end
+      end
+    end
+
+    class << self
+      # @return [Overcommit::Logger] logger with which to send debug output
+      attr_accessor :log
+
+      def script_path(script)
+        File.join(Overcommit::HOME, 'libexec', script)
+      end
+
+      # Returns an absolute path to the root of the repository.
+      #
+      # We do this ourselves rather than call `git rev-parse --show-toplevel` to
+      # solve an issue where the .git directory might not actually be valid in
+      # tests.
+      #
+      # @return [String]
+      def repo_root
+        @repo_root ||=
+          begin
+            result = execute(%w[git rev-parse --show-toplevel])
+            unless result.success?
+              raise Overcommit::Exceptions::InvalidGitRepo,
+                    'Unable to determine location of GIT_DIR. ' \
+                    'Not a recognizable Git repository!'
+            end
+            result.stdout.chomp("\n")
+          end
+      end
+
+      # Returns an absolute path to the .git directory for a repo.
+      #
+      # @return [String]
+      def git_dir
+        @git_dir ||=
+          begin
+            cmd = %w[git rev-parse]
+            cmd << (GIT_VERSION < '2.5' ? '--git-dir' : '--git-common-dir')
+            result = execute(cmd)
+            unless result.success?
+              raise Overcommit::Exceptions::InvalidGitRepo,
+                    'Unable to determine location of GIT_DIR. ' \
+                    'Not a recognizable Git repository!'
+            end
+            File.expand_path(result.stdout.chomp("\n"), Dir.pwd)
+          end
+      end
+
+      # Remove ANSI escape sequences from a string.
+      #
+      # This is useful for stripping colorized output from external tools.
+      #
+      # @param text [String]
+      # @return [String]
+      def strip_color_codes(text)
+        text.gsub(/\e\[(\d+)(;\d+)*m/, '')
+      end
+
+      # Shamelessly stolen from:
+      # stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
+      def snake_case(str)
+        str.gsub(/::/, '/').
+            gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+            gsub(/([a-z\d])([A-Z])/, '\1_\2').
+            tr('-', '_').
+            downcase
+      end
+
+      # Converts a string containing underscores/hyphens/spaces into CamelCase.
+      def camel_case(str)
+        str.split(/_|-| /).map { |part| part.sub(/^\w/, &:upcase) }.join
+      end
+
+      # Returns a list of supported hook types (pre-commit, commit-msg, etc.)
+      def supported_hook_types
+        Dir[File.join(HOOK_DIRECTORY, '*')].
+          select { |file| File.directory?(file) }.
+          reject { |file| File.basename(file) == 'shared' }.
+          map { |file| File.basename(file).tr('_', '-') }
+      end
+
+      # Returns a list of supported hook classes (PreCommit, CommitMsg, etc.)
+      def supported_hook_type_classes
+        supported_hook_types.map do |file|
+          file.split('-').map(&:capitalize).join
+        end
+      end
+
+      # @param cmd [String]
+      # @return [true,false] whether a command can be found given the current
+      #   environment path.
+      def in_path?(cmd)
+        # ENV['PATH'] doesn't include the repo root, but that is a valid
+        # location for executables, so we want to add it to the list of places
+        # we are checking for the executable.
+        paths = [repo_root] + ENV['PATH'].split(File::PATH_SEPARATOR)
+        exts  = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        paths.each do |path|
+          exts.each do |ext|
+            cmd_with_ext = cmd.upcase.end_with?(ext.upcase) ? cmd : "#{cmd}#{ext}"
+            full_path = File.join(path, cmd_with_ext)
+            return true if File.executable?(full_path)
+          end
+        end
+        false
+      end
+
+      # Return the parent command that triggered this hook run
+      #
+      # @return [String,nil] the command as a string, if a parent exists.
+      def parent_command
+        # When run in Docker containers, there may be no parent process.
+        return if Process.ppid.zero?
+
+        if OS.windows?
+          `wmic process where ProcessId=#{Process.ppid} get CommandLine /FORMAT:VALUE`.
+            strip.
+            slice(/(?<=CommandLine=).+/)
+        elsif OS.cygwin?
+          # Cygwin's `ps` command behaves differently than the traditional
+          # Linux version, but a comparable `procps` is provided to compensate.
+          `procps -ocommand= -p #{Process.ppid}`.chomp
+        else
+          `ps -ocommand= -p #{Process.ppid}`.chomp
+        end
+      end
+
+      # Execute a command in a subprocess, capturing exit status and output from
+      # both standard and error streams.
+      #
+      # This is intended to provide a centralized place to perform any checks or
+      # filtering of the command before executing it.
+      #
+      # The `args` option provides a convenient way of splitting up long
+      # argument lists which would otherwise exceed the maximum command line
+      # length of the OS. It will break up the list into chunks and run the
+      # command with the same prefix `initial_args`, finally combining the
+      # output together at the end.
+      #
+      # This requires that the external command you are running can have its
+      # work split up in this way and still produce the same resultant output
+      # when outputs of the individual commands are concatenated back together.
+      #
+      # @param initial_args [Array<String>]
+      # @param options [Hash]
+      # @option options [Array<String>] :args long list of arguments to split up
+      # @return [Overcommit::Subprocess::Result] status, stdout, and stderr
+      def execute(initial_args, options = {})
+        if initial_args.include?('|')
+          raise Overcommit::Exceptions::InvalidCommandArgs,
+                'Cannot pipe commands with the `execute` helper'
+        end
+
+        result =
+          if (splittable_args = options.fetch(:args) { [] }).any?
+            debug(initial_args.join(' ') + " ... (#{splittable_args.length} splittable args)")
+            Overcommit::CommandSplitter.execute(initial_args, options)
+          else
+            debug(initial_args.join(' '))
+            Overcommit::Subprocess.spawn(initial_args, options)
+          end
+
+        debug("EXIT STATUS: #{result.status}")
+        debug("STDOUT: #{result.stdout.inspect}")
+        debug("STDERR: #{result.stderr.inspect}")
+
+        result
+      end
+
+      # Execute a command in a subprocess, returning immediately.
+      #
+      # This provides a convenient way to execute long-running processes for
+      # which we do not need to know the result.
+      #
+      # @param args [Array<String>]
+      # @return [ChildProcess] detached process spawned in the background
+      def execute_in_background(args)
+        if args.include?('|')
+          raise Overcommit::Exceptions::InvalidCommandArgs,
+                'Cannot pipe commands with the `execute_in_background` helper'
+        end
+
+        debug("Spawning background task: #{args.join(' ')}")
+        Subprocess.spawn_detached(args)
+      end
+
+      # Return the number of processors used by the OS for process scheduling.
+      #
+      # @see https://github.com/grosser/parallel/blob/v1.6.1/lib/parallel/processor_count.rb#L17-L51
+      def processor_count # rubocop:disable all
+        @processor_count ||=
+          begin
+            if Overcommit::OS.windows?
+              require 'win32ole'
+              result = WIN32OLE.connect('winmgmts://').ExecQuery(
+                'select NumberOfLogicalProcessors from Win32_Processor'
+              )
+              result.to_enum.collect(&:NumberOfLogicalProcessors).reduce(:+)
+            elsif File.readable?('/proc/cpuinfo')
+              IO.read('/proc/cpuinfo').scan(/^processor/).size
+            elsif File.executable?('/usr/bin/hwprefs')
+              IO.popen('/usr/bin/hwprefs thread_count').read.to_i
+            elsif File.executable?('/usr/sbin/psrinfo')
+              IO.popen('/usr/sbin/psrinfo').read.scan(/^.*on-*line/).size
+            elsif File.executable?('/usr/sbin/ioscan')
+              IO.popen('/usr/sbin/ioscan -kC processor') do |out|
+                out.read.scan(/^.*processor/).size
+              end
+            elsif File.executable?('/usr/sbin/pmcycles')
+              IO.popen('/usr/sbin/pmcycles -m').read.count("\n")
+            elsif File.executable?('/usr/sbin/lsdev')
+              IO.popen('/usr/sbin/lsdev -Cc processor -S 1').read.count("\n")
+            elsif File.executable?('/usr/sbin/sysctl')
+              IO.popen('/usr/sbin/sysctl -n hw.ncpu').read.to_i
+            elsif File.executable?('/sbin/sysctl')
+              IO.popen('/sbin/sysctl -n hw.ncpu').read.to_i
+            else
+              # Unknown platform; assume 1 processor
+              1
+            end
+          end
+      end
+
+      # Calls a block of code with a modified set of environment variables,
+      # restoring them once the code has executed.
+      def with_environment(env)
+        old_env = {}
+        env.each do |var, value|
+          old_env[var] = ENV[var.to_s]
+          ENV[var.to_s] = value
+        end
+
+        yield
+      ensure
+        old_env.each { |var, value| ENV[var.to_s] = value }
+      end
+
+      # Returns whether a file is a broken symlink.
+      #
+      # @return [true,false]
+      def broken_symlink?(file)
+        # JRuby's implementation of File.exist? returns true for broken
+        # symlinks, so we need use File.size?
+        Overcommit::Utils::FileUtils.symlink?(file) && File.size?(file).nil?
+      end
+
+      # Convert a glob pattern to an absolute path glob pattern rooted from the
+      # repository root directory.
+      #
+      # @param glob [String]
+      # @return [String]
+      def convert_glob_to_absolute(glob)
+        File.join(repo_root, glob)
+      end
+
+      # Return whether a pattern matches the given path.
+      #
+      # @param pattern [String]
+      # @param path [String]
+      def matches_path?(pattern, path)
+        File.fnmatch?(
+          pattern, path,
+          File::FNM_PATHNAME | # Wildcard doesn't match separator
+          File::FNM_DOTMATCH   # Wildcards match dotfiles
+        )
+      end
+
+      private
+
+      # Log debug output.
+      #
+      # This is necessary since some specs indirectly call utility functions but
+      # don't explicitly set the logger for the Utils class, so we do a quick
+      # check here to see if it's set before we attempt to log.
+      #
+      # @param args [Array<String>]
+      def debug(*args)
+        log&.debug(*args)
+      end
+    end
+  end
+end