overcommit 0.5.0 → 0.6.0

data/lib/overcommit/plugins/pre_commit/haml_style.rb

@@ -1,34 +0,0 @@
-module Overcommit::GitHook
-  class HamlStyle < HookSpecificCheck
-    include HookRegistry
-    file_types :haml
-
-    def run_check
-      unless in_path?('haml-lint')
-        return :warn, 'haml-lint not installed -- run `gem install haml-lint`'
-      end
-
-      paths_to_staged_files = Hash[staged.map { |s| [s.path, s] }]
-      staged_files = paths_to_staged_files.keys
-
-      output = `haml-lint #{staged_files.join(' ')} 2>&1`
-      return :good if $?.success?
-
-      # Keep lines from the output for files that we actually modified
-      error_lines, warning_lines = output.lines.partition do |output_line|
-        if match = output_line.match(/^([^:]+):(\d+)/)
-          file = match[1]
-          line = match[2]
-        end
-        unless paths_to_staged_files[file]
-          return :warn, "Unexpected output from haml-lint:\n#{output}"
-        end
-        paths_to_staged_files[file].modified_lines.include?(line.to_i)
-      end
-
-      return :bad, error_lines.join unless error_lines.empty?
-      return :warn, "Modified files have lints (on lines you didn't modify)\n" <<
-                    warning_lines.join
-    end
-  end
-end

data/lib/overcommit/plugins/pre_commit/haml_syntax.rb

@@ -1,24 +0,0 @@
-module Overcommit::GitHook
-  class HamlSyntax < HookSpecificCheck
-    include HookRegistry
-    file_type :haml
-
-    def run_check
-      begin
-        require 'haml'
-      rescue LoadError
-        return :warn, "'haml' gem not installed -- run `gem install haml`"
-      end
-
-      staged.map { |s| s.path }.each do |path|
-        begin
-          Haml::Engine.new(File.read(path), :check_syntax => true)
-        rescue Haml::Error => e
-          return :bad, e.message
-        end
-      end
-
-      :good
-    end
-  end
-end

data/lib/overcommit/plugins/pre_commit/image_optimization.rb

@@ -1,50 +0,0 @@
-module Overcommit::GitHook
-  class ImageOptimization < HookSpecificCheck
-    include HookRegistry
-    file_types :gif, :jpeg, :jpg, :png
-
-    def run_check
-      begin
-        require 'image_optim'
-      rescue LoadError
-        return :warn, "'image_optim' gem not installed -- run `gem install image_optim`"
-      end
-
-      optimized_images =
-        begin
-          ImageSet.new(staged.map(&:original_path)).
-            optimize_with(ImageOptim.new(:pngout => false))
-
-        rescue ImageOptim::BinNotFoundError => e
-          return :stop,
-            "#{e.message}. The image_optim gem is dependendent on this binary. " <<
-            "See https://github.com/toy/image_optim for more info."
-        end
-
-      if optimized_images.any?
-        return :bad,
-          "Optimized #{optimized_images.map(&:to_s).inspect}. " <<
-            " Please add them to your commit."
-      else
-        return :good
-      end
-    end
-
-    class ImageSet
-      attr_reader :image_paths
-
-      def initialize(image_paths)
-        @image_paths ||= image_paths
-      end
-
-      def optimize_with(image_optim)
-        results =
-          image_optim.optimize_images!(image_paths) do |path, was_optimized|
-            path if was_optimized
-          end
-
-        results.compact
-      end
-    end
-  end
-end

data/lib/overcommit/plugins/pre_commit/js_console_log.rb

@@ -1,16 +0,0 @@
-module Overcommit::GitHook
-  class JSConsoleLog < HookSpecificCheck
-    include HookRegistry
-    file_type :js
-
-    # https://www.pivotaltracker.com/story/show/18119495
-    def run_check
-      paths = staged.collect(&:path).join(' ')
-      output = `grep -n -e 'console\\.log' #{paths}`.split("\n").reject do |line|
-        /^\d+:\s*\/\// =~ line ||     # Skip comments
-          /ALLOW_CONSOLE_LOG/ =~ line # and lines with ALLOW_CONSOLE_LOG
-      end.join("\n")
-      return (output.empty? ? :good : :bad), output
-    end
-  end
-end

data/lib/overcommit/plugins/pre_commit/js_syntax.rb

@@ -1,30 +0,0 @@
-module Overcommit::GitHook
-  class JSSyntax < HookSpecificCheck
-    include HookRegistry
-    file_type :js
-
-    def run_check
-      return :warn, 'Need either `jshint` or `rhino` in path' unless runner
-
-      paths = staged.collect(&:path).join(' ')
-      output = runner.call(paths)
-
-      return (output.empty? ? :good : :bad), output
-    end
-
-  private
-
-    JS_HINT_PATH        = Overcommit::Utils.script_path 'jshint.js'
-    JS_HINT_RUNNER_PATH = Overcommit::Utils.script_path 'jshint_runner.js'
-
-    def runner
-      if in_path? 'jshint'
-        lambda { |paths| `jshint #{paths}` }
-      elsif in_path? 'rhino'
-        lambda do |paths|
-          `rhino -strict -f #{JS_HINT_PATH} #{JS_HINT_RUNNER_PATH} #{paths} 2>&1 | grep -v warning | grep -v -e '^js: '`
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Overcommit::GitHook
-  class PythonFlake8 < HookSpecificCheck
-    include HookRegistry
-    file_type :py
-
-    def run_check
-      unless in_path? 'flake8'
-        return :warn, 'Run `pip install flake8`'
-      end
-
-      output = `flake8 #{(staged.collect(&:path).join(' '))}`.split("\n")
-      return ($?.success? ? :good : :bad), output
-    end
-  end
-end

data/lib/overcommit/plugins/pre_commit/ruby_style.rb

@@ -1,67 +0,0 @@
-require 'enumerator'
-require 'pathname'
-
-module Overcommit::GitHook
-  class RubyStyle < HookSpecificCheck
-    include HookRegistry
-    file_types :rb, :rake
-
-    def run_check
-      unless in_path?('rubocop')
-        return :warn, 'rubocop not installed -- run `gem install rubocop`'
-      end
-
-      paths_to_staged_files = Hash[staged.map { |s| [s.path, s] }]
-
-      success, output = run_rubocop
-      return :good if success
-
-      # Keep lines from the output for files that we actually modified
-      error_lines, warning_lines = output.lines.partition do |output_line|
-        if match = output_line.match(/^([^:]+):(\d+)/)
-          file = match[1]
-          line = match[2]
-        end
-        unless paths_to_staged_files[file]
-          return :warn, "Unexpected output from rubocop:\n#{output}"
-        end
-        paths_to_staged_files[file].modified_lines.include?(line.to_i)
-      end
-
-      return :bad, error_lines.join unless error_lines.empty?
-      return :warn, "Modified files have style lints (on lines you didn't modify)\n" <<
-                    warning_lines.join
-    end
-
-  private
-
-    def run_rubocop
-      success, output = true, ''
-      rubocop_config_mapping.each do |config, files|
-        config = config ? "-c #{config}" : ''
-        output += `rubocop #{config} --format=emacs #{files.join(' ')} 2>&1`
-        success = success && $?.success?
-      end
-      [success, output]
-    end
-
-    def rubocop_config_mapping
-      staged.inject({}) do |mapping, file|
-        config = rubocop_yml_for(file)
-        mapping[config] ||= []
-        mapping[config] << file.path
-        mapping
-      end
-    end
-
-    def rubocop_yml_for(staged_file)
-      possible_files(staged_file.original_path).find { |path| path.file? }
-    end
-
-    def possible_files(file_path)
-      files = Pathname.new(file_path).enum_for(:ascend).
-                       map { |path| path + '.rubocop.yml' }
-      files << Pathname.new('.rubocop.yml')
-    end
-  end
-end

data/lib/overcommit/plugins/pre_commit/ruby_syntax.rb

@@ -1,19 +0,0 @@
-module Overcommit::GitHook
-  class RubySyntax < HookSpecificCheck
-    include HookRegistry
-    file_types :rb, :rake
-
-    def run_check
-      clean = true
-      output = []
-      staged.each do |staged|
-        syntax = `ruby -c #{staged.path} 2>&1`
-        unless $?.success?
-          output += syntax.lines.to_a
-          clean = false
-        end
-      end
-      return (clean ? :good : :bad), output
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-module Overcommit::GitHook
-  class ScssLint < HookSpecificCheck
-    include HookRegistry
-    file_type :scss
-
-    def run_check
-      begin
-        require 'scss_lint'
-      rescue LoadError
-        return :warn, 'scss-lint not installed -- run `gem install scss-lint`'
-      end
-
-      paths_to_staged_files = Hash[staged.map { |s| [s.path, s] }]
-
-      success, output = run_scss_lint
-      return :good if success
-
-      # Keep lines from the output for files that we actually modified
-      error_lines, warning_lines = output.lines.partition do |output_line|
-        if match = output_line.match(/^([^:]+):(\d+)/)
-          file = match[1]
-          line = match[2]
-        end
-        unless paths_to_staged_files[file]
-          return :warn, "Unexpected output from scss-lint:\n#{output}"
-        end
-        paths_to_staged_files[file].modified_lines.include?(line.to_i)
-      end
-
-      return :bad, error_lines.join unless error_lines.empty?
-      return :warn, "Modified files have lints (on lines you didn't modify)\n" <<
-                    warning_lines.join
-    end
-
-  private
-
-    def run_scss_lint
-      success, output = true, ''
-      scss_lint_config_mapping.each do |config, files|
-        config = config ? "-c #{config}" : ''
-        output += `scss-lint #{config} #{files.join(' ')} 2>&1`
-        success = success && $?.success?
-      end
-      [success, output]
-    end
-
-    def scss_lint_config_mapping
-      staged.inject({}) do |mapping, file|
-        config = scss_lint_yml_for(file)
-        mapping[config] ||= []
-        mapping[config] << file.path
-        mapping
-      end
-    end
-
-    def scss_lint_yml_for(staged_file)
-      possible_files(staged_file.original_path).find { |path| path.file? }
-    end
-
-    def possible_files(file_path)
-      files = Pathname.new(file_path).enum_for(:ascend).
-                       map { |path| path + '.scss-lint.yml' }
-      files << Pathname.new('.scss-lint.yml')
-    end
-  end
-end

data/lib/overcommit/plugins/pre_commit/test_history.rb

@@ -1,58 +0,0 @@
-module Overcommit::GitHook
-  class TestHistory < HookSpecificCheck
-    include HookRegistry
-
-    def relevant_tests
-      @relevant_test ||=
-        `relevant-tests 2> /dev/null -- #{modified_files.join(' ')}`.
-        split("\n").map { |r| File.expand_path r }
-    end
-
-    def skip?
-      !FileTest.exist?('spec/support/record_results_formatter.rb')
-    end
-
-    TEST_RESULTS_FILE = '.spec-results'
-    def run_check
-      output = []
-      unless relevant_tests.any?
-        return :warn, 'No relevant tests for this change...write some?'
-      end
-
-      begin
-        good_tests = File.open(TEST_RESULTS_FILE, 'r').readlines.map do |spec_file|
-          File.expand_path spec_file.strip
-        end
-      rescue Errno::ENOENT
-        good_tests = []
-      end
-
-      unless good_tests.any?
-        return :bad,
-          'The relevant tests for this change have not yet been run using `specr`'
-      end
-
-      missed_tests = (relevant_tests - good_tests)
-      unless missed_tests.empty?
-        output << 'The following relevant tests have not been run recently:'
-        output << missed_tests.sort
-        return :bad, output
-      end
-
-      # Find files modified after the tests were run
-      test_time = File.mtime(TEST_RESULTS_FILE)
-      untested_files = modified_files.reject do |file|
-        File.mtime(file) < test_time
-      end
-
-      unless untested_files.empty?
-        output << 'The following files were modified after `specr` was run.'
-        output << '(their associated tests may be broken):'
-        output << untested_files.sort
-        return :bad, output
-      end
-
-      return :good
-    end
-  end
-end

data/lib/overcommit/plugins/pre_commit/whitespace.rb

@@ -1,21 +0,0 @@
-module Overcommit::GitHook
-  class Whitespace < HookSpecificCheck
-    include HookRegistry
-
-    def run_check
-      paths = staged.collect(&:path).join(' ')
-
-      # Catches hard tabs
-      output = `grep -Inl "\t" #{paths}`
-      unless output.empty?
-        return :stop, "Don't use hard tabs:\n#{output}"
-      end
-
-      # Catches trailing whitespace, conflict markers etc
-      output = `git diff --check --cached`
-      return :stop, output unless $?.exitstatus.zero?
-
-      :good
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-require 'yaml'
-
-module Overcommit::GitHook
-  class YamlSyntax < HookSpecificCheck
-    include HookRegistry
-    file_type :yml
-
-    def run_check
-      clean = true
-      output = []
-      staged.each do |staged_file|
-        begin
-          YAML.load_file(staged_file.path)
-        rescue ArgumentError => e
-          output << "#{e.message} parsing #{staged_file.path}"
-          clean = false
-        end
-      end
-      return (clean ? :good : :bad), output
-    end
-  end
-end

data/lib/overcommit/reporter.rb

@@ -1,90 +0,0 @@
-module Overcommit
-  class Reporter
-    def initialize(name, checks)
-      @name    = name
-      @checks  = checks
-      @width   = 60 - (@checks.map { |s| s.friendly_name.length }.max || 0)
-      @results = []
-    end
-
-    def with_status(check, &block)
-      title = "  Checking #{check.name}"
-      log.partial title unless check.stealth?
-
-      status, output = yield
-
-      print_incremental_result(title, status, output, check.stealth?)
-      @results << status
-    end
-
-    def print_header
-      log.log "Running #{@name} checks"
-    end
-
-    def print_result
-      log.log # Newline
-
-      case final_result
-      when :good
-        log.success "+++ All #{@name} checks passed"
-        exit 0
-      when :bad
-        log.error "!!! One or more #{@name} checks failed"
-        exit 1
-      when :stop
-        log.warning "*** One or more #{@name} checks needs attention"
-        log.warning '*** If you really want to commit, use SKIP_CHECKS'
-        log.warning "*** (takes a space-separated list of checks to skip, or 'all')"
-        exit 1
-      end
-    end
-
-  private
-
-    def log
-      Overcommit::Logger.instance
-    end
-
-    def print_incremental_result(title, status, output, stealth = false)
-      if stealth
-        return if status == :good
-        log.partial title
-      end
-
-      print '.' * (@width - title.length)
-      case status
-      when :good
-        log.success 'OK'
-      when :bad
-        log.error 'FAILED'
-        print_report output
-      when :warn
-        log.warning 'WARNING'
-        print_report output
-      when :stop
-        log.warning 'UH OH'
-        print_report output
-      else
-        log.error '???'
-        print_report "Check didn't return a status"
-        exit 1
-      end
-    end
-
-    def final_result
-      return :bad  if @results.include?(:bad)
-      return :stop if @results.include?(:stop)
-      return :good
-    end
-
-    OUTPUT_INDENT = ' ' * 4
-    def print_report(output)
-      unless output.empty?
-        # Take each line of output and add indentation so it nests under check
-        # name (except for the last newline if there is one)
-        output = OUTPUT_INDENT + output.gsub(/\n(?!$)/, "\n#{OUTPUT_INDENT}")
-        log.log output
-      end
-    end
-  end
-end