overcommit 0.5.0 → 0.6.0

data/lib/overcommit/hook_runner.rb

@@ -0,0 +1,150 @@
+# encoding: utf-8
+
+module Overcommit
+  # Responsible for loading the hooks the repository has configured and running
+  # them, collecting and displaying the results.
+  class HookRunner
+    def initialize(config, logger, context)
+      @config = config
+      @log = logger
+      @context = context
+      @hooks = []
+    end
+
+    # Loads and runs the hooks registered for this {HookRunner}.
+    def run
+      load_hooks
+      @context.setup_environment
+      run_hooks
+    ensure
+      @context.cleanup_environment
+    end
+
+  private
+
+    attr_reader :log
+
+    def run_hooks
+      if @hooks.any? { |hook| hook.run? || hook.skip? }
+        log.bold "Running #{@context.hook_script_name} hooks"
+
+        statuses = @hooks.map { |hook| run_hook(hook) }.compact
+
+        log.log # Newline
+
+        run_failed = statuses.include?(:bad)
+
+        if run_failed
+          log.error "✗ One or more #{@context.hook_script_name} hooks failed"
+        else
+          log.success "✓ All #{@context.hook_script_name} hooks passed"
+        end
+
+        log.log # Newline
+
+        !run_failed
+      else
+        log.success "✓ No applicable #{@context.hook_script_name} hooks to run"
+        true # Run was successful
+      end
+    end
+
+    def run_hook(hook)
+      return unless hook.enabled?
+
+      if hook.skip?
+        if hook.required?
+          log.warning "Cannot skip #{hook.name} since it is required"
+        else
+          log.warning "Skipping #{hook.name}"
+          return
+        end
+      end
+
+      return unless hook.run?
+
+      unless hook.quiet?
+        print_header(hook)
+      end
+
+      begin
+        status, output = hook.run
+      rescue => ex
+        status = :bad
+        output = "Hook raised unexpected error\n#{ex.message}"
+      end
+
+      # Want to print the header in the event the result wasn't good so that the
+      # user knows what failed
+      if hook.quiet? && status != :good
+        print_header(hook)
+      end
+
+      case status
+      when :good
+        log.success 'OK' unless hook.quiet?
+      when :warn
+        log.warning 'WARNING'
+        print_report(output, :bold_warning)
+      when :bad
+        log.error 'FAILED'
+        print_report(output, :bold_error)
+      end
+
+      status
+    end
+
+    def print_header(hook)
+      log.partial hook.description
+      log.partial '.' * (70 - hook.description.length)
+    end
+
+    def print_report(output, format = :log)
+      log.send(format, output) unless output.empty?
+    end
+
+    # Loads hooks that will be run.
+    # This is done explicitly so that we only load hooks which will actually be
+    # used.
+    def load_hooks
+      require "overcommit/hook/#{@context.hook_type_name}/base"
+
+      load_builtin_hooks
+      load_hook_plugins # Load after so they can subclass/modify existing hooks
+    end
+
+    # Load hooks that ship with Overcommit, ignoring ones that are excluded from
+    # the repository's configuration.
+    def load_builtin_hooks
+      @config.enabled_builtin_hooks(@context.hook_class_name).each do |hook_name|
+        underscored_hook_name = Overcommit::Utils.snake_case(hook_name)
+        require "overcommit/hook/#{@context.hook_type_name}/#{underscored_hook_name}"
+        @hooks << create_hook(hook_name)
+      end
+    end
+
+    # Load hooks that are stored in the repository's plugin directory.
+    def load_hook_plugins
+      directory = File.join(@config.plugin_directory, @context.hook_type_name)
+
+      Dir[File.join(directory, '*.rb')].sort.each do |plugin|
+        require plugin
+
+        hook_name = Overcommit::Utils.camel_case(File.basename(plugin, '.rb'))
+        @hooks << create_hook(hook_name)
+      end
+    end
+
+    # Load and return a {Hook} from a CamelCase hook name and the given
+    # hook configuration.
+    def create_hook(hook_name)
+      Overcommit::Hook.const_get(@context.hook_class_name).
+                       const_get(hook_name).
+                       new(@config, @context)
+    rescue LoadError, NameError => error
+      raise Overcommit::Exceptions::HookLoadError,
+            "Unable to load hook '#{hook_name}': #{error}",
+            error.backtrace
+    end
+  end
+end

data/lib/overcommit/installer.rb

@@ -1,113 +1,106 @@
 require 'fileutils'
-require 'yaml'
 
 module Overcommit
+  # Manages the installation of Overcommit hooks in a git repository.
   class Installer
-    def initialize(options, target)
-      @options = options
-      @target  = target
+    def initialize(logger)
+      @log = logger
     end
 
-    def run
+    def run(target, options)
+      @target = target
+      @options = options
       validate_target
-      @options[:uninstall] ? uninstall : install
+      @options[:action] == :uninstall ? uninstall : install
     end
 
+  private
+
+    attr_reader :log
+
     def install
       log.log "Installing hooks into #{@target}"
 
-      install_scripts
-      install_hooks
-      write_configuration
+      ensure_hooks_directory
+      install_master_hook
+      install_hook_symlinks
+
+      log.success "Successfully installed hooks into #{@target}"
     end
 
     def uninstall
       log.log "Removing hooks from #{@target}"
 
-      uninstall_scripts
-      uninstall_hooks
-      rm_configuration
-    end
+      uninstall_master_hook
+      uninstall_hook_symlinks
 
-  private
+      log.success "Successfully removed hooks from #{@target}"
+    end
 
-    def log
-      Logger.instance
+    def hooks_path
+      absolute_target = File.expand_path(@target)
+      File.join(absolute_target, '.git', 'hooks')
     end
 
-    def hook_path
-      absolute_target = File.expand_path @target
-      File.join(absolute_target, '.git/hooks')
+    def ensure_hooks_directory
+      FileUtils.mkdir_p(hooks_path)
     end
 
     def validate_target
-      absolute_target = File.expand_path @target
-      unless File.directory? absolute_target
-        raise NotAGitRepoError, 'is not a directory'
+      absolute_target = File.expand_path(@target)
+
+      unless File.directory?(absolute_target)
+        raise Overcommit::Exceptions::InvalidGitRepo, 'is not a directory'
       end
 
       unless File.directory?(File.join(absolute_target, '.git'))
-        raise NotAGitRepoError, 'does not appear to be a git repository'
+        raise Overcommit::Exceptions::InvalidGitRepo, 'does not appear to be a git repository'
       end
     end
 
-    # Make helper scripts available locally inside the repo
-    def install_scripts
-      FileUtils.cp_r Utils.absolute_path('bin/scripts'), hook_path
+    def install_master_hook
+      master_hook = File.join(OVERCOMMIT_HOME, 'template-dir', 'hooks', 'overcommit-hook')
+      install_location = File.join(hooks_path, 'overcommit-hook')
+      FileUtils.mkdir_p(hooks_path)
+      FileUtils.cp(master_hook, install_location)
     end
 
-    # Install all available git hooks into the repo
-    def install_hooks
-      hooks.each do |hook|
-        FileUtils.cp hook, File.join(hook_path, File.basename(hook))
-      end
+    def uninstall_master_hook
+      install_location = File.join(hooks_path, 'overcommit-hook')
+      FileUtils.rm_rf(install_location)
     end
 
-    def uninstall_hooks
-      hooks.each do |hook|
-        delete File.join(hook_path, File.basename(hook))
+    def install_hook_symlinks
+      # Link each hook type (pre-commit, commit-msg, etc.) to the master hook.
+      # We change directories so that the relative symlink paths work regardless
+      # of where the repository is located.
+      Dir.chdir(hooks_path) do
+        Overcommit::Utils.supported_hook_types.each do |hook_type|
+          unless can_replace_file?(hook_type)
+            raise Overcommit::Exceptions::PreExistingHooks,
+                  "Hook '#{File.expand_path(hook_type)}' already exists and was not installed by Overcommit"
+          end
+          FileUtils.ln_sf('overcommit-hook', hook_type)
+        end
       end
     end
 
-    def uninstall_scripts
-      scripts = File.join(hook_path, 'scripts')
-      FileUtils.rm_r scripts rescue false
+    def can_replace_file?(file)
+      @options[:force] ||
+        !File.exists?(file) ||
+        overcommit_symlink?(file)
     end
 
-    def hooks
-      Dir[Utils.absolute_path('bin/hooks/*')]
-    end
-
-    # Dump a YAML document containing requested configuration
-    def write_configuration
-      template = @options.fetch(:template, 'default')
-      base_config = Overcommit.config.templates[template]
-      if base_config.nil?
-        raise ArgumentError, "No such template '#{template}'"
-      end
-
-      base_config = base_config.dup
-      (base_config['excludes'] ||= {}).
-        merge!(@options[:excludes] || {}) do |_, a, b|
-        # Concat the arrays together
-        a + b
-      end
-
-      File.open(configuration_location, 'w') do |config|
-        YAML.dump(base_config, config)
+    def uninstall_hook_symlinks
+      Dir.chdir(hooks_path) do
+        Overcommit::Utils.supported_hook_types.each do |hook_type|
+          FileUtils.rm_rf(hook_type) if overcommit_symlink?(hook_type)
+        end
       end
     end
 
-    def rm_configuration
-      delete configuration_location
-    end
-
-    def configuration_location
-      File.join(hook_path, 'overcommit.yml')
-    end
-
-    def delete(file)
-      File.delete file rescue false
+    def overcommit_symlink?(file)
+      File.symlink?(file) && File.readlink(file) == 'overcommit-hook'
     end
   end
 end

data/lib/overcommit/logger.rb

@@ -1,18 +1,21 @@
-require 'singleton'
-
-# This class centralizes all communication to STDOUT
 module Overcommit
+  # Encapsulates all communication to an output source.
   class Logger
-    include Singleton
+    # Helper for creating a logger which outputs nothing.
+    def self.silent
+      new(File.open('/dev/null', 'w'))
+    end
 
-    attr_accessor :output
+    def initialize(out)
+      @out = out
+    end
 
     def partial(*args)
-      out.print *args
+      @out.print(*args)
     end
 
     def log(*args)
-      out.puts *args
+      @out.puts(*args)
     end
 
     def bold(str)
@@ -23,6 +26,10 @@ module Overcommit
       color(31, str)
     end
 
+    def bold_error(str)
+      color('1;31', str)
+    end
+
     def success(str)
       color(32, str)
     end
@@ -31,18 +38,14 @@ module Overcommit
       color(33, str)
     end
 
-    def notice(str)
+    def bold_warning(str)
       color('1;33', str)
     end
 
-    def out
-      self.output ||= $stdout
-    end
-
   private
 
     def color(code, str)
-      log(out.isatty ? "\033[#{code}m#{str}\033[0m" : str)
+      log(@out.tty? ? "\033[#{code}m#{str}\033[0m" : str)
     end
   end
 end

data/lib/overcommit/utils.rb

@@ -1,62 +1,87 @@
+require 'wopen3'
+
 module Overcommit
+  # Utility functions for general use.
   module Utils
     class << self
-      @@hooks = []
-
-      def register_hook(hook)
-        @@hooks << hook
-      end
-
-      def run_hooks(*args)
-        @@hooks.each { |hook| hook.new.run(*args) }
+      def script_path(script)
+        File.join(OVERCOMMIT_HOME, 'libexec', script)
       end
 
-      def hook_name
-        File.basename($0).tr('-', '_')
+      # Returns an absolute path to the root of the repository.
+      def repo_root
+        @repo_root ||=
+          begin
+            result = `git rev-parse --show-toplevel`.chomp
+            result if $?.success?
+          end
       end
 
-      def load_hooks
-        require File.expand_path("../hooks/#{hook_name}", __FILE__)
-      rescue LoadError
-        log.error "No hook definition found for #{hook_name}"
-        exit 1
+      # Shamelessly stolen from:
+      # stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
+      def snake_case(str)
+        str.gsub(/::/, '/').
+            gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+            gsub(/([a-z\d])([A-Z])/, '\1_\2').
+            tr('-', '_').
+            downcase
       end
 
-      def script_path(script)
-        File.join(File.expand_path('../../hooks/scripts', $0), script)
+      # Converts a string containing underscores/hyphens/spaces into CamelCase.
+      def camel_case(str)
+        str.split(/_|-| /).map { |part| part.sub(/^\w/) { |c| c.upcase } }.join
       end
 
-      def absolute_path(path)
-        File.join(File.expand_path('../../..', __FILE__), path)
+      # Returns a list of supported hook types (pre-commit, commit-msg, etc.)
+      def supported_hook_types
+        Dir[File.join(OVERCOMMIT_HOME, 'lib', 'overcommit', 'hook', '*')].
+          select { |file| File.directory?(file) }.
+          map { |file| File.basename(file, '.rb').gsub('_', '-') }
       end
 
-      # File.expand_path takes one more '..' than you're used to... we want to
-      # go two directories up from the caller (which will be .git/hooks/something)
-      # to the root of the git repo.
-      def repo_path(path)
-        File.join(File.expand_path('../../..', $0), path)
+      # Returns a list of supported hook classes (PreCommit, CommitMsg, etc.)
+      def supported_hook_type_classes
+        supported_hook_types.map do |file|
+          file.split('-').map { |part| part.capitalize }.join
+        end
       end
 
-      # Shamelessly stolen from:
-      # http://stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
-      def underscorize(str)
-        str.gsub(/::/, '/').
-            gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
-            gsub(/([a-z\d])([A-Z])/, '\1_\2').
-            tr('-', '_').
-            downcase
+      # Returns whether a command can be found given the current environment path.
+      def in_path?(cmd)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            return true if File.executable?(exe)
+          end
+        end
+        false
       end
 
-      # Get a list of staged Added, Copied, or Modified files (ignore renames
-      # and deletions, since there should be nothing to check).
-      def modified_files
-        `git diff --cached --name-only --diff-filter=ACM --ignore-submodules=all`.split "\n"
+      # Wrap external subshell calls. This is necessary in order to allow
+      # Overcommit to call other Ruby executables without requiring that they be
+      # specified in Overcommit's Gemfile--a nasty consequence of using
+      # `bundle exec overcommit` while developing locally.
+      def command(command)
+        with_environment 'RUBYOPT' => nil do
+          Wopen3.system(command)
+        end
       end
 
     private
 
-      def log
-        Logger.instance
+      # Calls a block of code with a modified set of environment variables,
+      # restoring them once the code has executed.
+      def with_environment(env, &block)
+        old_env = {}
+        env.each do |var, value|
+          old_env[var] = ENV[var.to_s]
+          ENV[var.to_s] = value
+        end
+
+        yield
+      ensure
+        old_env.each { |var, value| ENV[var.to_s] = value }
       end
     end
   end