IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge #21663 lua: "nvim -l" scriptname in _G.arg[0]

Browse Source
This commit is contained in:
Justin M. Keyes 2023-01-06 22:07:34 -05:00 committed by GitHub
commit 42afa0369a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 373 additions and 384 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
MAINTAIN.md
View File

@ -64,7 +64,7 @@ Third-party dependencies
------------------------
These "bundled" dependencies can be updated by bumping their versions in `cmake.deps/CMakeLists.txt`.
Some can be auto-bumped by `scripts/bump-deps.sh`.
Some can be auto-bumped by `scripts/bump_deps.lua`.
* [LuaJIT](https://github.com/LuaJIT/LuaJIT)
* [Lua](https://www.lua.org/download.html)

12
runtime/doc/starting.txt
View File

@ -218,14 +218,12 @@ argument.
-l {script} [args]
Executes Lua {script} non-interactively (no UI) with optional
[args] after processing any preceding Nvim |cli-arguments|,
then exits. See |-S| to run multiple Lua scripts without args,
or in an interactive session.
then exits. Exits 1 on Lua error. See |-S| to run multiple Lua
scripts without args, with a UI.
*lua-args*
All [args] are treated as {script} arguments and passed
literally to Lua (in the conventional `_G.arg` global table),
thus "-l" ends processing of Nvim arguments.
Exits with code 1 on Lua error.
All [args] are treated as {script} arguments and stored in the
Lua `_G.arg` global table, thus "-l" ends processing of Nvim
arguments. The {script} name is stored at `_G.arg[0]`.
Sets 'verbose' to 1 (like "-V1"), so Lua `print()` writes to
output.

108
scripts/bump-deps.sh
View File

@ -1,108 +0,0 @@
#!/usr/bin/env bash
set -e
set -u
# Use privileged mode, which e.g. skips using CDPATH.
set -p
# Ensure that the user has a bash that supports -A
if [[ "${BASH_VERSINFO[0]}" -lt 4 ]]; then
echo >&2 "error: script requires bash 4+ (you have ${BASH_VERSION})."
exit 1
fi
readonly NVIM_SOURCE_DIR="${NVIM_SOURCE_DIR:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}"
readonly VIM_SOURCE_DIR_DEFAULT="${NVIM_SOURCE_DIR}/.vim-src"
readonly VIM_SOURCE_DIR="${VIM_SOURCE_DIR:-${VIM_SOURCE_DIR_DEFAULT}}"
BASENAME="$(basename "${0}")"
readonly BASENAME
usage() {
echo "Bump Nvim dependencies"
echo
echo "Usage: ${BASENAME} [ -h | --pr | --branch=<dep> | --dep=<dependency> ]"
echo " Update a dependency:"
echo " ./scripts/bump-deps.sh --dep Luv --version 1.43.0-0"
echo " Create a PR:"
echo " ./scripts/bump-deps.sh --pr"
echo
echo "Options:"
echo " -h show this message and exit."
echo " --pr submit pr for bumping deps."
echo " --branch=<dep> create a branch bump-<dep> from current branch."
echo " --dep=<dependency> bump to a specific release or tag."
echo
echo "Dependency Options:"
echo " --version=<tag> bump to a specific release or tag."
echo " --commit=<hash> bump to a specific commit."
echo " --HEAD bump to a current head."
echo
echo " <dependency> is one of:"
echo " \"LuaJIT\", \"libuv\", \"Luv\", \"tree-sitter\""
}
# Checks if a program is in the user's PATH, and is executable.
check_executable() {
test -x "$(command -v "${1}")"
}
require_executable() {
if ! check_executable "${1}"; then
echo >&2 "${BASENAME}: '${1}' not found in PATH or not executable."
exit 1
fi
}
require_executable "nvim"
if [ $# -eq 0 ]; then
usage
exit 1
fi
PARSED_ARGS=$(getopt -a -n "$BASENAME" -o h --long pr,branch:,dep:,version:,commit:,HEAD -- "$@")
DEPENDENCY=""
eval set -- "$PARSED_ARGS"
while :; do
case "$1" in
-h)
usage
exit 0
;;
--pr)
nvim -es +"lua require('scripts.bump_deps').submit_pr()"
exit 0
;;
--branch)
DEP=$2
nvim -es +"lua require('scripts.bump_deps').create_branch('$DEP')"
exit 0
;;
--dep)
DEPENDENCY=$2
shift 2
;;
--version)
VERSION=$2
nvim -es +"lua require('scripts.bump_deps').version('$DEPENDENCY', '$VERSION')"
exit 0
;;
--commit)
COMMIT=$2
nvim -es +"lua require('scripts.bump_deps').commit('$DEPENDENCY', '$COMMIT')"
exit 0
;;
--HEAD)
nvim -es +"lua require('scripts.bump_deps').head('$DEPENDENCY')"
exit 0
;;
*)
break
;;
esac
done
usage
exit 1
# vim: et sw=2

369
scripts/bump_deps.lua Normal file → Executable file
View File

@ -1,35 +1,24 @@
#!/usr/bin/env -S nvim -l
-- Usage:
-- # bump to version
-- nvim -es +"lua require('scripts.bump_deps').version(dependency, version_tag)"
--
-- # bump to commit
-- nvim -es +"lua require('scripts.bump_deps').commit(dependency, commit_hash)"
--
-- # bump to HEAD
-- nvim -es +"lua require('scripts.bump_deps').head(dependency)"
--
-- # submit PR
-- nvim -es +"lua require('scripts.bump_deps').submit_pr()"
--
-- # create branch
-- nvim -es +"lua require('scripts.bump_deps').create_branch()"
-- ./scripts/bump_deps.lua -h
local M = {}
local _trace = false
local required_branch_prefix = "bump-"
local commit_prefix = "build(deps): "
local required_branch_prefix = 'bump-'
local commit_prefix = 'build(deps): '
-- Print message
local function p(s)
vim.cmd("set verbose=1")
vim.api.nvim_echo({ { s, "" } }, false, {})
vim.cmd("set verbose=0")
vim.cmd('set verbose=1')
vim.api.nvim_echo({ { s, '' } }, false, {})
vim.cmd('set verbose=0')
end
local function die()
p("")
vim.cmd("cquit 1")
p('')
vim.cmd('cquit 1')
end
-- Executes and returns the output of `cmd`, or nil on failure.
@ -38,9 +27,9 @@ end
-- Prints `cmd` if `trace` is enabled.
local function _run(cmd, die_on_fail, die_msg)
if _trace then
p("run: " .. vim.inspect(cmd))
p('run: ' .. vim.inspect(cmd))
end
local rv = vim.trim(vim.fn.system(cmd)) or ""
local rv = vim.trim(vim.fn.system(cmd)) or ''
if vim.v.shell_error ~= 0 then
if die_on_fail then
if _trace then
@ -56,7 +45,7 @@ end
-- Run a command, return nil on failure
local function run(cmd)
return _run(cmd, false, "")
return _run(cmd, false, '')
end
-- Run a command, die on failure with err_msg
@ -65,40 +54,40 @@ local function run_die(cmd, err_msg)
end
local function require_executable(cmd)
local cmd_path = run_die({ "command", "-v", cmd }, cmd .. " not found!")
run_die({ "test", "-x", cmd_path }, cmd .. " is not executable")
local cmd_path = run_die({ 'command', '-v', cmd }, cmd .. ' not found!')
run_die({ 'test', '-x', cmd_path }, cmd .. ' is not executable')
end
local function rm_file_if_present(path_to_file)
run({ "rm", "-f", path_to_file })
run({ 'rm', '-f', path_to_file })
end
local nvim_src_dir = vim.fn.getcwd()
local temp_dir = nvim_src_dir .. "/tmp"
run({ "mkdir", "-p", temp_dir })
local temp_dir = nvim_src_dir .. '/tmp'
run({ 'mkdir', '-p', temp_dir })
local function get_dependency(dependency_name)
local dependency_table = {
["LuaJIT"] = {
repo = "LuaJIT/LuaJIT",
symbol = "LUAJIT",
['LuaJIT'] = {
repo = 'LuaJIT/LuaJIT',
symbol = 'LUAJIT',
},
["libuv"] = {
repo = "libuv/libuv",
symbol = "LIBUV",
['libuv'] = {
repo = 'libuv/libuv',
symbol = 'LIBUV',
},
["Luv"] = {
repo = "luvit/luv",
symbol = "LUV",
['Luv'] = {
repo = 'luvit/luv',
symbol = 'LUV',
},
["tree-sitter"] = {
repo = "tree-sitter/tree-sitter",
symbol = "TREESITTER",
['tree-sitter'] = {
repo = 'tree-sitter/tree-sitter',
symbol = 'TREESITTER',
},
}
local dependency = dependency_table[dependency_name]
if dependency == nil then
p("Not a dependency: " .. dependency_name)
p('Not a dependency: ' .. dependency_name)
die()
end
dependency.name = dependency_name
@ -106,89 +95,121 @@ local function get_dependency(dependency_name)
end
local function get_gh_commit_sha(repo, ref)
require_executable("gh")
require_executable('gh')
local sha = run_die(
{ "gh", "api", "repos/" .. repo .. "/commits/" .. ref, "--jq", ".sha" },
"Failed to get commit hash from GitHub. Not a valid ref?"
{ 'gh', 'api', 'repos/' .. repo .. '/commits/' .. ref, '--jq', '.sha' },
'Failed to get commit hash from GitHub. Not a valid ref?'
)
return sha
end
local function get_archive_info(repo, ref)
require_executable("curl")
require_executable('curl')
local archive_name = ref .. ".tar.gz"
local archive_path = temp_dir .. "/" .. archive_name
local archive_url = "https://github.com/" .. repo .. "/archive/" .. archive_name
local archive_name = ref .. '.tar.gz'
local archive_path = temp_dir .. '/' .. archive_name
local archive_url = 'https://github.com/' .. repo .. '/archive/' .. archive_name
rm_file_if_present(archive_path)
run_die({ "curl", "-sL", archive_url, "-o", archive_path }, "Failed to download archive from GitHub")
run_die(
{ 'curl', '-sL', archive_url, '-o', archive_path },
'Failed to download archive from GitHub'
)
local archive_sha = run({ "sha256sum", archive_path }):gmatch("%w+")()
local shacmd = (vim.fn.executable('sha256sum') == 1
and{ 'sha256sum', archive_path }
or { 'shasum', '-a', '256', archive_path })
local archive_sha = run(shacmd):gmatch('%w+')()
return { url = archive_url, sha = archive_sha }
end
local function write_cmakelists_line(symbol, kind, value)
require_executable("sed")
require_executable('sed')
local cmakelists_path = nvim_src_dir .. "/" .. "cmake.deps/CMakeLists.txt"
local cmakelists_path = nvim_src_dir .. '/' .. 'cmake.deps/CMakeLists.txt'
run_die({
"sed",
"-i",
"-e",
"s/set(" .. symbol .. "_" .. kind .. ".*$" .. "/set(" .. symbol .. "_" .. kind .. " " .. value .. ")" .. "/",
'sed',
'-i',
'-e',
's/set('
.. symbol
.. '_'
.. kind
.. '.*$'
.. '/set('
.. symbol
.. '_'
.. kind
.. ' '
.. value
.. ')'
.. '/',
cmakelists_path,
}, "Failed to write " .. cmakelists_path)
}, 'Failed to write ' .. cmakelists_path)
end
local function explicit_create_branch(dep)
require_executable("git")
require_executable('git')
local checked_out_branch = run({ "git", "rev-parse", "--abbrev-ref", "HEAD" })
if checked_out_branch ~= "master" then
p("Not on master!")
local checked_out_branch = run({ 'git', 'rev-parse', '--abbrev-ref', 'HEAD' })
if checked_out_branch ~= 'master' then
p('Not on master!')
die()
end
run_die({ "git", "checkout", "-b", "bump-" .. dep }, "git failed to create branch")
run_die({ 'git', 'checkout', '-b', 'bump-' .. dep }, 'git failed to create branch')
end
local function verify_branch(new_branch_suffix)
require_executable("git")
require_executable('git')
local checked_out_branch = run({ "git", "rev-parse", "--abbrev-ref", "HEAD" })
if not checked_out_branch:match("^" .. required_branch_prefix) then
p("Current branch '" .. checked_out_branch .. "' doesn't seem to start with " .. required_branch_prefix)
p("Checking out to bump-" .. new_branch_suffix)
local checked_out_branch = assert(run({ 'git', 'rev-parse', '--abbrev-ref', 'HEAD' }))
if not checked_out_branch:match('^' .. required_branch_prefix) then
p(
"Current branch '"
.. checked_out_branch
.. "' doesn't seem to start with "
.. required_branch_prefix
)
p('Checking out to bump-' .. new_branch_suffix)
explicit_create_branch(new_branch_suffix)
end
end
local function update_cmakelists(dependency, archive, comment)
require_executable("git")
require_executable('git')
verify_branch(dependency.name)
local changed_file = nvim_src_dir .. "/" .. "cmake.deps/CMakeLists.txt"
local changed_file = nvim_src_dir .. '/' .. 'cmake.deps/CMakeLists.txt'
p("Updating " .. dependency.name .. " to " .. archive.url .. "\n")
write_cmakelists_line(dependency.symbol, "URL", archive.url:gsub("/", "\\/"))
write_cmakelists_line(dependency.symbol, "SHA256", archive.sha)
p('Updating ' .. dependency.name .. ' to ' .. archive.url .. '\n')
write_cmakelists_line(dependency.symbol, 'URL', archive.url:gsub('/', '\\/'))
write_cmakelists_line(dependency.symbol, 'SHA256', archive.sha)
run_die(
{ "git", "commit", changed_file, "-m", commit_prefix .. "bump " .. dependency.name .. " to " .. comment },
"git failed to commit"
{
'git',
'commit',
changed_file,
'-m',
commit_prefix .. 'bump ' .. dependency.name .. ' to ' .. comment,
},
'git failed to commit'
)
end
local function verify_cmakelists_committed()
require_executable("git")
require_executable('git')
local cmakelists_path = nvim_src_dir .. "/" .. "cmake.deps/CMakeLists.txt"
run_die({ "git", "diff", "--quiet", "HEAD", "--", cmakelists_path }, cmakelists_path .. " has uncommitted changes")
local cmakelists_path = nvim_src_dir .. '/' .. 'cmake.deps/CMakeLists.txt'
run_die(
{ 'git', 'diff', '--quiet', 'HEAD', '--', cmakelists_path },
cmakelists_path .. ' has uncommitted changes'
)
end
local function warn_luv_symbol()
p("warning: " .. get_dependency("Luv").symbol .. "_VERSION will not be updated")
p('warning: ' .. get_dependency('Luv').symbol .. '_VERSION will not be updated')
end
-- return first 9 chars of commit
@ -198,110 +219,116 @@ end
-- TODO: remove hardcoded fork
local function gh_pr(pr_title, pr_body)
require_executable("gh")
require_executable('gh')
local pr_url = run_die({
"gh",
"pr",
"create",
"--title",
'gh',
'pr',
'create',
'--title',
pr_title,
"--body",
'--body',
pr_body,
}, "Failed to create PR")
}, 'Failed to create PR')
return pr_url
end
local function find_git_remote(fork)
require_executable("git")
require_executable('git')
local remotes = run({ "git", "remote", "-v" })
local git_remote = ""
for remote in remotes:gmatch("[^\r\n]+") do
local remotes = assert(run({ 'git', 'remote', '-v' }))
local git_remote = ''
for remote in remotes:gmatch('[^\r\n]+') do
local words = {}
for word in remote:gmatch("%w+") do
for word in remote:gmatch('%w+') do
table.insert(words, word)
end
local match = words[1]:match("/github.com[:/]neovim/neovim/")
if fork == "fork" then
local match = words[1]:match('/github.com[:/]neovim/neovim/')
if fork == 'fork' then
match = not match
end
if match and words[3] == "(fetch)" then
if match and words[3] == '(fetch)' then
git_remote = words[0]
break
end
end
if git_remote == "" then
git_remote = "origin"
if git_remote == '' then
git_remote = 'origin'
end
return git_remote
end
local function create_pr(pr_title, pr_body)
require_executable("git")
require_executable('git')
local push_first = true
local checked_out_branch = run({ "git", "rev-parse", "--abbrev-ref", "HEAD" })
local checked_out_branch = run({ 'git', 'rev-parse', '--abbrev-ref', 'HEAD' })
if push_first then
local push_remote = run({ "git", "config", "--get", "branch." .. checked_out_branch .. ".pushRemote" })
local push_remote =
run({ 'git', 'config', '--get', 'branch.' .. checked_out_branch .. '.pushRemote' })
if push_remote == nil then
push_remote = run({ "git", "config", "--get", "remote.pushDefault" })
push_remote = run({ 'git', 'config', '--get', 'remote.pushDefault' })
if push_remote == nil then
push_remote = run({ "git", "config", "--get", "branch." .. checked_out_branch .. ".remote" })
push_remote =
run({ 'git', 'config', '--get', 'branch.' .. checked_out_branch .. '.remote' })
if push_remote == nil or push_remote == find_git_remote(nil) then
push_remote = find_git_remote("fork")
push_remote = find_git_remote('fork')
end
end
end
p("Pushing to " .. push_remote .. "/" .. checked_out_branch)
run_die({ "git", "push", push_remote, checked_out_branch }, "Git failed to push")
p('Pushing to ' .. push_remote .. '/' .. checked_out_branch)
run_die({ 'git', 'push', push_remote, checked_out_branch }, 'Git failed to push')
end
local pr_url = gh_pr(pr_title, pr_body)
p("\nCreated PR: " .. pr_url .. "\n")
p('\nCreated PR: ' .. pr_url .. '\n')
end
function M.commit(dependency_name, commit)
local dependency = get_dependency(dependency_name)
local dependency = assert(get_dependency(dependency_name))
verify_cmakelists_committed()
local commit_sha = get_gh_commit_sha(dependency.repo, commit)
if commit_sha ~= commit then
p("Not a commit: " .. commit .. ". Did you mean version?")
p('Not a commit: ' .. commit .. '. Did you mean version?')
die()
end
local archive = get_archive_info(dependency.repo, commit)
if dependency_name == "Luv" then
if dependency_name == 'Luv' then
warn_luv_symbol()
end
update_cmakelists(dependency, archive, short_commit(commit))
end
function M.version(dependency_name, version)
local dependency = get_dependency(dependency_name)
vim.validate{
dependency_name={dependency_name,'s'},
version={version,'s'},
}
local dependency = assert(get_dependency(dependency_name))
verify_cmakelists_committed()
local commit_sha = get_gh_commit_sha(dependency.repo, version)
if commit_sha == version then
p("Not a version: " .. version .. ". Did you mean commit?")
p('Not a version: ' .. version .. '. Did you mean commit?')
die()
end
local archive = get_archive_info(dependency.repo, version)
if dependency_name == "Luv" then
write_cmakelists_line(dependency.symbol, "VERSION", version)
if dependency_name == 'Luv' then
write_cmakelists_line(dependency.symbol, 'VERSION', version)
end
update_cmakelists(dependency, archive, version)
end
function M.head(dependency_name)
local dependency = get_dependency(dependency_name)
local dependency = assert(get_dependency(dependency_name))
verify_cmakelists_committed()
local commit_sha = get_gh_commit_sha(dependency.repo, "HEAD")
local commit_sha = get_gh_commit_sha(dependency.repo, 'HEAD')
local archive = get_archive_info(dependency.repo, commit_sha)
if dependency_name == "Luv" then
if dependency_name == 'Luv' then
warn_luv_symbol()
end
update_cmakelists(dependency, archive, "HEAD - " .. short_commit(commit_sha))
update_cmakelists(dependency, archive, 'HEAD - ' .. short_commit(commit_sha))
end
function M.create_branch(dep)
@ -309,35 +336,111 @@ function M.create_branch(dep)
end
function M.submit_pr()
require_executable("git")
require_executable('git')
verify_branch("deps")
verify_branch('deps')
local nvim_remote = find_git_remote(nil)
local relevant_commit = run_die({
"git",
"log",
"--grep=" .. commit_prefix,
"--reverse",
local relevant_commit = assert(run_die({
'git',
'log',
'--grep=' .. commit_prefix,
'--reverse',
"--format='%s'",
nvim_remote .. "/master..HEAD",
"-1",
}, "Failed to fetch commits")
nvim_remote .. '/master..HEAD',
'-1',
}, 'Failed to fetch commits'))
local pr_title
local pr_body
if relevant_commit == "" then
pr_title = commit_prefix .. "bump some dependencies"
pr_body = "bump some dependencies"
if relevant_commit == '' then
pr_title = commit_prefix .. 'bump some dependencies'
pr_body = 'bump some dependencies'
else
relevant_commit = relevant_commit:gsub("'", "")
relevant_commit = relevant_commit:gsub("'", '')
pr_title = relevant_commit
pr_body = relevant_commit:gsub(commit_prefix:gsub("%(", "%%("):gsub("%)", "%%)"), "")
pr_body = relevant_commit:gsub(commit_prefix:gsub('%(', '%%('):gsub('%)', '%%)'), '')
end
pr_body = pr_body .. "\n\n(add explanations if needed)"
p(pr_title .. "\n" .. pr_body .. "\n")
pr_body = pr_body .. '\n\n(add explanations if needed)'
p(pr_title .. '\n' .. pr_body .. '\n')
create_pr(pr_title, pr_body)
end
local function usage()
local this_script = _G.arg[0]:match("[^/]*.lua$")
print(([=[
Bump Nvim dependencies
Usage: nvim -l %s [options]
Bump to HEAD, tagged version, commit, or branch:
nvim -l %s --dep Luv --head
nvim -l %s --dep Luv --version 1.43.0-0
nvim -l %s --dep Luv --commit abc123
nvim -l %s --dep Luv --branch
Create a PR:
nvim -l %s --pr
Options:
-h show this message and exit.
--pr submit pr for bumping deps.
--branch <dep> create a branch bump-<dep> from current branch.
--dep <dependency> bump to a specific release or tag.
Dependency Options:
--version <tag> bump to a specific release or tag.
--commit <hash> bump to a specific commit.
--HEAD bump to a current head.
<dependency> is one of:
"LuaJIT", "libuv", "Luv", "tree-sitter"
]=]):format(this_script, this_script, this_script, this_script, this_script, this_script))
end
local function parseargs()
local args = {}
for i = 1, #_G.arg do
if _G.arg[i] == '-h' then
args.h = true
elseif _G.arg[i] == '--pr' then
args.pr = true
elseif _G.arg[i] == '--branch' then
args.branch = _G.arg[i+1]
elseif _G.arg[i] == '--dep' then
args.dep = _G.arg[i+1]
elseif _G.arg[i] == '--version' then
args.version = _G.arg[i+1]
elseif _G.arg[i] == '--commit' then
args.commit = _G.arg[i+1]
elseif _G.arg[i] == '--head' then
args.head = true
end
end
return args
end
local is_main = _G.arg[0]:match('bump_deps.lua')
if is_main then
local args = parseargs()
if args.h then
usage()
elseif args.pr then
M.submit_pr()
elseif args.head then
M.head(args.dep)
elseif args.branch then
M.create_branch(args.dep)
elseif args.version then
M.version(args.dep, args.version)
elseif args.commit then
M.commit(args.dep, args.commit)
elseif args.pr then
M.submit_pr()
else
print('missing required arg\n')
os.exit(1)
end
else
return M
end

18
src/nvim/lua/executor.c
View File

@ -323,13 +323,12 @@ static int nlua_thr_api_nvim__get_runtime(lua_State *lstate)
return 1;
}
/// Copies args starting at `lua_arg0` into the Lua `arg` global.
/// Copies args starting at `lua_arg0` to Lua `_G.arg`, and sets `_G.arg[0]` to the scriptname.
///
/// Example (`lua_arg0` points to "--arg1"):
/// Example (arg[0] => "foo.lua", arg[1] => "--arg1", …):
/// nvim -l foo.lua --arg1 --arg2
///
/// @note Lua CLI sets arguments upto "-e" as _negative_ `_G.arg` indices, but we currently don't
/// follow that convention.
/// @note Lua CLI sets args before "-e" as _negative_ `_G.arg` indices, but we currently don't.
///
/// @see https://www.lua.org/pil/1.4.html
/// @see https://github.com/premake/premake-core/blob/1c1304637f4f5e50ba8c57aae8d1d80ec3b7aaf2/src/host/premake.c#L563-L594
@ -337,12 +336,19 @@ static int nlua_thr_api_nvim__get_runtime(lua_State *lstate)
/// @returns number of args
static int nlua_init_argv(lua_State *const L, char **argv, int argc, int lua_arg0)
{
lua_newtable(L); // _G.arg
int i = 0;
lua_newtable(L); // _G.arg
if (lua_arg0 > 0) {
lua_pushstring(L, argv[lua_arg0 - 1]);
lua_rawseti(L, -2, 0); // _G.arg[0] = "foo.lua"
for (; lua_arg0 >= 0 && i + lua_arg0 < argc; i++) {
lua_pushstring(L, argv[i + lua_arg0]);
lua_rawseti(L, -2, i + 1); // _G.arg[i+1] = "arg1"
lua_rawseti(L, -2, i + 1); // _G.arg[i+1] = "--foo"
}
}
lua_setglobal(L, "arg");
return i;
}

50
test/functional/core/startup_spec.lua
View File

@ -108,7 +108,9 @@ describe('startup', function()
assert_l_out([[
bufs:
nvim args: 7
lua args: { "-arg1", "--exitcode", "73", "--arg2" }]],
lua args: { "-arg1", "--exitcode", "73", "--arg2",
[0] = "test/functional/fixtures/startup.lua"
}]],
{},
{ '-arg1', "--exitcode", "73", '--arg2' }
)
@ -126,11 +128,11 @@ describe('startup', function()
end)
it('executes stdin "-"', function()
assert_l_out('args=2 whoa',
assert_l_out('arg0=- args=2 whoa',
nil,
{ 'arg1', 'arg 2' },
'-',
"print(('args=%d %s'):format(#_G.arg, 'whoa'))")
"print(('arg0=%s args=%d %s'):format(_G.arg[0], #_G.arg, 'whoa'))")
assert_l_out('biiig input: 1000042',
nil,
nil,
@ -140,23 +142,15 @@ describe('startup', function()
end)
it('sets _G.arg', function()
-- nvim -l foo.lua -arg1 -- a b c
-- nvim -l foo.lua [args]
assert_l_out([[
bufs:
nvim args: 6
lua args: { "-arg1", "--arg2", "arg3" }]],
nvim args: 7
lua args: { "-arg1", "--arg2", "--", "arg3",
[0] = "test/functional/fixtures/startup.lua"
}]],
{},
{ '-arg1', '--arg2', 'arg3' }
)
eq(0, eval('v:shell_error'))
-- nvim -l foo.lua --
assert_l_out([[
bufs:
nvim args: 4
lua args: { "--" }]],
{},
{ '--' }
{ '-arg1', '--arg2', '--', 'arg3' }
)
eq(0, eval('v:shell_error'))
@ -164,27 +158,21 @@ describe('startup', function()
assert_l_out([[
bufs: file1 file2
nvim args: 10
lua args: { "-arg1", "arg 2", "--", "file3", "file4" }]],
lua args: { "-arg1", "arg 2", "--", "file3", "file4",
[0] = "test/functional/fixtures/startup.lua"
}]],
{ 'file1', 'file2', },
{ '-arg1', 'arg 2', '--', 'file3', 'file4' }
)
eq(0, eval('v:shell_error'))
-- nvim file1 file2 -l foo.lua -arg1 --
assert_l_out([[
bufs: file1 file2
nvim args: 7
lua args: { "-arg1", "--" }]],
{ 'file1', 'file2', },
{ '-arg1', '--' }
)
eq(0, eval('v:shell_error'))
-- nvim -l foo.lua <vim args>
assert_l_out([[
bufs:
nvim args: 5
lua args: { "-c", "set wrap?" }]],
lua args: { "-c", "set wrap?",
[0] = "test/functional/fixtures/startup.lua"
}]],
{},
{ '-c', 'set wrap?' }
)
@ -198,7 +186,9 @@ describe('startup', function()
bufs:
nvim args: 7
lua args: { "-c", "set wrap?" }]],
lua args: { "-c", "set wrap?",
[0] = "test/functional/fixtures/startup.lua"
}]],
{ '-c', 'set wrap?' },
{ '-c', 'set wrap?' }
)