Refactor Overcommit framework

Initial refactor commit. Specs are currently broken, but I'm marking
this off as a chunk of work for now, and will start working more
atomically from now on.

Change-Id: I8a120cb660046e3d7b23e302b0054de932df2bec
Reviewed-on: http://gerrit.causes.com/35559
Reviewed-by: Shane da Silva <shane@causes.com>
Tested-by: Shane da Silva <shane@causes.com>

Author: sds

TODO

@@ -0,0 +1,49 @@
+Handle case where hooks are installed but overcommit isn't
+Add user-friendly installation instructions (e.g. run `overcommit` in git
+repo and get asked to install if it is not installed)
+Symlink all scripts to single Overcommit file
+Ask to remove sample files
+Parallelize hook checks
+Stash non-indexed changes before running checks so real filename can be used
+(`git stash save --keep-index --include-untracked`)
+Allow hooks to depend on other hooks being run first? (`depends` option)
+Auto install hooks on updating overcommit during next hook run
+Auto update hook integration script when newer overcommit runs
+Allow GIT_TEMPLATE_DIR to be set with `export GIT_TEMPLATE_DIR=`overcommit --template-dir`
+Allow hooks to specify required executable (`executable` option, coupled with
+  install instructions of some sort)
+Allow hooks to specify whether they only apply to lines the user modified
+Split out Whitespace check into individual checks
+Allow SKIP arguments to be case insensitive
+
+
+Allow features of hooks to be customized (stealth, required, etc.)
+
+`overcommit pre-commit`
+`overcommit commit-msg <file-with-message>`
+`overcommit post-checkout <prev-HEAD> <new-HEAD> <file-checkout[0/1]>`
+
+Core philosophies:
+- Git Hooks are a first-class artifact that don't vary from system to system
+  (should be stored in source control)
+  - Copying hooks between multiple repositories is annoying
+  - Using `git config` as a method of storing hook configuration doesn't persist
+- Repository is the fundamental unit of configuration (no global configuration
+  for multiple repositories stored elsewhere)
+- Overcommit is the homebrew of git hooks
+
+
+
+WHAT's FIXED:
+- Renaming of core concepts
+- Control flow fixed to not `exit` in random places
+- No longer need temp files for staged files and the various hacks related to it
+  (e.g. rubocop/scss-lint config loading)
+- Easier for developers to test new hooks (just run `bundle exec git commit`,
+  etc.)
+- Removed the HookRegistry
+- Allow fine grained control over which checks apply to which files
+
+
+NICE TO HAVES:
+- report status sizes to width of terminal

bin/overcommit

@@ -1,11 +1,11 @@
 #!/usr/bin/env ruby
 
-$: << File.expand_path('../../lib', __FILE__)
-
 require 'overcommit'
 require 'overcommit/cli'
 
-Overcommit::CLI.new(ARGV).tap do |cli|
+logger = Overcommit::Logger.new(STDOUT)
+
+Overcommit::CLI.new(ARGV, logger).tap do |cli|
   cli.parse_arguments
   cli.run
 end

config/default.yml

@@ -0,0 +1,94 @@
+# Default configuration that all Overcommit configurations inherit from.
+#
+# This is an opinionated list of which hooks are valuable to run and what their
+# out-of-the-box settings should be.
+
+# 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
+# to the root of the repository.
+plugin_directory: '.githooks'
+
+# Hooks that are run after `git commit` is executed, before the commit message
+# editor is displayed. These hooks are ideal for syntax checkers, linters, and
+# other checks that you want to run before you allow a commit object to be
+# created.
+pre_commit:
+  ALL:
+    requires_files: true
+    required: false
+    quiet: false
+
+  AuthorName:
+    requires_files: false
+    required: true
+    silent: true
+
+  CoffeeLint:
+    description: 'Analyzing with coffeelint'
+    include: '**/*.coffee'
+
+  CssLint:
+    description: 'Analyzing with csslint'
+    include: '**/*.css'
+
+  HamlLint:
+    description: 'Analyzing with haml-lint'
+    include: '**/*.haml'
+
+  JsHint:
+    description: 'Analyzing with JSHint'
+    include: '**/*.js'
+
+  PythonFlake8:
+    description: 'Analyzing with flake8'
+    include: '**/*.py'
+
+  Rubocop:
+    description: 'Analyzing with Rubocop'
+    include:
+      - '**/*.gemspec'
+      - '**/*.rake'
+      - '**/*.rb'
+      - '**/Gemfile'
+      - '**/Rakefile'
+
+  ScssLint:
+    description: 'Analyzing with scss-lint'
+    include: '**/*.scss'
+
+  Whitespace:
+    description: 'Checking for invalid whitespace'
+
+  YamlSyntax:
+    description: 'Checking YAML syntax'
+    include: '**/*.yml'
+
+# Hooks that are run after all pre-commit hooks have run, before the user's
+# commit message editor is opened.
+# These hooks are used to edit the commit message based on the proprosed changes
+# (for example, if you want to include additional metadata with the commit
+# message).
+prepare_commit_msg:
+
+# Hooks that are run against every commit message after a user has written it.
+# These hooks are useful for enforcing policies on commit messages written for a
+# project.
+commit_msg:
+  ALL:
+    quiet: false
+
+  HardTabs:
+    description: 'Checking for hard tabs'
+
+  RussianNovel:
+    description: 'Checking length of commit message'
+    quiet: true
+
+  SingleLineSubject:
+    description: 'Checking subject line'
+
+  TextWidth:
+    description: 'Checking text width'
+
+  TrailingPeriod:
+    description: 'Checking for trailing periods in subject'

lib/overcommit.rb

@@ -1,10 +1,12 @@
+require 'overcommit/constants'
+require 'overcommit/exceptions'
 require 'overcommit/configuration'
-require 'overcommit/errors'
-require 'overcommit/git_hook'
-require 'overcommit/hook_specific_check'
+require 'overcommit/configuration_loader'
+require 'overcommit/hook/base'
+require 'overcommit/hook_runner'
+require 'overcommit/hook_runner/base'
 require 'overcommit/installer'
 require 'overcommit/logger'
 require 'overcommit/reporter'
-require 'overcommit/staged_file'
 require 'overcommit/utils'
 require 'overcommit/version'

lib/overcommit/cli.rb

@@ -1,69 +1,33 @@
 require 'optparse'
 
 module Overcommit
+  # Responsible for parsing command-line options and executing appropriate
+  # application logic based on those options.
   class CLI
-    attr_reader :options
-
-    def initialize(arguments = [])
+    def initialize(arguments, logger)
       @arguments = arguments
+      @log       = logger
       @options   = {}
     end
 
     def parse_arguments
       @parser = OptionParser.new do |opts|
-        opts.banner = "Usage: #{opts.program_name} [options] target"
+        opts.banner = "Usage: #{opts.program_name} [options] [target-repo]"
 
         opts.on_tail('-h', '--help', 'Show this message') do
           print_help opts.help
         end
 
         opts.on_tail('-v', '--version', 'Show version') do
-          log.log VERSION
-          exit 0
-        end
-
-        opts.on('-l', '--list-templates', 'List built-in templates') do
-          Overcommit.config.templates.each_pair do |name, configuration|
-            log.bold name
-            log.log YAML.dump(configuration), ''
-          end
-          exit 0
-        end
-
-        opts.on('-a', '--all', 'Include all git hooks') do
-          @options[:template] = 'all'
+          print_version(opts.program_name)
         end
 
-        opts.on('-t', '--template template',
-                'Specify a template of hooks') do |template|
-          @options[:template] = template
-        end
-
-        opts.on('--uninstall', 'Remove overcommit from target') do
+        opts.on('--uninstall', 'Remove Overcommit hooks from a repository') do
           @options[:uninstall] = true
         end
 
-        opts.on('-e', '--exclude hook_name,...', Array,
-                'Exclude hooks from installation') do |excludes|
-          # Transform from:
-          #
-          #   pre_commit/test_history,commit_msg/change_id
-          #
-          # Into:
-          #
-          #   {
-          #     'commit_msg' => ['change_id'],
-          #     'pre_commit' => ['test_history']
-          #   }
-          @options[:excludes] = excludes.inject({}) do |memo, exclude|
-            parts = exclude.split(%r{[:/.]})
-            next memo unless parts.size == 2
-
-            memo[parts.first] ||= []
-            memo[parts.first] << parts.last
-
-            memo
-          end
+        opts.on('--install', 'Install Overcommit hooks in a repository') do
+          @options[:install] = true
         end
       end
 
@@ -78,37 +42,43 @@ def parse_arguments
     end
 
     def run
-      if @options[:targets].nil? || @options[:targets].empty?
-        log.warning 'You must supply at least one directory'
-        log.log @parser.help
-        exit 2
+      if Array(@options[:targets]).empty?
+        @options[:targets] = [Overcommit::Utils.repo_root].compact
+        if @options[:targets].empty?
+          log.warning 'You are not in a git repository.'
+          log.log 'You must either specify the path to a repository or ' <<
+                  'change your current directory to a repository.'
+          halt 64 # EX_USAGE
+        end
       end
 
       @options[:targets].each do |target|
         begin
-          Installer.new(@options, target).run
-        rescue NotAGitRepoError => e
-          log.warning "Skipping #{target}: #{e}"
+          Installer.new(@options, target, log).run
+        rescue Overcommit::Exceptions::InvalidGitRepo => error
+          log.warning "Skipping #{target}: #{error}"
         end
       end
-
-      log.success "#{@options[:uninstall] ? 'Removal' : 'Installation'} complete"
-
-    rescue ArgumentError => ex
-      error "Installation failed: #{ex}"
-      exit 3
     end
 
   private
 
-    def log
-      Logger.instance
-    end
+    attr_reader :log
 
-    def print_help(message, ex = nil)
-      log.error ex.to_s + "\n" if ex
+    def print_help(message, error = nil)
+      log.error "#{error}\n" if error
       log.log message
-      exit 0
+      halt(error ? 64 : 0) # 64 = EX_USAGE
+    end
+
+    def print_version(program_name)
+      log.log "#{program_name} #{Overcommit::VERSION}"
+      halt
+    end
+
+    # Used for ease of stubbing in tests
+    def halt(status = 0)
+      exit status
     end
   end
 end