overcommit 0.26.0 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f071e1a8038ef082833913a8eb83e6bfb44b371
-  data.tar.gz: eb442b2dc4457f8173f9fff48572f575839c39e9
+  metadata.gz: b15d613ceeafdf7cf3c762c611b309b596bf9fd9
+  data.tar.gz: 89d01be1ecf271fc7f8f6b6472fb6e056e8980c7
 SHA512:
-  metadata.gz: c2e2faad1aea169d67e252967d22397bf05a4511fdb5247a57f3b2d12e66fa186ea594a24819619e648d56d90b30a965e643027e320e8b4340c785f31e6ae4b9
-  data.tar.gz: a8b53b06f1ab3b4eb6cbf31cf77abfdf053a7af1719f2b0e1482ca5c1e4ea62082357d00a921415286f8340675e9734cad1d73d0a69fd0dd261bf6194ef43b27
+  metadata.gz: 5a665c68e8e3066f1f4f2b62997474b20f910360a7aadf2b24d5c2caad64260a3c2f485ffbd9174b7681fbd24a743a07a97820a2c4fed38e5d54c00c95ceccd8
+  data.tar.gz: a570dcdcf2ac15e352f837ebb404819f197d74428881586f2c2eec1f6a4f4eebfbf5e4c80536cb38fe2a6ca941b5de129357ae0437c8b739a747738a4f2d1baf

data/config/default.yml

@@ -2,6 +2,37 @@
 #
 # This is an opinionated list of which hooks are valuable to run and what their
 # out-of-the-box settings should be.
+#-------------------------------------------------------------------------------
+
+# Loads Bundler context from a Gemfile. If false, does nothing (default).
+#
+# Specifying a Gemfile for Bundler to load allows you to control which gems are
+# available in the load path (i.e. loadable via `require`) within your hook
+# runs. Note that having a Gemfile requires you to include `overcommit` itself
+# in your Gemfile (otherwise Overcommit can't load itself!).
+#
+# This is useful if you want to:
+#
+#   - Enforce a specific version of Overcommit to use for all hook runs
+#     (or to use a version from the master branch that has not been released yet)
+#   - Enforce a specific version or unreleased branch is used for a gem you want
+#     to use in your git hooks
+#
+# WARNING: This makes your hook runs slower, but you can work around this!
+#
+# Loading a Bundler context necessarily adds a startup delay to your hook runs
+# as Bundler parses the Gemfile and checks that the dependencies are satisfied.
+# Thus for projects with many gems this can introduce a noticeable delay.
+#
+# The recommended workaround is to create a separate Gemfile in the root of your
+# repository (call it `.overcommit_gems.rb`), and include only the gems that
+# your Overcommit hooks need in order to run. This significantly reduces the
+# startup delay in your hook runs. Make sure to commit both
+# `.overcommit_gems.rb` and the resulting `.overcommit_gems.rb.lock` file to
+# your repository, and then set the `gemfile` option below to the name you gave
+# the file.
+# (Generate lock file by running `bundle install --gemfile=.overcommit_gems.rb`)
+gemfile: false
 
 # Where to store hook plugins specific to a repository. These are loaded in
 # addition to the default hooks Overcommit comes with. The location is relative
@@ -195,6 +226,13 @@ PreCommit:
     required_executable: 'grep'
     flags: ['-IHn', "\t"]
 
+  HtmlHint:
+    enabled: false
+    description: 'Analyzing with HTMLHint'
+    required_executable: 'htmlhint'
+    install_command: 'npm install -g htmlhint'
+    include: '**/*.html'
+
   HtmlTidy:
     enabled: false
     description: 'Analyzing HTML with tidy'

data/config/starter.yml

@@ -17,6 +17,7 @@
 
 #PreCommit:
 #  RuboCop:
+#    enabled: true
 #    on_warn: fail # Treat all warnings as failures
 #
 #  TrailingWhitespace:
@@ -25,7 +26,7 @@
 #
 #PostCheckout:
 #  ALL: # Special hook name that customizes all hooks of this type
-#   quiet: true # Change all post-checkout hooks to only display output on failure
+#    quiet: true # Change all post-checkout hooks to only display output on failure
 #
 #  IndexTags:
 #    enabled: true # Generate a tags file with `ctags` each time HEAD changes

data/lib/overcommit/cli.rb

@@ -9,6 +9,8 @@ module Overcommit
       @input     = input
       @log       = logger
       @options   = {}
+
+      Overcommit::Utils.log = logger
     end
 
     def run

data/lib/overcommit/command_splitter.rb

@@ -0,0 +1,144 @@
+module Overcommit
+  # Distributes a list of arguments over multiple invocations of a command.
+  #
+  # This accomplishes the same functionality provided by `xargs` but in a
+  # cross-platform way that does not require any pre-existing tools.
+  #
+  # One of the tradeoffs with this approach is that we no longer deal with a
+  # single exit status from a command, but multiple (one for each invocation).
+  #
+  # This will return a struct similar to `Subprocess::Result` but with
+  # additional `statuses`, `stdouts`, and `stderrs` fields so hook authors can
+  # actually see the results of each invocation. If they don't care, the
+  # standard `status`, `stdout`, and `stderr` will still work but be a
+  # aggregation/concatenation of all statuses/outputs.
+  class CommandSplitter
+    # Encapsulates the result of a split argument run.
+    #
+    # @attr_reader statuses [Array<Integer>] status codes for invocations
+    # @attr_reader stdouts [Array<String>] standard outputs from invocations
+    # @attr_reader stderrs [Array<String>] standard error outputs from invocations
+    Result = Struct.new(:statuses, :stdouts, :stderrs) do
+      # Returns whether all invocations were successful.
+      #
+      # @return [true,false]
+      def success?
+        status == 0
+      end
+
+      # Returns `0` if all invocations returned `0`; `1` otherwise.
+      #
+      # @return [true,false]
+      def status
+        statuses.all? { |code| code == 0 } ? 0 : 1
+      end
+
+      # Returns concatenated standard output streams of all invocations in the
+      # order they were executed.
+      #
+      # @return [String]
+      def stdout
+        stdouts.join
+      end
+
+      # Returns concatenated standard error streams of all invocations in the
+      # order they were executed.
+      #
+      # @return [String]
+      def stderr
+        stderrs.join
+      end
+    end
+
+    class << self
+      def execute(initial_args, options)
+        options = options.dup
+
+        if (splittable_args = (options.delete(:args) { [] })).empty?
+          raise Overcommit::Exceptions::InvalidCommandArgs,
+                'Must specify list of arguments to split on'
+        end
+
+        # Execute each chunk of arguments in serial. We don't parallelize (yet)
+        # since in theory we want to support parallelization at the hook level
+        # and not within individual hooks.
+        results = extract_argument_lists(initial_args, splittable_args).map do |arg_list|
+          Overcommit::Subprocess.spawn(arg_list, options)
+        end
+
+        Result.new(results.map(&:status), results.map(&:stdout), results.map(&:stderr))
+      end
+
+      private
+
+      # Given a list of prefix arguments and suffix arguments that can be split,
+      # returns a list of argument lists that are executable on the current OS
+      # without exceeding command line limitations.
+      def extract_argument_lists(args, splittable_args)
+        # Total number of bytes needed to contain the prefix command
+        # (including byte separators between each argument)
+        prefix_bytes = (args.size - 1) + args.reduce(0) { |sum, arg| sum + arg.bytesize }
+
+        if prefix_bytes >= max_command_length
+          raise Overcommit::Exceptions::InvalidCommandArgs,
+                "Command `#{args.take(5).join(' ')} ...` is longer than the " \
+                'maximum number of bytes allowed by the operating system ' \
+                "(#{max_command_length})"
+        end
+
+        arg_lists = []
+        index = 0
+        while index <= splittable_args.length - 1
+          arg_list, index = arguments_under_limit(splittable_args,
+                                                  index,
+                                                  max_command_length - prefix_bytes)
+          arg_lists << args + arg_list
+        end
+
+        arg_lists
+      end
+
+      # @return [Array<Array<String>, Integer>] tuple of arguments and new index
+      def arguments_under_limit(splittable_args, start_index, byte_limit)
+        index = start_index
+        total_bytes = 0
+
+        loop do
+          break if index > splittable_args.length - 1
+          total_bytes += splittable_args[index].bytesize
+          break if total_bytes > byte_limit # Not enough room
+          index += 1
+        end
+
+        if index == start_index
+          # No argument was consumed; perhaps a really long argument?
+          raise Overcommit::Exceptions::InvalidCommandArgs,
+                "Argument `#{splittable_args[index][0..5]}...` exceeds the " \
+                'maximum command length when appended to command prefix and ' \
+                "can't be split further"
+        end
+
+        [splittable_args[start_index...index], index]
+      end
+
+      # Returns the maximum number of arguments allowed in a single command on
+      # this system.
+      #
+      # @return [Integer]
+      def max_command_length
+        @max_command_length ||=
+          if Gem.win_platform?
+            # Windows is limited to 2048 since that is a worst-case scenario.
+            # http://blogs.msdn.com/b/oldnewthing/archive/2003/12/10/56028.aspx
+            2048
+          else
+            # We fudge factor this by halving the buffer size since *nix systems
+            # usually have pretty large limits, and the actual limit changes
+            # depending on how much of your stack is environment variables.
+            # Definitely erring on the side of overly cautious.
+            `getconf ARG_MAX`.to_i / 2
+          end
+      end
+    end
+  end
+end

data/lib/overcommit/configuration.rb

@@ -18,10 +18,18 @@ module Overcommit
     end
     alias_method :eql?, :==
 
+    # Access the configuration as if it were a hash.
+    #
+    # @param key [String]
+    # @return [Array,Hash,Number,String]
+    def [](key)
+      @hash[key]
+    end
+
     # Returns absolute path to the directory that external hook plugins should
     # be loaded from.
     def plugin_directory
-      File.join(Overcommit::Utils.repo_root, @hash['plugin_directory'] || '.githooks')
+      File.join(Overcommit::Utils.repo_root, @hash['plugin_directory'] || '.git-hooks')
     end
 
     def verify_plugin_signatures?
@@ -88,6 +96,14 @@ module Overcommit
         select { |hook_name| hook_enabled?(hook_context, hook_name) }
     end
 
+    # Returns the ad hoc hooks that have been enabled for a hook type.
+    def enabled_ad_hoc_hooks(hook_context)
+      @hash[hook_context.hook_class_name].keys.
+        select { |hook_name| hook_name != 'ALL' }.
+        select { |hook_name| ad_hoc_hook?(hook_context, hook_name) }.
+        select { |hook_name| hook_enabled?(hook_context, hook_name) }
+    end
+
     # Returns a non-modifiable configuration for a hook.
     def for_hook(hook, hook_type = nil)
       unless hook_type
@@ -117,17 +133,25 @@ module Overcommit
     # environment variables.
     def apply_environment!(hook_context, env)
       skipped_hooks = "#{env['SKIP']} #{env['SKIP_CHECKS']} #{env['SKIP_HOOKS']}".split(/[:, ]/)
+      only_hooks = env.fetch('ONLY', '').split(/[:, ]/)
       hook_type = hook_context.hook_class_name
 
-      if skipped_hooks.include?('all') || skipped_hooks.include?('ALL')
+      if only_hooks.any? || skipped_hooks.include?('all') || skipped_hooks.include?('ALL')
         @hash[hook_type]['ALL']['skip'] = true
-      else
-        skipped_hooks.select { |hook_name| hook_exists?(hook_context, hook_name) }.
-                      map { |hook_name| Overcommit::Utils.camel_case(hook_name) }.
-                      each do |hook_name|
-          @hash[hook_type][hook_name] ||= {}
-          @hash[hook_type][hook_name]['skip'] = true
-        end
+      end
+
+      only_hooks.select { |hook_name| hook_exists?(hook_context, hook_name) }.
+                 map { |hook_name| Overcommit::Utils.camel_case(hook_name) }.
+                 each do |hook_name|
+        @hash[hook_type][hook_name] ||= {}
+        @hash[hook_type][hook_name]['skip'] = false
+      end
+
+      skipped_hooks.select { |hook_name| hook_exists?(hook_context, hook_name) }.
+                    map { |hook_name| Overcommit::Utils.camel_case(hook_name) }.
+                    each do |hook_name|
+        @hash[hook_type][hook_name] ||= {}
+        @hash[hook_type][hook_name]['skip'] = true
       end
     end
 
@@ -149,6 +173,16 @@ module Overcommit
 
     private
 
+    def ad_hoc_hook?(hook_context, hook_name)
+      ad_hoc_conf = @hash.fetch(hook_context.hook_class_name, {}).fetch(hook_name, {})
+
+      # Ad hoc hooks are neither built-in nor have a plugin file written but
+      # still have a `command` specified to be run
+      !built_in_hook?(hook_context, hook_name) &&
+        !plugin_hook?(hook_context, hook_name) &&
+        (ad_hoc_conf['command'] || ad_hoc_conf['required_executable'])
+    end
+
     def built_in_hook?(hook_context, hook_name)
       hook_name = Overcommit::Utils.snake_case(hook_name)
 
@@ -158,7 +192,8 @@ module Overcommit
 
     def hook_exists?(hook_context, hook_name)
       built_in_hook?(hook_context, hook_name) ||
-        plugin_hook?(hook_context, hook_name)
+        plugin_hook?(hook_context, hook_name) ||
+        ad_hoc_hook?(hook_context, hook_name)
     end
 
     def hook_enabled?(hook_context_or_type, hook_name)

data/lib/overcommit/exceptions.rb

@@ -30,6 +30,9 @@ module Overcommit::Exceptions
   # Raised when an installation target is not a valid git repository.
   class InvalidGitRepo < StandardError; end
 
+  # Raised when a hook was defined incorrectly.
+  class InvalidHookDefinition < StandardError; end
+
   # Raised when one or more hook plugin signatures have changed.
   class InvalidHookSignature < StandardError; end
 

data/lib/overcommit/git_repo.rb

@@ -113,6 +113,14 @@ module Overcommit
         reject { |file| File.directory?(file) } # Exclude submodule directories
     end
 
+    # Returns whether the specified file/path is tracked by this repository.
+    #
+    # @param path [String]
+    # @return [true,false]
+    def tracked?(path)
+      Overcommit::Utils.execute(%W[git ls-files #{path} --error-unmatch]).success?
+    end
+
     # Returns the names of all files that are tracked by git.
     #
     # @return [Array<String>] list of absolute file paths

data/lib/overcommit/hook/base.rb

@@ -82,8 +82,22 @@ module Overcommit::Hook
       Overcommit::Utils.in_path?(cmd)
     end
 
-    def execute(cmd)
-      Overcommit::Utils.execute(cmd)
+    # Execute a command in a separate process.
+    #
+    # If `splittable_args` is specified, ensures that those arguments are
+    # concatenated onto the end of the `cmd` arguments, but split up so that the
+    # operating system's maximum command length is not exceeded. This is useful
+    # for splitting up long file lists.
+    #
+    # @param cmd [Array<String>] command arguments
+    # @param options [Hash]
+    # @option options [Array<String>] :args arguments that can be split up over
+    #   multiple invocations (usually a list of files)
+    # @option options [String] :input string to pass to process' standard input
+    #   stream
+    # @return [#status,#stdout,#stderr] struct containing result of invocation
+    def execute(cmd, options = {})
+      Overcommit::Utils.execute(cmd, options)
     end
 
     def execute_in_background(cmd)

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

@@ -5,6 +5,6 @@ module Overcommit::Hook::PostRewrite
   class Base < Overcommit::Hook::Base
     extend Forwardable
 
-    def_delegators :@context, :amend?, :rebase?
+    def_delegators :@context, :amend?, :rebase?, :rewritten_commits
   end
 end

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

@@ -6,7 +6,7 @@ module Overcommit::Hook::PreCommit
       repo_files = Set.new(applicable_files)
 
       unless Overcommit::GitRepo.initial_commit?
-        paths = repo_files.map { |file| File.dirname(file) + File::SEPARATOR }
+        paths = repo_files.map { |file| File.dirname(file) + File::SEPARATOR }.uniq
         repo_files += Overcommit::GitRepo.list_files(paths)
       end
 

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

@@ -2,7 +2,7 @@ module Overcommit::Hook::PreCommit
   # Checks for hard tabs in files.
   class HardTabs < Base
     def run
-      result = execute(command + applicable_files)
+      result = execute(command, args: applicable_files)
 
       extract_messages(
         result.stdout.split("\n"),

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

@@ -0,0 +1,21 @@
+module Overcommit::Hook::PreCommit
+  # Runs `htmlhint` against any modified HTML files.
+  #
+  # @see http://htmlhint.com/
+  class HtmlHint < Base
+    def run
+      result = execute(command + applicable_files)
+      output = Overcommit::Utils.strip_color_codes(result.stdout.chomp)
+
+      message_groups = output.split("\n\n")[0..-2]
+      message_groups.map do |group|
+        lines = group.split("\n").map(&:strip)
+        file = lines[0][/(.+):/, 1]
+        extract_messages(
+          lines[1..-1].map { |msg| "#{file}: #{msg}" },
+          /^(?<file>[^:]+): line (?<line>\d+)/
+        )
+      end.flatten
+    end
+  end
+end

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

@@ -2,7 +2,7 @@ module Overcommit::Hook::PreCommit
   # Checks for local paths in files and issues a warning
   class LocalPathsInGemfile < Base
     def run
-      result = execute(command + applicable_files)
+      result = execute(command, args: applicable_files)
 
       unless result.stdout.empty?
         return :warn, "Avoid pointing to local paths in Gemfiles:\n#{result.stdout}"