opensourcemirror
/
neovim
mirror of https://github.com/neovim/neovim.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge #6272 'stdpath()'

This commit is contained in:
Justin M. Keyes 2018-04-15 04:09:30 +02:00 committed by GitHub
parent 5abfa94ed2 ec459965f5
commit 1e7d5e8cdf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 347 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
runtime/doc/eval.txt
View File

@ -2286,6 +2286,7 @@ split({expr} [, {pat} [, {keepempty}]])
List make |List| from {pat} separated {expr}
sqrt({expr}) Float square root of {expr}
stdioopen({dict}) Number open stdio in a headless instance.
stdpath({what}) String/List returns the standard path(s) for {what}
str2float({expr}) Float convert String to Float
str2nr({expr} [, {base}]) Number convert String to Number
strchars({expr} [, {skipcc}]) Number character length of the String {expr}
@ -7262,6 +7263,23 @@ stdioopen({opts}) *stdioopen()*
- 0 on invalid arguments
stdpath({what}) *stdpath()* *E6100*
Returns the standard path(s) for {what}.
These directories are the default locations for various files
used by Neovim.
{what} Type Description ~
cache String Cache directory. Useful for plugins
that need temporary files to work.
config String User configuration directory. The
|init.vim| is stored here.
config_dirs List Additional configuration directories.
data String User data directory. The |shada-file|
is stored here.
data_dirs List Additional data directories.
str2float({expr}) *str2float()*
Convert String {expr} to a Float. This mostly works the same
as when using a floating point number in an expression, see

50
src/nvim/eval.c
View File

@ -15702,6 +15702,56 @@ static void f_split(typval_T *argvars, typval_T *rettv, FunPtr fptr)
p_cpo = save_cpo;
}
/// "stdpath()" helper for list results
static void get_xdg_var_list(const XDGVarType xdg, typval_T *rettv)
FUNC_ATTR_NONNULL_ALL
{
const void *iter = NULL;
list_T *const list = tv_list_alloc(kListLenShouldKnow);
rettv->v_type = VAR_LIST;
rettv->vval.v_list = list;
tv_list_ref(list);
char *const dirs = stdpaths_get_xdg_var(xdg);
do {
size_t dir_len;
const char *dir;
iter = vim_env_iter(':', dirs, iter, &dir, &dir_len);
if (dir != NULL && dir_len > 0) {
char *dir_with_nvim = xmemdupz(dir, dir_len);
dir_with_nvim = concat_fnames_realloc(dir_with_nvim, "nvim", true);
tv_list_append_string(list, dir_with_nvim, strlen(dir_with_nvim));
xfree(dir_with_nvim);
}
} while (iter != NULL);
xfree(dirs);
}
/// "stdpath(type)" function
static void f_stdpath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
{
rettv->v_type = VAR_STRING;
rettv->vval.v_string = NULL;
const char *const p = tv_get_string_chk(&argvars[0]);
if (p == NULL) {
return; // Type error; errmsg already given.
}
if (strcmp(p, "config") == 0) {
rettv->vval.v_string = (char_u *)get_xdg_home(kXDGConfigHome);
} else if (strcmp(p, "data") == 0) {
rettv->vval.v_string = (char_u *)get_xdg_home(kXDGDataHome);
} else if (strcmp(p, "cache") == 0) {
rettv->vval.v_string = (char_u *)get_xdg_home(kXDGCacheHome);
} else if (strcmp(p, "config_dirs") == 0) {
get_xdg_var_list(kXDGConfigDirs, rettv);
} else if (strcmp(p, "data_dirs") == 0) {
get_xdg_var_list(kXDGDataDirs, rettv);
} else {
EMSG2(_("E6100: \"%s\" is not a valid stdpath"), p);
}
}
/*
* "str2float()" function
*/

1
src/nvim/eval.h
View File

@ -10,6 +10,7 @@
#include "nvim/event/rstream.h"
#include "nvim/event/wstream.h"
#include "nvim/channel.h"
#include "nvim/os/stdpaths_defs.h"
#define COPYID_INC 2
#define COPYID_MASK (~0x1)

1
src/nvim/eval.lua
View File

@ -280,6 +280,7 @@ return {
spellsuggest={args={1, 3}},
split={args={1, 3}},
sqrt={args=1, func="float_op_wrapper", data="&sqrt"},
stdpath={args=1},
str2float={args=1},
str2nr={args={1, 2}},
strcharpart={args={2, 3}},

2
src/nvim/os/stdpaths.c
View File

@ -88,7 +88,7 @@ char *stdpaths_get_xdg_var(const XDGVarType idx)
///
/// In WIN32 get_xdg_home(kXDGDataHome) returns `{xdg_directory}/nvim-data` to
/// avoid storing configuration and data files in the same path.
static char *get_xdg_home(const XDGVarType idx)
char *get_xdg_home(const XDGVarType idx)
FUNC_ATTR_WARN_UNUSED_RESULT
{
char *dir = stdpaths_get_xdg_var(idx);

276
test/functional/options/defaults_spec.lua
View File

@ -5,12 +5,15 @@ local Screen = require('test.functional.ui.screen')
local meths = helpers.meths
local command = helpers.command
local clear = helpers.clear
local exc_exec = helpers.exc_exec
local eval = helpers.eval
local eq = helpers.eq
local funcs = helpers.funcs
local insert = helpers.insert
local neq = helpers.neq
local mkdir = helpers.mkdir
local rmdir = helpers.rmdir
local alter_slashes = helpers.alter_slashes
describe('startup defaults', function()
describe(':filetype', function()
@ -422,3 +425,276 @@ describe('XDG-based defaults', function()
end)
end)
end)
describe('stdpath()', function()
context('returns a String', function()
describe('with "config"' , function ()
it('knows XDG_CONFIG_HOME', function()
clear({env={
XDG_CONFIG_HOME=alter_slashes('/home/docwhat/.config'),
}})
eq(alter_slashes('/home/docwhat/.config/nvim'), funcs.stdpath('config'))
end)
it('handles changes during runtime', function()
clear({env={
XDG_CONFIG_HOME=alter_slashes('/home/original'),
}})
eq(alter_slashes('/home/original/nvim'), funcs.stdpath('config'))
command("let $XDG_CONFIG_HOME='"..alter_slashes('/home/new').."'")
eq(alter_slashes('/home/new/nvim'), funcs.stdpath('config'))
end)
it("doesn't expand $VARIABLES", function()
clear({env={
XDG_CONFIG_HOME='$VARIABLES',
VARIABLES='this-should-not-happen',
}})
eq(alter_slashes('$VARIABLES/nvim'), funcs.stdpath('config'))
end)
it("doesn't expand ~/", function()
clear({env={
XDG_CONFIG_HOME=alter_slashes('~/frobnitz'),
}})
eq(alter_slashes('~/frobnitz/nvim'), funcs.stdpath('config'))
end)
end)
describe('with "data"' , function ()
local appended_dir
setup(function()
-- Windows appends 'nvim-data' instead of just 'nvim' to
-- prevent collisions due to XDG_CONFIG_HOME and XDG_DATA_HOME
-- being the same.
if helpers.iswin() then
appended_dir = '/nvim-data'
else
appended_dir = '/nvim'
end
end)
it('knows XDG_DATA_HOME', function()
clear({env={
XDG_DATA_HOME=alter_slashes('/home/docwhat/.local'),
}})
eq(alter_slashes('/home/docwhat/.local' .. appended_dir), funcs.stdpath('data'))
end)
it('handles changes during runtime', function()
clear({env={
XDG_DATA_HOME=alter_slashes('/home/original'),
}})
eq(alter_slashes('/home/original' .. appended_dir), funcs.stdpath('data'))
command("let $XDG_DATA_HOME='"..alter_slashes('/home/new').."'")
eq(alter_slashes('/home/new' .. appended_dir), funcs.stdpath('data'))
end)
it("doesn't expand $VARIABLES", function()
clear({env={
XDG_DATA_HOME='$VARIABLES',
VARIABLES='this-should-not-happen',
}})
eq(alter_slashes('$VARIABLES' .. appended_dir), funcs.stdpath('data'))
end)
it("doesn't expand ~/", function()
clear({env={
XDG_DATA_HOME=alter_slashes('~/frobnitz'),
}})
eq(alter_slashes('~/frobnitz' .. appended_dir), funcs.stdpath('data'))
end)
end)
describe('with "cache"' , function ()
it('knows XDG_CACHE_HOME', function()
clear({env={
XDG_CACHE_HOME=alter_slashes('/home/docwhat/.cache'),
}})
eq(alter_slashes('/home/docwhat/.cache/nvim'), funcs.stdpath('cache'))
end)
it('handles changes during runtime', function()
clear({env={
XDG_CACHE_HOME=alter_slashes('/home/original'),
}})
eq(alter_slashes('/home/original/nvim'), funcs.stdpath('cache'))
command("let $XDG_CACHE_HOME='"..alter_slashes('/home/new').."'")
eq(alter_slashes('/home/new/nvim'), funcs.stdpath('cache'))
end)
it("doesn't expand $VARIABLES", function()
clear({env={
XDG_CACHE_HOME='$VARIABLES',
VARIABLES='this-should-not-happen',
}})
eq(alter_slashes('$VARIABLES/nvim'), funcs.stdpath('cache'))
end)
it("doesn't expand ~/", function()
clear({env={
XDG_CACHE_HOME=alter_slashes('~/frobnitz'),
}})
eq(alter_slashes('~/frobnitz/nvim'), funcs.stdpath('cache'))
end)
end)
end)
context('returns a List', function()
-- Some OS specific variables the system would have set.
local function base_env()
if helpers.iswin() then
return {
HOME='C:\\Users\\docwhat', -- technically, is not a usual PATH
HOMEDRIVE='C:',
HOMEPATH='\\Users\\docwhat',
LOCALAPPDATA='C:\\Users\\docwhat\\AppData\\Local',
TEMP='C:\\Users\\docwhat\\AppData\\Local\\Temp',
TMPDIR='C:\\Users\\docwhat\\AppData\\Local\\Temp',
TMP='C:\\Users\\docwhat\\AppData\\Local\\Temp',
}
else
return {
HOME='/home/docwhat',
HOMEDRIVE='HOMEDRIVE-should-be-ignored',
HOMEPATH='HOMEPATH-should-be-ignored',
LOCALAPPDATA='LOCALAPPDATA-should-be-ignored',
TEMP='TEMP-should-be-ignored',
TMPDIR='TMPDIR-should-be-ignored',
TMP='TMP-should-be-ignored',
}
end
end
local function set_paths_via_system(var_name, paths)
local env = base_env()
env[var_name] = table.concat(paths, ':')
clear({env=env})
end
local function set_paths_at_runtime(var_name, paths)
clear({env=base_env()})
meths.set_var('env_val', table.concat(paths, ':'))
command(('let $%s=g:env_val'):format(var_name))
end
local function behaves_like_dir_list_env(msg, stdpath_arg, env_var_name, paths, expected_paths)
describe(msg, function()
it('set via system', function()
set_paths_via_system(env_var_name, paths)
eq(expected_paths, funcs.stdpath(stdpath_arg))
end)
it('set at runtime', function()
set_paths_at_runtime(env_var_name, paths)
eq(expected_paths, funcs.stdpath(stdpath_arg))
end)
end)
end
describe('with "config_dirs"' , function ()
behaves_like_dir_list_env(
'handles XDG_CONFIG_DIRS with one path',
'config_dirs', 'XDG_CONFIG_DIRS',
{
alter_slashes('/home/docwhat/.config')
},
{
alter_slashes('/home/docwhat/.config/nvim')
})
behaves_like_dir_list_env(
'handles XDG_CONFIG_DIRS with two paths',
'config_dirs', 'XDG_CONFIG_DIRS',
{
alter_slashes('/home/docwhat/.config'),
alter_slashes('/etc/config')
},
{
alter_slashes('/home/docwhat/.config/nvim'),
alter_slashes('/etc/config/nvim')
})
behaves_like_dir_list_env(
"doesn't expand $VAR and $IBLES",
'config_dirs', 'XDG_CONFIG_DIRS',
{ '$HOME', '$TMP' },
{
alter_slashes('$HOME/nvim'),
alter_slashes('$TMP/nvim')
})
behaves_like_dir_list_env(
"doesn't expand ~/",
'config_dirs', 'XDG_CONFIG_DIRS',
{
alter_slashes('~/.oldconfig'),
alter_slashes('~/.olderconfig')
},
{
alter_slashes('~/.oldconfig/nvim'),
alter_slashes('~/.olderconfig/nvim')
})
end)
describe('with "data_dirs"' , function ()
behaves_like_dir_list_env(
'knows XDG_DATA_DIRS with one path',
'data_dirs', 'XDG_DATA_DIRS',
{
alter_slashes('/home/docwhat/.data')
},
{
alter_slashes('/home/docwhat/.data/nvim')
})
behaves_like_dir_list_env(
'knows XDG_DATA_DIRS with two paths',
'data_dirs', 'XDG_DATA_DIRS',
{
alter_slashes('/home/docwhat/.data'),
alter_slashes('/etc/local')
},
{
alter_slashes('/home/docwhat/.data/nvim'),
alter_slashes('/etc/local/nvim'),
})
behaves_like_dir_list_env(
"doesn't expand $VAR and $IBLES",
'data_dirs', 'XDG_DATA_DIRS',
{ '$HOME', '$TMP' },
{
alter_slashes('$HOME/nvim'),
alter_slashes('$TMP/nvim')
})
behaves_like_dir_list_env(
"doesn't expand ~/",
'data_dirs', 'XDG_DATA_DIRS',
{
alter_slashes('~/.oldconfig'),
alter_slashes('~/.olderconfig')
},
{
alter_slashes('~/.oldconfig/nvim'),
alter_slashes('~/.olderconfig/nvim'),
})
end)
end)
describe('errors', function()
it('on unknown strings', function()
eq('Vim(call):E6100: "capybara" is not a valid stdpath', exc_exec('call stdpath("capybara")'))
eq('Vim(call):E6100: "" is not a valid stdpath', exc_exec('call stdpath("")'))
eq('Vim(call):E6100: "23" is not a valid stdpath', exc_exec('call stdpath(23)'))
end)
it('on non-strings', function()
eq('Vim(call):E731: using Dictionary as a String', exc_exec('call stdpath({"eris": 23})'))
eq('Vim(call):E730: using List as a String', exc_exec('call stdpath([23])'))
end)
end)
end)