overcommit 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 92e61229cb593b12785dc6f250aaf20b59335277
-  data.tar.gz: 6109a2ebdd9e9ad8fb6612178dc38c919decc366
+  metadata.gz: 6030d9d4951a3c37f536bfd4caefc3890c6c4f2d
+  data.tar.gz: 04a5f6031e2217c33382a2c034f7670f711dbdbe
 SHA512:
-  metadata.gz: 9a30a6cef4ea66c146c536e3868e12e2ce8a80dbc4c10955e3e6f18990dc0f75a21e439032bdcd180086aa6fd47a4a327d9ca36441f654f4e1400777ce333d8c
-  data.tar.gz: 1d0a931ee95dac1fa0f7bf35f3e154033d831df840f1ba30772108612bc5aafd52315bded077ec359873cc2d3298f76aca2800fec55ae862b89f45867af15b11
+  metadata.gz: c6769844c60d201e95417a06610daef7c1a5465184c176423ad7bf9bfb958373116fe8d17085ecc9f2d741677d9a928e28df6ac6b174f5499d8907837eef1305
+  data.tar.gz: 49c7bbeafda273737fafc8aba005eda1b5c13774932a143c7c85664ee32f4f84898999c1da2cea9f4b2ffb2eae490386bef0b8c744b76a798a9c90478f859000

data/config/default.yml

@@ -8,6 +8,12 @@
 # to the root of the repository.
 plugin_directory: '.git-hooks'
 
+# Whether to check if a hook plugin has changed since Overcommit last ran it.
+# This is a defense mechanism when working with repositories which can contain
+# untrusted code (e.g. when you fetch a pull request from a third party).
+# See https://github.com/causes/overcommit#security for more information.
+verify_plugin_signatures: true
+
 # 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.
@@ -105,6 +111,10 @@ PreCommit:
   TrailingWhitespace:
     description: 'Checking for trailing whitespace'
 
+  TravisLint:
+    description: 'Checking Travis CI configuration'
+    include: '.travis.yml'
+
   YamlSyntax:
     description: 'Checking YAML syntax'
     include: '**/*.yml'

data/lib/overcommit.rb

@@ -5,6 +5,11 @@ require 'overcommit/configuration_loader'
 require 'overcommit/hook/base'
 require 'overcommit/hook_context/base'
 require 'overcommit/hook_context'
+require 'overcommit/user_input'
+require 'overcommit/hook_signer'
+require 'overcommit/hook_loader/base'
+require 'overcommit/hook_loader/built_in_hook_loader'
+require 'overcommit/hook_loader/plugin_hook_loader'
 require 'overcommit/hook_runner'
 require 'overcommit/installer'
 require 'overcommit/logger'

data/lib/overcommit/cli.rb

@@ -74,7 +74,7 @@ module Overcommit
 
       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 ' <<
+        log.log 'You must either specify the path to a repository or ' \
                 'change your current directory to a repository.'
         halt 64 # EX_USAGE
       end

data/lib/overcommit/configuration.rb

@@ -18,6 +18,10 @@ module Overcommit
       File.join(Overcommit::Utils.repo_root, @hash['plugin_directory'] || '.githooks')
     end
 
+    def verify_plugin_signatures?
+      @hash['verify_plugin_signatures'] != false
+    end
+
     # Returns the built-in hooks that have been enabled for a hook type.
     def enabled_builtin_hooks(hook_context)
       @hash[hook_context.hook_class_name].keys.

data/lib/overcommit/configuration_loader.rb

@@ -6,42 +6,44 @@ module Overcommit
     DEFAULT_CONFIG_PATH = File.join(OVERCOMMIT_HOME, 'config', 'default.yml')
     FILE_NAME = '.overcommit.yml'
 
-    def self.load_repo_config
-      overcommit_yml = File.join(Overcommit::Utils.repo_root, FILE_NAME)
+    class << self
+      def load_repo_config
+        overcommit_yml = File.join(Overcommit::Utils.repo_root, FILE_NAME)
 
-      if File.exists?(overcommit_yml)
-        load_file(overcommit_yml)
-      else
-        default_configuration
+        if File.exist?(overcommit_yml)
+          load_file(overcommit_yml)
+        else
+          default_configuration
+        end
       end
-    end
 
-    def self.default_configuration
-      @default_config ||= load_from_file(DEFAULT_CONFIG_PATH)
-    end
+      def default_configuration
+        @default_config ||= load_from_file(DEFAULT_CONFIG_PATH)
+      end
 
-  private
+    private
 
-    # Loads a configuration, ensuring it extends the default configuration.
-    def self.load_file(file)
-      config = load_from_file(file)
+      # Loads a configuration, ensuring it extends the default configuration.
+      def load_file(file)
+        config = load_from_file(file)
 
-      default_configuration.merge(config)
-    rescue => error
-      raise Overcommit::Exceptions::ConfigurationError,
-            "Unable to load configuration from '#{file}': #{error}",
-            error.backtrace
-    end
+        default_configuration.merge(config)
+      rescue => error
+        raise Overcommit::Exceptions::ConfigurationError,
+              "Unable to load configuration from '#{file}': #{error}",
+              error.backtrace
+      end
 
-    def self.load_from_file(file)
-      hash =
-        if yaml = YAML.load_file(file)
-          yaml.to_hash
-        else
-          {}
-        end
+      def load_from_file(file)
+        hash =
+          if yaml = YAML.load_file(file)
+            yaml.to_hash
+          else
+            {}
+          end
 
-      Overcommit::Configuration.new(hash)
+        Overcommit::Configuration.new(hash)
+      end
     end
   end
 end

data/lib/overcommit/exceptions.rb

@@ -2,6 +2,12 @@ module Overcommit::Exceptions
   # Raised when a {Configuration} could not be loaded from a file.
   class ConfigurationError < StandardError; end
 
+  # Raised when trying to read/write to/from the local repo git config fails.
+  class GitConfigError < StandardError; end
+
+  # Raised when a hook run was cancelled by the user.
+  class HookCancelled < StandardError; end
+
   # Raised when a hook could not be loaded by a {HookRunner}.
   class HookLoadError < StandardError; end
 

data/lib/overcommit/hook/commit_msg/gerrit_change_id.rb

@@ -6,13 +6,13 @@ module Overcommit::Hook::CommitMsg
   # you need to do it in a commit-msg hook. This is because the user could still
   # edit the message after a prepare-commit-msg hook was run.
   class GerritChangeId < Base
+    SCRIPT_LOCATION = Overcommit::Utils.script_path('gerrit-change-id')
+
     def run
       result = execute([SCRIPT_LOCATION, commit_message_file])
-      return (result.success? ? :good : :bad), result.stdout
-    end
+      return :good if result.success?
 
-  private
-
-    SCRIPT_LOCATION = Overcommit::Utils.script_path('gerrit-change-id')
+      [:bad, result.stdout]
+    end
   end
 end

data/lib/overcommit/hook/commit_msg/text_width.rb

@@ -16,7 +16,7 @@ module Overcommit::Hook::CommitMsg
         commit_message_lines[2..-1].each_with_index do |line, index|
           chomped = line.chomp
           if chomped.size > max_body_width
-            error = "Line #{index + 3} of commit message has > " <<
+            error = "Line #{index + 3} of commit message has > " \
                     "#{max_body_width} characters"
             errors << error
           end

data/lib/overcommit/hook/post_checkout/bundle_check.rb

@@ -7,13 +7,17 @@ module Overcommit::Hook::PostCheckout
         return :warn, 'bundler not installed -- run `gem install bundler`'
       end
 
-      return :warn if dependencies_changed? && !dependencies_satisfied?
+      if dependencies_changed? && !dependencies_satisfied?
+        return :warn, "#{LOCK_FILE} is not up-to-date -- run `bundle check`"
+      end
 
       :good
     end
 
   private
 
+    LOCK_FILE = 'Gemfile.lock'
+
     def dependencies_changed?
       result = execute(%w[git diff --exit-code --name-only] + [new_head, previous_head])
 

data/lib/overcommit/hook/pre_commit/author_email.rb

@@ -6,8 +6,8 @@ module Overcommit::Hook::PreCommit
       email = result.stdout.chomp
 
       unless email =~ /#{@config['pattern']}/
-        return :bad, "Author has an invalid email address: '#{email}'\n" <<
-                     'Set your email with ' <<
+        return :bad, "Author has an invalid email address: '#{email}'\n" \
+                     'Set your email with ' \
                      '`git config --global user.email your_email@example.com`'
       end
 

data/lib/overcommit/hook/pre_commit/author_name.rb

@@ -6,8 +6,8 @@ module Overcommit::Hook::PreCommit
       name = result.stdout.chomp
 
       unless name.split(' ').count >= 2
-        return :bad, 'Author must have at least first and last name, but ' <<
-                     "was: '#{name}'.\nSet your name with " <<
+        return :bad, 'Author must have at least first and last name, but ' \
+                     "was: '#{name}'.\nSet your name with " \
                      "`git config --global user.name 'Your Name'`"
       end
 

data/lib/overcommit/hook/pre_commit/bundle_check.rb

@@ -2,6 +2,8 @@ module Overcommit::Hook::PreCommit
   # Check if local Gemfile.lock matches Gemfile when either changes, unless
   # Gemfile.lock is ignored by git.
   class BundleCheck < Base
+    LOCK_FILE = 'Gemfile.lock'
+
     def run
       unless in_path?('bundle')
         return :warn, 'bundler not installed -- run `gem install bundler`'
@@ -22,9 +24,5 @@ module Overcommit::Hook::PreCommit
 
       :good
     end
-
-  private
-
-    LOCK_FILE = 'Gemfile.lock'
   end
 end

data/lib/overcommit/hook/pre_commit/coffee_lint.rb

@@ -8,7 +8,8 @@ module Overcommit::Hook::PreCommit
 
       result = execute(%w[coffeelint --quiet] + applicable_files)
       return :good if result.success?
-      return :bad, result.stdout
+
+      [:bad, result.stdout]
     end
   end
 end

data/lib/overcommit/hook/pre_commit/css_lint.rb

@@ -7,8 +7,9 @@ module Overcommit::Hook::PreCommit
       end
 
       result = execute(%w[csslint --quiet --format=compact] + applicable_files)
-      output = result.stdout
-      return (output !~ /Error - (?!Unknown @ rule)/ ? :good : :bad), output
+      return :good if result.stdout !~ /Error - (?!Unknown @ rule)/
+
+      [:bad, result.stdout]
     end
   end
 end

data/lib/overcommit/hook/pre_commit/haml_lint.rb

@@ -19,8 +19,9 @@ module Overcommit::Hook::PreCommit
       end
 
       return :bad, error_lines.join("\n") unless error_lines.empty?
-      return :warn, "Modified files have lints (on lines you didn't modify)\n" <<
-                    warning_lines.join("\n")
+
+      [:warn, "Modified files have lints (on lines you didn't modify)\n" <<
+              warning_lines.join("\n")]
     end
   end
 end

data/lib/overcommit/hook/pre_commit/js_hint.rb

@@ -9,7 +9,9 @@ module Overcommit::Hook::PreCommit
       result = execute(%w[jshint] + applicable_files)
       output = result.stdout
 
-      return (output.empty? ? :good : :bad), output
+      return :good if output.empty?
+
+      [:bad, output]
     end
   end
 end

data/lib/overcommit/hook/pre_commit/jscs.rb

@@ -24,8 +24,9 @@ module Overcommit::Hook::PreCommit
       end
 
       return :bad, error_lines.join("\n") unless error_lines.empty?
-      return :warn, "Modified files have lints (on lines you didn't modify)\n" <<
-                    warning_lines.join("\n")
+
+      [:warn, "Modified files have lints (on lines you didn't modify)\n" <<
+              warning_lines.join("\n")]
     end
   end
 end

data/lib/overcommit/hook/pre_commit/python_flake8.rb

@@ -7,8 +7,9 @@ module Overcommit::Hook::PreCommit
       end
 
       result = execute(%w[flake8] + applicable_files)
+      return :good if result.success?
 
-      return (result.success? ? :good : :bad), result.stdout
+      [:bad, result.stdout]
     end
   end
 end

data/lib/overcommit/hook/pre_commit/rubocop.rb

@@ -21,8 +21,9 @@ module Overcommit::Hook::PreCommit
       end
 
       return :bad, error_lines.join("\n") unless error_lines.empty?
-      return :warn, "Modified files have lints (on lines you didn't modify)\n" <<
-                    warning_lines.join("\n")
+
+      [:warn, "Modified files have lints (on lines you didn't modify)\n" <<
+              warning_lines.join("\n")]
     end
   end
 end

data/lib/overcommit/hook/pre_commit/scss_lint.rb

@@ -19,8 +19,9 @@ module Overcommit::Hook::PreCommit
       end
 
       return :bad, error_lines.join("\n") unless error_lines.empty?
-      return :warn, "Modified files have lints (on lines you didn't modify)\n" <<
-                    warning_lines.join("\n")
+
+      [:warn, "Modified files have lints (on lines you didn't modify)\n" <<
+              warning_lines.join("\n")]
     end
   end
 end

data/lib/overcommit/hook/pre_commit/travis_lint.rb

@@ -0,0 +1,15 @@
+module Overcommit::Hook::PreCommit
+  # Runs `travis-lint` against any modified Travis CI files.
+  class TravisLint < Base
+    def run
+      unless in_path?('travis-lint')
+        return :warn, 'Run `gem install travis-lint`'
+      end
+
+      result = execute(%w[travis-lint] + applicable_files)
+      return :good if result.success?
+
+      [:bad, result.stdout.strip]
+    end
+  end
+end

data/lib/overcommit/hook/pre_commit/yaml_syntax.rb

@@ -4,7 +4,6 @@ module Overcommit::Hook::PreCommit
   # Checks the syntax of any modified YAML files.
   class YamlSyntax < Base
     def run
-      clean = true
       output = []
 
       applicable_files.each do |file|
@@ -12,11 +11,12 @@ module Overcommit::Hook::PreCommit
           YAML.load_file(file)
         rescue ArgumentError => e
           output << "#{e.message} parsing #{file}"
-          clean = false
         end
       end
 
-      return (clean ? :good : :bad), output
+      return :good if output.empty?
+
+      [:bad, output]
     end
   end
 end

data/lib/overcommit/hook_context/post_checkout.rb

@@ -1,4 +1,6 @@
 module Overcommit::HookContext
+  # Contains helpers related to contextual information used by post-checkout
+  # hooks.
   class PostCheckout < Base
     # Returns the ref of the HEAD that we transitioned from.
     def previous_head

data/lib/overcommit/hook_loader/base.rb

@@ -0,0 +1,38 @@
+module Overcommit::HookLoader
+  # Responsible for loading hooks from a file.
+  class Base
+    # @param config [Overcommit::Configuration]
+    # @param context [Overcommit::HookContext]
+    # @param logger [Overcommit::Logger]
+    # @param input [Overcommit::UserInput]
+    def initialize(config, context, logger, input)
+      @config = config
+      @context = context
+      @log = logger
+      @input = input
+    end
+
+    # When implemented in subclasses, loads the hooks for which that subclass is
+    # responsible.
+    #
+    # @return [Array<Hook>]
+    def load_hooks
+      raise NotImplementedError
+    end
+
+  private
+
+    attr_reader :log
+
+    # Load and return a {Hook} from a CamelCase hook name.
+    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/hook_loader/built_in_hook_loader.rb

@@ -0,0 +1,12 @@
+module Overcommit::HookLoader
+  # Responsible for loading hooks that ship with Overcommit.
+  class BuiltInHookLoader < Base
+    def load_hooks
+      @config.enabled_builtin_hooks(@context).map do |hook_name|
+        underscored_hook_name = Overcommit::Utils.snake_case(hook_name)
+        require "overcommit/hook/#{@context.hook_type_name}/#{underscored_hook_name}"
+        create_hook(hook_name)
+      end
+    end
+  end
+end

data/lib/overcommit/hook_loader/plugin_hook_loader.rb

@@ -0,0 +1,51 @@
+require 'digest'
+
+module Overcommit::HookLoader
+  # Responsible for loading hooks that are specific to the repository Overcommit
+  # is running in.
+  class PluginHookLoader < Base
+    def load_hooks
+      directory = File.join(@config.plugin_directory, @context.hook_type_name)
+      plugin_paths = Dir[File.join(directory, '*.rb')].sort
+
+      check_for_modified_plugins(plugin_paths) if @config.verify_plugin_signatures?
+
+      plugin_paths.map do |plugin_path|
+        require plugin_path
+
+        hook_name = Overcommit::Utils.camel_case(File.basename(plugin_path, '.rb'))
+        create_hook(hook_name)
+      end
+    end
+
+  private
+
+    def check_for_modified_plugins(plugin_paths)
+      modified_plugins = plugin_paths.
+        map { |path| Overcommit::HookSigner.new(path, @config, @context) }.
+        select { |signer| signer.signature_changed? }
+
+      return if modified_plugins.empty?
+
+      log.bold_warning "The following #{@context.hook_script_name} plugins " \
+                       "have been added, changed, or had their configuration modified:"
+      log.log
+
+      modified_plugins.each do |signer|
+        log.warning " * #{signer.hook_name} in #{signer.hook_path}"
+      end
+
+      log.log
+      log.bold_warning 'You should verify the changes before continuing'
+      log.log "For more information, see #{Overcommit::REPO_URL}#security"
+      log.log
+      log.partial 'Continue? (y/n) '
+
+      unless (answer = @input.get) && answer.strip.downcase.start_with?('y')
+        raise Overcommit::Exceptions::HookCancelled
+      end
+
+      modified_plugins.each { |signer| signer.update_signature! }
+    end
+  end
+end

data/lib/overcommit/hook_runner.rb

@@ -4,17 +4,22 @@ 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)
+    # @param config [Overcommit::Configuration]
+    # @param logger [Overcommit::Logger]
+    # @param context [Overcommit::HookContext]
+    # @param input [Overcommit::UserInput]
+    def initialize(config, logger, context, input)
       @config = config
       @log = logger
       @context = context
+      @input = input
       @hooks = []
     end
 
     # Loads and runs the hooks registered for this {HookRunner}.
     def run
-      load_hooks
       @context.setup_environment
+      load_hooks
       run_hooks
     ensure
       @context.cleanup_environment
@@ -26,7 +31,7 @@ module Overcommit
 
     def run_hooks
       if @hooks.any? { |hook| hook.run? || hook.skip? }
-        log.bold "Running #{@context.hook_script_name} hooks"
+        log.bold "Running #{hook_script_name} hooks"
 
         statuses = @hooks.map { |hook| run_hook(hook) }.compact
 
@@ -35,33 +40,22 @@ module Overcommit
         run_failed = statuses.include?(:bad)
 
         if run_failed
-          log.error "✗ One or more #{@context.hook_script_name} hooks failed"
+          log.error "✗ One or more #{hook_script_name} hooks failed"
         else
-          log.success "✓ All #{@context.hook_script_name} hooks passed"
+          log.success "✓ All #{hook_script_name} hooks passed"
         end
 
         log.log # Newline
 
         !run_failed
       else
-        log.success "✓ No applicable #{@context.hook_script_name} hooks to run"
+        log.success "✓ No applicable #{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?
+      return if should_skip?(hook)
 
       unless hook.quiet?
         print_header(hook)
@@ -80,6 +74,32 @@ module Overcommit
         print_header(hook)
       end
 
+      print_result(hook, status, output)
+
+      status
+    end
+
+    def print_header(hook)
+      log.partial hook.description
+      log.partial '.' * (70 - hook.description.length)
+    end
+
+    def should_skip?(hook)
+      return true 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 true
+        end
+      end
+
+      !hook.run?
+    end
+
+    def print_result(hook, status, output)
       case status
       when :good
         log.success 'OK' unless hook.quiet?
@@ -90,61 +110,23 @@ module Overcommit
         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.nil? || 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
+      @hooks += HookLoader::BuiltInHookLoader.new(@config, @context, @log, @input).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(@context).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
+      # Load plugin hooks after so they can subclass existing hooks
+      @hooks += HookLoader::PluginHookLoader.new(@config, @context, @log, @input).load_hooks
     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
+    def hook_script_name
+      @context.hook_script_name
     end
   end
 end

data/lib/overcommit/hook_signer.rb

@@ -0,0 +1,73 @@
+module Overcommit
+  # Calculates, stores, and retrieves stored signatures of hook plugins.
+  class HookSigner
+    attr_reader :hook_path, :hook_name
+
+    # @param hook_path [String] path to the actual hook definition
+    # @param config [Overcommit::Configuration]
+    # @param context [Overcommit::HookContext]
+    def initialize(hook_path, config, context)
+      @hook_path = hook_path
+      @config = config
+      @context = context
+
+      @hook_name = Overcommit::Utils.camel_case(File.basename(@hook_path, '.rb'))
+    end
+
+    # Return whether the signature for this hook has changed since it was last
+    # calculated.
+    #
+    # @return [true,false]
+    def signature_changed?
+      signature != stored_signature
+    end
+
+    # Update the current stored signature for this hook.
+    def update_signature!
+      result = Overcommit::Utils.execute(
+        %w[git config --local] + [signature_config_key, signature]
+      )
+
+      unless result.success?
+        raise Overcommit::Exceptions::GitConfigError,
+              "Unable to write to local repo git config: #{result.stderr}"
+      end
+    end
+
+  private
+
+    # Calculates a hash of a hook using a combination of its configuration and
+    # file contents.
+    #
+    # This way, if either the plugin code changes or its configuration changes,
+    # the hash will change and we can alert the user to this change.
+    def signature
+      hook_config = @config.for_hook(@hook_name, @context.hook_class_name)
+
+      Digest::SHA256.hexdigest(hook_contents + hook_config.to_s)
+    end
+
+    def hook_contents
+      File.open(@hook_path, 'r').read
+    end
+
+    def stored_signature
+      result = Overcommit::Utils.execute(
+        %w[git config --local --get] + [signature_config_key]
+      )
+
+      if result.status == 1 # Key doesn't exist
+        return ''
+      elsif result.status != 0
+        raise Overcommit::Exceptions::GitConfigError,
+              "Unable to read from local repo git config: #{result.stderr}"
+      end
+
+      result.stdout.chomp
+    end
+
+    def signature_config_key
+      "overcommit.#{@context.hook_class_name}.#{@hook_name}.signature"
+    end
+  end
+end

data/lib/overcommit/installer.rb

@@ -3,6 +3,9 @@ require 'fileutils'
 module Overcommit
   # Manages the installation of Overcommit hooks in a git repository.
   class Installer
+    MASTER_HOOK =
+      File.join(OVERCOMMIT_HOME, 'template-dir', 'hooks', 'overcommit-hook')
+
     def initialize(logger)
       @log = logger
     end
@@ -11,7 +14,13 @@ module Overcommit
       @target = target
       @options = options
       validate_target
-      @options[:action] == :uninstall ? uninstall : install
+
+      case @options[:action]
+      when :uninstall then uninstall
+      when :update then update
+      else
+        install
+      end
     end
 
   private
@@ -37,11 +46,24 @@ module Overcommit
       log.success "Successfully removed hooks from #{@target}"
     end
 
+    # @return [true,false] whether the hooks were updated
+    def update
+      unless FileUtils.compare_file(MASTER_HOOK, master_hook_install_path)
+        install_master_hook
+        install_hook_symlinks
+        true
+      end
+    end
+
     def hooks_path
       absolute_target = File.expand_path(@target)
       File.join(absolute_target, '.git', 'hooks')
     end
 
+    def master_hook_install_path
+      File.join(hooks_path, 'overcommit-hook')
+    end
+
     def ensure_hooks_directory
       FileUtils.mkdir_p(hooks_path)
     end
@@ -59,15 +81,12 @@ module Overcommit
     end
 
     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)
+      FileUtils.cp(MASTER_HOOK, master_hook_install_path)
     end
 
     def uninstall_master_hook
-      install_location = File.join(hooks_path, 'overcommit-hook')
-      FileUtils.rm_rf(install_location)
+      FileUtils.rm_rf(master_hook_install_path)
     end
 
     def install_hook_symlinks
@@ -78,7 +97,8 @@ module Overcommit
         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"
+                  "Hook '#{File.expand_path(hook_type)}' already exists and " \
+                  'was not installed by Overcommit'
           end
           FileUtils.ln_sf('overcommit-hook', hook_type)
         end
@@ -87,7 +107,7 @@ module Overcommit
 
     def can_replace_file?(file)
       @options[:force] ||
-        !File.exists?(file) ||
+        !File.exist?(file) ||
         overcommit_symlink?(file)
     end
 

data/lib/overcommit/user_input.rb

@@ -0,0 +1,26 @@
+module Overcommit
+  # Encapsulates prompting for and fetching input from a user.
+  class UserInput
+    # @param io [IO] device to fetch input from
+    def initialize(io)
+      @io = io
+
+      reopen_tty
+    end
+
+    # Get a string of input from the user (up to the next newline character).
+    def get(&block)
+      @io.gets
+    end
+
+  private
+
+    # Git hooks are not interactive and will close STDIN by default.
+    def reopen_tty
+      # If the hook isn't interactive, we need to map STDIN to keyboard manually
+      STDIN.reopen('/dev/tty') if STDIN.eof?
+    rescue
+      # Happens in tests run with no console available
+    end
+  end
+end

data/lib/overcommit/version.rb

@@ -1,4 +1,4 @@
 # Defines the gem version.
 module Overcommit
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/template-dir/hooks/commit-msg

@@ -5,13 +5,13 @@
 # to manage your hooks for you.
 
 # Required for Ruby 1.8 compatibility (for older OSX versions)
-if RUBY_VERSION.split('.')[0..1] == ['1', '8']
+if RUBY_VERSION.split('.')[0..1] == %w[1 8]
   require 'rubygems'
 end
 
 hook_type = File.basename($0)
 if hook_type == 'overcommit-hook'
-  puts "Don't run `overcommit-hook` directly; it is intended to be symlinked " <<
+  puts "Don't run `overcommit-hook` directly; it is intended to be symlinked " \
        "by each hook in a repository's .git/hooks directory."
   exit 64 # EX_USAGE
 end
@@ -19,13 +19,14 @@ end
 begin
   require 'overcommit'
 rescue LoadError
-  puts 'Overcommit is not installed. Install it to manage git hooks for ' <<
+  puts 'Overcommit is not installed. Install it to manage git hooks for ' \
        'this repository? (y/n)'
 
   # If the hook isn't interactive, we need to map STDIN to keyboard manually
   STDIN.reopen('/dev/tty') if STDIN.eof?
 
   if (answer = gets) && answer.strip.downcase.start_with?('y')
+    puts 'Installing...'
     if system('gem install overcommit')
       Gem.clear_paths # Reset load paths so newly installed gem is found
       require 'overcommit'
@@ -41,21 +42,30 @@ rescue LoadError
 end
 
 if Gem::Version.new(Overcommit::VERSION) < Gem::Version.new('0.6.0')
-  puts "Installed version of Overcommit (#{Overcommit::VERSION}) is " <<
-       "incompatible with the installed hooks.\n" <<
-       'Run `gem install overcommit && overcommit --install` to ensure ' <<
+  puts "Installed version of Overcommit (#{Overcommit::VERSION}) is " \
+       "incompatible with the installed hooks.\n" \
+       'Run `gem install overcommit && overcommit --install` to ensure ' \
        "you're up-to-date."
   exit 64 # EX_USAGE
 end
 
 begin
+  logger = Overcommit::Logger.new(STDOUT)
+
+  # Ensure master hook is up-to-date
+  installer = Overcommit::Installer.new(logger)
+  if installer.run(Overcommit::Utils.repo_root, :action => :update)
+    exec $0 # Execute the updated hook
+  end
+
   config = Overcommit::ConfigurationLoader.load_repo_config
 
   context = Overcommit::HookContext.create(hook_type, config, ARGV, STDIN)
   config.apply_environment!(context, ENV)
 
-  logger = Overcommit::Logger.new(STDOUT)
-  runner = Overcommit::HookRunner.new(config, logger, context)
+  input = Overcommit::UserInput.new(STDIN)
+
+  runner = Overcommit::HookRunner.new(config, logger, context, input)
 
   status = runner.run
 
@@ -67,6 +77,9 @@ rescue Overcommit::Exceptions::HookContextLoadError => error
   puts error
   puts 'Are you running an old version of Overcommit?'
   exit 69 # EX_UNAVAILABLE
+rescue Overcommit::Exceptions::HookCancelled
+  puts 'You cancelled the hook run'
+  exit 1
 rescue Overcommit::Exceptions::InvalidGitRepo => error
   puts error
   exit 64 # EX_USAGE

data/template-dir/hooks/overcommit-hook

@@ -5,13 +5,13 @@
 # to manage your hooks for you.
 
 # Required for Ruby 1.8 compatibility (for older OSX versions)
-if RUBY_VERSION.split('.')[0..1] == ['1', '8']
+if RUBY_VERSION.split('.')[0..1] == %w[1 8]
   require 'rubygems'
 end
 
 hook_type = File.basename($0)
 if hook_type == 'overcommit-hook'
-  puts "Don't run `overcommit-hook` directly; it is intended to be symlinked " <<
+  puts "Don't run `overcommit-hook` directly; it is intended to be symlinked " \
        "by each hook in a repository's .git/hooks directory."
   exit 64 # EX_USAGE
 end
@@ -19,13 +19,14 @@ end
 begin
   require 'overcommit'
 rescue LoadError
-  puts 'Overcommit is not installed. Install it to manage git hooks for ' <<
+  puts 'Overcommit is not installed. Install it to manage git hooks for ' \
        'this repository? (y/n)'
 
   # If the hook isn't interactive, we need to map STDIN to keyboard manually
   STDIN.reopen('/dev/tty') if STDIN.eof?
 
   if (answer = gets) && answer.strip.downcase.start_with?('y')
+    puts 'Installing...'
     if system('gem install overcommit')
       Gem.clear_paths # Reset load paths so newly installed gem is found
       require 'overcommit'
@@ -41,21 +42,30 @@ rescue LoadError
 end
 
 if Gem::Version.new(Overcommit::VERSION) < Gem::Version.new('0.6.0')
-  puts "Installed version of Overcommit (#{Overcommit::VERSION}) is " <<
-       "incompatible with the installed hooks.\n" <<
-       'Run `gem install overcommit && overcommit --install` to ensure ' <<
+  puts "Installed version of Overcommit (#{Overcommit::VERSION}) is " \
+       "incompatible with the installed hooks.\n" \
+       'Run `gem install overcommit && overcommit --install` to ensure ' \
        "you're up-to-date."
   exit 64 # EX_USAGE
 end
 
 begin
+  logger = Overcommit::Logger.new(STDOUT)
+
+  # Ensure master hook is up-to-date
+  installer = Overcommit::Installer.new(logger)
+  if installer.run(Overcommit::Utils.repo_root, :action => :update)
+    exec $0 # Execute the updated hook
+  end
+
   config = Overcommit::ConfigurationLoader.load_repo_config
 
   context = Overcommit::HookContext.create(hook_type, config, ARGV, STDIN)
   config.apply_environment!(context, ENV)
 
-  logger = Overcommit::Logger.new(STDOUT)
-  runner = Overcommit::HookRunner.new(config, logger, context)
+  input = Overcommit::UserInput.new(STDIN)
+
+  runner = Overcommit::HookRunner.new(config, logger, context, input)
 
   status = runner.run
 
@@ -67,6 +77,9 @@ rescue Overcommit::Exceptions::HookContextLoadError => error
   puts error
   puts 'Are you running an old version of Overcommit?'
   exit 69 # EX_UNAVAILABLE
+rescue Overcommit::Exceptions::HookCancelled
+  puts 'You cancelled the hook run'
+  exit 1
 rescue Overcommit::Exceptions::InvalidGitRepo => error
   puts error
   exit 64 # EX_USAGE

data/template-dir/hooks/post-checkout

@@ -5,13 +5,13 @@
 # to manage your hooks for you.
 
 # Required for Ruby 1.8 compatibility (for older OSX versions)
-if RUBY_VERSION.split('.')[0..1] == ['1', '8']
+if RUBY_VERSION.split('.')[0..1] == %w[1 8]
   require 'rubygems'
 end
 
 hook_type = File.basename($0)
 if hook_type == 'overcommit-hook'
-  puts "Don't run `overcommit-hook` directly; it is intended to be symlinked " <<
+  puts "Don't run `overcommit-hook` directly; it is intended to be symlinked " \
        "by each hook in a repository's .git/hooks directory."
   exit 64 # EX_USAGE
 end
@@ -19,13 +19,14 @@ end
 begin
   require 'overcommit'
 rescue LoadError
-  puts 'Overcommit is not installed. Install it to manage git hooks for ' <<
+  puts 'Overcommit is not installed. Install it to manage git hooks for ' \
        'this repository? (y/n)'
 
   # If the hook isn't interactive, we need to map STDIN to keyboard manually
   STDIN.reopen('/dev/tty') if STDIN.eof?
 
   if (answer = gets) && answer.strip.downcase.start_with?('y')
+    puts 'Installing...'
     if system('gem install overcommit')
       Gem.clear_paths # Reset load paths so newly installed gem is found
       require 'overcommit'
@@ -41,21 +42,30 @@ rescue LoadError
 end
 
 if Gem::Version.new(Overcommit::VERSION) < Gem::Version.new('0.6.0')
-  puts "Installed version of Overcommit (#{Overcommit::VERSION}) is " <<
-       "incompatible with the installed hooks.\n" <<
-       'Run `gem install overcommit && overcommit --install` to ensure ' <<
+  puts "Installed version of Overcommit (#{Overcommit::VERSION}) is " \
+       "incompatible with the installed hooks.\n" \
+       'Run `gem install overcommit && overcommit --install` to ensure ' \
        "you're up-to-date."
   exit 64 # EX_USAGE
 end
 
 begin
+  logger = Overcommit::Logger.new(STDOUT)
+
+  # Ensure master hook is up-to-date
+  installer = Overcommit::Installer.new(logger)
+  if installer.run(Overcommit::Utils.repo_root, :action => :update)
+    exec $0 # Execute the updated hook
+  end
+
   config = Overcommit::ConfigurationLoader.load_repo_config
 
   context = Overcommit::HookContext.create(hook_type, config, ARGV, STDIN)
   config.apply_environment!(context, ENV)
 
-  logger = Overcommit::Logger.new(STDOUT)
-  runner = Overcommit::HookRunner.new(config, logger, context)
+  input = Overcommit::UserInput.new(STDIN)
+
+  runner = Overcommit::HookRunner.new(config, logger, context, input)
 
   status = runner.run
 
@@ -67,6 +77,9 @@ rescue Overcommit::Exceptions::HookContextLoadError => error
   puts error
   puts 'Are you running an old version of Overcommit?'
   exit 69 # EX_UNAVAILABLE
+rescue Overcommit::Exceptions::HookCancelled
+  puts 'You cancelled the hook run'
+  exit 1
 rescue Overcommit::Exceptions::InvalidGitRepo => error
   puts error
   exit 64 # EX_USAGE

data/template-dir/hooks/pre-commit

@@ -5,13 +5,13 @@
 # to manage your hooks for you.
 
 # Required for Ruby 1.8 compatibility (for older OSX versions)
-if RUBY_VERSION.split('.')[0..1] == ['1', '8']
+if RUBY_VERSION.split('.')[0..1] == %w[1 8]
   require 'rubygems'
 end
 
 hook_type = File.basename($0)
 if hook_type == 'overcommit-hook'
-  puts "Don't run `overcommit-hook` directly; it is intended to be symlinked " <<
+  puts "Don't run `overcommit-hook` directly; it is intended to be symlinked " \
        "by each hook in a repository's .git/hooks directory."
   exit 64 # EX_USAGE
 end
@@ -19,13 +19,14 @@ end
 begin
   require 'overcommit'
 rescue LoadError
-  puts 'Overcommit is not installed. Install it to manage git hooks for ' <<
+  puts 'Overcommit is not installed. Install it to manage git hooks for ' \
        'this repository? (y/n)'
 
   # If the hook isn't interactive, we need to map STDIN to keyboard manually
   STDIN.reopen('/dev/tty') if STDIN.eof?
 
   if (answer = gets) && answer.strip.downcase.start_with?('y')
+    puts 'Installing...'
     if system('gem install overcommit')
       Gem.clear_paths # Reset load paths so newly installed gem is found
       require 'overcommit'
@@ -41,21 +42,30 @@ rescue LoadError
 end
 
 if Gem::Version.new(Overcommit::VERSION) < Gem::Version.new('0.6.0')
-  puts "Installed version of Overcommit (#{Overcommit::VERSION}) is " <<
-       "incompatible with the installed hooks.\n" <<
-       'Run `gem install overcommit && overcommit --install` to ensure ' <<
+  puts "Installed version of Overcommit (#{Overcommit::VERSION}) is " \
+       "incompatible with the installed hooks.\n" \
+       'Run `gem install overcommit && overcommit --install` to ensure ' \
        "you're up-to-date."
   exit 64 # EX_USAGE
 end
 
 begin
+  logger = Overcommit::Logger.new(STDOUT)
+
+  # Ensure master hook is up-to-date
+  installer = Overcommit::Installer.new(logger)
+  if installer.run(Overcommit::Utils.repo_root, :action => :update)
+    exec $0 # Execute the updated hook
+  end
+
   config = Overcommit::ConfigurationLoader.load_repo_config
 
   context = Overcommit::HookContext.create(hook_type, config, ARGV, STDIN)
   config.apply_environment!(context, ENV)
 
-  logger = Overcommit::Logger.new(STDOUT)
-  runner = Overcommit::HookRunner.new(config, logger, context)
+  input = Overcommit::UserInput.new(STDIN)
+
+  runner = Overcommit::HookRunner.new(config, logger, context, input)
 
   status = runner.run
 
@@ -67,6 +77,9 @@ rescue Overcommit::Exceptions::HookContextLoadError => error
   puts error
   puts 'Are you running an old version of Overcommit?'
   exit 69 # EX_UNAVAILABLE
+rescue Overcommit::Exceptions::HookCancelled
+  puts 'You cancelled the hook run'
+  exit 1
 rescue Overcommit::Exceptions::InvalidGitRepo => error
   puts error
   exit 64 # EX_USAGE

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: overcommit
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Causes Engineering
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-06 00:00:00.000000000 Z
+date: 2014-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: childprocess
@@ -43,16 +43,16 @@ dependencies:
   name: image_optim
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 0.12.0
+        version: 0.13.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 0.12.0
+        version: 0.13.0
 description: Utility to install, configure, and extend Git hooks
 email:
 - eng@causes.com
@@ -71,6 +71,7 @@ files:
 - lib/overcommit/constants.rb
 - lib/overcommit/utils.rb
 - lib/overcommit/hook_runner.rb
+- lib/overcommit/user_input.rb
 - lib/overcommit/subprocess.rb
 - lib/overcommit/hook/commit_msg/trailing_period.rb
 - lib/overcommit/hook/commit_msg/gerrit_change_id.rb
@@ -86,6 +87,7 @@ files:
 - lib/overcommit/hook/pre_commit/author_email.rb
 - lib/overcommit/hook/pre_commit/image_optim.rb
 - lib/overcommit/hook/pre_commit/css_lint.rb
+- lib/overcommit/hook/pre_commit/travis_lint.rb
 - lib/overcommit/hook/pre_commit/bundle_check.rb
 - lib/overcommit/hook/pre_commit/yaml_syntax.rb
 - lib/overcommit/hook/pre_commit/trailing_whitespace.rb
@@ -99,12 +101,16 @@ files:
 - lib/overcommit/hook/pre_commit/jscs.rb
 - lib/overcommit/hook/pre_commit/scss_lint.rb
 - lib/overcommit/hook/pre_commit/base.rb
+- lib/overcommit/hook_signer.rb
 - lib/overcommit/hook_context/pre_commit.rb
 - lib/overcommit/hook_context/commit_msg.rb
 - lib/overcommit/hook_context/base.rb
 - lib/overcommit/hook_context/post_checkout.rb
 - lib/overcommit/installer.rb
 - lib/overcommit/configuration_loader.rb
+- lib/overcommit/hook_loader/built_in_hook_loader.rb
+- lib/overcommit/hook_loader/plugin_hook_loader.rb
+- lib/overcommit/hook_loader/base.rb
 - lib/overcommit/exceptions.rb
 - lib/overcommit/configuration.rb
 - lib/overcommit/logger.rb
@@ -141,4 +147,3 @@ signing_key:
 specification_version: 4
 summary: Git hook manager
 test_files: []
-has_rdoc: