pre-commit 0.8.1 → 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6287e78942b84e9f14387a16d0995edbd49e6818
+  data.tar.gz: 86896dde7b2c8297c94daf14597c3f0e318cf413
+SHA512:
+  metadata.gz: 21d22b4b4cb415f30d4b47342e82c406acc47de83759d7b3afa66770824639baf5102025e9a0a2f50bfa6ac63028b618cd21361a8af416217a38514002af711b
+  data.tar.gz: 813cd48195f51c2b7d5048aadebb55d478933f2984e5b0398b70a0bc5dee9618b889217814cef621a112694c4fd27b91ffad5a89e5e36abcb3841dae5a31df7b

data/README.md

@@ -26,8 +26,7 @@ These are the available checks:
 * pry
 * tabs
 * jshint
-* js\_lint\_all (Runs JSLint on all staged JS files)
-* js\_lint\_new (Runs JSLint on all new staged JS files)
+* js_lint
 * closure\_syntax\_check
 * php (Runs php -l on all staged files)
 * rspec_focus (Will check if you are about to check in a :focus in a spec file)
@@ -36,7 +35,7 @@ These are the available checks:
 * merge_conflict (Will check if you are about to check in a merge conflict)
 * migrations (Will make sure you check in the proper files after creating a Rails migration)
 * ci (Will run the `pre_commit:ci` rake task and pass or fail accordingly)
-* rubocop\_new and rubocop\_all (Check ruby code style using the rubocop gem. Rubocop must be installed)
+* rubocop (Check ruby code style using the rubocop gem. Rubocop must be installed)
 
 To configure which checks you would like to run, simply set the `pre-commit.checks` git configuration setting.
 

data/bin/pre-commit

@@ -12,8 +12,7 @@ if !File.exists?(".git")
   exit(1)
 end
 
-cli = PreCommit::Cli.new
-cli.install
+PreCommit::Cli.new.install
 
 puts "Installed hook: #{PreCommit::Cli::PRE_COMMIT_HOOK_PATH}"
 puts

data/lib/pre-commit/checks/ci_check.rb

@@ -1,49 +1,10 @@
 module PreCommit
   class CiCheck
-
     CI_TASK_NAME = 'pre_commit:ci'
 
-    def call
-      if rakefile_present? && has_ci_task?
-        run
-      else
-        $stderr.puts "pre-commit: skipping ci check. The `#{CI_TASK_NAME}` task is not defined."
-
-        # pretend the check passed and move on
-        true
-      end
-    end
-
-    def run
-      if tests_passed?
-        true
-      else
-        $stderr.puts 'pre-commit: your test suite has failed'
-        $stderr.puts "for the full output run `#{CI_TASK_NAME}`"
-        $stderr.puts
-
-        false
-      end
-    end
-
-    def tests_passed?
-      system("rake #{CI_TASK_NAME} --silent")
-    end
-
-    def rakefile_present?
-      ['rakefile', 'Rakefile', 'rakefile.rb', 'Rakefile.rb'].any? do |file|
-        File.exist?(file)
-      end
+    def self.call(_)
+      return if system("rake #{CI_TASK_NAME} --silent")
+      "your test suite has failed, for the full output run `#{CI_TASK_NAME}`"
     end
-
-    def has_ci_task?
-      require 'rake'
-      Rake.application.init
-      Rake.application.load_rakefile
-      Rake::Task.task_defined?(CI_TASK_NAME)
-    rescue LoadError
-      $stderr.puts 'pre-commit: rake not found, skipping ci check'
-    end
-
   end
 end

data/lib/pre-commit/checks/closure_check.rb

@@ -0,0 +1,13 @@
+module PreCommit
+  class ClosureCheck
+    CLOSURE_PATH = File.expand_path("../../support/closure/compiler.jar", __FILE__)
+
+    def self.call(staged_files)
+      return if staged_files.empty?
+      js_args = staged_files.map {|arg| "--js #{arg}"}.join(' ')
+      errors = `java -jar #{CLOSURE_PATH} #{js_args} --js_output_file /tmp/jammit.js 2>&1`.strip
+      return if errors.empty?
+      errors
+    end
+  end
+end

data/lib/pre-commit/checks/console_log_check.rb

@@ -0,0 +1,11 @@
+module PreCommit
+  class ConsoleLogCheck
+    def self.call(staged_files)
+      staged_files.reject! { |f| File.extname(f) != ".js" }
+      return if staged_files.empty?
+      errors = `#{Utils.grep} -e "console\\.log" #{staged_files.join(" ")} | grep -v \/\/`.strip
+      return unless $?.success?
+      "console.log found:\n#{errors}"
+    end
+  end
+end

data/lib/pre-commit/checks/debugger_check.rb

@@ -1,47 +1,10 @@
 module PreCommit
   class DebuggerCheck
-
-    attr_accessor :staged_files, :error_message, :grep_command
-
-    def self.call(quiet=false)
-      dirs = ['app/', 'lib/', 'script/', 'vendor/', 'test/'].reject {|d| !File.exists?(d)}
-      check = new
-      check.staged_files = Utils.staged_files(*dirs)
-
-      result = check.run
-      if !quiet && !result
-        $stderr.puts check.error_message
-        $stderr.puts
-        check.print_dash_n_reminder
-      end
-      result
+    def self.call(staged_files)
+      return if staged_files.empty?
+      errors = `#{Utils.grep} debugger #{staged_files.join(" ")}`.strip
+      return unless $?.success?
+      "debugger statement(s) found:\n#{errors}"
     end
-
-    def run
-      return true if staged_files.empty?
-
-      if detected_bad_code?
-        @error_message = "pre-commit: debugger statement(s) found:\n"
-        @error_message += instances_of_debugger_violations
-        false
-      else
-        true
-      end
-    end
-
-    def detected_bad_code?
-      !system("git diff --cached -Sdebugger --quiet --exit-code")
-    end
-
-    def instances_of_debugger_violations
-      cmd = grep_command || "git grep"
-      `#{cmd} -nH debugger #{staged_files}`
-    end
-
-    def print_dash_n_reminder
-      $stderr.puts 'You can bypass this check using `git commit -n`'
-      $stderr.puts
-    end
-
   end
 end

data/lib/pre-commit/checks/gemfile_path_check.rb

@@ -0,0 +1,12 @@
+require 'pre-commit/utils'
+
+module PreCommit
+  class GemfilePathCheck
+    def self.call(staged_files)
+      return unless staged_files.include?("Gemfile")
+      errors = `#{Utils.grep} 'path:|:path\\s*=>' Gemfile`.strip
+      return unless $?.success?
+      "local path found in Gemfile:\n#{errors}"
+    end
+  end
+end

data/lib/pre-commit/checks/js_check.rb

@@ -1,61 +1,35 @@
-require 'pre-commit/base'
 require 'pre-commit/utils'
 require 'execjs'
 
 module PreCommit
   class JsCheck
+    def self.call(staged_files)
+      staged_files = staged_files.select { |f| File.extname(f) == ".js" }
+      return if staged_files.empty?
 
-    def call
-      js_files = reject_non_js(files_to_check)
-      if should_run?(js_files)
-        run(js_files)
-      else
-        # pretend the check passed and move on
-        true
-      end
-    end
-
-    def run(js_files)
       errors = []
-
-      js_files.each do |file|
+      staged_files.each do |file|
         error_list = Array(run_check(file))
         error_list.each { |error_object| errors << display_error(error_object, file) }
       end
 
-      if errors.empty?
-        true
-      else
-        $stderr.puts errors.join("\n")
-        $stderr.puts
-        $stderr.puts 'pre-commit: You can bypass this check using `git commit -n`'
-        $stderr.puts
-        false
-      end
-    end
-
-    def should_run?(js_files)
-      js_files.any?
+      return if errors.empty?
+      errors.join("\n")
     end
 
-    def reject_non_js(staged_files)
-      staged_files.select { |f| f =~ /\.js$/ }
-    end
-
-    def check_name
+    def self.check_name
       raise "Must be defined by subclass"
     end
 
-    def linter_src
+    def self.linter_src
       raise "Must be defined by subclass"
     end
 
-    def display_error(error_object, file)
+    def self.display_error(error_object, file)
       return "" unless error_object
 
       line = error_object['line'].to_i + 1
-      "pre-commit: #{check_name.upcase} #{error_object['reason']}\n#{file}:#{line} #{error_object['evidence']}"
+      "#{error_object['reason']}\n#{file}:#{line} #{error_object['evidence']}"
     end
-
   end
 end

data/lib/pre-commit/checks/jshint_check.rb

@@ -2,34 +2,25 @@ require 'pre-commit/checks/js_check'
 
 module PreCommit
   class JshintCheck < JsCheck
-
-    def check_name
-      "JSHint"
-    end
-
-    def files_to_check
-      Utils.staged_files('.').split(" ")
-    end
-
-    def config
-      config_file = ENV['JSHINT_CONFIG']
-      config_file ||= File.exists?(".jshintrc") ? ".jshintrc" : nil
-
-      if config_file
+    def self.config
+      if config_file = [ENV['JSHINT_CONFIG'], ".jshintrc"].compact.detect { |f| File.exist?(f) }
         ExecJS.exec("return (#{File.read(config_file)});")
       else
         {}
       end
     end
 
-    def run_check(file)
+    def self.check_name
+      "JSHint"
+    end
+
+    def self.run_check(file)
       context = ExecJS.compile(File.read(linter_src))
       context.call('JSHINT', File.read(file), config)
     end
 
-    def linter_src
-      File.join(PreCommit.root, 'lib', 'support', 'jshint', 'jshint.js')
+    def self.linter_src
+      File.expand_path("../../support/jshint/jshint.js", __FILE__)
     end
-
   end
 end

data/lib/pre-commit/checks/jslint_check.rb

@@ -2,27 +2,11 @@ require 'pre-commit/checks/js_check'
 
 module PreCommit
   class JslintCheck < JsCheck
-
-    attr_accessor :type
-
-    def check_name
+    def self.check_name
       "JSLint"
     end
 
-    def initialize(type = :all)
-      @type = type
-    end
-
-    def files_to_check
-      case @type
-      when :new
-        Utils.new_files('.').split(" ")
-      else
-        Utils.staged_files('.').split(" ")
-      end
-    end
-
-    def run_check(file)
+    def self.run_check(file)
       context = ExecJS.compile(File.read(linter_src))
       if !(context.call('JSLINT', File.read(file)))
         context.exec('return JSLINT.errors;')
@@ -31,9 +15,8 @@ module PreCommit
       end
     end
 
-    def linter_src
-      File.join(PreCommit.root, 'lib', 'support', 'jslint', 'lint.js')
+    def self.linter_src
+      File.expand_path("../../support/jslint/lint.js", __FILE__)
     end
-
   end
 end

data/lib/pre-commit/checks/local_check.rb

@@ -1,28 +1,11 @@
-require 'pre-commit/utils'
-
 module PreCommit
   class LocalCheck
-
     DEFAULT_LOCATION = "config/pre-commit.rb"
-    attr_accessor :error_message
 
-    def self.call(quiet=false)
-      check = new
-      result = check.run(DEFAULT_LOCATION, Utils.staged_files("."))
-      puts check.error_message if !result && !quiet
-      result
+    def self.call(staged_files, script=DEFAULT_LOCATION)
+      return unless File.exist?(script)
+      output = `ruby #{script} #{staged_files.join(" ")} 2>&1`
+      "#{script} failed:\n#{output}" unless $?.success?
     end
-
-    def run(file, staged_files)
-      return true unless File.exist?(file)
-      output = `ruby #{file} #{staged_files} 2>&1`
-      if $?.success?
-        true
-      else
-        self.error_message = "#{file} failed:\n#{output}"
-        false
-      end
-    end
-
   end
 end

data/lib/pre-commit/checks/merge_conflict_check.rb

@@ -0,0 +1,10 @@
+module PreCommit
+  class MergeConflictCheck
+    def self.call(staged_files)
+      return if staged_files.empty?
+      errors = `#{Utils.grep} '<<<<<<<' #{staged_files.join(" ")}`.strip
+      return unless $?.success?
+      "detected a merge conflict\n#{errors}"
+    end
+  end
+end

data/lib/pre-commit/checks/migration_check.rb

@@ -1,39 +1,21 @@
 module PreCommit
   class MigrationCheck
-
-    attr_accessor :error_message
-
-    def call
-      staged_files = load_staged_files
-      run(staged_files)
-
-      if !passed? && error_message
-        $stderr.puts "pre-commit: #{error_message}"
-      end
-
-      passed?
-    end
-
-    def run(staged_files)
+    def self.call(staged_files)
       migration_present = migration_file_present?(staged_files)
       schema_change = schema_file_present?(staged_files)
 
       if migration_present && !schema_change
-        @error_message = "It looks like you're adding a migration, but did not update the schema file"
-        @passed = false
+        "It looks like you're adding a migration, but did not update the schema file"
       elsif schema_change && !migration_present
-        @error_message = "You're trying to change the schema without adding a migration file"
-        @passed = false
-      else
-        @passed = true
+        "You're trying to change the schema without adding a migration file"
       end
     end
 
-    def migration_file_present?(staged_files)
+    def self.migration_file_present?(staged_files)
       staged_files.any? { |file| file =~ /db\/migrate\/.*\.rb/ }
     end
 
-    def schema_file_present?(staged_files)
+    def self.schema_file_present?(staged_files)
       staged_files.any? do |file|
         basename = File.basename(file)
 
@@ -42,14 +24,5 @@ module PreCommit
         end
       end
     end
-
-    def passed?
-      @passed
-    end
-
-    def load_staged_files
-      Utils.staged_files('.').split(" ")
-    end
-
   end
 end

data/lib/pre-commit/checks/nb_space_check.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module PreCommit
+  class NbSpaceCheck
+    def self.call(staged_files)
+      nb_space = " "
+      raise "you messed that up" unless nb_space.bytes.to_a == [194, 160]
+
+      staged_files.reject! { |f| f =~ /^vendor\// || !File.read(f).include?(nb_space) }
+
+      bad = staged_files.map do |file|
+        content = File.read(file).lines.to_a
+        line_no = content.index { |l| l.include?(nb_space) }
+        char_no = content[line_no].index(nb_space)
+        [file, line_no, char_no]
+      end
+
+      return if bad.empty?
+      "Detected non-breaking space in #{bad.map { |f,l,c| "#{f}:#{l+1} character:#{c+1}" }.join(" and")}, remove it!"
+    end
+  end
+end

data/lib/pre-commit/checks/php_check.rb

@@ -1,73 +1,25 @@
-require 'pre-commit/base'
 require 'pre-commit/utils'
 
 module PreCommit
   class PhpCheck
+    def self.call(staged_files)
+      staged_files = staged_files.grep /\.(php|engine|theme|install|inc|module|test)$/
+      return if staged_files.empty?
 
-    def files_to_check
-      Utils.staged_files('.').split(" ")
-    end
-
-    def call
-      php_files = reject_non_php(files_to_check)
-      if should_run?(php_files)
-        run(php_files)
-      else
-        # pretend the check passed and move on
-        true
-      end
-    end
-
-    def check_name
-      "PHP Lint"
-    end
-
-    def run(php_files)
-      errors = []
-
-      php_files.each do |file|
-        error = run_check(file)
-        unless error.nil?
-          errors << display_error(error)
-        end
-      end
+      errors = staged_files.map { |file| run_check(file) }.compact
+      return if errors.empty?
 
-      if errors.empty?
-        true
-      else
-        $stderr.puts errors.join("\n")
-        $stderr.puts
-        $stderr.puts 'pre-commit: You can bypass this check using `git commit -n`'
-        $stderr.puts
-        false
-      end
+      errors.join("\n")
     end
 
-    def should_run?(php_files)
-      php_files.any?
-    end
-
-    def reject_non_php(staged_files)
-      staged_files.select { |f| f =~ /\.(php|engine|theme|install|inc|module|test)$/ }
-    end
-
-    def run_check(file)
+    def self.run_check(file)
       # We force PHP to display errors otherwise they will likely end up in the
       # error_log and not in stdout.
-      cmd = "php -d display_errors=1 -l #{file}"
-      result = %x[ #{cmd} ]
+      result = `php -d display_errors=1 -l #{file}`
       # Filter out the obvious note from PHP.
       result = result.split($/).find_all {|line| line !~ /Errors/}.join($/)
       # If PHP exited non-zero then there was a parse error.
-      if ($? != 0)
-        result
-      end
+      result.strip unless $? == 0
     end
-
-    # Format an error line.
-    def display_error(error)
-      "pre-commit: #{check_name.upcase} #{error}"
-    end
-
   end
 end

data/lib/pre-commit/checks/pry_check.rb

@@ -1,47 +1,10 @@
 module PreCommit
   class PryCheck
-
-    attr_accessor :staged_files, :error_message, :grep_command
-
-    def self.call(quiet=false)
-      dirs = ['app/', 'lib/', 'script/', 'vendor/', 'test/'].reject {|d| !File.exists?(d)}
-      check = new
-      check.staged_files = Utils.staged_files(*dirs)
-
-      result = check.run
-      if !quiet && !result
-        $stderr.puts check.error_message
-        $stderr.puts
-        check.print_dash_n_reminder
-      end
-      result
+    def self.call(staged_files)
+      return if staged_files.empty?
+      result = `#{Utils.grep} binding.pry #{staged_files.join(" ")}`.strip
+      return unless $?.success?
+      "binding.pry found:\n#{result}"
     end
-
-    def run
-      return true if staged_files.empty?
-
-      if detected_bad_code?
-        @error_message = "pre-commit: binding.pry statement(s) found:\n"
-        @error_message += instances_of_pry_violations
-        false
-      else
-        true
-      end
-    end
-
-    def detected_bad_code?
-      !system("git diff --cached -S binding.pry --quiet --exit-code")
-    end
-
-    def instances_of_pry_violations
-      cmd = grep_command || "git grep"
-      `#{cmd} -nH "binding\.pry" #{staged_files}`
-    end
-
-    def print_dash_n_reminder
-      $stderr.puts 'You can bypass this check using `git commit -n`'
-      $stderr.puts
-    end
-
   end
 end

data/lib/pre-commit/checks/rspec_focus_check.rb

@@ -1,54 +1,11 @@
 module PreCommit
   class RSpecFocusCheck
-
-    attr_accessor :staged_files, :error_message, :grep_command, :spec_files
-
-    def self.call(quiet=false)
-      dirs = ['spec/'].reject {|d| !File.exists?(d)}
-      check = new
-      check.staged_files = Utils.staged_files(*dirs)
-
-      result = check.run
-      if !quiet && !result
-        $stderr.puts check.error_message
-        $stderr.puts
-        check.print_dash_n_reminder
-      end
-      result
+    def self.call(staged_files)
+      staged_files = staged_files.grep(/_spec\.rb$/)
+      return if staged_files.empty?
+      result = `#{Utils.grep} ':focus' #{staged_files.join(" ")}`.strip
+      return unless $?.success?
+      ":focus found in specs:\n#{result}"
     end
-
-    def run
-      return true if staged_files.empty?
-
-      if detected_bad_code?
-        @error_message = "pre-commit: :focus in spec(s) found:\n"
-        @error_message += instances_of_rspec_focus_violations
-        false
-      else
-        true
-      end
-    end
-
-    def detected_bad_code?
-      spec_files = staged_files.split(' ').select do |file|
-        file =~ /_spec\.rb$/
-      end
-
-      return false if spec_files.empty?
-
-      diff = `git diff --cached -G:focus #{spec_files.join(" ")}`
-      !!(diff =~ /[\W\s]:focus[\W\s]/)
-    end
-
-    def instances_of_rspec_focus_violations
-      cmd = grep_command || "git grep"
-      `#{cmd} -nHw ':focus' #{staged_files}`
-    end
-
-    def print_dash_n_reminder
-      $stderr.puts 'You can bypass this check using `git commit -n`'
-      $stderr.puts
-    end
-
   end
 end