overcommit 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd49b47c55670147b58f3b1f9d24c563af35b589
-  data.tar.gz: 986b58c2716ebd051826a84f420e1c568ba98e7e
+  metadata.gz: a23b361b3bac1357e190f81ea1912710b9bd62bf
+  data.tar.gz: d0d707d8f82ed50aff865fd170b769baf8d78869
 SHA512:
-  metadata.gz: 555c4a7777514b88d459eff53b03e5be698499273c95d24b0fa39b779f5ab0d2d59334ec497eaca1061852e06ca14b4d69af0fdd8119dbdc40509c069d29a3b5
-  data.tar.gz: d4e0f5ce2ca1c0a5af8f430c65e7f485c3936837e09659f460e489d8f11cfcf30731ac4fd331984816ecb501cffeaff0e87624911c8cabb93e16be8d21580f5b
+  metadata.gz: a7a1110c6239f00662de316e677dab141db03ae87f9c13eca2c2a0dc2b78ed5b3bb41cbbf0d4c11a79436423b0a3cda2215de6a4d926c7b3a48e0b4ab586e1ca
+  data.tar.gz: 408ac82b4911e94f48670c674870eb79acfd93109f2edd1ca19993c49f6a40f193161a8cd1f26ec7b4121ee66e0391f3ce12715a332152bca128636ec218476d

data/bin/overcommit

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

data/config/default.yml

@@ -0,0 +1,139 @@
+# 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: '.git-hooks'
+
+# Hooks that run after HEAD changes or a file is explicitly checked out. Useful
+# for updating source tags (e.g. via ctags) or warning about new migrations,
+# etc.
+PostCheckout:
+  ALL:
+    required: false
+    quiet: false
+  BundleCheck:
+    description: 'Checking Gemfile dependencies'
+    include:
+      - 'Gemfile'
+      - 'Gemfile.lock'
+      - '*.gemspec'
+  IndexTags:
+    description: 'Indexing source code tags'
+
+# 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.
+PreCommit:
+  ALL:
+    requires_files: true
+    required: false
+    quiet: false
+
+  AuthorEmail:
+    description: 'Checking author email'
+    requires_files: false
+    required: true
+    quiet: true
+    pattern: '^[^@]+@.*$'
+
+  AuthorName:
+    description: 'Checking for author name'
+    requires_files: false
+    required: true
+    quiet: true
+
+  BundleCheck:
+    description: 'Checking Gemfile dependencies'
+    include:
+      - 'Gemfile'
+      - 'Gemfile.lock'
+      - '*.gemspec'
+
+  CoffeeLint:
+    description: 'Analyzing with coffeelint'
+    include: '**/*.coffee'
+
+  CssLint:
+    description: 'Analyzing with csslint'
+    include: '**/*.css'
+
+  HamlLint:
+    description: 'Analyzing with haml-lint'
+    include: '**/*.haml'
+
+  HardTabs:
+    description: 'Checking for hard tabs'
+
+  ImageOptim:
+    description: 'Checking for optimizable images'
+    include:
+      - '**/*.gif'
+      - '**/*.jpg'
+      - '**/*.jpeg'
+      - '**/*.png'
+
+  Jscs:
+    description: 'Analyzing with JSCS'
+    include: '**/*.js'
+
+  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'
+
+  TrailingWhitespace:
+    description: 'Checking for trailing whitespace'
+
+  YamlSyntax:
+    description: 'Checking YAML syntax'
+    include: '**/*.yml'
+
+# 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.
+CommitMsg:
+  ALL:
+    requires_files: false
+    quiet: false
+
+  GerritChangeId:
+    enabled: false
+    description: 'Ensuring Gerrit Change-Id is present'
+    required: true
+
+  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'

data/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_context/base'
+require 'overcommit/hook_context'
+require 'overcommit/hook_runner'
 require 'overcommit/installer'
 require 'overcommit/logger'
-require 'overcommit/reporter'
-require 'overcommit/staged_file'
 require 'overcommit/utils'
 require 'overcommit/version'

data/lib/overcommit/cli.rb

@@ -1,75 +1,61 @@
 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 run
+      parse_arguments
+
+      case @options[:action]
+      when :install, :uninstall
+        install_or_uninstall
+      when :template_dir
+        print_template_directory_path
+      end
+    end
+
+  private
+
+    attr_reader :log
+
     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
+          print_version(opts.program_name)
         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
+        opts.on('-u', '--uninstall', 'Remove Overcommit hooks from a repository') do
+          @options[:action] = :uninstall
         end
 
-        opts.on('-a', '--all', 'Include all git hooks') do
-          @options[:template] = 'all'
+        opts.on('-i', '--install', 'Install Overcommit hooks in a repository') do
+          @options[:action] = :install
         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
-          @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('-t', '--template-dir', 'Print location of template directory') do
+          @options[:action] = :template_dir
         end
       end
 
       begin
         @parser.parse!(@arguments)
 
+        # Default action is to install
+        @options[:action] ||= :install
+
         # Unconsumed arguments are our targets
         @options[:targets] = @arguments
       rescue OptionParser::InvalidOption => ex
@@ -77,38 +63,47 @@ module Overcommit
       end
     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
+    def install_or_uninstall
+      if Array(@options[:targets]).empty?
+        @options[:targets] = [Overcommit::Utils.repo_root].compact
+      end
+
+      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
 
       @options[:targets].each do |target|
         begin
-          Installer.new(@options, target).run
-        rescue NotAGitRepoError => e
-          log.warning "Skipping #{target}: #{e}"
+          Installer.new(log).run(target, @options)
+        rescue Overcommit::Exceptions::InvalidGitRepo => error
+          log.warning "Invalid repo #{target}: #{error}"
+          halt 69 # EX_UNAVAILABLE
         end
       end
+    end
 
-      log.success "#{@options[:uninstall] ? 'Removal' : 'Installation'} complete"
-
-    rescue ArgumentError => ex
-      error "Installation failed: #{ex}"
-      exit 3
+    def print_template_directory_path
+      puts File.join(OVERCOMMIT_HOME, 'template-dir')
+      halt
     end
 
-  private
+    def print_help(message, error = nil)
+      log.error "#{error}\n" if error
+      log.log message
+      halt(error ? 64 : 0) # 64 = EX_USAGE
+    end
 
-    def log
-      Logger.instance
+    def print_version(program_name)
+      log.log "#{program_name} #{Overcommit::VERSION}"
+      halt
     end
 
-    def print_help(message, ex = nil)
-      log.error ex.to_s + "\n" if ex
-      log.log message
-      exit 0
+    # Used for ease of stubbing in tests
+    def halt(status = 0)
+      exit status
     end
   end
 end

data/lib/overcommit/configuration.rb

@@ -1,54 +1,128 @@
-require 'singleton'
-require 'yaml'
-
 module Overcommit
+  # Stores configuration for Overcommit and the hooks it runs.
   class Configuration
-    include Singleton
+    # Creates a configuration from the given hash.
+    def initialize(hash)
+      @hash = hash
+      validate
+    end
+
+    def ==(other)
+      super || @hash == other.hash
+    end
+    alias_method :eql?, :==
 
-    attr_reader :templates
+    # 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')
+    end
 
-    def initialize
-      @templates = YAML.load_file(Utils.absolute_path('config/templates.yml'))
+    # Returns the built-in hooks that have been enabled for a hook type.
+    def enabled_builtin_hooks(hook_type)
+      @hash[hook_type].keys.
+        select { |hook_name| hook_name != 'ALL' }.
+        select { |hook_name| hook_enabled?(hook_type, hook_name) }
     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')
+    # Returns a non-modifiable configuration for a hook.
+    def for_hook(hook, hook_type = nil)
+      unless hook_type
+        components = hook.class.name.split('::')
+        hook = components.last
+        hook_type = components[-2]
+      end
 
-      File.exist?(config_file) ? YAML.load_file(config_file) : {}
+      # Merge hook configuration with special 'ALL' config
+      smart_merge(@hash[hook_type]['ALL'], @hash[hook_type][hook] || {}).freeze
     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'] || {}
+    # Merges the given configuration with this one, returning a new
+    # {Configuration}. The provided configuration will either add to or replace
+    # any options defined in this configuration.
+    def merge(config)
+      self.class.new(smart_merge(@hash, config.hash))
+    end
 
-      plugin_directories.map do |dir|
-        Dir[File.join(dir, Utils.hook_name, '*.rb')].map do |plugin|
-          basename = File.basename(plugin, '.rb')
-          if !(excludes[Utils.hook_name] || []).include?(basename)
-            plugin
-          end
-        end.compact
-      end.flatten
+    # Applies additional configuration settings based on the provided
+    # environment variables.
+    def apply_environment!(hook_type, env)
+      skipped_hooks = "#{env['SKIP']} #{env['SKIP_CHECKS']} #{env['SKIP_HOOKS']}".split(/[:, ]/)
+
+      if skipped_hooks.include?('all') || skipped_hooks.include?('ALL')
+        @hash[hook_type]['ALL']['skip'] = true
+      else
+        skipped_hooks.select { |hook_name| hook_exists?(hook_type, 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
     end
 
+  protected
+
+    attr_reader :hash
+
   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')
+    def hook_exists?(hook_type, hook_name)
+      hook_name = Overcommit::Utils.snake_case(hook_name)
+      underscored_hook_type = Overcommit::Utils.snake_case(hook_type)
+
+      File.exist?(File.join(OVERCOMMIT_HOME, 'lib', 'overcommit', 'hook',
+                            underscored_hook_type, "#{hook_name}.rb"))
+    end
+
+    def hook_enabled?(hook_type, hook_name)
+      individual_enabled = @hash[hook_type][hook_name]['enabled']
+      return individual_enabled unless individual_enabled.nil?
 
-      # Add on any repo-specific checks
-      plugin_dirs << repo_specific if File.directory?(repo_specific)
+      all_enabled = @hash[hook_type]['ALL']['enabled']
+      return all_enabled unless all_enabled.nil?
 
-      plugin_dirs
+      true
     end
-  end
 
-  def self.config
-    Configuration.instance
+    # Validates the configuration for any invalid options, normalizing it where
+    # possible.
+    def validate
+      @hash = convert_nils_to_empty_hashes(@hash)
+      ensure_hook_type_sections_exist(@hash)
+    end
+
+    def smart_merge(parent, child)
+      parent.merge(child) do |key, old, new|
+        case old
+        when Array
+          old + Array(new)
+        when Hash
+          smart_merge(old, new)
+        else
+          new
+        end
+      end
+    end
+
+    def ensure_hook_type_sections_exist(hash)
+      Overcommit::Utils.supported_hook_type_classes.each do |hook_type|
+        hash[hook_type] ||= {}
+        hash[hook_type]['ALL'] ||= {}
+      end
+    end
+
+    def convert_nils_to_empty_hashes(hash)
+      hash.inject({}) do |h, (key, value)|
+        h[key] =
+          case value
+          when nil  then {}
+          when Hash then convert_nils_to_empty_hashes(value)
+          else
+            value
+          end
+        h
+      end
+    end
   end
 end