overcommit 0.19.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 996dd0cae1610ccd8862512890ce60c917eb9998
-  data.tar.gz: 8a7a2dc6f4f36ec0d650fea031bff26a963ef510
+  metadata.gz: dcf7ae4335496b2ce26f507167d772d304a7afd2
+  data.tar.gz: 25ef2ce0e6350399b0814b94b7ac78929923b2bc
 SHA512:
-  metadata.gz: 40272621da3bd248750062ae0cb16a7c8a5e08fd3cdef1d508579ac740a4ec80a69147e121f66316f3e14c3a68297b5e572b8805fac33294e1c568814aaec3c0
-  data.tar.gz: 2321fa13f258e8d24952655e06f9a3c450a03365759c94dc4e9b60e0a2c6b087e8b7298c168c81a38a4a6577a8f8a86cd80e2f090d8f16df5d87147d10e91fff
+  metadata.gz: ab8e8e06501b756741038cc6ea651d215ffd47201390dbff2351fdc0fc668d51378402cf9f08d13ba887c50fa74cfbca7cafa954d908f5ca9f6f1405adc25eed
+  data.tar.gz: 9043450a453504dc2a41110bd184ef5d08ec4580cac9f78f29bfa5eb8cea715f84b660e1e9e024b7cad42049d564e771f2a475c93b0f33bb5c6882b2f6a9fb9c

data/config/default.yml

@@ -31,6 +31,7 @@ PostCheckout:
 # created.
 PreCommit:
   ALL:
+    problem_on_unmodified_line: warn
     requires_files: true
     required: false
     quiet: false
@@ -154,7 +155,7 @@ PreCommit:
     include: '**/*.jsx'
 
   LocalPathsInGemfile:
-    description: 'Checking for references to local paths in your Gemfile'
+    description: 'Checking for local paths in Gemfile'
     include: '**/Gemfile'
 
   MergeConflicts:

data/lib/overcommit/cli.rb

@@ -18,7 +18,14 @@ module Overcommit
         install_or_uninstall
       when :template_dir
         print_template_directory_path
+      when :sign_plugins
+        sign_plugins
+      when :run_all
+        run_all
       end
+    rescue Overcommit::Exceptions::HookContextLoadError => ex
+      puts ex
+      exit 64 # EX_USAGE
     end
 
     private
@@ -77,9 +84,18 @@ module Overcommit
       opts.on('-f', '--force', 'Overwrite any previously installed hooks') do
         @options[:force] = true
       end
+
+      opts.on('-r', '--run', 'Run pre-commit hook against all git tracked files') do
+        @options[:action] = :run_all
+      end
     end
 
     def add_other_options(opts)
+      opts.on('-s', '--sign hook', 'Update plugin signatures for hook', String) do |hook|
+        @options[:action] = :sign_plugins
+        @options[:hook_to_sign] = hook
+      end
+
       opts.on('-t', '--template-dir', 'Print location of template directory') do
         @options[:action] = :template_dir
       end
@@ -152,11 +168,35 @@ module Overcommit
         if repo_config.plugin_hook?(hook_type, hook_name)
           log.warning(' (plugin)')
         else
-          log.log
+          log.newline
         end
       end
     end
 
+    def sign_plugins
+      config = Overcommit::ConfigurationLoader.load_repo_config
+      context = Overcommit::HookContext.create(@options[:hook_to_sign],
+                                               config,
+                                               @arguments)
+      Overcommit::HookLoader::PluginHookLoader.new(config,
+                                                   context,
+                                                   log).update_signatures
+      halt
+    end
+
+    def run_all
+      config  = Overcommit::ConfigurationLoader.load_repo_config
+      context = Overcommit::HookContext.create('run-all', config, @arguments)
+      config.apply_environment!(context, ENV)
+
+      printer = Overcommit::Printer.new(log, context)
+      runner  = Overcommit::HookRunner.new(config, log, context, printer)
+
+      status = runner.run
+
+      halt(status ? 0 : 65)
+    end
+
     # Used for ease of stubbing in tests
     def halt(status = 0)
       exit status

data/lib/overcommit/configuration_validator.rb

@@ -26,7 +26,7 @@ module Overcommit
     # together, since it's easier to merge two hashes than to have to check if
     # one of the values is nil.
     def convert_nils_to_empty_hashes(hash)
-      hash.inject({}) do |h, (key, value)|
+      hash.each_with_object({}) do |(key, value), h|
         h[key] =
           case value
           when nil  then {}
@@ -34,7 +34,6 @@ module Overcommit
           else
             value
           end
-        h
       end
     end
   end

data/lib/overcommit/exceptions.rb

@@ -27,6 +27,9 @@ module Overcommit::Exceptions
   # Raised when an installation target is not a valid git repository.
   class InvalidGitRepo < StandardError; end
 
+  # Raised when one or more hook plugin signatures have changed.
+  class InvalidHookSignature < StandardError; end
+
   # Raised when an installation target already contains non-Overcommit hooks.
   class PreExistingHooks < StandardError; end
 end

data/lib/overcommit/git_repo.rb

@@ -23,7 +23,6 @@ module Overcommit
 
       `git diff --no-ext-diff -U0 #{flags} -- #{file_path}`.
         scan(DIFF_HUNK_REGEX) do |start_line, lines_added|
-
         lines_added = (lines_added || 1).to_i # When blank, one line was added
         cur_line = start_line.to_i
 
@@ -49,6 +48,15 @@ module Overcommit
         map { |relative_file| File.expand_path(relative_file) }
     end
 
+    # Returns the names of all files that are tracked by git.
+    #
+    # @return [Array<String>] list of absolute file paths
+    def all_files
+      `git ls-files`.
+        split(/\n/).
+        map { |relative_file| File.expand_path(relative_file) }
+    end
+
     # Returns whether the current git branch is empty (has no commits).
     # @return [true,false]
     def initial_commit?

data/lib/overcommit/hook/base.rb

@@ -1,6 +1,18 @@
 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
@@ -30,12 +42,38 @@ module Overcommit::Hook
       if output = check_for_executable
         status = :fail
       else
-        status, output = run
+        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
@@ -62,8 +100,7 @@ module Overcommit::Hook
 
     def run?
       enabled? &&
-        (!skip? || required?) &&
-        !(requires_modified_files? && applicable_files.empty?)
+        !(@config['requires_files'] && applicable_files.empty?)
     end
 
     def in_path?(cmd)
@@ -78,10 +115,6 @@ module Overcommit::Hook
       @config['required_executable']
     end
 
-    def install_command
-      @config['install_command']
-    end
-
     # Gets a list of staged files that apply to this hook based on its
     # configured `include` and `exclude` lists.
     def applicable_files
@@ -90,35 +123,24 @@ module Overcommit::Hook
 
     private
 
-    def requires_modified_files?
-      @config['requires_files']
-    end
-
     def applicable_file?(file)
-      includes = Array(@config['include']).map { |glob| convert_glob_to_absolute(glob) }
-      included = includes.empty? ||
-                 includes.any? { |glob| matches_path?(glob, file) }
+      includes = Array(@config['include']).map do |glob|
+        Overcommit::Utils.convert_glob_to_absolute(glob)
+      end
 
-      excludes = Array(@config['exclude']).map { |glob| convert_glob_to_absolute(glob) }
-      excluded = excludes.any? { |glob| matches_path?(glob, file) }
+      included = includes.empty? || includes.any? do |glob|
+        Overcommit::Utils.matches_path?(glob, file)
+      end
 
-      included && !excluded
-    end
+      excludes = Array(@config['exclude']).map do |glob|
+        Overcommit::Utils.convert_glob_to_absolute(glob)
+      end
 
-    def convert_glob_to_absolute(glob)
-      repo_root = Overcommit::Utils.repo_root
-      File.join(repo_root, glob)
-    end
+      excluded = excludes.any? do |glob|
+        Overcommit::Utils.matches_path?(glob, file)
+      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
-      )
+      included && !excluded
     end
 
     # If the hook defines a required executable, check if it's in the path and
@@ -128,7 +150,7 @@ module Overcommit::Hook
 
       output = "'#{executable}' is not installed (or is not in your PATH)"
 
-      if install_command
+      if install_command = @config['install_command']
         output += "\nInstall it by running: #{install_command}"
       end
 

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

@@ -3,29 +3,36 @@ module Overcommit::Hook::CommitMsg
   # under the preferred limits.
   class TextWidth < Base
     def run
-      errors = []
+      @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']
-      max_body_width = config['max_body_width']
+      return unless subject.length > max_subject_width
 
-      if commit_message_lines.first.size > max_subject_width
-        errors << "Please keep the subject <= #{max_subject_width} characters"
-      end
+      @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']
 
-      if commit_message_lines.size > 2
-        commit_message_lines[2..-1].each_with_index do |line, index|
-          chomped = line.chomp
-          if chomped.size > max_body_width
-            error = "Line #{index + 3} of commit message has > " \
+      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"
-            errors << error
-          end
         end
       end
-
-      return :warn, errors.join("\n") if errors.any?
-
-      :pass
     end
   end
 end

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

@@ -5,6 +5,66 @@ module Overcommit::Hook::PreCommit
   class Base < Overcommit::Hook::Base
     extend Forwardable
 
-    def_delegators :@context, :modified_lines
+    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

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

@@ -1,23 +1,19 @@
 module Overcommit::Hook::PreCommit
   # Runs `haml-lint` against any modified HAML files.
   class HamlLint < Base
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('W') ? :warning : :error
+    end
+
     def run
       result = execute([executable] + applicable_files)
       return :pass if result.success?
 
-      # Keep lines from the output for files that we actually modified
-      error_lines, warning_lines = result.stdout.split("\n").partition do |output_line|
-        if match = output_line.match(/^([^:]+):(\d+)/)
-          file = match[1]
-          line = match[2]
-        end
-        modified_lines(file).include?(line.to_i)
-      end
-
-      return :fail, error_lines.join("\n") unless error_lines.empty?
-
-      [:warn, "Modified files have lints (on lines you didn't modify)\n" <<
-              warning_lines.join("\n")]
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>[^:]+):(?<line>\d+)[^ ]* (?<type>[^ ]+)/,
+        MESSAGE_TYPE_CATEGORIZER,
+      )
     end
   end
 end

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

@@ -19,7 +19,7 @@ module Overcommit::Hook::PreCommit
         return :fail,
           "The following images are optimizable:\n#{optimized_images.join("\n")}" \
           "\n\nOptimize them by running:\n" \
-          "  image_optim --no-pngout #{optimized_images.join(' ')}"
+          "  image_optim --skip-missing-workers #{optimized_images.join(' ')}"
       end
 
       :pass
@@ -28,10 +28,10 @@ module Overcommit::Hook::PreCommit
     private
 
     def optimize_images(image_paths)
-      image_optim = ::ImageOptim.new(:pngout => false)
+      image_optim = ::ImageOptim.new(skip_missing_workers: true)
 
       optimized_images =
-        image_optim.optimize_images!(image_paths) do |path, optimized|
+        image_optim.optimize_images(image_paths) do |path, optimized|
           path if optimized
         end
 

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

@@ -7,22 +7,14 @@ module Overcommit::Hook::PreCommit
       return :pass if result.success?
 
       if result.status == 1
+        # No configuration was found
         return :warn, result.stderr.chomp
       end
 
-      # Keep lines from the output for files that we actually modified
-      error_lines, warning_lines = result.stdout.split("\n").partition do |output_line|
-        if match = output_line.match(/^([^:]+):[^\d]+(\d+)/)
-          file = match[1]
-          line = match[2]
-        end
-        modified_lines(file).include?(line.to_i)
-      end
-
-      return :fail, error_lines.join("\n") unless error_lines.empty?
-
-      [:warn, "Modified files have lints (on lines you didn't modify)\n" <<
-              warning_lines.join("\n")]
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>[^:]+):[^\d]+(?<line>\d+)/,
+      )
     end
   end
 end

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

@@ -7,22 +7,14 @@ module Overcommit::Hook::PreCommit
       return :pass if result.success?
 
       if result.status == 1
+        # No configuration found
         return :warn, result.stderr.chomp
       end
 
-      # Keep lines from the output for files that we actually modified
-      error_lines, warning_lines = result.stdout.split("\n").partition do |output_line|
-        if match = output_line.match(/^([^:]+):[^\d]+(\d+)/)
-          file = match[1]
-          line = match[2]
-        end
-        modified_lines(file).include?(line.to_i)
-      end
-
-      return :fail, error_lines.join("\n") unless error_lines.empty?
-
-      [:warn, "Modified files have lints (on lines you didn't modify)\n" <<
-              warning_lines.join("\n")]
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>[^:]+):[^\d]+(?<line>\d+)/,
+      )
     end
   end
 end

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

@@ -5,24 +5,17 @@ module Overcommit::Hook::PreCommit
       result = execute(%W[#{executable} --single-line --no-color] + applicable_files)
       return :pass if result.success?
 
-      output = cleanup_output(result.stdout + result.stderr)
+      output = scrub_output(result.stdout + result.stderr)
 
-      # Keep lines from the output for files that we actually modified
-      error_lines, warning_lines = output.partition do |output_line|
-        if (match = output_line.match(/^([^:]+):(\d+)/))
-          file = match[1]
-          line = match[2]
-        end
-        modified_lines(file).include?(line.to_i)
-      end
-
-      return :fail, error_lines.join("\n") unless error_lines.empty?
-
-      [:warn, "Modified files have lints (on lines you didn't modify)\n" <<
-          warning_lines.join("\n")]
+      extract_messages(
+        output,
+        /^(?<file>[^:]+):(?<line>\d+):/,
+      )
     end
 
-    def cleanup_output(raw_output)
+    private
+
+    def scrub_output(raw_output)
       raw_output.split("\n").grep(/^(.(?!warning))*$/)
     end
   end

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

@@ -1,25 +1,19 @@
 module Overcommit::Hook::PreCommit
   # Runs `rubocop` against any modified Ruby files.
   class Rubocop < Base
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('W') ? :warning : :error
+    end
+
     def run
       result = execute(%W[#{executable} --format=emacs --force-exclusion] + applicable_files)
       return :pass if result.success?
 
-      output = result.stdout + result.stderr
-
-      # Keep lines from the output for files that we actually modified
-      error_lines, warning_lines = output.split("\n").partition do |output_line|
-        if match = output_line.match(/^([^:]+):(\d+)/)
-          file = match[1]
-          line = match[2]
-        end
-        modified_lines(file).include?(line.to_i)
-      end
-
-      return :fail, error_lines.join("\n") unless error_lines.empty?
-
-      [:warn, "Modified files have lints (on lines you didn't modify)\n" <<
-              warning_lines.join("\n")]
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>[^:]+):(?<line>\d+):[^ ]+ (?<type>[^ ]+)/,
+        MESSAGE_TYPE_CATEGORIZER,
+      )
     end
   end
 end

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

@@ -1,23 +1,19 @@
 module Overcommit::Hook::PreCommit
   # Runs `scss-lint` against any modified SCSS files.
   class ScssLint < Base
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('W') ? :warning : :error
+    end
+
     def run
       result = execute([executable] + applicable_files)
       return :pass if result.success?
 
-      # Keep lines from the output for files that we actually modified
-      error_lines, warning_lines = result.stdout.split("\n").partition do |output_line|
-        if match = output_line.match(/^([^:]+):(\d+)/)
-          file = match[1]
-          line = match[2]
-        end
-        modified_lines(file).include?(line.to_i)
-      end
-
-      return :fail, error_lines.join("\n") unless error_lines.empty?
-
-      [:warn, "Modified files have lints (on lines you didn't modify)\n" <<
-              warning_lines.join("\n")]
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>[^:]+):(?<line>\d+)[^ ]* (?<type>[^ ]+)/,
+        MESSAGE_TYPE_CATEGORIZER,
+      )
     end
   end
 end

data/lib/overcommit/hook_context/base.rb

@@ -11,10 +11,11 @@ module Overcommit::HookContext
   # calculations can be memoized across all hooks in a single object, which
   # helps with performance.
   class Base
-    def initialize(config, args, input)
+    # @param config [Overcommit::Configuration]
+    # @param args [Array<String>]
+    def initialize(config, args)
       @config = config
       @args = args
-      @input = input
     end
 
     # Returns the camel-cased type of this hook (e.g. PreCommit)

data/lib/overcommit/hook_context/pre_commit.rb

@@ -64,14 +64,22 @@ module Overcommit::HookContext
     # Get a list of added, copied, or modified files that have been staged.
     # Renames and deletions are ignored, since there should be nothing to check.
     def modified_files
-      @modified_files ||= Overcommit::GitRepo.modified_files(:staged => true)
+      @modified_files ||= Overcommit::GitRepo.modified_files(staged: true)
+    end
+
+    # @deprecated
+    # TODO: Remove this once we've moved all existing hooks to stop using this
+    # endpoint
+    def modified_lines(file)
+      modified_lines_in_file(file)
     end
 
     # Returns the set of line numbers corresponding to the lines that were
     # changed in a specified file.
-    def modified_lines(file)
+    def modified_lines_in_file(file)
       @modified_lines ||= {}
-      @modified_lines[file] ||= Overcommit::GitRepo.extract_modified_lines(file, :staged => true)
+      @modified_lines[file] ||=
+        Overcommit::GitRepo.extract_modified_lines(file, staged: true)
     end
 
     private