overcommit 0.1.0

data/bin/scripts/jshint_runner.js

@@ -0,0 +1,48 @@
+/**
+ * @author kamil@causes.com
+ *
+ * This is a script to run jshint against files passed in via
+ * command line arguments
+ **/
+
+if (typeof JSHINT === "undefined") {
+  print("jshint not available. Make sure it was included properly.");
+  quit();
+}
+
+// Options:
+// https://gist.github.com/1489652
+
+var i, j, file, source, result, error,
+  options = {
+    boss:   true,
+    curly:  true,
+    eqeqeq: true,
+    forin:  true,
+    newcap: true
+  };
+
+for (i = 0; i < arguments.length; i++) {
+
+  file = arguments[i];
+  source = readFile(file);
+  result = JSHINT(source, options);
+
+  if (result === true) {
+    print(arguments[i] + " -- OK");
+  }
+  else {
+    for (j = 0; j < JSHINT.errors.length; j++) {
+      error = JSHINT.errors[j];
+
+      print("ERROR in " + file + " at " + error.line + ":" + error.character);
+      print("");
+      print("\t" + error.reason);
+      print("");
+      print("\t" + error.evidence);
+      print("");
+    }
+  }
+}
+
+

data/config/templates.yml

@@ -0,0 +1,12 @@
+---
+default:
+  excludes:
+    pre_commit:
+      - causes_email
+      - test_history
+      - restricted_paths
+    commit_msg:
+      - change_id
+      - release_note
+all:
+  excludes:

data/lib/overcommit.rb

@@ -0,0 +1,8 @@
+require 'overcommit/configuration'
+require 'overcommit/console_methods'
+require 'overcommit/git_hook'
+require 'overcommit/hook_specific_check'
+require 'overcommit/installer'
+require 'overcommit/reporter'
+require 'overcommit/utils'
+require 'overcommit/version'

data/lib/overcommit/cli.rb

@@ -0,0 +1,95 @@
+require 'optparse'
+
+module Overcommit
+  class CLI
+    def initialize(arguments = [])
+      @arguments = arguments
+      @options   = {}
+    end
+
+    def parse_arguments
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{opts.program_name} [options] target"
+
+        opts.on_tail('-h', '--help', 'Show this message') do
+          print_help opts.help
+        end
+
+        opts.on_tail('-v', '--version', 'Show version') do
+          puts VERSION
+          exit 0
+        end
+
+        opts.on('-a', '--all', 'Include all git hooks') do
+          @options[:template] = 'all'
+        end
+
+        opts.on('-t', '--template template',
+                'Specify a template of hooks') do |template|
+          @options[:template] = template
+        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
+        end
+      end
+
+      begin
+        parser.parse!(@arguments)
+
+        # Unconsumed arguments are our targets
+        @options[:targets] = @arguments
+      rescue OptionParser::InvalidOption => ex
+        print_help parser.help, ex
+      end
+    end
+
+    def run
+      if @options[:targets].nil? || @options[:targets].empty?
+        puts 'You must supply at least one directory to install into.'
+        puts 'For example:', ''
+        puts "  #{File.basename($0)} <target directory>"
+        exit 2
+      end
+
+      installer = Installer.new(@options)
+
+      @options[:targets].each do |target|
+        installer.install(target)
+      end
+
+      puts 'Installation complete.'
+
+    rescue ArgumentError => ex
+      puts "Installation failed: #{ex}"
+      exit 3
+    end
+
+  private
+
+    def print_help(message, ex = nil)
+      puts ex, '' if ex
+      puts message
+      exit 0
+    end
+  end
+end

data/lib/overcommit/configuration.rb

@@ -0,0 +1,58 @@
+require 'singleton'
+require 'yaml'
+
+module Overcommit
+  class Configuration
+    include Singleton
+
+    attr_reader :templates
+
+    def initialize
+      @templates = YAML.load_file(Utils.absolute_path('config/templates.yml'))
+    end
+
+    # Read the repo-specific 'overcommit.yml' file to determine what behavior
+    # the user wants.
+    def repo_settings
+      config_file = Utils.repo_path('.git/hooks/overcommit.yml')
+
+      File.exist?(config_file) ? YAML.load_file(config_file) : {}
+    end
+
+    # Given the current configuration, return a set of paths which should be
+    # loaded as plugins (`require`d)
+    def desired_plugins
+      excludes    = repo_settings['excludes']
+      skip_checks = ENV.fetch('SKIP_CHECKS', '').split(/[:, ]/)
+
+      return [] if skip_checks.include? 'all'
+
+      plugin_directories.map do |dir|
+        Dir[File.join(dir, Utils.hook_name, '*.rb')].map do |plugin|
+          basename = File.basename(plugin, '.rb')
+          if !skip_checks.include?(basename) &&
+             !(excludes[Utils.hook_name] || []).include?(basename)
+            plugin
+          end
+        end.compact
+      end.flatten
+    end
+
+  private
+
+    def plugin_directories
+      # Start with the base plugins provided by the gem
+      plugin_dirs   = [File.expand_path('../plugins', __FILE__)]
+      repo_specific = Utils.repo_path('.githooks')
+
+      # Add on any repo-specific checks
+      plugin_dirs << repo_specific if File.directory?(repo_specific)
+
+      plugin_dirs
+    end
+  end
+
+  def self.config
+    Configuration.instance
+  end
+end

data/lib/overcommit/console_methods.rb

@@ -0,0 +1,23 @@
+module Overcommit
+  module ConsoleMethods
+    def bold(str)
+      puts "\033[1;37m#{str}\033[0m"
+    end
+
+    def error(str)
+      puts "\033[31m#{str}\033[0m"
+    end
+
+    def success(str)
+      puts "\033[32m#{str}\033[0m"
+    end
+
+    def warning(str)
+      puts "\033[33m#{str}\033[0m"
+    end
+
+    def notice(str)
+      puts "\033[1;33m#{str}\033[0m"
+    end
+  end
+end

data/lib/overcommit/git_hook.rb

@@ -0,0 +1,50 @@
+module Overcommit
+  module GitHook
+    class BaseHook
+      include ConsoleMethods
+
+      def initialize
+        Overcommit.config.desired_plugins.each do |plugin|
+          require plugin
+        end
+      rescue NameError => ex
+        error "Couldn't load plugin: #{ex}"
+        exit 0
+      end
+
+      def run(*args)
+        # Support 'bare' installation where we don't have any hooks yet.
+        # Silently pass.
+        exit unless (checks = HookRegistry.checks) && checks.any?
+
+        exit if requires_modified_files? && Utils.modified_files.empty?
+
+        reporter = Reporter.new(Overcommit::Utils.hook_name, checks)
+
+        reporter.print_header
+
+        checks.each do |check_class|
+          check = check_class.new(*args)
+          next if check.skip?
+
+          # Ignore a check if it only applies to a specific file type and there
+          # are no staged files of that type in the tree
+          next if check_class.filetype && check.staged.empty?
+
+          reporter.with_status(check) do
+            check.run_check
+          end
+        end
+
+        reporter.print_result
+      end
+
+    private
+
+      # If true, only run this check when there are modified files.
+      def requires_modified_files?
+        false
+      end
+    end
+  end
+end

data/lib/overcommit/hook_specific_check.rb

@@ -0,0 +1,81 @@
+module Overcommit
+  module GitHook
+    module HookRegistry
+      @checks = []
+      class << self
+        attr_reader :checks
+        def included(base)
+          @checks << base
+        end
+      end
+    end
+
+    class HookSpecificCheck
+      class << self
+        attr_accessor :filetype
+        attr_accessor :stealth
+
+        def stealth!
+          self.stealth = true
+        end
+      end
+
+      def initialize(*args)
+        @arguments = args
+      end
+
+      def name
+        Overcommit::Utils.underscorize self.class.name.to_s.split('::').last
+      end
+
+      def skip?
+        false
+      end
+
+      def stealth?
+        self.class.stealth
+      end
+
+      def staged
+        @staged ||= Utils.modified_files.select do |filename|
+          filename.end_with?(".#{self.class.filetype}")
+        end
+      end
+
+      def run_check
+        [:bad, 'No checks defined!']
+      end
+
+    private
+
+      def modified_files
+        Overcommit::Utils.modified_files
+      end
+
+      def in_path?(cmd)
+        system("which #{cmd} &> /dev/null")
+      end
+
+      def commit_message
+        @commit_message ||= begin
+          unless @arguments[0] && ::File.exist?(@arguments[0])
+            fail 'Not running in the context of a commit message'
+          end
+
+          File.readlines(@arguments[0])
+        end
+      end
+
+      # Strip comments and diff (from git-commit --verbose)
+      def user_commit_message
+        @user_commit_message ||= commit_message.
+          reject     { |line| line =~ /^#/ }.
+          take_while { |line| !line.start_with?('diff --git') }
+      end
+
+      def self.file_type(type)
+        self.filetype = type
+      end
+    end
+  end
+end

data/lib/overcommit/hooks/commit_msg.rb

@@ -0,0 +1,7 @@
+module Overcommit
+  class CommitMessageHook < GitHook::BaseHook
+    # No special behavior
+  end
+
+  Utils.register_hook(CommitMessageHook)
+end

data/lib/overcommit/hooks/pre_commit.rb

@@ -0,0 +1,9 @@
+module Overcommit
+  class PreCommitHook < GitHook::BaseHook
+    def requires_modified_files?
+      true
+    end
+  end
+
+  Utils.register_hook(PreCommitHook)
+end

data/lib/overcommit/installer.rb

@@ -0,0 +1,59 @@
+require 'fileutils'
+require 'yaml'
+
+module Overcommit
+  class Installer
+    def initialize(options = {})
+      @options = options
+    end
+
+    def install(target)
+      absolute_target = File.expand_path(target)
+      unless File.directory?(File.join(absolute_target, '.git'))
+
+        raise ArgumentError, "#{target} does not appear to be a git repository"
+      end
+
+      puts "Installing hooks into #{target}"
+      hook_path = File.join(absolute_target, '.git/hooks')
+
+      install_scripts(hook_path)
+      install_hooks(hook_path)
+      write_configuration(hook_path)
+    end
+
+  private
+
+    # Make helper scripts available locally inside the repo
+    def install_scripts(target)
+      FileUtils.cp_r Utils.absolute_path('bin/scripts'), target
+    end
+
+    # Install all available git hooks into the repo
+    def install_hooks(target)
+      Dir[Utils.absolute_path('bin/hooks/*')].each do |hook|
+        FileUtils.cp hook, File.join(target, File.basename(hook))
+      end
+    end
+
+    # Dump a YAML document containing requested configuration
+    def write_configuration(target)
+      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(File.join(target, 'overcommit.yml'), 'w') do |config|
+        YAML.dump(base_config, config)
+      end
+    end
+  end
+end