overcommit 0.30.0 → 0.32.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b041ebaa80bcfe3013027b461fd01453c6b9206
-  data.tar.gz: aa64ece4843d4d6153850d9e8e2a3bc14399257c
+  metadata.gz: b45a46c1290a6ddd0fd418f28012e7138f01470e
+  data.tar.gz: 1443470dae06fb17b84fe99823d8e2c655bdb792
 SHA512:
-  metadata.gz: c2c6d61a99022f38a43bcaa286bb5907fda839325d0334112450e45226b52b51b3b52841121ef767dbabaed8bec3d595a8129c9fabbee2691eff8f994fea9a68
-  data.tar.gz: c36a4c528cb64b8387caeeedee2dda72207da0d42fc4c92b849fd9d9c0e7ee5bfa2a3a998165fdea66a4d7c91632dcc5521b2e7d47cffc3550910480e99ad446
+  metadata.gz: 133dc22840e178a2473670780a385fb0b4c46a48d175c5ab7ad391eccfb0fc1517a1f4318f8ad91e1ef53ca40cd2925d3e3912fb203b91e8aeeb8a9285892df1
+  data.tar.gz: 0847b5f3045de5b413be8704a76fbd6fdef908a34e11b64414a58628eadc3f961d77efa1e2257ef0a7b77b6e861b2496a1ec97f5752a02cbe1f9a17fe1cd1adb

data/config/default.yml

@@ -39,6 +39,13 @@ gemfile: false
 # to the root of the repository.
 plugin_directory: '.git-hooks'
 
+# Number of hooks that can be run concurrently. Typically this won't need to be
+# adjusted, but if you know that some of your hooks themselves use multiple
+# processors you can lower this value accordingly. You can define
+# single-operator mathematical expressions, e.g. '%{processors} * 2', or
+# '%{processors} / 2'.
+concurrency: '%{processors}'
+
 # Whether to check if a hook plugin has changed since Overcommit last ran it.
 # This is a defense mechanism when working with repositories which can contain
 # untrusted code (e.g. when you fetch a pull request from a third party).
@@ -324,6 +331,13 @@ PreCommit:
     flags: ['-IHnE', "^[^#]*((\\bpath:)|(:path[ \t]*=>))"]
     include: '**/Gemfile'
 
+  Mdl:
+    enabled: false
+    description: 'Analyzing with mdl'
+    required_executable: 'mdl'
+    install_command: 'gem install mdl'
+    include: '**/*.md'
+
   MergeConflicts:
     enabled: true
     description: 'Checking for merge conflicts'
@@ -392,6 +406,7 @@ PreCommit:
     enabled: false
     description: 'Analyzing with RailsBestPractices'
     required_executable: 'rails_best_practices'
+    flags: ['--without-color']
     install_command: 'gem install rails_best_practices'
 
   RailsSchemaUpToDate:

data/lib/overcommit/configuration.rb

@@ -13,13 +13,15 @@ module Overcommit
     def initialize(hash, options = {})
       @options = options.dup
       @options[:logger] ||= Overcommit::Logger.silent
-      @hash = Overcommit::ConfigurationValidator.new.validate(hash, options)
+      @hash = hash # Assign so validator can read original values
+      unless options[:validate] == false
+        @hash = Overcommit::ConfigurationValidator.new.validate(self, hash, options)
+      end
     end
 
     def ==(other)
       super || @hash == other.hash
     end
-    alias_method :eql?, :==
 
     # Access the configuration as if it were a hash.
     #
@@ -35,6 +37,26 @@ module Overcommit
       File.join(Overcommit::Utils.repo_root, @hash['plugin_directory'] || '.git-hooks')
     end
 
+    def concurrency
+      @concurrency ||=
+        begin
+          cores = Overcommit::Utils.processor_count
+          content = @hash.fetch('concurrency', '%{processors}')
+          if content.is_a?(String)
+            concurrency_expr = content % { processors: cores }
+
+            a, op, b = concurrency_expr.scan(%r{(\d+)\s*([+\-*\/])\s*(\d+)})[0]
+            if a
+              a.to_i.send(op, b.to_i)
+            else
+              concurrency_expr.to_i
+            end
+          else
+            content.to_i
+          end
+        end
+    end
+
     # Returns configuration for all hooks in each hook type.
     #
     # @return [Hash]

data/lib/overcommit/configuration_validator.rb

@@ -3,12 +3,13 @@ module Overcommit
   class ConfigurationValidator
     # Validates hash for any invalid options, normalizing where possible.
     #
+    # @param config [Overcommit::Configuration]
     # @param hash [Hash] hash representation of YAML config
     # @param options[Hash]
     # @option default [Boolean] whether hash represents the default built-in config
     # @option logger [Overcommit::Logger] logger to output warnings to
     # @return [Hash] validated hash (potentially modified)
-    def validate(hash, options)
+    def validate(config, hash, options)
       @options = options.dup
       @log = options[:logger]
 
@@ -16,6 +17,7 @@ module Overcommit
       ensure_hook_type_sections_exist(hash)
       check_hook_name_format(hash)
       check_for_missing_enabled_option(hash) unless @options[:default]
+      check_for_too_many_processors(config, hash)
       check_for_verify_plugin_signatures_option(hash)
 
       hash
@@ -96,6 +98,31 @@ module Overcommit
       @log.newline if any_warnings
     end
 
+    # Prints a warning if any hook has a number of processors larger than the
+    # global `concurrency` setting.
+    def check_for_too_many_processors(config, hash)
+      concurrency = config.concurrency
+
+      errors = []
+      Overcommit::Utils.supported_hook_type_classes.each do |hook_type|
+        hash.fetch(hook_type, {}).each do |hook_name, hook_config|
+          processors = hook_config.fetch('processors', 1)
+          if processors > concurrency
+            errors << "#{hook_type}::#{hook_name} `processors` value " \
+                      "(#{processors}) is larger than the global `concurrency` " \
+                      "option (#{concurrency})"
+          end
+        end
+      end
+
+      if errors.any?
+        @log.error errors.join("\n") if @log
+        @log.newline if @log
+        raise Overcommit::Exceptions::ConfigurationError,
+              'One or more hooks had invalid `processor` value configured'
+      end
+    end
+
     # Prints a warning if the `verify_plugin_signatures` option is used instead
     # of the new `verify_signatures` option.
     def check_for_verify_plugin_signatures_option(hash)

data/lib/overcommit/constants.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 # Global application constants.
 module Overcommit
-  HOME = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
-  CONFIG_FILE_NAME = '.overcommit.yml'
+  HOME = File.expand_path(File.join(File.dirname(__FILE__), '..', '..')).freeze
+  CONFIG_FILE_NAME = '.overcommit.yml'.freeze
 
-  HOOK_DIRECTORY = File.join(HOME, 'lib', 'overcommit', 'hook')
+  HOOK_DIRECTORY = File.join(HOME, 'lib', 'overcommit', 'hook').freeze
 
-  REPO_URL = 'https://github.com/brigade/overcommit'
-  BUG_REPORT_URL = "#{REPO_URL}/issues"
+  REPO_URL = 'https://github.com/brigade/overcommit'.freeze
+  BUG_REPORT_URL = "#{REPO_URL}/issues".freeze
 end

data/lib/overcommit/exceptions.rb

@@ -11,6 +11,9 @@ module Overcommit::Exceptions
   # Raised when there was a problem reading submodule information for a repo.
   class GitSubmoduleError < StandardError; end
 
+  # Raised when there was a problem reading git revision information with `rev-list`.
+  class GitRevListError < StandardError; end
+
   # Raised when a {HookContext} is unable to setup the environment before a run.
   class HookSetupFailed < StandardError; end
 

data/lib/overcommit/hook/base.rb

@@ -11,7 +11,7 @@ module Overcommit::Hook
   end
 
   # Possible types of messages.
-  MESSAGE_TYPES = [:error, :warning]
+  MESSAGE_TYPES = [:error, :warning].freeze
 
   # Functionality common to all hooks.
   class Base # rubocop:disable Metrics/ClassLength
@@ -61,6 +61,14 @@ module Overcommit::Hook
       @config['required']
     end
 
+    def parallelize?
+      @config['parallelize'] != false
+    end
+
+    def processors
+      @config.fetch('processors', 1)
+    end
+
     def quiet?
       @config['quiet']
     end

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

@@ -5,7 +5,7 @@ module Overcommit::Hook::CommitMsg
       return :pass if empty_message?
 
       first_letter = commit_message_lines[0].to_s.match(/^[[:punct:]]*(.)/)[1]
-      unless first_letter.match(/[[:upper:]]/)
+      unless first_letter =~ /[[:upper:]]/
         return :warn, 'Subject should start with a capital letter'
       end
 

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

@@ -40,7 +40,9 @@ module Overcommit::Hook::PreCommit
     end
 
     def extract_file(match, message)
-      if match[:file].nil? || match[:file].empty?
+      return unless match.names.include?('file')
+
+      if match[:file].to_s.empty?
         raise "Unexpected output: no file found in '#{message}'"
       end
 
@@ -48,6 +50,7 @@ module Overcommit::Hook::PreCommit
     end
 
     def extract_line(match, message)
+      return unless match.names.include?('line')
       Integer(match[:line])
     rescue ArgumentError, TypeError
       raise "Unexpected output: invalid line number found in '#{message}'"

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Overcommit::Hook::PreCommit
   # Check if local Berksfile.lock matches Berksfile when either changes, unless
   # Berksfile.lock is ignored by git.
   #
   # @see http://berkshelf.com/
   class BerksfileCheck < Base
-    LOCK_FILE = 'Berksfile.lock'
+    LOCK_FILE = 'Berksfile.lock'.freeze
 
     def run
       # Ignore if Berksfile.lock is not tracked by git

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Overcommit::Hook::PreCommit
   # Check if local Gemfile.lock matches Gemfile when either changes, unless
   # Gemfile.lock is ignored by git.
   #
   # @see http://bundler.io/
   class BundleCheck < Base
-    LOCK_FILE = 'Gemfile.lock'
+    LOCK_FILE = 'Gemfile.lock'.freeze
 
     def run
       # Ignore if Gemfile.lock is not tracked by git

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

@@ -0,0 +1,23 @@
+module Overcommit::Hook::PreCommit
+  # Runs `mdl` against any modified Markdown files
+  #
+  # @see https://github.com/mivok/markdownlint
+  class Mdl < Base
+    MESSAGE_REGEX = /^(?<file>(?:\w:)?[^:]+):(?<line>\d+)/
+
+    def run
+      result = execute(command, args: applicable_files)
+      output = result.stdout.chomp
+
+      return :pass if result.success?
+      return [:fail, result.stderr] unless result.stderr.empty?
+
+      # example message:
+      #   path/to/file.md:1: MD001 Error message
+      extract_messages(
+        output.split("\n"),
+        MESSAGE_REGEX
+      )
+    end
+  end
+end

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

@@ -3,20 +3,31 @@ module Overcommit::Hook::PreCommit
   #
   # @see http://batsov.com/rubocop/
   class RuboCop < Base
-    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+    GENERIC_MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type =~ /^warn/ ? :warning : :error
+    end
+
+    COP_MESSAGE_TYPE_CATEGORIZER = lambda do |type|
       type.include?('W') ? :warning : :error
     end
 
     def run
       result = execute(command, args: applicable_files)
       return :pass if result.success?
-      return [:fail, result.stderr] unless result.stderr.empty?
 
-      extract_messages(
+      generic_messages = extract_messages(
+        result.stderr.split("\n"),
+        /^(?<type>[a-z]+)/i,
+        GENERIC_MESSAGE_TYPE_CATEGORIZER,
+      )
+
+      cop_messages = extract_messages(
         result.stdout.split("\n"),
         /^(?<file>(?:\w:)?[^:]+):(?<line>\d+):[^ ]+ (?<type>[^ ]+)/,
-        MESSAGE_TYPE_CATEGORIZER,
+        COP_MESSAGE_TYPE_CATEGORIZER,
       )
+
+      generic_messages + cop_messages
     end
   end
 end

data/lib/overcommit/hook/pre_push/protected_branches.rb

@@ -13,15 +13,22 @@ module Overcommit::Hook::PrePush
 
     private
 
-    def branches
-      @branches ||= config['branches']
-    end
-
     def illegal_pushes
       @illegal_pushes ||= pushed_refs.select do |pushed_ref|
-        (pushed_ref.deleted? || pushed_ref.forced?) &&
-          branches.any? { |branch| pushed_ref.remote_ref == "refs/heads/#{branch}" }
+        protected?(pushed_ref.remote_ref) && pushed_ref.destructive?
       end
     end
+
+    def protected?(remote_ref)
+      ref_name = remote_ref[%r{refs/heads/(.*)}, 1]
+      protected_branch_patterns.any? do |pattern|
+        File.fnmatch(pattern, ref_name)
+      end
+    end
+
+    def protected_branch_patterns
+      @protected_branch_patterns ||= Array(config['branches']).
+        concat(Array(config['branch_patterns']))
+    end
   end
 end

data/lib/overcommit/hook_context/pre_push.rb

@@ -30,6 +30,10 @@ module Overcommit::HookContext
         local_sha1 == '0' * 40
       end
 
+      def destructive?
+        deleted? || forced?
+      end
+
       def to_s
         "#{local_ref} #{local_sha1} #{remote_ref} #{remote_sha1}"
       end
@@ -37,7 +41,14 @@ module Overcommit::HookContext
       private
 
       def overwritten_commits
-        `git rev-list #{remote_sha1} ^#{local_sha1}`.split("\n")
+        return @overwritten_commits if defined? @overwritten_commits
+        result = Overcommit::Subprocess.spawn(%W[git rev-list #{remote_sha1} ^#{local_sha1}])
+        if result.success?
+          result.stdout.split("\n")
+        else
+          raise Overcommit::Exceptions::GitRevListError,
+                "Unable to check if commits on the remote ref will be overwritten: #{result.stderr}"
+        end
       end
     end
   end

data/lib/overcommit/hook_runner.rb

@@ -1,7 +1,7 @@
 module Overcommit
   # Responsible for loading the hooks the repository has configured and running
   # them, collecting and displaying the results.
-  class HookRunner
+  class HookRunner # rubocop:disable Metrics/ClassLength
     # @param config [Overcommit::Configuration]
     # @param logger [Overcommit::Logger]
     # @param context [Overcommit::HookContext]
@@ -12,6 +12,10 @@ module Overcommit
       @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}.
@@ -51,78 +55,120 @@ module Overcommit
       if @hooks.any?(&:enabled?)
         @printer.start_run
 
-        interrupted = false
-        run_failed = false
-        run_warned = false
-
-        @hooks.each do |hook|
-          hook_status = run_hook(hook)
+        # 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)) }
 
-          run_failed = true if hook_status == :fail
-          run_warned = true if hook_status == :warn
-
-          if hook_status == :interrupt
-            # Stop running any more hooks and assume a bad result
-            interrupted = true
-            break
+        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(run_failed, run_warned, interrupted)
+        print_results
 
-        !(run_failed || interrupted)
+        !(@failed || @interrupted)
       else
         @printer.nothing_to_run
         true # Run was successful
       end
     end
 
-    # @param failed [Boolean]
-    # @param warned [Boolean]
-    # @param interrupted [Boolean]
-    def print_results(failed, warned, interrupted)
-      if interrupted
+    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)
+          end
+        end
+      end
+    end
+
+    def release_slot(hook)
+      @lock.synchronize do
+        slots_released = processors_for_hook(hook)
+        @slots_available += slots_released
+
+        if @hooks_left.any?
+          # Signal once. `wait_for_slot` will perform additional signals if
+          # there are still slots available. This prevents us from sending out
+          # useless signals
+          @resource.signal
+        end
+      end
+    end
+
+    def processors_for_hook(hook)
+      hook.parallelize? ? hook.processors : @config.concurrency
+    end
+
+    def print_results
+      if @interrupted
         @printer.run_interrupted
-      elsif failed
+      elsif @failed
         @printer.run_failed
-      elsif warned
+      elsif @warned
         @printer.run_warned
       else
         @printer.run_succeeded
       end
     end
 
-    def run_hook(hook)
-      return if should_skip?(hook)
-
-      @printer.start_hook(hook)
-
+    def run_hook(hook) # rubocop:disable Metrics/CyclomaticComplexity
       status, output = nil, nil
 
       begin
-        # Disable the interrupt handler during individual hook run so that
-        # Ctrl-C actually stops the current hook from being run, but doesn't
-        # halt the entire process.
-        InterruptHandler.disable_until_finished_or_interrupted do
-          status, output = hook.run_and_transform
-        end
+        wait_for_slot(hook)
+        return if should_skip?(hook)
+
+        status, output = hook.run_and_transform
       rescue => ex
         status = :fail
         output = "Hook raised unexpected error\n#{ex.message}\n#{ex.backtrace.join("\n")}"
-      rescue Interrupt
-        # At this point, interrupt has been handled and protection is back in
-        # effect thanks to the InterruptHandler.
-        status = :interrupt
-        output = 'Hook was interrupted by Ctrl-C; restoring repo state...'
       end
 
-      @printer.end_hook(hook, status, output)
+      @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 unless hook.enabled?
+      return true if @interrupted || !hook.enabled?
 
       if hook.skip?
         if hook.required?

data/lib/overcommit/hook_signer.rb

@@ -5,7 +5,7 @@ module Overcommit
 
     # We don't want to include the skip setting as it is set by Overcommit
     # itself
-    IGNORED_CONFIG_KEYS = %w[skip]
+    IGNORED_CONFIG_KEYS = %w[skip].freeze
 
     # @param hook_name [String] name of the hook
     # @param config [Overcommit::Configuration]

data/lib/overcommit/message_processor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Overcommit
   # Utility class that encapsulates the handling of hook messages and whether
   # they affect lines the user has modified or not.
@@ -6,10 +8,12 @@ module Overcommit
   # output tuple from an array of {Overcommit::Hook::Message}s, respecting the
   # configuration settings for the given hook.
   class MessageProcessor
-    ERRORS_MODIFIED_HEADER = 'Errors on modified lines:'
-    WARNINGS_MODIFIED_HEADER = 'Warnings on modified lines:'
-    ERRORS_UNMODIFIED_HEADER = "Errors on lines you didn't modify:"
-    WARNINGS_UNMODIFIED_HEADER = "Warnings on lines you didn't modify:"
+    ERRORS_MODIFIED_HEADER = 'Errors on modified lines:'.freeze
+    WARNINGS_MODIFIED_HEADER = 'Warnings on modified lines:'.freeze
+    ERRORS_UNMODIFIED_HEADER = "Errors on lines you didn't modify:".freeze
+    WARNINGS_UNMODIFIED_HEADER = "Warnings on lines you didn't modify:".freeze
+    ERRORS_GENERIC_HEADER = 'Errors:'.freeze
+    WARNINGS_GENERIC_HEADER = 'Warnings:'.freeze
 
     # @param hook [Overcommit::Hook::Base]
     # @param unmodified_lines_setting [String] how to treat messages on
@@ -40,10 +44,19 @@ module Overcommit
     def handle_modified_lines(messages, status)
       messages = remove_ignored_messages(messages)
 
-      messages_on_modified_lines, messages_on_unmodified_lines =
-        messages.partition { |message| message_on_modified_line?(message) }
+      messages_with_line, generic_messages = messages.partition(&:line)
 
+      # Always print generic messages first
       output = print_messages(
+        generic_messages,
+        ERRORS_GENERIC_HEADER,
+        WARNINGS_GENERIC_HEADER
+      )
+
+      messages_on_modified_lines, messages_on_unmodified_lines =
+        messages_with_line.partition { |message| message_on_modified_line?(message) }
+
+      output += print_messages(
         messages_on_modified_lines,
         ERRORS_MODIFIED_HEADER,
         WARNINGS_MODIFIED_HEADER
@@ -54,7 +67,7 @@ module Overcommit
         WARNINGS_UNMODIFIED_HEADER
       )
 
-      [transform_status(status, messages_on_modified_lines), output]
+      [transform_status(status, generic_messages + messages_on_modified_lines), output]
     end
 
     def transform_status(status, messages_on_modified_lines)

data/lib/overcommit/os.rb

@@ -27,10 +27,10 @@ module Overcommit
       private
 
       def host_os
-        @os ||= ::RbConfig::CONFIG['host_os']
+        @os ||= ::RbConfig::CONFIG['host_os'].freeze
       end
     end
 
-    SEPARATOR = self.windows? ? '\\' : File::SEPARATOR
+    SEPARATOR = (windows? ? '\\' : File::SEPARATOR).freeze
   end
 end

data/lib/overcommit/printer.rb

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+require 'monitor'
+
 module Overcommit
   # Provide a set of callbacks which can be executed as events occur during the
   # course of {HookRunner#run}.
@@ -9,6 +11,8 @@ module Overcommit
     def initialize(logger, context)
       @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.
@@ -20,13 +24,6 @@ module Overcommit
       log.debug "✓ No applicable #{hook_script_name} hooks to run"
     end
 
-    # Executed at the start of an individual hook run.
-    def start_hook(hook)
-      unless hook.quiet?
-        print_header(hook)
-      end
-    end
-
     def hook_skipped(hook)
       log.warning "Skipping #{hook.name}"
     end
@@ -39,11 +36,16 @@ module Overcommit
     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? && status != :pass
+      print_header(hook) if !hook.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
@@ -108,5 +110,27 @@ module Overcommit
     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 do
+            __send__(old_method, *args)
+          end
+        end
+
+        self.class.__send__(:alias_method, method_name, new_method)
+      end
+    end
   end
 end

data/lib/overcommit/utils.rb

@@ -211,6 +211,42 @@ module Overcommit
         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)

data/lib/overcommit/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 # Defines the gem version.
 module Overcommit
-  VERSION = '0.30.0'
+  VERSION = '0.32.0.rc1'.freeze
 end

data/template-dir/hooks/commit-msg

@@ -30,7 +30,15 @@ require 'yaml'
 # rubocop:disable Style/RescueModifier
 if gemfile = YAML.load_file('.overcommit.yml')['gemfile'] rescue nil
   ENV['BUNDLE_GEMFILE'] = gemfile
-  require 'bundler/setup'
+  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
 

data/template-dir/hooks/overcommit-hook

@@ -30,7 +30,15 @@ require 'yaml'
 # rubocop:disable Style/RescueModifier
 if gemfile = YAML.load_file('.overcommit.yml')['gemfile'] rescue nil
   ENV['BUNDLE_GEMFILE'] = gemfile
-  require 'bundler/setup'
+  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
 

data/template-dir/hooks/post-checkout

@@ -30,7 +30,15 @@ require 'yaml'
 # rubocop:disable Style/RescueModifier
 if gemfile = YAML.load_file('.overcommit.yml')['gemfile'] rescue nil
   ENV['BUNDLE_GEMFILE'] = gemfile
-  require 'bundler/setup'
+  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
 

data/template-dir/hooks/post-commit

@@ -30,7 +30,15 @@ require 'yaml'
 # rubocop:disable Style/RescueModifier
 if gemfile = YAML.load_file('.overcommit.yml')['gemfile'] rescue nil
   ENV['BUNDLE_GEMFILE'] = gemfile
-  require 'bundler/setup'
+  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
 

data/template-dir/hooks/post-merge

@@ -30,7 +30,15 @@ require 'yaml'
 # rubocop:disable Style/RescueModifier
 if gemfile = YAML.load_file('.overcommit.yml')['gemfile'] rescue nil
   ENV['BUNDLE_GEMFILE'] = gemfile
-  require 'bundler/setup'
+  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
 

data/template-dir/hooks/post-rewrite

@@ -30,7 +30,15 @@ require 'yaml'
 # rubocop:disable Style/RescueModifier
 if gemfile = YAML.load_file('.overcommit.yml')['gemfile'] rescue nil
   ENV['BUNDLE_GEMFILE'] = gemfile
-  require 'bundler/setup'
+  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
 

data/template-dir/hooks/pre-commit

@@ -30,7 +30,15 @@ require 'yaml'
 # rubocop:disable Style/RescueModifier
 if gemfile = YAML.load_file('.overcommit.yml')['gemfile'] rescue nil
   ENV['BUNDLE_GEMFILE'] = gemfile
-  require 'bundler/setup'
+  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
 

data/template-dir/hooks/pre-push

@@ -30,7 +30,15 @@ require 'yaml'
 # rubocop:disable Style/RescueModifier
 if gemfile = YAML.load_file('.overcommit.yml')['gemfile'] rescue nil
   ENV['BUNDLE_GEMFILE'] = gemfile
-  require 'bundler/setup'
+  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
 

data/template-dir/hooks/pre-rebase

@@ -30,7 +30,15 @@ require 'yaml'
 # rubocop:disable Style/RescueModifier
 if gemfile = YAML.load_file('.overcommit.yml')['gemfile'] rescue nil
   ENV['BUNDLE_GEMFILE'] = gemfile
-  require 'bundler/setup'
+  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
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: overcommit
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.32.0.rc1
 platform: ruby
 authors:
 - Brigade Engineering
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-24 00:00:00.000000000 Z
+date: 2016-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: childprocess
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.6
+        version: 0.5.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.6
+        version: 0.5.8
 - !ruby/object:Gem::Dependency
   name: iniparse
   requirement: !ruby/object:Gem::Requirement
@@ -39,6 +39,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -155,6 +169,7 @@ files:
 - lib/overcommit/hook/pre_commit/jsl.rb
 - lib/overcommit/hook/pre_commit/json_syntax.rb
 - lib/overcommit/hook/pre_commit/local_paths_in_gemfile.rb
+- lib/overcommit/hook/pre_commit/mdl.rb
 - lib/overcommit/hook/pre_commit/merge_conflicts.rb
 - lib/overcommit/hook/pre_commit/nginx_test.rb
 - lib/overcommit/hook/pre_commit/pep257.rb
@@ -248,9 +263,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.5.1