overcommit-jeygeethanmedia 0.53.1

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `flake8` against any modified Python files.
+  #
+  # @see https://pypi.python.org/pypi/flake8
+  class PythonFlake8 < Base
+    MESSAGE_REGEX = /^(?<file>(?:\w:)?.+):(?<line>\d+):\d+:\s(?<type>\w\d+)/
+
+    # Classify 'Exxx' and 'Fxxx' message codes as errors,
+    # everything else as warnings.
+    #   http://flake8.readthedocs.org/en/latest/warnings.html
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      'EF'.include?(type[0]) ? :error : :warning
+    end
+
+    def run
+      result = execute(command, args: applicable_files)
+      return :pass if result.success?
+
+      output = result.stdout.chomp
+
+      # example message:
+      #   path/to/file.py:2:13: F812 list comprehension redefines name from line 1
+      extract_messages(
+        output.split("\n").grep(MESSAGE_REGEX),
+        MESSAGE_REGEX,
+        MESSAGE_TYPE_CATEGORIZER
+      )
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Overcommit
+  module Hook
+    module PreCommit
+      # Runs `rails_best_practices` against Ruby files
+      #
+      # @see https://github.com/railsbp/rails_best_practices
+      class RailsBestPractices < Base
+        ERROR_REGEXP = /^(?<file>(?:\w:)?[^:]+):(?<line>\d+)\s-\s(?<type>.+)/
+
+        def run
+          result = execute(command, args: applicable_files)
+
+          return :pass if result.success?
+          return [:fail, result.stderr] unless result.stderr.empty?
+
+          extract_messages(
+            filter_output(result.stdout),
+            ERROR_REGEXP
+          )
+        end
+
+        private
+
+        def filter_output(stdout)
+          stdout.split("\n").select do |message|
+            message.match ERROR_REGEXP
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Check to see whether the schema file is in line with the migrations. When a
+  # schema file is present but a migration file is not, this is usually a
+  # failure. The exception is if the schema is at version 0 (i.e before any
+  # migrations have been run). In this case it is OK if there are no migrations.
+  class RailsSchemaUpToDate < Base
+    def run # rubocop:disable CyclomaticComplexity, PerceivedComplexity
+      if migration_files.any? && schema_files.none?
+        return :fail, "It looks like you're adding a migration, but did not update the schema file"
+      elsif migration_files.none? && schema_files.any? && non_zero_schema_version?
+        return :fail, "You're trying to change the schema without adding a migration file"
+      elsif migration_files.any? && schema_files.any?
+        # Get the latest version from the migration filename. Use
+        # `File.basename` to prevent finding numbers that could appear in
+        # directories, such as the home directory of a user with a number in
+        # their username.
+        latest_version = migration_files.map do |file|
+          File.basename(file)[/\d+/]
+        end.sort.last
+
+        up_to_date = schema.include?(latest_version)
+
+        unless up_to_date
+          return :fail, "The latest migration version you're committing is " \
+                       "#{latest_version}, but your schema file " \
+                       "#{schema_files.join(' or ')} is on a different version."
+        end
+      end
+
+      :pass
+    end
+
+    private
+
+    def migration_files
+      @migration_files ||= applicable_files.select do |file|
+        file.match %r{db/migrate/.*\.rb}
+      end
+    end
+
+    def schema_files
+      @schema_files ||= applicable_files.select do |file|
+        file.match %r{db/schema\.rb|db/structure.*\.sql}
+      end
+    end
+
+    def schema
+      @schema ||= schema_files.map { |file| File.read(file) }.join
+      @schema.tr('_', '')
+    end
+
+    def non_zero_schema_version?
+      schema =~ /\d{14}/
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'overcommit/hook/shared/rake_target'
+
+module Overcommit::Hook::PreCommit
+  # Runs rake targets
+  #
+  # @see Overcommit::Hook::Shared::RakeTarget
+  class RakeTarget < Base
+    include Overcommit::Hook::Shared::RakeTarget
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `reek` against any modified Ruby files.
+  #
+  # @see https://github.com/troessner/reek
+  class Reek < Base
+    def run
+      result = execute(command, args: applicable_files)
+      return :pass if result.success?
+
+      output = scrub_output(result.stdout + result.stderr)
+
+      extract_messages(
+        output,
+        /^\s*(?<file>(?:\w:)?[^:]+):(?<line>\d+):/,
+      )
+    end
+
+    private
+
+    def scrub_output(raw_output)
+      raw_output.split("\n").grep(/^(.(?!warning))*$/)
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `rst-lint` against any modified reStructuredText files
+  #
+  # @see https://github.com/twolfson/restructuredtext-lint
+  class RstLint < Base
+    MESSAGE_REGEX = /
+    ^(?<type>INFO|WARNING|ERROR|SEVERE)(?<file>(?:\w:)?[^:]+):(?<line>\d+)\s(?<msg>.+)
+    /x
+
+    def run
+      result = execute(command, args: applicable_files)
+      output = result.stdout.chomp
+
+      return :pass if result.success?
+      return [:fail, result.stderr] unless result.stderr.empty?
+
+      # example message:
+      # WARNING README.rst:7 Title underline too short.
+      extract_messages(
+        output.split("\n"),
+        MESSAGE_REGEX
+      )
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `rubocop` against any modified Ruby files.
+  #
+  # @see http://batsov.com/rubocop/
+  class RuboCop < Base
+    GENERIC_MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.match?(/^warn/) ? :warning : :error
+    end
+
+    COP_MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('W') ? :warning : :error
+    end
+
+    def run
+      result = execute(command, args: applicable_files)
+      return :pass if result.success?
+
+      generic_messages = extract_messages(
+        result.stderr.split("\n"),
+        /^(?<type>[a-z]+)/i,
+        GENERIC_MESSAGE_TYPE_CATEGORIZER,
+      )
+
+      cop_messages = extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>(?:\w:)?[^:]+):(?<line>\d+):[^ ]+ (?<type>[^ ]+)/,
+        COP_MESSAGE_TYPE_CATEGORIZER,
+      )
+
+      generic_messages + cop_messages
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `ruby-lint` against any modified Ruby files.
+  #
+  # @see https://github.com/YorickPeterse/ruby-lint
+  class RubyLint < Base
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('W') ? :warning : :error
+    end
+
+    def run
+      result = execute(command, args: applicable_files)
+      return :pass if result.success?
+
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>(?:\w:)?[^:]+):(?<type>[^:]+):(?<line>\d+)/,
+        MESSAGE_TYPE_CATEGORIZER
+      )
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `ruby -c` against all Ruby files.
+  #
+  class RubySyntax < Base
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.match?(/^(syntax)?\s*error/) ? :error : :warning
+    end
+
+    def run
+      result = execute(command, args: applicable_files)
+
+      result_lines = result.stderr.split("\n")
+
+      return :pass if result_lines.length.zero?
+
+      # Example message:
+      #   path/to/file.rb:1: syntax error, unexpected '^'
+      extract_messages(
+        result_lines,
+        /^(?<file>[^:]+):(?<line>\d+):\s*(?<type>[^,]+),\s*(?<message>.+)/,
+        MESSAGE_TYPE_CATEGORIZER
+      )
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `scalariform` against any modified Scala files.
+  #
+  # @see https://github.com/mdr/scalariform
+  class Scalariform < Base
+    MESSAGE_REGEX = /^\[(?<type>FAILED|ERROR)\]\s+(?<file>(?:\w:)?.+)/
+
+    def run
+      result = execute(command, args: applicable_files)
+
+      # example message:
+      #   [FAILED] path/to/file.scala
+      extract_messages(
+        result.stdout.split("\n").grep(MESSAGE_REGEX),
+        MESSAGE_REGEX,
+        lambda { |type| type == 'ERROR' ? :error : :warning }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `scalastyle` against any modified Scala files.
+  #
+  # @see http://www.scalastyle.org/
+  class Scalastyle < Base
+    MESSAGE_REGEX = /
+      ^(?<type>error|warning)\s
+      file=(?<file>(?:\w:)?.+)\s
+      message=.+\s*
+      (line=(?<line>\d+))?
+    /x
+
+    def run
+      result = execute(command, args: applicable_files)
+      output = result.stdout.chomp + result.stderr.chomp
+      messages = output.split("\n").grep(MESSAGE_REGEX)
+
+      return [:fail, output] unless result.success? || messages.any?
+
+      # example message:
+      #   error file=/path/to/file.scala message=Error message line=1 column=1
+      extract_messages(
+        messages,
+        MESSAGE_REGEX,
+        lambda { |type| type.to_sym }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `scss-lint` against any modified SCSS files.
+  #
+  # @see https://github.com/sds/scss-lint
+  class ScssLint < Base
+    def run
+      result = execute(command, args: applicable_files)
+
+      # Status code 81 indicates the applicable files were all filtered by
+      # exclusions defined by the configuration. In this case, we're happy to
+      # return success since there were technically no lints.
+      return :pass if [0, 81].include?(result.status)
+
+      # Any status that isn't indicating lint warnings or errors indicates failure
+      return :fail, (result.stdout + result.stderr) unless [1, 2].include?(result.status)
+
+      begin
+        collect_lint_messages(JSON.parse(result.stdout))
+      rescue JSON::ParserError => ex
+        return :fail, "Unable to parse JSON returned by SCSS-Lint: #{ex.message}\n" \
+                      "STDOUT: #{result.stdout}\nSTDERR: #{result.stderr}"
+      end
+    end
+
+    private
+
+    def collect_lint_messages(files_to_lints)
+      files_to_lints.flat_map do |path, lints|
+        lints.map do |lint|
+          severity = lint['severity'] == 'warning' ? :warning : :error
+
+          message = lint['reason']
+          message = "#{lint['linter']}: #{message}" if lint['linter']
+          message = "#{path}:#{lint['line']} #{message}"
+
+          Overcommit::Hook::Message.new(severity, path, lint['line'], message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `semistandard` against any modified JavaScript files.
+  #
+  # @see https://github.com/Flet/semistandard
+  class SemiStandard < Base
+    MESSAGE_REGEX = /^\s*(?<file>(?:\w:)?[^:]+):(?<line>\d+)/
+
+    def run
+      result = execute(command, args: applicable_files)
+      output = result.stdout.chomp
+      return :pass if result.success? && output.empty?
+
+      # example message:
+      #   path/to/file.js:1:1: Error message (ruleName)
+      extract_messages(
+        output.split("\n").grep(MESSAGE_REGEX), # ignore header line
+        MESSAGE_REGEX
+      )
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `shellcheck` against any modified shell script files.
+  #
+  # @see http://www.shellcheck.net/
+  class ShellCheck < Base
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('note') ? :warning : :error
+    end
+
+    def run
+      result = execute(command, args: applicable_files)
+      return :pass if result.success?
+
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>(?:\w:)?[^:]+):(?<line>\d+):[^ ]+ (?<type>[^ ]+)/,
+        MESSAGE_TYPE_CATEGORIZER,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `slim-lint` against any modified Slim templates.
+  #
+  # @see https://github.com/sds/slim-lint
+  class SlimLint < Base
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('W') ? :warning : :error
+    end
+
+    def run
+      result = execute(command, args: applicable_files)
+      return :pass if result.success?
+
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>(?:\w:)?[^:]+):(?<line>\d+)[^ ]* (?<type>[^ ]+)/,
+        MESSAGE_TYPE_CATEGORIZER,
+      )
+    end
+  end
+end