overcommit-jeygeethanmedia 0.53.1

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Check for "token" strings
+  class FixMe < Base
+    def run
+      keywords = config['keywords']
+      result = execute(command, args: [keywords.join('|')] + applicable_files)
+
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>(?:\w:)?[^:]+):(?<line>\d+)/,
+        lambda { |_type| :warning }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `flay` against any modified files.
+  #
+  # @see https://github.com/seattlerb/flay
+  class Flay < Base
+    # Flay prints two kinds of messages:
+    #
+    # 1) IDENTICAL code found in :defn (mass*2 = MASS)
+    # file_path_1.rb:LINE_1
+    # file_path_2.rb:LINE_2
+    #
+    # 2) Similar code found in :defn (mass = MASS)
+    # file_path_1.rb:LINE_1
+    # file_path_2.rb:LINE_2
+    #
+
+    def run
+      command = ['flay', '--mass', @config['mass_threshold'].to_s, '--fuzzy', @config['fuzzy'].to_s]
+      # Use a more liberal detection method
+      command += ['--liberal'] if @config['liberal']
+      messages = []
+      # Run the command for each file
+      applicable_files.each do |file|
+        result = execute(command, args: [file])
+        results = result.stdout.split("\n\n")
+        results.shift
+        unless results.empty?
+          error_message = results.join("\n").gsub(/^\d+\)\s*/, '')
+          message = Overcommit::Hook::Message.new(:error, nil, nil, error_message)
+          messages << message
+        end
+      end
+      messages
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `foodcritic` against any modified Ruby files from Chef directory structure.
+  #
+  # @see http://www.foodcritic.io/
+  #
+  # There are two "modes" you can run this hook in based on the repo:
+  #
+  # SINGLE COOKBOOK REPO MODE
+  # -------------------------
+  # The default. Use this if your repository contains just a single cookbook,
+  # i.e. the top-level repo directory contains directories called `attributes`,
+  # `libraries`, `recipes`, etc.
+  #
+  # To get this to work well, you'll want to set your Overcommit configuration
+  # for this hook to something like:
+  #
+  # PreCommit:
+  #   Foodcritic:
+  #     enabled: true
+  #     include:
+  #       - 'attributes/**/*'
+  #       - 'definitions/**/*'
+  #       - 'files/**/*'
+  #       - 'libraries/**/*'
+  #       - 'providers/**/*'
+  #       - 'recipes/**/*'
+  #       - 'resources/**/*'
+  #       - 'templates/**/*'
+  #
+  # MONOLITHIC REPO MODE
+  # --------------------
+  # Use this if you store multiple cookbooks, environments, and roles (or any
+  # combination thereof) in a single repository.
+  #
+  # There are three configuration options relevant here:
+  #
+  #   * `cookbooks_directory`
+  #     When set, hook will treat the path as a directory containing cookbooks.
+  #     Each subdirectory of this directory will be treated as a separate
+  #     cookbook.
+  #
+  #   * `environments_directory`
+  #     When set, hook will treat the path as a directory containing environment
+  #     files.
+  #
+  #   * `roles_directory`
+  #     When set, hook will treat the given path as a directory containing role
+  #     files.
+  #
+  # In order to run in monolithic repo mode, YOU MUST SET `cookbooks_directory`.
+  # The other configuration options are optional, if you happen to store
+  # environments/roles in another repo.
+  #
+  # To get this to work well, you'll want to set your Overcommit configuration
+  # for this hook to something like:
+  #
+  # PreCommit:
+  #   Foodcritic:
+  #     enabled: true
+  #     cookbooks_directory: 'cookbooks'
+  #     environments_directory: 'environments'
+  #     roles_directory: 'roles'
+  #     include:
+  #       - 'cookbooks/**/*'
+  #       - 'environments/**/*'
+  #       - 'roles/**/*'
+  #
+  # ADDITIONAL CONFIGURATION
+  # ------------------------
+  # You can disable rules using the `flags` hook option. For example:
+  #
+  # PreCommit:
+  #   Foodcritic:
+  #     enabled: true
+  #     ...
+  #     flags:
+  #       - '--epic-fail=any'
+  #       - '-t~FC011' # Missing README in markdown format
+  #       - '-t~FC064' # Ensure issues_url is set in metadata
+  #
+  # Any other command line flag supported by the `foodcritic` executable can be
+  # specified here.
+  #
+  # If you want the hook run to fail (and not just warn), set the `on_warn`
+  # option for the hook to `fail`:
+  #
+  # PreCommit:
+  #   Foodcritic:
+  #     enabled: true
+  #     on_warn: fail
+  #     ...
+  #
+  # This will treat any warnings as failures and cause the hook to exit
+  # unsuccessfully.
+  class Foodcritic < Base
+    def run
+      args = modified_cookbooks_args + modified_environments_args + modified_roles_args
+      result = execute(command, args: args)
+
+      if result.success?
+        :pass
+      else
+        return [:warn, result.stderr + result.stdout]
+      end
+    end
+
+    private
+
+    def directories_changed(dir_prefix)
+      applicable_files.
+        select    { |path| path.start_with?(dir_prefix) }.
+        map       { |path| path.gsub(%r{^#{dir_prefix}/}, '') }.
+        group_by  { |path| path.split('/').first }.
+        keys.
+        map { |path| File.join(dir_prefix, path) }
+    end
+
+    def modified_environments_args
+      modified('environments').map { |env| %W[-E #{env}] }.flatten
+    end
+
+    def modified_roles_args
+      modified('roles').map { |role| %W[-R #{role}] }.flatten
+    end
+
+    def modified_cookbooks_args
+      # Return the repo root if repository contains a single cookbook
+      if !config['cookbooks_directory'] || config['cookbooks_directory'].empty?
+        ['-B', Overcommit::Utils.repo_root]
+      else
+        # Otherwise return all modified cookbooks in the cookbook directory
+        modified('cookbooks').map { |cookbook| ['-B', cookbook] }.flatten
+      end
+    end
+
+    def modified(type)
+      return [] if !config["#{type}_directory"] || config["#{type}_directory"].empty?
+      @modified ||= {}
+      @modified[type] ||= directories_changed(full_directory_path("#{type}_directory"))
+    end
+
+    def full_directory_path(config_option)
+      return config[config_option] if config[config_option].start_with?(File::SEPARATOR)
+      File.absolute_path(File.join(Overcommit::Utils.repo_root, config[config_option]))
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Prevents commits to branches matching one of the configured patterns.
+  class ForbiddenBranches < Base
+    def run
+      return :pass unless forbidden_commit?
+
+      [:fail, "Committing to #{current_branch} is forbidden"]
+    end
+
+    private
+
+    def forbidden_commit?
+      forbidden_branch_patterns.any? { |p| File.fnmatch(p, current_branch) }
+    end
+
+    def forbidden_branch_patterns
+      @forbidden_branch_patterns ||= Array(config['branch_patterns'])
+    end
+
+    def current_branch
+      @current_branch ||= Overcommit::GitRepo.current_branch
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Check for "focused" tests
+  class GinkgoFocus < Base
+    def run
+      keywords = config['keywords']
+      result = execute(command, args: [keywords.join('|')] + applicable_files)
+
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>(?:\w:)?[^:]+):(?<line>\d+)/,
+        lambda { |_type| :warning }
+      )
+    end
+
+    def applicable_test_files
+      applicable_files.select do |f|
+        f if f =~ /_test\.go/
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs go fmt for all modified Go files
+  class GoFmt < Base
+    def run
+      errors = []
+      applicable_files.each do |file|
+        result = execute(command, args: [file])
+        errors << (result.stdout + result.stderr) unless result.success?
+      end
+      return :pass if errors.empty?
+
+      [:fail, errors.join("\n")]
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `golint` against any modified Golang files.
+  #
+  # @see https://github.com/golang/lint
+  class GoLint < Base
+    def run
+      output = ''
+
+      # golint doesn't accept multiple file arguments if
+      # they belong to different packages
+      applicable_files.each do |gofile|
+        result = execute(command, args: Array(gofile))
+        output += result.stdout + result.stderr
+      end
+
+      # Unfortunately the exit code is always 0
+      return :pass if output.empty?
+
+      # example message:
+      #   path/to/file.go:1:1: Error message
+      extract_messages(
+        output.split("\n"),
+        /^(?<file>(?:\w:)?[^:]+):(?<line>\d+)/
+      )
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `go vet` against any modified Golang files.
+  #
+  # @see https://godoc.org/code.google.com/p/go-zh.tools/cmd/vet
+  class GoVet < Base
+    def run
+      result = execute(command, args: applicable_files)
+      return :pass if result.success?
+
+      if result.stderr.match?(/no such tool "vet"/)
+        return :fail, "`go tool vet` is not installed#{install_command_prompt}"
+      end
+
+      # example message:
+      #   path/to/file.go:7: Error message
+      extract_messages(
+        result.stderr.split("\n"),
+        /^(?<file>(?:\w:)?[^:]+):(?<line>\d+)/
+      )
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `golangci-lint run` against any modified packages
+  #
+  # @see https://github.com/golangci/golangci-lint
+  class GolangciLint < Base
+    def run
+      packages = applicable_files.map { |f| File.dirname(f) }.uniq
+      result = execute(command, args: packages)
+      return :pass if result.success?
+      return [:fail, result.stderr] unless result.stderr.empty?
+
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>(?:\w:)?[^:]+):(?<line>\d+)/,
+        nil
+      )
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `hadolint` against any modified Dockefile files.
+  #
+  # @see http://hadolint.lukasmartinelli.ch/
+  class Hadolint < Base
+    def run
+      output = ''
+      success = true
+
+      # hadolint doesn't accept multiple arguments
+      applicable_files.each do |dockerfile|
+        result = execute(command, args: Array(dockerfile))
+        output += result.stdout
+        success &&= result.success?
+      end
+
+      return :pass if success
+
+      extract_messages(
+        output.split("\n"),
+        /^(?<file>[^:]+):(?<line>\d+)/,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `haml-lint` against any modified HAML files.
+  #
+  # @see https://github.com/brigade/haml-lint/
+  class HamlLint < 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

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Checks for hard tabs in files.
+  class HardTabs < Base
+    def run
+      result = execute(command, args: applicable_files)
+
+      extract_messages(
+        result.stdout.split("\n"),
+        /^(?<file>(?:\w:)?[^:]+):(?<line>\d+)/,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Runs `hlint` against any modified Haskell files.
+  #
+  # @see https://github.com/ndmitchell/hlint
+  class Hlint < Base
+    MESSAGE_REGEX = /
+      ^(?<file>(?:\w:)?[^:]+)
+      :(?<line>\d+)
+      :\d+
+      :\s*(?<type>\w+)
+    /x
+
+    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?
+
+      raw_messages = result.stdout.split("\n").grep(MESSAGE_REGEX)
+
+      # example message:
+      #   path/to/file.hs:1:0: Error: message
+      extract_messages(
+        raw_messages,
+        MESSAGE_REGEX,
+        MESSAGE_TYPE_CATEGORIZER
+      )
+    end
+  end
+end