overcommit 0.23.0 → 0.24.0

data/config/starter.yml

@@ -1,6 +1,6 @@
 # Use this file to configure the Overcommit hooks you wish to use. This will
 # extend the default configuration defined in:
-# https://github.com/causes/overcommit/blob/master/config/default.yml
+# https://github.com/brigade/overcommit/blob/master/config/default.yml
 #
 # At the topmost level of this YAML file is a key representing type of hook
 # being run (e.g. pre-commit, commit-msg, etc.). Within each type you can
@@ -8,10 +8,10 @@
 # `include`), whether to only display output if it fails (via `quiet`), etc.
 #
 # For a complete list of hooks, see:
-# https://github.com/causes/overcommit/tree/master/lib/overcommit/hook
+# https://github.com/brigade/overcommit/tree/master/lib/overcommit/hook
 #
 # For a complete list of options that you can use to customize hooks, see:
-# https://github.com/causes/overcommit#configuration
+# https://github.com/brigade/overcommit#configuration
 #
 # Uncomment the following lines to make the configuration take effect.
 

data/lib/overcommit.rb

@@ -1,5 +1,7 @@
 require 'overcommit/constants'
 require 'overcommit/exceptions'
+require 'overcommit/utils'
+require 'overcommit/git_version'
 require 'overcommit/configuration_validator'
 require 'overcommit/configuration'
 require 'overcommit/configuration_loader'
@@ -16,5 +18,4 @@ require 'overcommit/printer'
 require 'overcommit/hook_runner'
 require 'overcommit/installer'
 require 'overcommit/logger'
-require 'overcommit/utils'
 require 'overcommit/version'

data/lib/overcommit/cli.rb

@@ -4,8 +4,9 @@ module Overcommit
   # Responsible for parsing command-line options and executing appropriate
   # application logic based on those options.
   class CLI # rubocop:disable ClassLength
-    def initialize(arguments, logger)
+    def initialize(arguments, input, logger)
       @arguments = arguments
+      @input     = input
       @log       = logger
       @options   = {}
     end
@@ -127,7 +128,7 @@ module Overcommit
     end
 
     def print_template_directory_path
-      puts File.join(OVERCOMMIT_HOME, 'template-dir')
+      puts File.join(Overcommit::HOME, 'template-dir')
       halt
     end
 
@@ -145,8 +146,6 @@ module Overcommit
     # Prints the hooks available in the current repo and whether they're
     # enabled/disabled.
     def print_installed_hooks
-      config = Overcommit::ConfigurationLoader.load_repo_config
-
       config.all_hook_configs.each do |hook_type, hook_configs|
         print_hooks_for_hook_type(config, hook_configs, hook_type)
       end
@@ -174,10 +173,10 @@ module Overcommit
     end
 
     def sign_plugins
-      config = Overcommit::ConfigurationLoader.load_repo_config
       context = Overcommit::HookContext.create(@options[:hook_to_sign],
                                                config,
-                                               @arguments)
+                                               @arguments,
+                                               @input)
       Overcommit::HookLoader::PluginHookLoader.new(config,
                                                    context,
                                                    log).update_signatures
@@ -185,8 +184,7 @@ module Overcommit
     end
 
     def run_all
-      config  = Overcommit::ConfigurationLoader.load_repo_config
-      context = Overcommit::HookContext.create('run-all', config, @arguments)
+      context = Overcommit::HookContext.create('run-all', config, @arguments, @input)
       config.apply_environment!(context, ENV)
 
       printer = Overcommit::Printer.new(log, context)
@@ -201,5 +199,10 @@ module Overcommit
     def halt(status = 0)
       exit status
     end
+
+    # Returns the configuration for this repository.
+    def config
+      @config ||= Overcommit::ConfigurationLoader.new(log).load_repo_config
+    end
   end
 end

data/lib/overcommit/configuration.rb

@@ -2,8 +2,15 @@ module Overcommit
   # Stores configuration for Overcommit and the hooks it runs.
   class Configuration # rubocop:disable ClassLength
     # Creates a configuration from the given hash.
-    def initialize(hash)
-      @hash = ConfigurationValidator.new.validate(hash)
+    #
+    # @param hash [Hash] loaded YAML config file as a hash
+    # @param options [Hash]
+    # @option default [Boolean] whether this is the default built-in configuration
+    # @option logger [Overcommit::Logger]
+    def initialize(hash, options = {})
+      @options = options.dup
+      @options[:logger] ||= Overcommit::Logger.silent
+      @hash = Overcommit::ConfigurationValidator.new.validate(hash, options)
     end
 
     def ==(other)
@@ -145,7 +152,7 @@ module Overcommit
     def built_in_hook?(hook_context, hook_name)
       hook_name = Overcommit::Utils.snake_case(hook_name)
 
-      File.exist?(File.join(OVERCOMMIT_HOME, 'lib', 'overcommit', 'hook',
+      File.exist?(File.join(Overcommit::HOME, 'lib', 'overcommit', 'hook',
                             hook_context.hook_type_name, "#{hook_name}.rb"))
     end
 
@@ -164,10 +171,17 @@ module Overcommit
       all_enabled = @hash[hook_type]['ALL']['enabled']
       return all_enabled unless all_enabled.nil?
 
-      true
+      false
     end
 
     def smart_merge(parent, child)
+      # Treat the ALL hook specially so that it overrides any configuration
+      # specified by the default configuration.
+      child_all = child['ALL']
+      unless child_all.nil?
+        parent = Hash[parent.collect { |k, v| [k, smart_merge(v, child_all)] }]
+      end
+
       parent.merge(child) do |_key, old, new|
         case old
         when Hash

data/lib/overcommit/configuration_loader.rb

@@ -3,38 +3,24 @@ require 'yaml'
 module Overcommit
   # Manages configuration file loading.
   class ConfigurationLoader
-    DEFAULT_CONFIG_PATH = File.join(OVERCOMMIT_HOME, 'config', 'default.yml')
+    DEFAULT_CONFIG_PATH = File.join(Overcommit::HOME, 'config', 'default.yml')
 
     class << self
-      def load_repo_config
-        overcommit_yml = File.join(Overcommit::Utils.repo_root,
-                                   OVERCOMMIT_CONFIG_FILE_NAME)
-
-        if File.exist?(overcommit_yml)
-          load_file(overcommit_yml)
-        else
-          default_configuration
-        end
-      end
-
+      # Loads and returns the default configuration.
+      #
+      # @return [Overcommit::Configuration]
       def default_configuration
-        @default_config ||= load_from_file(DEFAULT_CONFIG_PATH)
-      end
-
-      private
-
-      # Loads a configuration, ensuring it extends the default configuration.
-      def load_file(file)
-        config = load_from_file(file)
-
-        default_configuration.merge(config)
-      rescue => error
-        raise Overcommit::Exceptions::ConfigurationError,
-              "Unable to load configuration from '#{file}': #{error}",
-              error.backtrace
+        @default_config ||= load_from_file(DEFAULT_CONFIG_PATH, default: true)
       end
 
-      def load_from_file(file)
+      # Loads configuration from file.
+      #
+      # @param file [String] path to file
+      # @param options [Hash]
+      # @option default [Boolean] whether this is the default built-in configuration
+      # @option logger [Overcommit::Logger]
+      # @return [Overcommit::Configuration]
+      def load_from_file(file, options = {})
         hash =
           if yaml = YAML.load_file(file)
             yaml.to_hash
@@ -42,8 +28,39 @@ module Overcommit
             {}
           end
 
-        Overcommit::Configuration.new(hash)
+        Overcommit::Configuration.new(hash, options)
       end
     end
+
+    # Create a configuration loader which writes warnings/errors to the given
+    # {Overcommit::Logger} instance.
+    def initialize(logger)
+      @log = logger
+    end
+
+    # Loads and returns the configuration for the repository we're running in.
+    #
+    # @return [Overcommit::Configuration]
+    def load_repo_config
+      overcommit_yml = File.join(Overcommit::Utils.repo_root,
+                                 Overcommit::CONFIG_FILE_NAME)
+
+      if File.exist?(overcommit_yml)
+        load_file(overcommit_yml)
+      else
+        self.class.default_configuration
+      end
+    end
+
+    # Loads a configuration, ensuring it extends the default configuration.
+    def load_file(file)
+      config = self.class.load_from_file(file, default: false, logger: @log)
+
+      self.class.default_configuration.merge(config)
+    rescue => error
+      raise Overcommit::Exceptions::ConfigurationError,
+            "Unable to load configuration from '#{file}': #{error}",
+            error.backtrace
+    end
   end
 end

data/lib/overcommit/configuration_validator.rb

@@ -2,9 +2,19 @@ module Overcommit
   # Validates and normalizes a configuration.
   class ConfigurationValidator
     # Validates hash for any invalid options, normalizing where possible.
-    def validate(hash)
+    #
+    # @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)
+      @options = options.dup
+      @log = options[:logger]
+
       hash = convert_nils_to_empty_hashes(hash)
       ensure_hook_type_sections_exist(hash)
+      check_for_missing_enabled_option(hash) unless @options[:default]
 
       hash
     end
@@ -36,5 +46,27 @@ module Overcommit
           end
       end
     end
+
+    # Prints a warning if there are any hooks listed in the configuration
+    # without `enabled` explicitly set.
+    def check_for_missing_enabled_option(hash)
+      return unless @log
+
+      any_warnings = false
+
+      Overcommit::Utils.supported_hook_type_classes.each do |hook_type|
+        hash.fetch(hook_type, {}).each do |hook_name, hook_config|
+          next if hook_name == 'ALL'
+
+          if hook_config['enabled'].nil?
+            @log.warning "#{hook_type}::#{hook_name} hook does not explicitly " \
+                         'set `enabled` option in .overcommit.yml'
+            any_warnings = true
+          end
+        end
+      end
+
+      @log.newline if any_warnings
+    end
   end
 end

data/lib/overcommit/constants.rb

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

data/lib/overcommit/exceptions.rb

@@ -5,6 +5,9 @@ module Overcommit::Exceptions
   # Raised when trying to read/write to/from the local repo git config fails.
   class GitConfigError < StandardError; end
 
+  # Raised when there was a problem reading submodule information for a repo.
+  class GitSubmoduleError < StandardError; end
+
   # Raised when a {HookContext} is unable to setup the environment before a run.
   class HookSetupFailed < StandardError; end
 

data/lib/overcommit/git_repo.rb

@@ -1,3 +1,5 @@
+require 'iniparse'
+
 module Overcommit
   # Provide a set of utilities for certain interactions with `git`.
   module GitRepo
@@ -11,6 +13,50 @@ module Overcommit
       \s@@.*$
     /x
 
+    # Regular expression used to extract information from lines of
+    # `git submodule status` output
+    SUBMODULE_STATUS_REGEX = /
+      ^\s*(?<prefix>[-+U]?)(?<sha1>\w+)
+      \s(?<path>[^\s]+?)
+      (?:\s\((?<describe>.+)\))?$
+    /x
+
+    # Struct encapsulating submodule information extracted from the
+    # output of `git submodule status`
+    SubmoduleStatus = Struct.new(:prefix, :sha1, :path, :describe) do
+      # Returns whether the submodule has not been initialized
+      def uninitialized?
+        prefix == '-'
+      end
+
+      # Returns whether the submodule is out of date with the current
+      # index, i.e. its checked-out commit differs from that stored in
+      # the index of the parent repo
+      def outdated?
+        prefix == '+'
+      end
+
+      # Returns whether the submodule reference has a merge conflict
+      def merge_conflict?
+        prefix == 'U'
+      end
+    end
+
+    # Returns a list of SubmoduleStatus objects, one for each submodule in the
+    # parent repository.
+    #
+    # @option options [Boolean] recursive check submodules recursively
+    # @return [Array<SubmoduleStatus>]
+    def submodule_statuses(options = {})
+      flags = '--recursive' if options[:recursive]
+
+      `git submodule status #{flags}`.
+        scan(SUBMODULE_STATUS_REGEX).
+        map do |prefix, sha1, path, describe|
+          SubmoduleStatus.new(prefix, sha1, path, describe)
+        end
+    end
+
     # Extract the set of modified lines from a given file.
     #
     # @param file_path [String]
@@ -54,6 +100,19 @@ module Overcommit
         map { |relative_file| File.expand_path(relative_file) }
     end
 
+    # Returns the names of files in the given paths that are tracked by git.
+    #
+    # @param paths [Array<String>] list of paths to check
+    # @option options [String] ref ('HEAD') Git ref to check
+    # @return [Array<String>] list of absolute file paths
+    def list_files(paths = [], options = {})
+      ref = options[:ref] || 'HEAD'
+      `git ls-tree --name-only #{ref} #{paths.join(' ')}`.
+        split(/\n/).
+        map { |relative_file| File.expand_path(relative_file) }.
+        reject { |file| File.directory?(file) } # Exclude submodule directories
+    end
+
     # Returns the names of all files that are tracked by git.
     #
     # @return [Array<String>] list of absolute file paths
@@ -132,5 +191,62 @@ module Overcommit
         @cherry_head = nil
       end
     end
+
+    # Contains information about a registered submodule.
+    Submodule = Struct.new(:path, :url)
+
+    # Returns the submodules that have been staged for removal.
+    #
+    # `git` has an unexpected behavior where removing a submodule without
+    # committing (i.e. such that the submodule directory is removed and the
+    # changes to the index are staged) and then doing a hard reset results in
+    # the index being wiped but the empty directory of the once existent
+    # submodule being restored (but with no content).
+    #
+    # This prevents restoration of the stash of the submodule index changes,
+    # which breaks pre-commit hook restorations of the working index.
+    #
+    # Thus we expose this helper so the restoration code can manually delete the
+    # directory.
+    #
+    # @raise [Overcommit::Exceptions::GitSubmoduleError] when
+    def staged_submodule_removals
+      # There were no submodules before, so none could have been removed
+      return [] if `git ls-files .gitmodules`.empty?
+
+      previous = submodules(ref: 'HEAD')
+      current = submodules
+
+      previous - current
+    end
+
+    # Returns the current set of registered submodules.
+    #
+    # @param options [Hash]
+    # @return [Array<Overcommit::GitRepo::Submodule>]
+    def submodules(options = {})
+      ref = options[:ref]
+
+      modules = []
+      IniParse.parse(`git show #{ref}:.gitmodules`).each do |section|
+        # git < 1.8.5 does not update the .gitmodules file with submodule
+        # changes, so when we are looking at the current state of the work tree,
+        # we need to check if the submodule actually exists via another method,
+        # since the .gitmodules file we parsed does not represent reality.
+        if ref.nil? && GIT_VERSION < '1.8.5'
+          result = Overcommit::Utils.execute(%W[
+            git submodule status #{section['path']}
+          ])
+          next unless result.success?
+        end
+
+        modules << Submodule.new(section['path'], section['url'])
+      end
+
+      modules
+    rescue IniParse::IniParseError => ex
+      raise Overcommit::Exceptions::GitSubmoduleError,
+            "Unable to read submodule information from #{ref}:.gitmodules file: #{ex.message}"
+    end
   end
 end