overcommit-jeygeethanmedia 0.53.1

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreCommit
+  # Check if local yarn.lock matches package.json when either changes, unless
+  # yarn.lock is ignored by git.
+  #
+  # @see https://yarnpkg.com/en/docs/cli/check
+  class YarnCheck < Base
+    LOCK_FILE = 'yarn.lock'
+
+    # A lot of the errors returned by `yarn check` are outside the developer's control
+    # (are caused by bad package specification, in the hands of the upstream maintainer)
+    # So limit reporting to errors the developer can do something about
+    ACTIONABLE_ERRORS = [
+      'Lockfile does not contain pattern',
+    ].freeze
+
+    def run
+      # Ignore if yarn.lock is not tracked by git
+      ignored_files = execute(%w[git ls-files -o -i --exclude-standard]).stdout.split("\n")
+      return :pass if ignored_files.include?(LOCK_FILE)
+
+      previous_lockfile = File.exist?(LOCK_FILE) ? File.read(LOCK_FILE) : nil
+      result = execute(command)
+      new_lockfile = File.exist?(LOCK_FILE) ? File.read(LOCK_FILE) : nil
+
+      # `yarn check` also throws many warnings, which should be ignored here
+      errors_regex = Regexp.new("^error (.*)(#{ACTIONABLE_ERRORS.join('|')})(.*)$")
+      errors = errors_regex.match(result.stderr)
+      unless errors.nil? && previous_lockfile == new_lockfile
+        return :fail, "#{LOCK_FILE} is not up-to-date -- run `yarn install`"
+      end
+
+      :pass
+    end
+  end
+end

data/lib/overcommit/hook/pre_push/base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'overcommit/utils/messages_utils'
+
+module Overcommit::Hook::PrePush
+  # Functionality common to all pre-push hooks.
+  class Base < Overcommit::Hook::Base
+    extend Forwardable
+
+    def_delegators :@context, :remote_name, :remote_url, :pushed_refs
+
+    def run?
+      super &&
+        !exclude_remotes.include?(remote_name) &&
+        (include_remote_ref_deletions? || !@context.remote_ref_deletion?)
+    end
+
+    private
+
+    def extract_messages(*args)
+      Overcommit::Utils::MessagesUtils.extract_messages(*args)
+    end
+
+    def exclude_remotes
+      @config['exclude_remotes'] || []
+    end
+
+    def include_remote_ref_deletions?
+      @config['include_remote_ref_deletions']
+    end
+  end
+end

data/lib/overcommit/hook/pre_push/brakeman.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PrePush
+  # Runs `brakeman` whenever Ruby/Rails files change.
+  #
+  # @see http://brakemanscanner.org/
+  class Brakeman < Base
+    def run
+      result = execute(command)
+      return :pass if result.success?
+
+      [:fail, result.stdout]
+    end
+  end
+end

data/lib/overcommit/hook/pre_push/cargo_test.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PrePush
+  # Runs `cargo test` before push if Rust files changed
+  class CargoTest < Base
+    def run
+      result = execute(command)
+      return :pass if result.success?
+      [:fail, result.stdout]
+    end
+  end
+end

data/lib/overcommit/hook/pre_push/go_test.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PrePush
+  # Runs `go test ./...` command on prepush
+  class GoTest < Base
+    def run
+      result = execute(command)
+      return :pass if result.success?
+
+      output = result.stdout + result.stderr
+      [:fail, output]
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PrePush
+  # Runs golangci-lint
+  #
+  # @see https://github.com/golangci/golangci-lint
+  class GolangciLint < Base
+    def run
+      result = execute(command)
+      return :pass if result.success?
+
+      output = result.stdout + result.stderr
+      [:fail, output]
+    end
+  end
+end

data/lib/overcommit/hook/pre_push/minitest.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PrePush
+  # Runs `minitest` test suite before push
+  #
+  # @see https://github.com/seattlerb/minitest
+  class Minitest < Base
+    def run
+      result = execute(command)
+      return :pass if result.success?
+
+      output = result.stdout + result.stderr
+      [:fail, output]
+    end
+
+    def command
+      super + included_files.map { |file| "-r#{file}" }
+    end
+  end
+end

data/lib/overcommit/hook/pre_push/php_unit.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PrePush
+  # Runs `phpunit` test suite before push
+  #
+  # @see https://phpunit.de/
+  class PhpUnit < Base
+    def run
+      result = execute(command)
+      return :pass if result.success?
+
+      output = result.stdout + result.stderr
+      [:fail, output]
+    end
+  end
+end

data/lib/overcommit/hook/pre_push/pronto.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'overcommit/hook/shared/pronto'
+
+module Overcommit::Hook::PrePush
+  # Runs `pronto`
+  #
+  # @see https://github.com/mmozuras/pronto
+  class Pronto < Base
+    include Overcommit::Hook::Shared::Pronto
+  end
+end

data/lib/overcommit/hook/pre_push/protected_branches.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PrePush
+  # Prevents updates to specified branches.
+  # Accepts a 'destructive_only' option globally or per branch
+  # to only prevent destructive updates.
+  class ProtectedBranches < Base
+    def run
+      return :pass unless illegal_pushes.any?
+
+      messages = illegal_pushes.map do |pushed_ref|
+        "Deleting or force-pushing to #{pushed_ref.remote_ref} is not allowed."
+      end
+
+      [:fail, messages.join("\n")]
+    end
+
+    private
+
+    def illegal_pushes
+      @illegal_pushes ||= pushed_refs.select do |pushed_ref|
+        protected?(pushed_ref)
+      end
+    end
+
+    def protected?(ref)
+      find_pattern(ref.remote_ref)&.destructive?(ref)
+    end
+
+    def find_pattern(remote_ref)
+      ref_name = remote_ref[%r{refs/heads/(.*)}, 1]
+      return if ref_name.nil?
+
+      patterns.find do |pattern|
+        File.fnmatch(pattern.to_s, ref_name)
+      end
+    end
+
+    def patterns
+      @patterns ||= fetch_patterns
+    end
+
+    def fetch_patterns
+      branch_configurations.map do |pattern|
+        if pattern.is_a?(Hash)
+          Pattern.new(pattern.keys.first, pattern['destructive_only'])
+        else
+          Pattern.new(pattern, global_destructive_only?)
+        end
+      end
+    end
+
+    def branch_configurations
+      config['branches'].to_a + config['branch_patterns'].to_a
+    end
+
+    def global_destructive_only?
+      config['destructive_only'].nil? || config['destructive_only']
+    end
+
+    Pattern = Struct.new('Pattern', :name, :destructive_only) do
+      alias_method :to_s, :name
+      alias_method :destructive_only?, :destructive_only
+
+      def destructive?(ref)
+        if destructive_only?
+          ref.destructive?
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/overcommit/hook/pre_push/pytest.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PrePush
+  # Runs `pytest` test suite before push
+  #
+  # @see https://github.com/pytest-dev/pytest
+  class Pytest < Base
+    def run
+      result = execute(command)
+      return :pass if result.success?
+
+      output = result.stdout + result.stderr
+      [:fail, output]
+    end
+  end
+end

data/lib/overcommit/hook/pre_push/python_nose.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PrePush
+  # Runs `nose` test suite before push
+  #
+  # @see https://nose.readthedocs.io/en/latest/
+  class PythonNose < Base
+    def run
+      result = execute(command)
+      return :pass if result.success?
+
+      output = result.stdout + result.stderr
+      [:fail, output]
+    end
+  end
+end

data/lib/overcommit/hook/pre_push/r_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PrePush
+  # Runs `rspec` test suite before push
+  #
+  # @see http://rspec.info/
+  class RSpec < Base
+    def run
+      result = execute(command)
+      return :pass if result.success?
+
+      output = result.stdout + result.stderr
+      [:fail, output]
+    end
+  end
+end

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

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

data/lib/overcommit/hook/pre_push/test_unit.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PrePush
+  # Runs `test-unit` test suite before push
+  #
+  # @see https://github.com/test-unit/test-unit
+  class TestUnit < Base
+    def run
+      result = execute(command)
+      return :pass if result.success?
+
+      output = result.stdout + result.stderr
+      [:fail, output]
+    end
+  end
+end

data/lib/overcommit/hook/pre_rebase/base.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Overcommit::Hook::PreRebase
+  # Functionality common to all pre-rebase hooks.
+  class Base < Overcommit::Hook::Base
+    extend Forwardable
+
+    def_delegators :@context,
+                   :upstream_branch, :rebased_branch, :detached_head?,
+                   :fast_forward?, :rebased_commits
+  end
+end

data/lib/overcommit/hook/pre_rebase/merged_commits.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PreRebase
+  # Prevents rebasing commits that have already been merged into one of
+  # a specified set of branches.
+  class MergedCommits < Base
+    def run
+      # Allow rebasing a detached HEAD since no refs are changed.
+      return :pass if detached_head? || illegal_commits.empty?
+
+      message = 'Cannot rebase commits that have already been merged into ' \
+                "one of #{branches.join(', ')}"
+
+      [:fail, message]
+    end
+
+    private
+
+    def branches
+      @branches ||= config['branches']
+    end
+
+    def illegal_commits
+      @illegal_commits ||= rebased_commits.select do |commit_sha1|
+        branches_containing_commit =
+          Overcommit::GitRepo.branches_containing_commit(commit_sha1)
+        (branches_containing_commit & branches).any?
+      end
+    end
+  end
+end

data/lib/overcommit/hook/prepare_commit_msg/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Overcommit::Hook::PrepareCommitMsg
+  # Functionality common to all prepare-commit-msg hooks.
+  class Base < Overcommit::Hook::Base
+    extend Forwardable
+
+    def_delegators :@context,
+                   :commit_message_filename, :commit_message_source, :commit, :lock
+
+    def modify_commit_message
+      raise 'This expects a block!' unless block_given?
+      # NOTE: this assumes all the hooks of the same type share the context's
+      # memory. If that's not the case, this won't work.
+      lock.synchronize do
+        contents = File.read(commit_message_filename)
+        File.open(commit_message_filename, 'w') do |f|
+          f << (yield contents)
+        end
+      end
+    end
+  end
+end

data/lib/overcommit/hook/prepare_commit_msg/replace_branch.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Overcommit::Hook::PrepareCommitMsg
+  # Prepends the commit message with a message based on the branch name.
+  # It's possible to reference parts of the branch name through the captures in
+  # the `branch_pattern` regex.
+  class ReplaceBranch < Base
+    def run
+      return :pass if skipped_commit_types.include? commit_message_source
+
+      Overcommit::Utils.log.debug(
+        "Checking if '#{Overcommit::GitRepo.current_branch}' matches #{branch_pattern}"
+      )
+
+      return :warn unless branch_pattern.match?(Overcommit::GitRepo.current_branch)
+
+      Overcommit::Utils.log.debug("Writing #{commit_message_filename} with #{new_template}")
+
+      modify_commit_message do |old_contents|
+        "#{new_template} #{old_contents}"
+      end
+
+      :pass
+    end
+
+    def new_template
+      @new_template ||= Overcommit::GitRepo.current_branch.gsub(branch_pattern, replacement_text)
+    end
+
+    def branch_pattern
+      @branch_pattern ||=
+        begin
+          pattern = config['branch_pattern']
+          Regexp.new((pattern || '').empty? ? '\A.*\w+[-_](\d+).*\z' : pattern)
+        end
+    end
+
+    def replacement_text
+      @replacement_text ||=
+        begin
+          if File.exist?(replacement_text_config)
+            File.read(replacement_text_config)
+          else
+            replacement_text_config
+          end
+        end
+    end
+
+    def replacement_text_config
+      @replacement_text_config ||= config['replacement_text']
+    end
+
+    def skipped_commit_types
+      @skipped_commit_types ||= config['skipped_commit_types'].map(&:to_sym)
+    end
+  end
+end