overcommit 0.23.0 → 0.24.0

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

@@ -2,40 +2,23 @@ module Overcommit::Hook::PreCommit
   # Checks for images that can be optimized with `image_optim`.
   class ImageOptim < Base
     def run
-      begin
-        require 'image_optim'
-      rescue LoadError
-        return :fail, 'image_optim not installed -- run `gem install image_optim`'
-      end
+      result = execute(command + applicable_files)
+      return [:fail, result.stdout + result.stderr] unless result.success?
 
-      optimized_images =
-        begin
-          optimize_images(applicable_files)
-        rescue ::ImageOptim::BinResolver::BinNotFound => e
-          return :fail, "#{e.message}. The image_optim gem is dependendent on this binary."
-        end
+      optimized_files = extract_optimized_files(result.stdout)
+      return :pass if optimized_files.empty?
 
-      if optimized_images.any?
-        return :fail,
-          "The following images are optimizable:\n#{optimized_images.join("\n")}" \
-          "\n\nOptimize them by running:\n" \
-          "  image_optim --skip-missing-workers #{optimized_images.join(' ')}"
-      end
-
-      :pass
+      output = "The following images are optimizable:\n#{optimized_files.join("\n")}"
+      output += "\n\nOptimize them by running `#{command.join(' ')} #{optimized_files.join(' ')}`"
+      [:fail, output]
     end
 
     private
 
-    def optimize_images(image_paths)
-      image_optim = ::ImageOptim.new(skip_missing_workers: true)
-
-      optimized_images =
-        image_optim.optimize_images(image_paths) do |path, optimized|
-          path if optimized
-        end
-
-      optimized_images.compact
+    def extract_optimized_files(output)
+      output.split("\n").
+             select { |line| line =~ /^\d+/ }.
+             map    { |line| line.split(/\s+/).last }
     end
   end
 end

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

@@ -0,0 +1,18 @@
+module Overcommit::Hook::PreCommit
+  # Runs `jslint` against any modified JavaScript files.
+  class JsLint < Base
+    MESSAGE_REGEX = /(?<file>[^:]+):(?<line>\d+)/
+
+    def run
+      result = execute(command + applicable_files)
+      return :pass if result.success?
+
+      # example message:
+      #   path/to/file.js:1:1: Error message
+      extract_messages(
+        result.stdout.split("\n").grep(MESSAGE_REGEX),
+        MESSAGE_REGEX
+      )
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Overcommit::Hook::PreCommit
+  # Runs `jsl` against any modified JavaScript files.
+  class Jsl < Base
+    MESSAGE_REGEX = /(?<file>.+)\((?<line>\d+)\):(?<type>[^:]+)/
+
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type =~ /warning/ ? :warning : :error
+    end
+
+    def run
+      file_flags = applicable_files.map { |file| ['-process', file] }
+      result = execute(command + file_flags.flatten)
+      return :pass if result.success?
+
+      # example message:
+      #   path/to/file.js(1): lint warning: Error message
+      extract_messages(
+        result.stdout.split("\n").grep(MESSAGE_REGEX),
+        MESSAGE_REGEX,
+        MESSAGE_TYPE_CATEGORIZER
+      )
+    end
+  end
+end

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

@@ -1,22 +1,19 @@
-require 'json'
-
 module Overcommit::Hook::PreCommit
   # Checks the syntax of any modified JSON files.
   class JsonSyntax < Base
     def run
-      output = []
+      messages = []
 
       applicable_files.each do |file|
         begin
           JSON.parse(IO.read(file))
         rescue JSON::ParserError => e
-          output << "#{e.message} parsing #{file}"
+          error = "#{e.message} parsing #{file}"
+          messages << Overcommit::Hook::Message.new(:error, file, nil, error)
         end
       end
 
-      return :pass if output.empty?
-
-      [:fail, output]
+      messages
     end
   end
 end

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

@@ -37,7 +37,7 @@ module Overcommit::Hook::PreCommit
     end
 
     def schema_files
-      @schema_files    ||= applicable_files.select do |file|
+      @schema_files ||= applicable_files.select do |file|
         file.match %r{db/schema\.rb|db/structure.*\.sql}
       end
     end

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

@@ -0,0 +1,19 @@
+module Overcommit::Hook::PreCommit
+  # Runs `ruby-lint` against any modified Ruby files.
+  class RubyLint < Base
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('W') ? :warning : :error
+    end
+
+    def run
+      result = execute(command + applicable_files)
+      return :pass if result.success?
+
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>[^:]+):(?<type>[^:]+):(?<line>\d+)/,
+        MESSAGE_TYPE_CATEGORIZER
+      )
+    end
+  end
+end

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

@@ -7,7 +7,14 @@ module Overcommit::Hook::PreCommit
 
     def run
       result = execute(command + applicable_files)
-      return :pass if result.success?
+
+      # Status code 81 indicates the applicable files were all filtered by
+      # exclusions defined by the configuration. In this case, we're happy to
+      # return success since there were technically no lints.
+      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)
 
       extract_messages(
         result.stdout.split("\n"),

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

@@ -2,24 +2,10 @@ module Overcommit::Hook::PreCommit
   # Runs `w3c_validators` against any modified CSS files.
   class W3cCss < Base
     def run
-      begin
-        require 'w3c_validators'
-      rescue LoadError
-        return :fail, 'w3c_validators not installed -- run `gem install w3c_validators`'
-      end
-
-      result_messages =
-        begin
-          collect_messages
-        rescue W3CValidators::ValidatorUnavailable => e
-          return :fail, e.message
-        rescue W3CValidators::ParsingError => e
-          return :fail, e.message
-        end
-
-      return :pass if result_messages.empty?
-
-      result_messages
+      collect_messages
+    rescue W3CValidators::ParsingError,
+           W3CValidators::ValidatorUnavailable => e
+      [:fail, e.message]
     end
 
     private

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

@@ -2,24 +2,10 @@ module Overcommit::Hook::PreCommit
   # Runs `w3c_validators` against any modified HTML files.
   class W3cHtml < Base
     def run
-      begin
-        require 'w3c_validators'
-      rescue LoadError
-        return :fail, 'w3c_validators not installed -- run `gem install w3c_validators`'
-      end
-
-      result_messages =
-        begin
-          collect_messages
-        rescue W3CValidators::ValidatorUnavailable => e
-          return :fail, e.message
-        rescue W3CValidators::ParsingError => e
-          return :fail, e.message
-        end
-
-      return :pass if result_messages.empty?
-
-      result_messages
+      collect_messages
+    rescue W3CValidators::ParsingError,
+           W3CValidators::ValidatorUnavailable => e
+      [:fail, e.message]
     end
 
     private

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

@@ -0,0 +1,19 @@
+module Overcommit::Hook::PreCommit
+  # Checks the syntax of any modified XML files.
+  class XmlSyntax < Base
+    def run
+      messages = []
+
+      applicable_files.each do |file|
+        begin
+          REXML::Document.new(IO.read(file))
+        rescue REXML::ParseException => e
+          error = "Error parsing #{file}: #{e.message}"
+          messages << Overcommit::Hook::Message.new(:error, file, nil, error)
+        end
+      end
+
+      messages
+    end
+  end
+end

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

@@ -1,22 +1,18 @@
-require 'yaml'
-
 module Overcommit::Hook::PreCommit
   # Checks the syntax of any modified YAML files.
   class YamlSyntax < Base
     def run
-      output = []
+      messages = []
 
       applicable_files.each do |file|
         begin
           YAML.load_file(file)
-        rescue ArgumentError => e
-          output << "#{e.message} parsing #{file}"
+        rescue ArgumentError, Psych::SyntaxError => e
+          messages << Overcommit::Hook::Message.new(:error, file, nil, e.message)
         end
       end
 
-      return :pass if output.empty?
-
-      [:fail, output]
+      messages
     end
   end
 end

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

@@ -0,0 +1,10 @@
+require 'forwardable'
+
+module Overcommit::Hook::PrePush
+  # Functionality common to all pre-push hooks.
+  class Base < Overcommit::Hook::Base
+    extend Forwardable
+
+    def_delegators :@context, :remote_name, :remote_url, :pushed_refs
+  end
+end

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

@@ -0,0 +1,27 @@
+module Overcommit::Hook::PrePush
+  # Prevents destructive updates to specified branches.
+  class ProtectedBranches < Base
+    def run
+      return :pass unless illegal_pushes.any?
+
+      messages = illegal_pushes.map do |pushed_ref|
+        "Deleting or force-pushing to #{pushed_ref.remote_ref} is not allowed."
+      end
+
+      [:fail, messages.join("\n")]
+    end
+
+    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}" }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Overcommit::Hook::PrePush
+  # Runs `rspec` test suite before push
+  class RSpec < Base
+    def run
+      result = execute(command)
+      return :pass if result.success?
+
+      output = result.stdout + result.stderr
+      [:fail, output]
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'forwardable'
+
+module Overcommit::Hook::PreRebase
+  # Functionality common to all pre-rebase hooks.
+  class Base < Overcommit::Hook::Base
+    extend Forwardable
+
+    def_delegators :@context,
+                   :upstream_branch, :rebased_branch, :fast_forward?, :rebased_commits
+  end
+end

data/lib/overcommit/hook_context.rb

@@ -1,12 +1,12 @@
 # Utility module which manages the creation of {HookContext}s.
 module Overcommit::HookContext
-  def self.create(hook_type, config, args)
+  def self.create(hook_type, config, args, input)
     hook_type_class = Overcommit::Utils.camel_case(hook_type)
     underscored_hook_type = Overcommit::Utils.snake_case(hook_type)
 
     require "overcommit/hook_context/#{underscored_hook_type}"
 
-    Overcommit::HookContext.const_get(hook_type_class).new(config, args)
+    Overcommit::HookContext.const_get(hook_type_class).new(config, args, input)
   rescue LoadError, NameError => error
     # Could happen when a symlink was created for a hook type Overcommit does
     # not yet support.

data/lib/overcommit/hook_context/base.rb

@@ -13,9 +13,10 @@ module Overcommit::HookContext
   class Base
     # @param config [Overcommit::Configuration]
     # @param args [Array<String>]
-    def initialize(config, args)
+    def initialize(config, args, input)
       @config = config
       @args = args
+      @input = input
     end
 
     # Returns the camel-cased type of this hook (e.g. PreCommit)
@@ -58,12 +59,9 @@ module Overcommit::HookContext
       []
     end
 
-    # Returns a set of lines that have been modified for a file.
-    #
-    # By default, this returns an empty set. Subclasses should implement if
-    # there is a concept of files changing for the type of hook being run.
-    def modified_lines(_file)
-      Set.new
+    # Returns an array of lines passed to the hook via STDIN.
+    def input_lines
+      @input_lines ||= @input.read.split("\n")
     end
   end
 end

data/lib/overcommit/hook_context/pre_commit.rb

@@ -7,7 +7,30 @@ module Overcommit::HookContext
   # This includes staged files, which lines of those files have been modified,
   # etc. It is also responsible for saving/restoring the state of the repo so
   # hooks only inspect staged changes.
-  class PreCommit < Base
+  class PreCommit < Base # rubocop:disable ClassLength
+    # Returns whether this hook run was triggered by `git commit --amend`
+    def amendment?
+      return @amendment unless @amendment.nil?
+
+      cmd = Overcommit::Utils.parent_command
+      amend_pattern = 'commit(\s.*)?\s--amend(\s|$)'
+
+      return @amendment if
+        # True if the command is a commit with the --amend flag
+        @amendment = !(/\s#{amend_pattern}/ =~ cmd).nil?
+
+      # Check for git aliases that call `commit --amend`
+      `git config --get-regexp '^alias\\.' '#{amend_pattern}'`.
+        scan(/alias\.([-\w]+)/). # Extract the alias
+        each do |match|
+          return @amendment if
+            # True if the command uses a git alias for `commit --amend`
+            @amendment = !(/git\s+#{match[0]}/ =~ cmd).nil?
+        end
+
+      @amendment
+    end
+
     # Stash unstaged contents of files so hooks don't see changes that aren't
     # about to be committed.
     def setup_environment
@@ -18,9 +41,9 @@ module Overcommit::HookContext
       if !initial_commit? && any_changes?
         @stash_attempted = true
 
+        stash_message = "Overcommit: Stash of repo state before hook run at #{Time.now}"
         result = Overcommit::Utils.execute(
-          %w[git stash save --keep-index --quiet] +
-          ["Overcommit: Stash of repo state before hook run at #{Time.now}"]
+          %w[git stash save --keep-index --quiet] + [stash_message]
         )
 
         unless result.success?
@@ -31,7 +54,7 @@ module Overcommit::HookContext
                 "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
         end
 
-        @changes_stashed = true
+        @changes_stashed = `git stash list -1`.include?(stash_message)
       end
 
       # While running the hooks make it appear as if nothing changed
@@ -64,34 +87,58 @@ 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)
-    end
+      unless @modified_files
+        @modified_files = Overcommit::GitRepo.modified_files(staged: true)
 
-    # @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)
+        # Include files modified in last commit if amending
+        if amendment?
+          subcmd = 'show --format=%n'
+          @modified_files += Overcommit::GitRepo.modified_files(subcmd: subcmd)
+        end
+      end
+      @modified_files
     end
 
     # Returns the set of line numbers corresponding to the lines that were
     # changed in a specified file.
     def modified_lines_in_file(file)
       @modified_lines ||= {}
-      @modified_lines[file] ||=
-        Overcommit::GitRepo.extract_modified_lines(file, staged: true)
+      unless @modified_lines[file]
+        @modified_lines[file] =
+          Overcommit::GitRepo.extract_modified_lines(file, staged: true)
+
+        # Include lines modified in last commit if amending
+        if amendment?
+          subcmd = 'show --format=%n'
+          @modified_lines[file] +=
+            Overcommit::GitRepo.extract_modified_lines(file, subcmd: subcmd)
+        end
+      end
+      @modified_lines[file]
     end
 
     private
 
     # Clears the working tree so that the stash can be applied.
     def clear_working_tree
+      removed_submodules = Overcommit::GitRepo.staged_submodule_removals
+
       result = Overcommit::Utils.execute(%w[git reset --hard])
       unless result.success?
         raise Overcommit::Exceptions::HookCleanupFailed,
               "Unable to cleanup working tree after #{hook_script_name} hooks run:" \
               "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
       end
+
+      # Hard-resetting a staged submodule removal results in the index being
+      # reset but the submodule being restored as an empty directory. This empty
+      # directory prevents us from stashing on a subsequent run if a hook fails.
+      #
+      # Work around this by removing these empty submodule directories as there
+      # doesn't appear any reason to keep them around.
+      removed_submodules.each do |submodule|
+        FileUtils.rmdir(submodule.path)
+      end
     end
 
     # Applies the stash to the working tree to restore the user's state.
@@ -128,8 +175,12 @@ module Overcommit::HookContext
     def store_modified_times
       @modified_times = {}
 
-      modified_files.each do |file|
+      staged_files = modified_files
+      unstaged_files = Overcommit::GitRepo.modified_files(staged: false)
+
+      (staged_files + unstaged_files).each do |file|
         next if Overcommit::Utils.broken_symlink?(file)
+        next unless File.exist?(file) # Ignore renamed files (old file no longer exists)
         @modified_times[file] = File.mtime(file)
       end
     end
@@ -137,10 +188,9 @@ module Overcommit::HookContext
     # Restores the file modification times for all modified files to make it
     # appear like they never changed.
     def restore_modified_times
-      modified_files.each do |file|
+      @modified_times.each do |file, time|
         next if Overcommit::Utils.broken_symlink?(file)
         next unless File.exist?(file)
-        time = @modified_times[file]
         File.utime(time, time, file)
       end
     end