overcommit 0.5.0 → 0.6.0

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

@@ -0,0 +1,16 @@
+module Overcommit::Hook::PreCommit
+  # Runs `csslint` against any modified CSS files.
+  class CssLint < Base
+    def run
+      unless in_path?('csslint')
+        return :warn, 'csslint not installed -- run `npm install -g csslint`'
+      end
+
+      paths = applicable_files.join(' ')
+
+      result = command("csslint --quiet --format=compact #{paths} | grep 'Error - '")
+      output = result.stdout
+      return (output !~ /Error - (?!Unknown @ rule)/ ? :good : :bad), output
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Overcommit::Hook::PreCommit
+  # Runs `haml-lint` against any modified HAML files.
+  class HamlLint < Base
+    def run
+      unless in_path?('haml-lint')
+        return :warn, 'haml-lint not installed -- run `gem install haml-lint`'
+      end
+
+      result = command("haml-lint #{applicable_files.join(' ')}")
+      return :good if result.success?
+
+      # Keep lines from the output for files that we actually modified
+      error_lines, warning_lines = result.stdout.split("\n").partition do |output_line|
+        if match = output_line.match(/^([^:]+):(\d+)/)
+          file = match[1]
+          line = match[2]
+        end
+        modified_lines(file).include?(line.to_i)
+      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")
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Overcommit::Hook::PreCommit
+  # Checks for hard tabs in files.
+  class HardTabs < Base
+    def run
+      paths = applicable_files.join(' ')
+
+      # Catches hard tabs
+      result = command("grep -IHn \"\t\" #{paths}")
+      unless result.stdout.empty?
+        return :bad, "Hard tabs detected:\n#{result.stdout}"
+      end
+
+      :good
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Overcommit::Hook::PreCommit
+  # Checks for images that can be optimized with `image_optim`.
+  class ImageOptim < Base
+    def run
+      begin
+        require 'image_optim'
+      rescue LoadError
+        return :warn, 'image_optim not installed -- run `gem install image_optim`'
+      end
+
+      optimized_images =
+        begin
+          optimize_images(applicable_files)
+        rescue ::ImageOptim::BinNotFoundError => e
+          return :bad, "#{e.message}. The image_optim gem is dependendent on this binary."
+        end
+
+      if optimized_images.any?
+        return :bad,
+          "The following images were optimized:\n" <<
+          optimized_images.join("\n") <<
+          "\nPlease add them to your commit."
+      end
+
+      :good
+    end
+
+  private
+
+    def optimize_images(image_paths)
+      image_optim = ::ImageOptim.new(:pngout => false)
+
+      optimized_images =
+        image_optim.optimize_images!(image_paths) do |path, optimized|
+          path if optimized
+        end
+
+      optimized_images.compact
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Overcommit::Hook::PreCommit
+  # Runs `jshint` against any modified JavaScript files.
+  class JsHint < Base
+    def run
+      unless in_path?('jshint')
+        return :warn, 'jshint not installed -- run `npm install -g jshint`'
+      end
+
+      result = command("jshint #{applicable_files.join(' ')}")
+      output = result.stdout
+
+      return (output.empty? ? :good : :bad), output
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Overcommit::Hook::PreCommit
+  # Runs `jscs` (JavaScript Code Style Checker) against any modified JavaScript
+  # files.
+  class Jscs < Base
+    def run
+      unless in_path?('jscs')
+        return :warn, 'jscs not installed -- run `npm install -g jscs`'
+      end
+
+      result = command("jscs --reporter=inline #{applicable_files.join(' ')}")
+      return :good if result.success?
+
+      if /Config.*not found/i =~ result.stderr
+        return :warn, result.stderr.chomp
+      end
+
+      # Keep lines from the output for files that we actually modified
+      error_lines, warning_lines = result.stdout.split("\n").partition do |output_line|
+        if match = output_line.match(/^([^:]+):[^\d]+(\d+)/)
+          file = match[1]
+          line = match[2]
+        end
+        modified_lines(file).include?(line.to_i)
+      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")
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Overcommit::Hook::PreCommit
+  # Runs `flake8` against any modified Python files.
+  class PythonFlake8 < Base
+    def run
+      unless in_path?('flake8')
+        return :warn, 'flake8 not installed -- run `pip install flake8`'
+      end
+
+      result = command("flake8 #{applicable_files.join(' ')}")
+
+      return (result.success? ? :good : :bad), result.stdout
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Overcommit::Hook::PreCommit
+  # Runs `rubocop` against any modified Ruby files.
+  class Rubocop < Base
+    def run
+      unless in_path?('rubocop')
+        return :warn, 'Rubocop not installed -- run `gem install rubocop`'
+      end
+
+      result = command("rubocop --format=emacs #{applicable_files.join(' ')} 2>&1")
+      return :good if result.success?
+
+      # Keep lines from the output for files that we actually modified
+      error_lines, warning_lines = result.stdout.split("\n").partition do |output_line|
+        if match = output_line.match(/^([^:]+):(\d+)/)
+          file = match[1]
+          line = match[2]
+        end
+        modified_lines(file).include?(line.to_i)
+      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")
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Overcommit::Hook::PreCommit
+  # Runs `scss-lint` against any modified SCSS files.
+  class ScssLint < Base
+    def run
+      unless in_path?('scss-lint')
+        return :warn, 'scss-lint not installed -- run `gem install scss-lint`'
+      end
+
+      result = command("scss-lint #{applicable_files.join(' ')}")
+      return :good if result.success?
+
+      # Keep lines from the output for files that we actually modified
+      error_lines, warning_lines = result.stdout.split("\n").partition do |output_line|
+        if match = output_line.match(/^([^:]+):(\d+)/)
+          file = match[1]
+          line = match[2]
+        end
+        modified_lines(file).include?(line.to_i)
+      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")
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Overcommit::Hook::PreCommit
+  # Checks for trailing whitespace in files.
+  class TrailingWhitespace < Base
+    def run
+      paths = applicable_files.join(' ')
+
+      result = command("grep -IHn \"\\s$\" #{paths}")
+      unless result.stdout.empty?
+        return :bad, "Trailing whitespace detected:\n#{result.stdout}"
+      end
+
+      :good
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'yaml'
+
+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|
+        begin
+          YAML.load_file(file)
+        rescue ArgumentError => e
+          output << "#{e.message} parsing #{file}"
+          clean = false
+        end
+      end
+
+      return (clean ? :good : :bad), output
+    end
+  end
+end

data/lib/overcommit/hook_context.rb

@@ -0,0 +1,16 @@
+# Utility module which manages the creation of {HookContext}s.
+module Overcommit::HookContext
+  def self.create(hook_type, config, args, input)
+    underscored_hook_type = Overcommit::Utils.snake_case(hook_type)
+
+    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
+end

data/lib/overcommit/hook_context/base.rb

@@ -0,0 +1,68 @@
+require 'set'
+
+module Overcommit::HookContext
+  # Contains helpers related to the context with which a hook is being run.
+  #
+  # It acts as an adapter to the arguments passed to the hook, as well as
+  # context-specific information such as staged files, providing a single source
+  # of truth for this context.
+  #
+  # This is also important to house in a separate object so that any
+  # calculations can be memoized across all hooks in a single object, which
+  # helps with performance.
+  class Base
+    def initialize(config, args, input)
+      @config = config
+      @args = args
+      @input = input
+    end
+
+    # Returns the camel-cased type of this hook (e.g. PreCommit)
+    def hook_class_name
+      self.class.name.split('::').last
+    end
+
+    # Returns the snake-cased type of this hook (e.g. pre_commit)
+    def hook_type_name
+      Overcommit::Utils.snake_case(hook_class_name)
+    end
+
+    # Returns the actual name of the hook script being run (e.g. pre-commit).
+    def hook_script_name
+      hook_type_name.gsub('_', '-')
+    end
+
+    # Initializes anything related to the environment.
+    #
+    # This is called before the hooks are run by the [HookRunner]. Different
+    # hook types can perform different setup.
+    def setup_environment
+      # Implemented by subclass
+    end
+
+    # Resets the environment to an appropriate state.
+    #
+    # This is called after the hooks have been run by the [HookRunner].
+    # Different hook types can perform different cleanup operations, which are
+    # intended to "undo" the results of the call to {#setup_environment}.
+    def cleanup_environment
+      # Implemented by subclass
+    end
+
+    # Returns a list of files that have been modified.
+    #
+    # By default, this returns an empty list. Subclasses should implement if
+    # there is a concept of files changing for the type of hook being run.
+    def modified_files
+      []
+    end
+
+    # Returns a set of lines that have been modified for a file.
+    #
+    # By default, this returns an empty set. Subclasses should implement if
+    # there is a concept of files changing for the type of hook being run.
+    def modified_lines(file)
+      Set.new
+    end
+  end
+end

data/lib/overcommit/hook_context/commit_msg.rb

@@ -0,0 +1,32 @@
+module Overcommit::HookContext
+  # Contains helpers related to contextual information used by commit-msg hooks.
+  class CommitMsg < Base
+    # User commit message stripped of comments and diff (from verbose output).
+    def commit_message
+      commit_message_lines.join
+    end
+
+    # Updates the commit message to the specified text.
+    def update_commit_message(message)
+      ::File.open(commit_message_file, 'w') do |file|
+        file.write(message)
+      end
+    end
+
+    def commit_message_lines
+      raw_commit_message_lines.
+        reject     { |line| line =~ /^#/ }.
+        take_while { |line| !line.start_with?('diff --git') }
+    end
+
+    def commit_message_file
+      @args[0]
+    end
+
+  private
+
+    def raw_commit_message_lines
+      ::IO.readlines(commit_message_file)
+    end
+  end
+end

data/lib/overcommit/hook_context/post_checkout.rb

@@ -0,0 +1,24 @@
+module Overcommit::HookContext
+  class PostCheckout < Base
+    # Returns the ref of the HEAD that we transitioned from.
+    def previous_head
+      @args[0]
+    end
+
+    # Returns the ref of the new current HEAD.
+    def new_head
+      @args[1]
+    end
+
+    # Returns whether this checkout was the result of changing/updating a
+    # branch.
+    def branch_checkout?
+      @args[2].to_i == 1
+    end
+
+    # Returns whether this checkout was for a single file.
+    def file_checkout?
+      !branch_checkout?
+    end
+  end
+end

data/lib/overcommit/hook_context/pre_commit.rb

@@ -0,0 +1,96 @@
+require 'set'
+
+module Overcommit::HookContext
+  # Contains helpers related to contextual information used by pre-commit hooks.
+  #
+  # This includes staged files, which lines of those files have been modified,
+  # etc.
+  class PreCommit < Base
+    # Stash unstaged contents of files so hooks don't see changes that aren't
+    # about to be committed.
+    def setup_environment
+      store_modified_times
+
+      if modified_files.any?
+        `git stash save --keep-index --quiet #{<<-MSG}`
+          "Overcommit: Stash of repo state before hook run at #{Time.now}"
+        MSG
+      end
+
+      # While running the hooks make it appear as if nothing changed
+      restore_modified_times
+    end
+
+    # Restore unstaged changes and reset file modification times so it appears
+    # as if nothing ever changed.
+    def cleanup_environment
+      `git reset --hard`
+      `git stash pop --index --quiet` if modified_files.any?
+
+      restore_modified_times
+    end
+
+    # Get a list of added, copied, or modified files that have been staged.
+    # Renames and deletions are ignored, since there should be nothing to check.
+    def modified_files
+      @modified_files ||=
+        `git diff --cached --name-only --diff-filter=ACM --ignore-submodules=all`.
+          split("\n").
+          map { |relative_file| File.expand_path(relative_file) }
+    end
+
+    # Returns the set of line numbers corresponding to the lines that were
+    # changed in a specified file.
+    def modified_lines(file)
+      @modified_lines ||= {}
+      @modified_lines[file] ||= extract_modified_lines(file)
+    end
+
+  private
+
+    DIFF_HUNK_REGEX = /
+      ^@@\s
+      [^\s]+\s           # Ignore old file range
+      \+(\d+)(?:,(\d+))? # Extract range of hunk containing start line and number of lines
+      \s@@.*$
+    /x
+
+    def extract_modified_lines(staged_file)
+      lines = Set.new
+
+      `git diff --no-ext-diff --cached -U0 -- #{staged_file}`.
+        scan(DIFF_HUNK_REGEX) do |start_line, lines_added|
+
+        lines_added = (lines_added || 1).to_i # When blank, one line was added
+        cur_line = start_line.to_i
+
+        lines_added.times do
+          lines.add cur_line
+          cur_line += 1
+        end
+      end
+
+      lines
+    end
+
+    def store_modified_times
+      @modified_times = {}
+
+      modified_files.each do |file|
+        @modified_times[file] = File.mtime(file)
+      end
+    end
+
+    # Stores the modification times for all modified files to make it appear like
+    # they never changed.
+    #
+    # This prevents editors from complaining about files changing when we stash
+    # changes before running the hooks.
+    def restore_modified_times
+      modified_files.each do |file|
+        time = @modified_times[file]
+        File.utime(time, time, file)
+      end
+    end
+  end
+end