overcommit-jeygeethanmedia 0.53.1

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `chamber compare` against a configurable set of namespaces.
+  #
+  # @see https://github.com/thekompanee/chamber/wiki/Git-Commit-Hooks#chamber-compare-pre-commit-hook
+  # rubocop:disable Metrics/MethodLength
+  class ChamberCompare < Base
+    def run
+      config['namespaces'].each_index do |index|
+        first  = config['namespaces'][index]
+        second = config['namespaces'][index + 1]
+
+        next unless second
+
+        result = execute(
+                   command,
+                   args: [
+                           "--first=#{first.join(' ')}",
+                           "--second=#{second.join(' ')}",
+                         ],
+                 )
+
+        unless result.stdout.empty?
+          trimmed_result = result.stdout.split("\n")
+          5.times { trimmed_result.shift }
+          trimmed_result = trimmed_result.join("\n")
+
+          return [
+                   :warn,
+                   "It appears your namespace settings between #{first} and " \
+                   "#{second} are not in sync:\n\n#{trimmed_result}\n\n" \
+                   "Run: chamber compare --first=#{first.join(' ')} " \
+                   "--second=#{second.join(' ')}",
+                 ]
+        end
+      end
+
+      :pass
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `chamber secure` against any modified Chamber settings files.
+  #
+  # @see https://github.com/thekompanee/chamber
+  class ChamberSecurity < Base
+    def run
+      result = execute(command, args: applicable_files)
+
+      return :pass if result.stdout.empty?
+      [:fail, "These settings appear to need to be secured but were not: #{result.stdout}"]
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `chamber sign --verify`.
+  #
+  # @see https://github.com/thekompanee/chamber/wiki/Git-Commit-Hooks#chamber-verification-pre-commit-hook
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  class ChamberVerification < Base
+    def run
+      approver_name  = config.fetch('approver_name') { 'your approver' }
+      approver_email = config['approver_email'] ? " (#{config['approver_email']})" : nil
+
+      result = execute(command)
+
+      return :pass if result.stdout.empty? && result.stderr.empty?
+      return :pass if result.stderr =~ /no signature key was found/
+
+      output = [
+        result.stdout.empty? ? nil : result.stdout,
+        result.stderr.empty? ? nil : result.stderr,
+      ].
+        compact.
+        join("\n\n")
+
+      output = "\n\n#{output}" unless output.empty?
+
+      [
+        :warn,
+        "One or more of your settings files does not match the signature.\n" \
+        "Talk to #{approver_name}#{approver_email} about getting them " \
+        "approved.#{output}",
+      ]
+    end
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `alfonsox` spell-checking tool against any modified code file.
+  #
+  # @see https://github.com/diegojromerolopez/alfonsox
+  class CodeSpellCheck < Base
+    def run
+      # Create default file config if it does not exist
+
+      # Run spell-check
+      result = execute(command, args: applicable_files)
+      return :pass if result.success?
+
+      spellchecking_errors = result.stderr.split("\n")
+      spellchecking_errors.pop
+
+      error_messages(spellchecking_errors)
+    end
+
+    private
+
+    # Create the error messages
+    def error_messages(spellchecking_errors)
+      messages = []
+      spellchecking_errors.each do |spellchecking_error_i|
+        error_location, word = spellchecking_error_i.split(' ')
+        error_file_path, line = error_location.split(':')
+        messages << Overcommit::Hook::Message.new(
+          :error, error_file_path, line, "#{error_location}: #{word}"
+        )
+      end
+      messages
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `coffeelint` against any modified CoffeeScript files.
+  #
+  # @see http://www.coffeelint.org/
+  class CoffeeLint < Base
+    MESSAGE_REGEX = /
+      ^(?<file>.+)
+      ,(?<line>\d*),\d*
+      ,(?<type>\w+)
+      ,(?<msg>.+)$
+    /x
+
+    MESSAGE_TYPE_CATEGORIZER = lambda do |type|
+      type.include?('w') ? :warning : :error
+    end
+
+    def run
+      result = execute(command, args: applicable_files)
+      parse_messages(result.stdout)
+    end
+
+    private
+
+    def parse_messages(output)
+      output.scan(MESSAGE_REGEX).map do |file, line, type, msg|
+        line = line.to_i
+        type = MESSAGE_TYPE_CATEGORIZER.call(type)
+        text = "#{file}:#{line}:#{type} #{msg}"
+        Overcommit::Hook::Message.new(type, file, line, text)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `cookstyle` against any modified Chef Ruby files.
+  #
+  # @see https://docs.chef.io/cookstyle.html
+  class CookStyle < 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/credo.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `credo` against any modified ex files.
+  #
+  # @see https://github.com/rrrene/credo
+  class Credo < Base
+    # example message:
+    # lib/file1.ex:1:11: R: Modules should have a @moduledoc tag.
+    # lib/file2.ex:12:81: R: Line is too long (max is 80, was 81).
+
+    def run
+      result = execute(command, args: applicable_files)
+      return :pass if result.success?
+
+      result.stdout.split("\n").map(&:strip).reject(&:empty?).
+        map { |error| message(error) }
+    end
+
+    private
+
+    def message(error)
+      file, line = error.split(':')
+      Overcommit::Hook::Message.new(:error, file, Integer(line), error)
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `csslint` against any modified CSS files.
+  #
+  # @see https://github.com/CSSLint/csslint
+  class CssLint < Base
+    MESSAGE_REGEX = /
+      ^(?<file>(?:\w:)?[^:]+):\s
+      (?:line\s(?<line>\d+)[^EW]+)?
+      (?<type>Error|Warning)
+    /x
+
+    def run
+      result = execute(command, args: applicable_files)
+      output = result.stdout.chomp
+      return :pass if result.success? && output.empty?
+
+      extract_messages(
+        output.split("\n").reject(&:empty?),
+        MESSAGE_REGEX,
+        lambda { |type| type.downcase.to_sym }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `dogma` against any modified ex files.
+  #
+  # @see https://github.com/lpil/dogma
+  class Dogma < Base
+    def run
+      result = execute command
+      return :pass if result.success?
+
+      messages = []
+      # example message:
+      #  == web/channels/user_socket.ex ==
+      #  26: LineLength: Line length should not exceed 80 chars (was 83).
+      #  1: ModuleDoc: Module Sample.UserSocket is missing a @moduledoc.
+      output = result.stdout.chomp.match(/(==.+)/m)
+
+      if output
+        output.captures.first.split(/\n\n/).each do |error_group|
+          errors = error_group.split /\n/
+          file = errors.shift.gsub /[ =]/, ''
+          errors.each do |error|
+            line = error.split(': ').first
+            messages << Overcommit::Hook::Message.new(:error, file, line, "#{file}: #{error}")
+          end
+        end
+      end
+
+      messages
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `eslint` against any modified JavaScript files.
+  #
+  # Protip: if you have an npm script set up to run eslint, you can configure
+  # this hook to run eslint via your npm script by using the `command` option in
+  # your .overcommit.yml file. This can be useful if you have some eslint
+  # configuration built into your npm script that you don't want to repeat
+  # somewhere else. Example:
+  #
+  #   EsLint:
+  #     required_executable: 'npm'
+  #     enabled: true
+  #     command: ['npm', 'run', 'lint', '--', '-f', 'compact']
+  #
+  # Note: This hook supports only compact format.
+  #
+  # @see http://eslint.org/
+  class EsLint < Base
+    def run
+      result = execute(command, args: applicable_files)
+      output = result.stdout.chomp
+      messages = output.split("\n").grep(/Warning|Error/)
+
+      return [:fail, result.stderr] if messages.empty? && !result.success?
+      return :pass if result.success? && output.empty?
+
+      # example message:
+      #   path/to/file.js: line 1, col 0, Error - Error message (ruleName)
+      extract_messages(
+        messages,
+        /^(?<file>(?:\w:)?[^:]+):[^\d]+(?<line>\d+).*?(?<type>Error|Warning)/,
+        lambda { |type| type.downcase.to_sym }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Checks for files with execute permissions, which are usually not necessary
+  # in source code files (and are typically caused by a misconfigured editor
+  # assigning incorrect default permissions).
+  #
+  # Protip: if you have some files that you want to allow execute permissions
+  # on, you can disable this hook for those files by using the `exclude` option
+  # on your .overcommit.yml file. Example:
+  #
+  #   ExecutePermissions:
+  #     enabled: true
+  #     exclude:
+  #       - 'path/to/my/file/that/should/have/execute/permissions.sh'
+  #       - 'directory/that/should/have/execute/permissions/**/*'
+  class ExecutePermissions < Base
+    def run
+      file_modes = {}
+
+      # We have to look in two places to determine the execute permissions of a
+      # file. The first is the Git tree for currently known file modes of all
+      # files, the second is the index for any staged changes to file modes.
+      # Staged changes take priority if they exist.
+      #
+      # This complexity is necessary because this hook can be run in the RunAll
+      # context, where there may be no staged changes but we stil want to check
+      # the permissions.
+      extract_from_git_tree(file_modes) unless initial_commit?
+      extract_from_git_index(file_modes)
+
+      file_modes.map do |file, mode|
+        next unless execute_permissions?(mode)
+
+        Overcommit::Hook::Message.new(
+          :error,
+          file,
+          nil,
+          "File #{file} has unnecessary execute permissions",
+        )
+      end.compact
+    end
+
+    private
+
+    def extract_from_git_tree(file_modes)
+      result = execute(%w[git ls-tree HEAD --], args: applicable_files)
+      raise 'Unable to access git tree' unless result.success?
+
+      result.stdout.split("\n").each do |line|
+        mode, _type, _hash, file = line.split(/\s+/, 4)
+        file_modes[file] = mode
+      end
+    end
+
+    def extract_from_git_index(file_modes)
+      result = execute(%w[git diff --raw --cached --no-color --], args: applicable_files)
+      raise 'Unable to access git index' unless result.success?
+
+      result.stdout.split("\n").each do |line|
+        _old_mode, new_mode, _old_hash, _new_hash, _status, file = line.split(/\s+/, 6)
+        file_modes[file] = new_mode
+      end
+    end
+
+    # Check if the 1st bit is toggled, indicating execute permissions.
+    #
+    # Git tracks only execute permissions, not individual read/write/execute
+    # permissions for user, group, and other, since that concept does not exist
+    # on all operating systems. If any of the user/group/other permissions
+    # have the executable bit set, they all will. Thus we check the first bit.
+    def execute_permissions?(mode)
+      (mode.to_i(8) & 1) == 1
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `fasterer` against any modified Ruby files.
+  #
+  # @see https://github.com/DamirSvrtan/fasterer
+  class Fasterer < Base
+    def run
+      result = execute(command, args: applicable_files)
+      output = result.stdout
+
+      if extract_offense_num(output) == 0
+        :pass
+      else
+        return [:warn, output]
+      end
+    end
+
+    private
+
+    def extract_offense_num(raw_output)
+      raw_output.scan(/(\d+) offense detected/).flatten.map(&:to_i).inject(0, :+)
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Checks for oversized files before committing.
+  class FileSize < Base
+    def run
+      return :pass if oversized_files.empty?
+
+      oversized_files.map do |file|
+        error_message_for(file)
+      end
+    end
+
+    def description
+      "Check for files over #{size_limit_bytes} bytes"
+    end
+
+    private
+
+    def oversized_files
+      @oversized_files ||= build_oversized_file_list
+    end
+
+    def build_oversized_file_list
+      applicable_files.select do |file|
+        File.exist?(file) && file_size(file) > size_limit_bytes
+      end
+    end
+
+    def size_limit_bytes
+      config.fetch('size_limit_bytes')
+    end
+
+    def error_message_for(file)
+      Overcommit::Hook::Message.new(
+        :error,
+        file,
+        nil,
+        "#{file} is #{file_size(file)} bytes"
+      )
+    end
+
+    def file_size(file)
+      File.size(file)
+    end
+  end
+end