Change top-level hook types to use CamelCase

Previously, the hook type names were snake case (`pre_commit`, etc).

This was a bit annoying as it was difficult to remember to switch
between underscores for the group name and camel case for the hook name.

Convert the naming convention to use camel case. Note that individual
settings are still snake case to make them further distinct from the
other camel-cased entries.

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

Author: sds

.overcommit.yml

@@ -1,3 +1,3 @@
-commit_msg:
+CommitMsg:
   GerritChangeId:
     enabled: true

config/default.yml

@@ -11,7 +11,7 @@ plugin_directory: '.githooks'
 # 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.
-post_checkout:
+PostCheckout:
   ALL:
     required: false
     quiet: true
@@ -27,7 +27,7 @@ post_checkout:
 # 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:
+PreCommit:
   ALL:
     requires_files: true
     required: false
@@ -97,7 +97,7 @@ pre_commit:
 # 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:
+CommitMsg:
   ALL:
     requires_files: false
     quiet: false

lib/overcommit/configuration.rb

@@ -30,7 +30,7 @@ def for_hook(hook, hook_type = nil)
       unless hook_type
         components = hook.class.name.split('::')
         hook = components.last
-        hook_type = Overcommit::Utils.underscorize(components[-2])
+        hook_type = components[-2]
       end
 
       # Merge hook configuration with special 'ALL' config
@@ -47,8 +47,6 @@ def merge(config)
     # Applies additional configuration settings based on the provided
     # environment variables.
     def apply_environment!(hook_type, env)
-      hook_type = hook_type.gsub('-', '_')
-
       skipped_hooks = "#{env['SKIP']} #{env['SKIP_CHECKS']}".split(/[:, ]/)
 
       if skipped_hooks.include?('all') || skipped_hooks.include?('ALL')
@@ -71,9 +69,10 @@ def apply_environment!(hook_type, env)
 
     def hook_exists?(hook_type, hook_name)
       hook_name = Overcommit::Utils.underscorize(hook_name)
+      underscored_hook_type = Overcommit::Utils.underscorize(hook_type)
 
       File.exist?(File.join(OVERCOMMIT_HOME, 'lib', 'overcommit', 'hook',
-                            hook_type, "#{hook_name}.rb"))
+                            underscored_hook_type, "#{hook_name}.rb"))
     end
 
     def hook_enabled?(hook_type, hook_name)
@@ -107,10 +106,7 @@ def smart_merge(parent, child)
     end
 
     def ensure_hook_type_sections_exist(hash)
-      hook_types = Overcommit::Utils.supported_hook_types.
-                                     map { |type| type.gsub('-', '_') }
-
-      hook_types.each do |hook_type|
+      Overcommit::Utils.supported_hook_type_classes.each do |hook_type|
         hash[hook_type] ||= {}
         hash[hook_type]['ALL'] ||= {}
       end

lib/overcommit/hook_context.rb

@@ -1,21 +1,16 @@
 # Utility module which manages the creation of {HookContext}s.
 module Overcommit::HookContext
   def self.create(hook_type, config, args, input)
-    require "overcommit/hook_context/#{hook_type.gsub('-', '_')}"
+    underscored_hook_type = Overcommit::Utils.underscorize(hook_type)
 
-    Overcommit::HookContext.const_get(hook_type_to_class_name(hook_type)).
-                            new(config, args, input)
+    require "overcommit/hook_context/#{underscored_hook_type}"
+
+    Overcommit::HookContext.const_get(hook_type).new(config, args, input)
   rescue LoadError, NameError => error
     # Could happen when a symlink was created for a hook type Overcommit does
     # not yet support.
     raise Overcommit::Exceptions::HookContextLoadError,
           "Unable to load '#{hook_type}' hook context: '#{error}'",
           error.backtrace
   end
-
-private
-
-  def self.hook_type_to_class_name(hook_type)
-    hook_type.split('-').map { |s| s.capitalize }.join
-  end
 end

lib/overcommit/hook_runner.rb

@@ -50,7 +50,7 @@ def load_hooks
     # Load hooks that ship with Overcommit, ignoring ones that are excluded from
     # the repository's configuration.
     def load_builtin_hooks
-      @config.enabled_builtin_hooks(underscored_hook_type).each do |hook_name|
+      @config.enabled_builtin_hooks(@context.hook_class_name).each do |hook_name|
         underscored_hook_name = Overcommit::Utils.underscorize(hook_name)
         require "overcommit/hook/#{underscored_hook_type}/#{underscored_hook_name}"
         @hooks << create_hook(hook_name)

lib/overcommit/utils.rb

@@ -39,6 +39,13 @@ def supported_hook_types
           map { |file| File.basename(file, '.rb').gsub('_', '-') }
       end
 
+      # 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
+
       # Returns whether a command can be found given the current environment path.
       def in_path?(cmd)
         exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']

libexec/overcommit-hook

@@ -16,7 +16,7 @@ end
 
 begin
   require 'overcommit'
-rescue LoadError => ex
+rescue LoadError
   puts 'Overcommit is not installed. Install it to manage git hooks for ' <<
        'this repository? (y/n)'
 
@@ -35,14 +35,16 @@ rescue LoadError => ex
 end
 
 begin
+  hook_type_class = Overcommit::Utils.camel_case(hook_type)
+
   config = Overcommit::ConfigurationLoader.load_repo_config
-  config.apply_environment!(hook_type, ENV)
+  config.apply_environment!(hook_type_class, ENV)
 
   # Ensure this script and all symlinks are always up-to-date (it's cheap to do)
   #Overcommit::Installer.new(Overcommit::Logger.silent).
   #                      run(Overcommit::Utils.repo_root, :action => :install)
 
-  context = Overcommit::HookContext.create(hook_type, config, ARGV, STDIN)
+  context = Overcommit::HookContext.create(hook_type_class, config, ARGV, STDIN)
   logger = Overcommit::Logger.new(STDOUT)
   runner = Overcommit::HookRunner.new(config, logger)
 

spec/integration/committing_spec.rb

@@ -4,10 +4,10 @@
   subject { shell('git commit --allow-empty -m "Test"') }
 
   let(:config) { <<-YML }
-    commit_msg:
+    CommitMsg:
       ALL:
         enabled: false
-    pre_commit:
+    PreCommit:
       ALL:
         enabled: false
       AuthorName:

spec/overcommit/configuration_spec.rb

@@ -14,25 +14,25 @@
 
     context 'when no configuration exists for a hook type' do
       it 'creates sections for those hook types' do
-        internal_hash.should have_key 'pre_commit'
+        internal_hash.should have_key 'PreCommit'
       end
 
       it 'creates the special ALL section for the hook type' do
-        internal_hash['pre_commit'].should have_key 'ALL'
+        internal_hash['PreCommit'].should have_key 'ALL'
       end
     end
 
     context 'when keys with empty values exist' do
       let(:hash) do
         {
-          'pre_commit' => {
+          'PreCommit' => {
             'SomeHook' => nil
           },
         }
       end
 
       it 'converts the values to empty hashes' do
-        internal_hash['pre_commit']['SomeHook'].should == {}
+        internal_hash['PreCommit']['SomeHook'].should == {}
       end
     end
   end
@@ -53,7 +53,7 @@
   describe '#enabled_builtin_hooks' do
     let(:hash) do
       {
-        'pre_commit' => {
+        'PreCommit' => {
           'SomeHook' => nil,
           'SomeOtherHook' => {
             'enabled' => false
@@ -62,7 +62,7 @@
       }
     end
 
-    subject { config.enabled_builtin_hooks('pre_commit') }
+    subject { config.enabled_builtin_hooks('PreCommit') }
 
     it 'includes hooks that are not disabled' do
       subject.should == ['SomeHook']
@@ -72,7 +72,7 @@
   describe '#for_hook' do
     let(:hash) do
       {
-        'pre_commit' => {
+        'PreCommit' => {
           'ALL' => {
             'required' => false,
           },
@@ -84,7 +84,7 @@
       }
     end
 
-    subject { config.for_hook('SomeHook', 'pre_commit') }
+    subject { config.for_hook('SomeHook', 'PreCommit') }
 
     it 'returns the subset of the config for the specified hook' do
       subject['enabled'].should be_true
@@ -132,43 +132,43 @@
     end
 
     context 'when parent item contains a hash' do
-      let(:parent) { { 'pre_commit' => { 'SomeHook' => { 'some-value' => 1 } } } }
+      let(:parent) { { 'PreCommit' => { 'SomeHook' => { 'some-value' => 1 } } } }
 
       context 'and child item contains a different hash under the same key' do
-        let(:child) { { 'pre_commit' => { 'SomeOtherHook' => { 'something' => 2 } } } }
+        let(:child) { { 'PreCommit' => { 'SomeOtherHook' => { 'something' => 2 } } } }
 
         it 'merges the hashes together' do
-          subject.for_hook('SomeHook', 'pre_commit').should == { 'some-value' => 1 }
-          subject.for_hook('SomeOtherHook', 'pre_commit').should == { 'something' => 2 }
+          subject.for_hook('SomeHook', 'PreCommit').should == { 'some-value' => 1 }
+          subject.for_hook('SomeOtherHook', 'PreCommit').should == { 'something' => 2 }
         end
       end
 
       context 'and child item contains a hash under a different key' do
-        let(:child) { { 'commit_msg' => { 'SomeHook' => { 'some-value' => 2 } } } }
+        let(:child) { { 'CommitMsg' => { 'SomeHook' => { 'some-value' => 2 } } } }
 
         it 'appends the item to the parent array' do
-          subject.for_hook('SomeHook', 'pre_commit').should == { 'some-value' => 1 }
-          subject.for_hook('SomeHook', 'commit_msg').should == { 'some-value' => 2 }
+          subject.for_hook('SomeHook', 'PreCommit').should == { 'some-value' => 1 }
+          subject.for_hook('SomeHook', 'CommitMsg').should == { 'some-value' => 2 }
         end
       end
     end
 
     context 'when parent item contains an array' do
-      let(:parent) { { 'pre_commit' => { 'SomeHook' => { 'list' => [1, 2, 3] } } } }
+      let(:parent) { { 'PreCommit' => { 'SomeHook' => { 'list' => [1, 2, 3] } } } }
 
       context 'and child item contains an array' do
-        let(:child) { { 'pre_commit' => { 'SomeHook' => { 'list' => [4, 5] } } } }
+        let(:child) { { 'PreCommit' => { 'SomeHook' => { 'list' => [4, 5] } } } }
 
         it 'concatenates the arrays together' do
-          subject.for_hook('SomeHook', 'pre_commit')['list'] == [1, 2, 3, 4, 5]
+          subject.for_hook('SomeHook', 'PreCommit')['list'] == [1, 2, 3, 4, 5]
         end
       end
 
       context 'and child item contains a single item' do
-        let(:child) { { 'pre_commit' => { 'SomeHook' => { 'list' => 4 } } } }
+        let(:child) { { 'PreCommit' => { 'SomeHook' => { 'list' => 4 } } } }
 
         it 'appends the item to the parent array' do
-          subject.for_hook('SomeHook', 'pre_commit')['list'] == [1, 2, 3, 4]
+          subject.for_hook('SomeHook', 'PreCommit')['list'] == [1, 2, 3, 4]
         end
       end
     end
@@ -181,7 +181,7 @@
     subject { config }
 
     before do
-      config.apply_environment!('pre-commit', env)
+      config.apply_environment!('PreCommit', env)
     end
 
     context 'when no hooks are requested to be skipped' do
@@ -204,22 +204,22 @@
       let(:env) { { 'SKIP' => 'AuthorName' } }
 
       it 'sets the skip option of the hook to true' do
-        subject.for_hook('AuthorName', 'pre_commit')['skip'].should be_true
+        subject.for_hook('AuthorName', 'PreCommit')['skip'].should be_true
       end
 
       context 'and the hook is spelt with underscores' do
         let(:env) { { 'SKIP' => 'author_name' } }
 
         it 'sets the skip option of the hook to true' do
-          subject.for_hook('AuthorName', 'pre_commit')['skip'].should be_true
+          subject.for_hook('AuthorName', 'PreCommit')['skip'].should be_true
         end
       end
 
       context 'and the hook is spelt with hyphens' do
         let(:env) { { 'SKIP' => 'author-name' } }
 
         it 'sets the skip option of the hook to true' do
-          subject.for_hook('AuthorName', 'pre_commit')['skip'].should be_true
+          subject.for_hook('AuthorName', 'PreCommit')['skip'].should be_true
         end
       end
     end
@@ -228,14 +228,14 @@
       let(:env) { { 'SKIP' => 'all' } }
 
       it 'sets the skip option of the ALL section to true' do
-        subject.for_hook('ALL', 'pre_commit')['skip'].should be_true
+        subject.for_hook('ALL', 'PreCommit')['skip'].should be_true
       end
 
       context 'and "all" is capitalized' do
         let(:env) { { 'SKIP' => 'ALL' } }
 
         it 'sets the skip option of the special ALL config to true' do
-          subject.for_hook('ALL', 'pre_commit')['skip'].should be_true
+          subject.for_hook('ALL', 'PreCommit')['skip'].should be_true
         end
       end
     end

spec/overcommit/hook/pre_commit/author_email_spec.rb

@@ -32,7 +32,7 @@
   context 'when a custom pattern is specified' do
     let(:config) do
       super().merge(Overcommit::Configuration.new(
-        'pre_commit' => {
+        'PreCommit' => {
           'AuthorEmail' => {
             'pattern' => '^[^@]+@causes\.com$'
           }