overcommit 0.30.0 → 0.32.0

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
 
@@ -39,6 +42,9 @@ module Overcommit::Exceptions
   # Raised when one or more hook plugin signatures have changed.
   class InvalidHookSignature < StandardError; end
 
+  # Raised when there is a problem processing output into {Hook::Messages}s.
+  class MessageProcessingError < StandardError; end
+
   # Raised when an installation target already contains non-Overcommit hooks.
   class PreExistingHooks < StandardError; end
 end

data/lib/overcommit/git_repo.rb

@@ -266,5 +266,11 @@ module Overcommit
         split(/\s+/).
         reject { |s| s.empty? || s == '*' }
     end
+
+    # Returns the name of the currently checked out branch.
+    # @return [String]
+    def current_branch
+      `git symbolic-ref --short -q HEAD`.chomp
+    end
   end
 end

data/lib/overcommit/hook/base.rb

@@ -11,13 +11,13 @@ 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
     extend Forwardable
 
-    def_delegators :@context, :modified_files
+    def_delegators :@context, :all_files, :modified_files
     attr_reader :config
 
     # @param config [Overcommit::Configuration]
@@ -54,13 +54,21 @@ module Overcommit::Hook
     end
 
     def description
-      @config['description'] || "Running #{name}"
+      @config['description'] || "Run #{name}"
     end
 
     def required?
       @config['required']
     end
 
+    def parallelize?
+      @config['parallelize'] != false
+    end
+
+    def processors
+      @config.fetch('processors', 1)
+    end
+
     def quiet?
       @config['quiet']
     end
@@ -147,11 +155,21 @@ module Overcommit::Hook
     # 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) }.sort
+      @applicable_files ||= select_applicable(modified_files)
+    end
+
+    # Gets a list of all files that apply to this hook based on its
+    # configured `include` and `exclude` lists.
+    def included_files
+      @included_files ||= select_applicable(all_files)
     end
 
     private
 
+    def select_applicable(list)
+      list.select { |file| applicable_file?(file) }.sort
+    end
+
     def applicable_file?(file)
       includes = Array(@config['include']).flatten.map do |glob|
         Overcommit::Utils.convert_glob_to_absolute(glob)

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/commit_msg/message_format.rb

@@ -0,0 +1,27 @@
+module Overcommit::Hook::CommitMsg
+  # Ensures the commit message follows a specific format.
+  class MessageFormat < Base
+    def run
+      error_msg = validate_pattern(commit_message_lines.join("\n"))
+      return :fail, error_msg if error_msg
+
+      :pass
+    end
+
+    private
+
+    def validate_pattern(message)
+      pattern = config['pattern']
+      return if pattern.empty?
+
+      expected_pattern_message = config['expected_pattern_message']
+      sample_message = config['sample_message']
+
+      [
+        'Commit message pattern mismatch.',
+        "Expected : #{expected_pattern_message}",
+        "Sample : #{sample_message}"
+      ].join("\n") unless message =~ /#{pattern}/
+    end
+  end
+end

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

@@ -22,13 +22,16 @@ module Overcommit::Hook::PreCommit
     # @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
+    # @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 do |message|
+      output_messages.map.with_index do |message, index|
         unless match = message.match(regex)
-          raise 'Unexpected output: unable to determine line number or type ' \
-                "of error/warning for message '#{message}'"
+          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)
@@ -40,17 +43,22 @@ module Overcommit::Hook::PreCommit
     end
 
     def extract_file(match, message)
-      if match[:file].nil? || match[:file].empty?
-        raise "Unexpected output: no file found in '#{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 "Unexpected output: invalid line number found in '#{message}'"
+      raise Overcommit::Exceptions::MessageProcessingError,
+            "Unexpected output: invalid line number found in '#{message}'"
     end
 
     def extract_type(match, message, type_categorizer)
@@ -58,7 +66,8 @@ module Overcommit::Hook::PreCommit
         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 " \
+          raise Overcommit::Exceptions::MessageProcessingError,
+                "Invalid message type '#{type}' for '#{message}': must " \
                 "be one of #{Overcommit::Hook::MESSAGE_TYPES.inspect}"
         end
         type

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/es_lint.rb

@@ -1,6 +1,16 @@
 module Overcommit::Hook::PreCommit
   # Runs `eslint` against any modified JavaScript files.
   #
+  # Protip: if you have an npm script set up to run eslint, you can configure
+  # this hook to run eslint via your npm script by using the `command` option in
+  # your .overcommit.yml file. This can be useful if you have some eslint
+  # configuration built into your npm script that you don't want to repeat
+  # somewhere else. Example:
+  #
+  #   EsLint:
+  #     enabled: true
+  #     command: ['npm', 'run', 'lint']
+  #
   # @see http://eslint.org/
   class EsLint < Base
     def run

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

@@ -2,6 +2,16 @@ module Overcommit::Hook::PreCommit
   # Checks for files with execute permissions, which are usually not necessary
   # in source code files (and are typically caused by a misconfigured editor
   # assigning incorrect default permissions).
+  #
+  # Protip: if you have some files that you want to allow execute permissions
+  # on, you can disable this hook for those files by using the `exclude` option
+  # on your .overcommit.yml file. Example:
+  #
+  #   ExecutePermissions:
+  #     enabled: true
+  #     exclude:
+  #       - 'path/to/my/file/that/should/have/execute/permissions.sh'
+  #       - 'directory/that/should/have/execute/permissions/**/*'
   class ExecutePermissions < Base
     def run
       file_modes = {}

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

@@ -0,0 +1,24 @@
+module Overcommit::Hook::PreCommit
+  # Prevents commits to branches matching one of the configured patterns.
+  class ForbiddenBranches < Base
+    def run
+      return :pass unless forbidden_commit?
+
+      [:fail, "Committing to #{current_branch} is forbidden"]
+    end
+
+    private
+
+    def forbidden_commit?
+      forbidden_branch_patterns.any? { |p| File.fnmatch(p, current_branch) }
+    end
+
+    def forbidden_branch_patterns
+      @forbidden_branch_patterns ||= Array(config['branch_patterns'])
+    end
+
+    def current_branch
+      @current_branch ||= Overcommit::GitRepo.current_branch
+    end
+  end
+end

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_commit/scss_lint.rb

@@ -3,10 +3,6 @@ module Overcommit::Hook::PreCommit
   #
   # @see https://github.com/brigade/scss-lint
   class ScssLint < Base
-    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
-      type.include?('W') ? :warning : :error
-    end
-
     def run
       result = execute(command, args: applicable_files)
 
@@ -16,13 +12,30 @@ module Overcommit::Hook::PreCommit
       return :pass if [0, 81].include?(result.status)
 
       # Any status that isn't indicating lint warnings or errors indicates failure
-      return :fail, result.stdout unless [1, 2].include?(result.status)
+      return :fail, (result.stdout + result.stderr) unless [1, 2].include?(result.status)
+
+      begin
+        collect_lint_messages(JSON.parse(result.stdout))
+      rescue JSON::ParserError => ex
+        return :fail, "Unable to parse JSON returned by SCSS-Lint: #{ex.message}\n" \
+                      "STDOUT: #{result.stdout}\nSTDERR: #{result.stderr}"
+      end
+    end
+
+    private
+
+    def collect_lint_messages(files_to_lints)
+      files_to_lints.flat_map do |path, lints|
+        lints.map do |lint|
+          severity = lint['severity'] == 'warning' ? :warning : :error
+
+          message = lint['reason']
+          message = "#{lint['linter']}: #{message}" if lint['linter']
+          message = "#{path}:#{lint['line']} #{message}"
 
-      extract_messages(
-        result.stdout.split("\n"),
-        /^(?<file>(?:\w:)?[^:]+):(?<line>\d+)[^ ]* (?<type>[^ ]+)/,
-        MESSAGE_TYPE_CATEGORIZER,
-      )
+          Overcommit::Hook::Message.new(severity, path, lint['line'], message)
+        end
+      end
     end
   end
 end

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

@@ -10,5 +10,9 @@ module Overcommit::Hook::PrePush
       output = result.stdout + result.stderr
       [:fail, output]
     end
+
+    def command
+      super + included_files.map { |file| "-r#{file}" }
+    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/base.rb

@@ -79,6 +79,13 @@ module Overcommit::HookContext
       []
     end
 
+    # Returns the full list of files tracked by git
+    #
+    # @return [Array<String>]
+    def all_files
+      Overcommit::GitRepo.all_files
+    end
+
     # Returns the contents of the entire standard input stream that were passed
     # to the hook.
     #

data/lib/overcommit/hook_context/pre_commit.rb

@@ -15,6 +15,13 @@ module Overcommit::HookContext
       cmd = Overcommit::Utils.parent_command
       amend_pattern = 'commit(\s.*)?\s--amend(\s|$)'
 
+      # Since the ps command can return invalid byte sequences for commands
+      # containing unicode characters, we replace the offending characters,
+      # since the pattern we're looking for will consist of ASCII characters
+      unless cmd.valid_encoding?
+        cmd.encode!('UTF-16be', invalid: :replace, replace: '?').encode!('UTF-8')
+      end
+
       return @amendment if
         # True if the command is a commit with the --amend flag
         @amendment = !(/\s#{amend_pattern}/ =~ cmd).nil?

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_context/run_all.rb

@@ -7,7 +7,7 @@ module Overcommit::HookContext
   # which is useful for automated CI scripts.
   class RunAll < Base
     def modified_files
-      @modified_files ||= Overcommit::GitRepo.all_files
+      @modified_files ||= all_files
     end
 
     # Returns all lines in the file since in this context the entire repo is