307 lines
8.6 KiB
Lua
307 lines
8.6 KiB
Lua
-- Usage:
|
|
-- # verbose
|
|
-- nvim -l scripts/lintcommit.lua main --trace
|
|
--
|
|
-- # silent
|
|
-- nvim -l scripts/lintcommit.lua main
|
|
--
|
|
-- # self-test
|
|
-- nvim -l scripts/lintcommit.lua _test
|
|
|
|
--- @type table<string,fun(opt: LintcommitOptions)>
|
|
local M = {}
|
|
|
|
local _trace = false
|
|
|
|
-- Print message
|
|
local function p(s)
|
|
vim.cmd('set verbose=1')
|
|
vim.api.nvim_echo({ { s, '' } }, false, {})
|
|
vim.cmd('set verbose=0')
|
|
end
|
|
|
|
-- Executes and returns the output of `cmd`, or nil on failure.
|
|
--
|
|
-- Prints `cmd` if `trace` is enabled.
|
|
local function run(cmd, or_die)
|
|
if _trace then
|
|
p('run: ' .. vim.inspect(cmd))
|
|
end
|
|
local rv = vim.trim(vim.fn.system(cmd)) or ''
|
|
if vim.v.shell_error ~= 0 then
|
|
if or_die then
|
|
p(rv)
|
|
os.exit(1)
|
|
end
|
|
return nil
|
|
end
|
|
return rv
|
|
end
|
|
|
|
-- Returns nil if the given commit message is valid, or returns a string
|
|
-- message explaining why it is invalid.
|
|
local function validate_commit(commit_message)
|
|
-- Return nil if the commit message starts with "fixup" as it signifies it's
|
|
-- a work in progress and shouldn't be linted yet.
|
|
if vim.startswith(commit_message, 'fixup') then
|
|
return nil
|
|
end
|
|
|
|
local commit_split = vim.split(commit_message, ':', { plain = true })
|
|
-- Return nil if the type is vim-patch since most of the normal rules don't
|
|
-- apply.
|
|
if commit_split[1] == 'vim-patch' then
|
|
return nil
|
|
end
|
|
|
|
-- Check that message isn't too long.
|
|
if commit_message:len() > 80 then
|
|
return [[Commit message is too long, a maximum of 80 characters is allowed.]]
|
|
end
|
|
|
|
local before_colon = commit_split[1]
|
|
|
|
local after_idx = 2
|
|
if before_colon:match('^[^%(]*%([^%)]*$') then
|
|
-- Need to find the end of commit scope when commit scope contains colons.
|
|
while after_idx <= vim.tbl_count(commit_split) do
|
|
after_idx = after_idx + 1
|
|
if commit_split[after_idx - 1]:find(')') then
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if after_idx > vim.tbl_count(commit_split) then
|
|
return [[Commit message does not include colons.]]
|
|
end
|
|
local after_colon = ''
|
|
while after_idx <= vim.tbl_count(commit_split) do
|
|
after_colon = after_colon .. commit_split[after_idx]
|
|
after_idx = after_idx + 1
|
|
end
|
|
|
|
-- Check if commit introduces a breaking change.
|
|
if vim.endswith(before_colon, '!') then
|
|
before_colon = before_colon:sub(1, -2)
|
|
end
|
|
|
|
-- Check if type is correct
|
|
local type = vim.split(before_colon, '(', { plain = true })[1]
|
|
local allowed_types =
|
|
{ 'build', 'ci', 'docs', 'feat', 'fix', 'perf', 'refactor', 'revert', 'test', 'vim-patch' }
|
|
if not vim.tbl_contains(allowed_types, type) then
|
|
return string.format(
|
|
[[Invalid commit type "%s". Allowed types are:
|
|
%s.
|
|
If none of these seem appropriate then use "fix"]],
|
|
type,
|
|
vim.inspect(allowed_types)
|
|
)
|
|
end
|
|
|
|
-- Check if scope is appropriate
|
|
if before_colon:match('%(') then
|
|
local scope = vim.trim(commit_message:match('%((.-)%)'))
|
|
|
|
if scope == '' then
|
|
return [[Scope can't be empty]]
|
|
end
|
|
|
|
if vim.startswith(scope, 'nvim_') then
|
|
return [[Scope should be "api" instead of "nvim_..."]]
|
|
end
|
|
|
|
local alternative_scope = {
|
|
['filetype.vim'] = 'filetype',
|
|
['filetype.lua'] = 'filetype',
|
|
['tree-sitter'] = 'treesitter',
|
|
['ts'] = 'treesitter',
|
|
['hl'] = 'highlight',
|
|
}
|
|
|
|
if alternative_scope[scope] then
|
|
return ('Scope should be "%s" instead of "%s"'):format(alternative_scope[scope], scope)
|
|
end
|
|
end
|
|
|
|
-- Check that description doesn't end with a period
|
|
if vim.endswith(after_colon, '.') then
|
|
return [[Description ends with a period (".").]]
|
|
end
|
|
|
|
-- Check that description starts with a whitespace.
|
|
if after_colon:sub(1, 1) ~= ' ' then
|
|
return [[There should be a whitespace after the colon.]]
|
|
end
|
|
|
|
-- Check that description doesn't start with multiple whitespaces.
|
|
if after_colon:sub(1, 2) == ' ' then
|
|
return [[There should only be one whitespace after the colon.]]
|
|
end
|
|
|
|
-- Allow lowercase or ALL_UPPER but not Titlecase.
|
|
if after_colon:match('^ *%u%l') then
|
|
return [[Description first word should not be Capitalized.]]
|
|
end
|
|
|
|
-- Check that description isn't just whitespaces
|
|
if vim.trim(after_colon) == '' then
|
|
return [[Description shouldn't be empty.]]
|
|
end
|
|
|
|
return nil
|
|
end
|
|
|
|
--- @param opt? LintcommitOptions
|
|
function M.main(opt)
|
|
_trace = not opt or not not opt.trace
|
|
|
|
local branch = run({ 'git', 'rev-parse', '--abbrev-ref', 'HEAD' }, true)
|
|
-- TODO(justinmk): check $GITHUB_REF
|
|
local ancestor = run({ 'git', 'merge-base', 'origin/master', branch })
|
|
if not ancestor then
|
|
ancestor = run({ 'git', 'merge-base', 'upstream/master', branch })
|
|
end
|
|
local commits_str = run({ 'git', 'rev-list', ancestor .. '..' .. branch }, true)
|
|
assert(commits_str)
|
|
|
|
local commits = {} --- @type string[]
|
|
for substring in commits_str:gmatch('%S+') do
|
|
table.insert(commits, substring)
|
|
end
|
|
|
|
local failed = 0
|
|
for _, commit_id in ipairs(commits) do
|
|
local msg = run({ 'git', 'show', '-s', '--format=%s', commit_id })
|
|
if vim.v.shell_error ~= 0 then
|
|
p('Invalid commit-id: ' .. commit_id .. '"')
|
|
else
|
|
local invalid_msg = validate_commit(msg)
|
|
if invalid_msg then
|
|
failed = failed + 1
|
|
|
|
-- Some breathing room
|
|
if failed == 1 then
|
|
p('\n')
|
|
end
|
|
|
|
p(string.format(
|
|
[[
|
|
Invalid commit message: "%s"
|
|
Commit: %s
|
|
%s
|
|
]],
|
|
msg,
|
|
commit_id,
|
|
invalid_msg
|
|
))
|
|
end
|
|
end
|
|
end
|
|
|
|
if failed > 0 then
|
|
p([[
|
|
See also:
|
|
https://github.com/neovim/neovim/blob/master/CONTRIBUTING.md#commit-messages
|
|
|
|
]])
|
|
os.exit(1)
|
|
else
|
|
p('')
|
|
end
|
|
end
|
|
|
|
function M._test()
|
|
-- message:expected_result
|
|
local test_cases = {
|
|
['ci: normal message'] = true,
|
|
['build: normal message'] = true,
|
|
['docs: normal message'] = true,
|
|
['feat: normal message'] = true,
|
|
['fix: normal message'] = true,
|
|
['perf: normal message'] = true,
|
|
['refactor: normal message'] = true,
|
|
['revert: normal message'] = true,
|
|
['test: normal message'] = true,
|
|
['ci(window): message with scope'] = true,
|
|
['ci!: message with breaking change'] = true,
|
|
['ci(tui)!: message with scope and breaking change'] = true,
|
|
['vim-patch:8.2.3374: Pyret files are not recognized (#15642)'] = true,
|
|
['vim-patch:8.1.1195,8.2.{3417,3419}'] = true,
|
|
['revert: "ci: use continue-on-error instead of "|| true""'] = true,
|
|
['fixup'] = true,
|
|
['fixup: commit message'] = true,
|
|
['fixup! commit message'] = true,
|
|
[':no type before colon 1'] = false,
|
|
[' :no type before colon 2'] = false,
|
|
[' :no type before colon 3'] = false,
|
|
['ci(empty description):'] = false,
|
|
['ci(only whitespace as description): '] = false,
|
|
['docs(multiple whitespaces as description): '] = false,
|
|
['revert(multiple whitespaces and then characters as description): description'] = false,
|
|
['ci no colon after type'] = false,
|
|
['test: extra space after colon'] = false,
|
|
['ci: tab after colon'] = false,
|
|
['ci:no space after colon'] = false,
|
|
['ci :extra space before colon'] = false,
|
|
['refactor(): empty scope'] = false,
|
|
['ci( ): whitespace as scope'] = false,
|
|
['ci: period at end of sentence.'] = false,
|
|
['ci: period: at end of sentence.'] = false,
|
|
['ci: Capitalized first word'] = false,
|
|
['ci: UPPER_CASE First Word'] = true,
|
|
['unknown: using unknown type'] = false,
|
|
['feat: foo:bar'] = true,
|
|
['feat: :foo:bar'] = true,
|
|
['feat(something): foo:bar'] = true,
|
|
['feat(something): :foo:bar'] = true,
|
|
['feat(:grep): read from pipe'] = true,
|
|
['feat(:grep/:make): read from pipe'] = true,
|
|
['feat(:grep): foo:bar'] = true,
|
|
['feat(:grep/:make): foo:bar'] = true,
|
|
['feat(:grep)'] = false,
|
|
['feat(:grep/:make)'] = false,
|
|
['feat(:grep'] = false,
|
|
['feat(:grep/:make'] = false,
|
|
["ci: you're saying this commit message just goes on and on and on and on and on and on for way too long?"] = false,
|
|
}
|
|
|
|
local failed = 0
|
|
for message, expected in pairs(test_cases) do
|
|
local is_valid = (nil == validate_commit(message))
|
|
if is_valid ~= expected then
|
|
failed = failed + 1
|
|
p(
|
|
string.format('[ FAIL ]: expected=%s, got=%s\n input: "%s"', expected, is_valid, message)
|
|
)
|
|
end
|
|
end
|
|
|
|
if failed > 0 then
|
|
os.exit(1)
|
|
end
|
|
end
|
|
|
|
--- @class LintcommitOptions
|
|
--- @field trace? boolean
|
|
local opt = {}
|
|
|
|
for _, a in ipairs(arg) do
|
|
if vim.startswith(a, '--') then
|
|
local nm, val = a:sub(3), true
|
|
if vim.startswith(a, '--no') then
|
|
nm, val = a:sub(5), false
|
|
end
|
|
|
|
if nm == 'trace' then
|
|
opt.trace = val
|
|
end
|
|
end
|
|
end
|
|
|
|
for _, a in ipairs(arg) do
|
|
if M[a] then
|
|
M[a](opt)
|
|
end
|
|
end
|