From 59d117ec99b6037cb9fad5bbfb6d0b18f5012927 Mon Sep 17 00:00:00 2001 From: "Justin M. Keyes" Date: Thu, 7 Dec 2023 12:19:35 +0100 Subject: [PATCH] build: enable lintlua for test/ dir Problem: Not all Lua code is checked by stylua. Automating code-style is an important mechanism for reducing time spent on accidental (non-essential) complexity. Solution: - Enable stylua for entire `test/` directory. - Exclude these high-churn files until this issue is resolved: https://github.com/JohnnyMorganz/StyLua/issues/829 ``` test/functional/ui/decorations_spec.lua | 3560 ++++++++++++++++++++++++++++++++++++---------------- test/functional/ui/float_spec.lua | 5826 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------- test/functional/ui/multigrid_spec.lua | 1349 ++++++++++++++------ ``` - Make surgical changes to these files (or add `stylua: ignore` in some small scopes) to improve the result: ``` test/functional/vimscript/msgpack_functions_spec.lua | 1414 +++++++++++++++------ test/functional/api/buffer_spec.lua | 1389 +++++++++++---------- test/functional/api/vim_spec.lua | 2740 +++++++++++++++++++++++----------------- ``` - These "high churn" files are NOT excluded because the changes are largely an improvement: ``` test/functional/plugin/lsp_spec.lua | 2198 ++++++++++++++++++--------------- test/functional/plugin/shada_spec.lua | 4078 +++++++++++++++++++++++++++++++++++------------------------- test/functional/ui/cmdline_spec.lua | 1199 +++++++++++------- test/functional/ui/popupmenu_spec.lua | 1267 +++++++++++-------- test/functional/ui/messages_spec.lua | 1643 +++++++++++++++--------- ``` - TODO: how to check "all directories"? With `GLOB_DIRS *` and `/.deps/` (or `.deps/`) in `.styluaignore`, Lua code in `.deps/` is still checked... --- .styluaignore | 7 +- CMakeLists.txt | 11 +- test/functional/api/buffer_spec.lua | 1194 ++++---- test/functional/api/vim_spec.lua | 2563 ++++++++++------- test/functional/core/spellfile_spec.lua | 22 +- .../vimscript/msgpack_functions_spec.lua | 287 +- 6 files changed, 2276 insertions(+), 1808 deletions(-) diff --git a/.styluaignore b/.styluaignore index 53f7ea2812..80c6a9692c 100644 --- a/.styluaignore +++ b/.styluaignore @@ -1,9 +1,12 @@ -/build +/build/ +/.deps/ /runtime/lua/coxpcall.lua /runtime/lua/vim/_meta /runtime/lua/vim/re.lua -/test/functional +test/functional/ui/decorations_spec.lua +test/functional/ui/float_spec.lua +test/functional/ui/multigrid_spec.lua /test/functional/fixtures/lua/syntax_error.lua /test/functional/legacy/030_fileformats_spec.lua /test/functional/legacy/044_099_regexp_multibyte_magic_spec.lua diff --git a/CMakeLists.txt b/CMakeLists.txt index bcce95ef1e..d64d1fc723 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -227,7 +227,7 @@ endif() find_program(SHELLCHECK_PRG shellcheck ${LINT_REQUIRED}) find_program(STYLUA_PRG stylua ${LINT_REQUIRED}) -set(STYLUA_DIRS runtime scripts src test/unit) +set(STYLUA_DIRS runtime scripts src test) add_glob_target( TARGET lintlua-luacheck @@ -235,7 +235,7 @@ add_glob_target( FLAGS -ll ${PROJECT_SOURCE_DIR}/test/lua_runner.lua ${CMAKE_BINARY_DIR}/usr luacheck -q GLOB_DIRS runtime scripts src test GLOB_PAT *.lua - TOUCH_STRATEGY SINGLE) + TOUCH_STRATEGY PER_DIR) add_dependencies(lintlua-luacheck lua-dev-deps) add_glob_target( @@ -244,7 +244,7 @@ add_glob_target( FLAGS --color=always --check --respect-ignores GLOB_DIRS ${STYLUA_DIRS} GLOB_PAT *.lua - TOUCH_STRATEGY SINGLE) + TOUCH_STRATEGY PER_DIR) add_custom_target(lintlua) add_dependencies(lintlua lintlua-luacheck lintlua-stylua) @@ -255,7 +255,7 @@ add_glob_target( FLAGS -x -a GLOB_DIRS scripts GLOB_PAT *.sh - TOUCH_STRATEGY SINGLE) + TOUCH_STRATEGY PER_DIR) add_custom_target(lintcommit COMMAND $ -u NONE -l ${PROJECT_SOURCE_DIR}/scripts/lintcommit.lua main) @@ -270,7 +270,8 @@ add_glob_target( COMMAND ${STYLUA_PRG} FLAGS --respect-ignores GLOB_DIRS ${STYLUA_DIRS} - GLOB_PAT *.lua) + GLOB_PAT *.lua + TOUCH_STRATEGY PER_DIR) add_custom_target(format) add_dependencies(format formatc formatlua) diff --git a/test/functional/api/buffer_spec.lua b/test/functional/api/buffer_spec.lua index b89101a5e7..e8fff7443d 100644 --- a/test/functional/api/buffer_spec.lua +++ b/test/functional/api/buffer_spec.lua @@ -23,16 +23,15 @@ describe('api/buf', function() -- access deprecated functions local function curbuf_depr(method, ...) - return request('buffer_'..method, 0, ...) + return request('buffer_' .. method, 0, ...) end - describe('nvim_buf_set_lines, nvim_buf_line_count', function() it('deprecated forms', function() eq(1, curbuf_depr('line_count')) - curbuf_depr('insert', -1, {'line'}) + curbuf_depr('insert', -1, { 'line' }) eq(2, curbuf_depr('line_count')) - curbuf_depr('insert', -1, {'line'}) + curbuf_depr('insert', -1, { 'line' }) eq(3, curbuf_depr('line_count')) curbuf_depr('del_line', -1) eq(2, curbuf_depr('line_count')) @@ -45,88 +44,88 @@ describe('api/buf', function() it("doesn't crash just after set undolevels=1 #24894", function() local buf = meths.create_buf(false, true) meths.buf_set_option(buf, 'undolevels', -1) - meths.buf_set_lines(buf, 0, 1, false, { }) + meths.buf_set_lines(buf, 0, 1, false, {}) assert_alive() end) it('cursor position is maintained after lines are inserted #9961', function() -- replace the buffer contents with these three lines. - request('nvim_buf_set_lines', 0, 0, -1, 1, {"line1", "line2", "line3", "line4"}) + request('nvim_buf_set_lines', 0, 0, -1, 1, { 'line1', 'line2', 'line3', 'line4' }) -- Set the current cursor to {3, 2}. - curwin('set_cursor', {3, 2}) + curwin('set_cursor', { 3, 2 }) -- add 2 lines and delete 1 line above the current cursor position. - request('nvim_buf_set_lines', 0, 1, 2, 1, {"line5", "line6"}) + request('nvim_buf_set_lines', 0, 1, 2, 1, { 'line5', 'line6' }) -- check the current set of lines in the buffer. - eq({"line1", "line5", "line6", "line3", "line4"}, buffer('get_lines', 0, 0, -1, 1)) + eq({ 'line1', 'line5', 'line6', 'line3', 'line4' }, buffer('get_lines', 0, 0, -1, 1)) -- cursor should be moved below by 1 line. - eq({4, 2}, curwin('get_cursor')) + eq({ 4, 2 }, curwin('get_cursor')) -- add a line after the current cursor position. - request('nvim_buf_set_lines', 0, 5, 5, 1, {"line7"}) + request('nvim_buf_set_lines', 0, 5, 5, 1, { 'line7' }) -- check the current set of lines in the buffer. - eq({"line1", "line5", "line6", "line3", "line4", "line7"}, buffer('get_lines', 0, 0, -1, 1)) + eq({ 'line1', 'line5', 'line6', 'line3', 'line4', 'line7' }, buffer('get_lines', 0, 0, -1, 1)) -- cursor position is unchanged. - eq({4, 2}, curwin('get_cursor')) + eq({ 4, 2 }, curwin('get_cursor')) -- overwrite current cursor line. - request('nvim_buf_set_lines', 0, 3, 5, 1, {"line8", "line9"}) + request('nvim_buf_set_lines', 0, 3, 5, 1, { 'line8', 'line9' }) -- check the current set of lines in the buffer. - eq({"line1", "line5", "line6", "line8", "line9", "line7"}, buffer('get_lines', 0, 0, -1, 1)) + eq({ 'line1', 'line5', 'line6', 'line8', 'line9', 'line7' }, buffer('get_lines', 0, 0, -1, 1)) -- cursor position is unchanged. - eq({4, 2}, curwin('get_cursor')) + eq({ 4, 2 }, curwin('get_cursor')) -- delete current cursor line. request('nvim_buf_set_lines', 0, 3, 5, 1, {}) -- check the current set of lines in the buffer. - eq({"line1", "line5", "line6", "line7"}, buffer('get_lines', 0, 0, -1, 1)) + eq({ 'line1', 'line5', 'line6', 'line7' }, buffer('get_lines', 0, 0, -1, 1)) -- cursor position is unchanged. - eq({4, 2}, curwin('get_cursor')) + eq({ 4, 2 }, curwin('get_cursor')) end) it('cursor position is maintained in non-current window', function() - meths.buf_set_lines(0, 0, -1, 1, {"line1", "line2", "line3", "line4"}) - meths.win_set_cursor(0, {3, 2}) + meths.buf_set_lines(0, 0, -1, 1, { 'line1', 'line2', 'line3', 'line4' }) + meths.win_set_cursor(0, { 3, 2 }) local win = meths.get_current_win() local buf = meths.get_current_buf() command('new') - meths.buf_set_lines(buf, 1, 2, 1, {"line5", "line6"}) - eq({"line1", "line5", "line6", "line3", "line4"}, meths.buf_get_lines(buf, 0, -1, true)) - eq({4, 2}, meths.win_get_cursor(win)) + meths.buf_set_lines(buf, 1, 2, 1, { 'line5', 'line6' }) + eq({ 'line1', 'line5', 'line6', 'line3', 'line4' }, meths.buf_get_lines(buf, 0, -1, true)) + eq({ 4, 2 }, meths.win_get_cursor(win)) end) it('cursor position is maintained in TWO non-current windows', function() - meths.buf_set_lines(0, 0, -1, 1, {"line1", "line2", "line3", "line4"}) - meths.win_set_cursor(0, {3, 2}) + meths.buf_set_lines(0, 0, -1, 1, { 'line1', 'line2', 'line3', 'line4' }) + meths.win_set_cursor(0, { 3, 2 }) local win = meths.get_current_win() local buf = meths.get_current_buf() command('split') - meths.win_set_cursor(0, {4, 2}) + meths.win_set_cursor(0, { 4, 2 }) local win2 = meths.get_current_win() -- set current window to third one with another buffer - command("new") + command('new') - meths.buf_set_lines(buf, 1, 2, 1, {"line5", "line6"}) - eq({"line1", "line5", "line6", "line3", "line4"}, meths.buf_get_lines(buf, 0, -1, true)) - eq({4, 2}, meths.win_get_cursor(win)) - eq({5, 2}, meths.win_get_cursor(win2)) + meths.buf_set_lines(buf, 1, 2, 1, { 'line5', 'line6' }) + eq({ 'line1', 'line5', 'line6', 'line3', 'line4' }, meths.buf_get_lines(buf, 0, -1, true)) + eq({ 4, 2 }, meths.win_get_cursor(win)) + eq({ 5, 2 }, meths.win_get_cursor(win2)) end) it('line_count has defined behaviour for unloaded buffers', function() -- we'll need to know our bufnr for when it gets unloaded local bufnr = curbuf('get_number') -- replace the buffer contents with these three lines - request('nvim_buf_set_lines', bufnr, 0, -1, 1, {"line1", "line2", "line3", "line4"}) + request('nvim_buf_set_lines', bufnr, 0, -1, 1, { 'line1', 'line2', 'line3', 'line4' }) -- check the line count is correct eq(4, request('nvim_buf_line_count', bufnr)) -- force unload the buffer (this will discard changes) command('new') - command('bunload! '..bufnr) + command('bunload! ' .. bufnr) -- line count for an unloaded buffer should always be 0 eq(0, request('nvim_buf_line_count', bufnr)) end) @@ -135,12 +134,12 @@ describe('api/buf', function() -- we'll need to know our bufnr for when it gets unloaded local bufnr = curbuf('get_number') -- replace the buffer contents with these three lines - buffer('set_lines', bufnr, 0, -1, 1, {"line1", "line2", "line3", "line4"}) + buffer('set_lines', bufnr, 0, -1, 1, { 'line1', 'line2', 'line3', 'line4' }) -- confirm that getting lines works - eq({"line2", "line3"}, buffer('get_lines', bufnr, 1, 3, 1)) + eq({ 'line2', 'line3' }, buffer('get_lines', bufnr, 1, 3, 1)) -- force unload the buffer (this will discard changes) command('new') - command('bunload! '..bufnr) + command('bunload! ' .. bufnr) -- attempting to get lines now always gives empty list eq({}, buffer('get_lines', bufnr, 1, 3, 1)) -- it's impossible to get out-of-bounds errors for an unloaded buffer @@ -152,12 +151,12 @@ describe('api/buf', function() before_each(function() screen = Screen.new(20, 12) screen:set_default_attr_ids { - [1] = {bold = true, foreground = Screen.colors.Blue1}; - [2] = {reverse = true, bold = true}; - [3] = {reverse = true}; + [1] = { bold = true, foreground = Screen.colors.Blue1 }, + [2] = { reverse = true, bold = true }, + [3] = { reverse = true }, } screen:attach() - meths.buf_set_lines(0, 0, -1, 1, {"aaa", "bbb", "ccc", "ddd", "www", "xxx", "yyy", "zzz"}) + meths.buf_set_lines(0, 0, -1, 1, { 'aaa', 'bbb', 'ccc', 'ddd', 'www', 'xxx', 'yyy', 'zzz' }) meths.set_option_value('modified', false, {}) end) @@ -166,9 +165,10 @@ describe('api/buf', function() local buf = meths.get_current_buf() command('new | wincmd w') - meths.win_set_cursor(win, {8,0}) + meths.win_set_cursor(win, { 8, 0 }) - screen:expect{grid=[[ + screen:expect { + grid = [[ | {1:~ }|*4 {3:[No Name] }| @@ -178,10 +178,12 @@ describe('api/buf', function() ^zzz | {2:[No Name] }| | - ]]} + ]], + } - meths.buf_set_lines(buf, 0, 2, true, {"aaabbb"}) - screen:expect{grid=[[ + meths.buf_set_lines(buf, 0, 2, true, { 'aaabbb' }) + screen:expect { + grid = [[ | {1:~ }|*4 {3:[No Name] }| @@ -191,11 +193,13 @@ describe('api/buf', function() ^zzz | {2:[No Name] [+] }| | - ]]} + ]], + } -- replacing topline keeps it the topline - meths.buf_set_lines(buf, 3, 4, true, {"wwweeee"}) - screen:expect{grid=[[ + meths.buf_set_lines(buf, 3, 4, true, { 'wwweeee' }) + screen:expect { + grid = [[ | {1:~ }|*4 {3:[No Name] }| @@ -205,11 +209,13 @@ describe('api/buf', function() ^zzz | {2:[No Name] [+] }| | - ]]} + ]], + } -- inserting just before topline does not scroll up if cursor would be moved - meths.buf_set_lines(buf, 3, 3, true, {"mmm"}) - screen:expect{grid=[[ + meths.buf_set_lines(buf, 3, 3, true, { 'mmm' }) + screen:expect { + grid = [[ | {1:~ }|*4 {3:[No Name] }| @@ -219,10 +225,13 @@ describe('api/buf', function() ^zzz | {2:[No Name] [+] }| | - ]], unchanged=true} + ]], + unchanged = true, + } - meths.win_set_cursor(0, {7, 0}) - screen:expect{grid=[[ + meths.win_set_cursor(0, { 7, 0 }) + screen:expect { + grid = [[ | {1:~ }|*4 {3:[No Name] }| @@ -232,10 +241,12 @@ describe('api/buf', function() zzz | {2:[No Name] [+] }| | - ]]} + ]], + } - meths.buf_set_lines(buf, 4, 4, true, {"mmmeeeee"}) - screen:expect{grid=[[ + meths.buf_set_lines(buf, 4, 4, true, { 'mmmeeeee' }) + screen:expect { + grid = [[ | {1:~ }|*4 {3:[No Name] }| @@ -245,7 +256,8 @@ describe('api/buf', function() ^yyy | {2:[No Name] [+] }| | - ]]} + ]], + } end) it('of non-current window', function() @@ -253,9 +265,10 @@ describe('api/buf', function() local buf = meths.get_current_buf() command('new') - meths.win_set_cursor(win, {8,0}) + meths.win_set_cursor(win, { 8, 0 }) - screen:expect{grid=[[ + screen:expect { + grid = [[ ^ | {1:~ }|*4 {2:[No Name] }| @@ -265,10 +278,12 @@ describe('api/buf', function() zzz | {3:[No Name] }| | - ]]} + ]], + } - meths.buf_set_lines(buf, 0, 2, true, {"aaabbb"}) - screen:expect{grid=[[ + meths.buf_set_lines(buf, 0, 2, true, { 'aaabbb' }) + screen:expect { + grid = [[ ^ | {1:~ }|*4 {2:[No Name] }| @@ -278,11 +293,13 @@ describe('api/buf', function() zzz | {3:[No Name] [+] }| | - ]]} + ]], + } -- replacing topline keeps it the topline - meths.buf_set_lines(buf, 3, 4, true, {"wwweeee"}) - screen:expect{grid=[[ + meths.buf_set_lines(buf, 3, 4, true, { 'wwweeee' }) + screen:expect { + grid = [[ ^ | {1:~ }|*4 {2:[No Name] }| @@ -292,11 +309,13 @@ describe('api/buf', function() zzz | {3:[No Name] [+] }| | - ]]} + ]], + } -- inserting just before topline scrolls up - meths.buf_set_lines(buf, 3, 3, true, {"mmm"}) - screen:expect{grid=[[ + meths.buf_set_lines(buf, 3, 3, true, { 'mmm' }) + screen:expect { + grid = [[ ^ | {1:~ }|*4 {2:[No Name] }| @@ -306,7 +325,8 @@ describe('api/buf', function() yyy | {3:[No Name] [+] }| | - ]]} + ]], + } end) it('of split windows with same buffer', function() @@ -314,10 +334,11 @@ describe('api/buf', function() local buf = meths.get_current_buf() command('split') - meths.win_set_cursor(win, {8,0}) - meths.win_set_cursor(0, {1,0}) + meths.win_set_cursor(win, { 8, 0 }) + meths.win_set_cursor(0, { 1, 0 }) - screen:expect{grid=[[ + screen:expect { + grid = [[ ^aaa | bbb | ccc | @@ -330,10 +351,12 @@ describe('api/buf', function() zzz | {3:[No Name] }| | - ]]} - meths.buf_set_lines(buf, 0, 2, true, {"aaabbb"}) + ]], + } + meths.buf_set_lines(buf, 0, 2, true, { 'aaabbb' }) - screen:expect{grid=[[ + screen:expect { + grid = [[ ^aaabbb | ccc | ddd | @@ -346,11 +369,13 @@ describe('api/buf', function() zzz | {3:[No Name] [+] }| | - ]]} + ]], + } -- replacing topline keeps it the topline - meths.buf_set_lines(buf, 3, 4, true, {"wwweeee"}) - screen:expect{grid=[[ + meths.buf_set_lines(buf, 3, 4, true, { 'wwweeee' }) + screen:expect { + grid = [[ ^aaabbb | ccc | ddd | @@ -363,11 +388,13 @@ describe('api/buf', function() zzz | {3:[No Name] [+] }| | - ]]} + ]], + } -- inserting just before topline scrolls up - meths.buf_set_lines(buf, 3, 3, true, {"mmm"}) - screen:expect{grid=[[ + meths.buf_set_lines(buf, 3, 3, true, { 'mmm' }) + screen:expect { + grid = [[ ^aaabbb | ccc | ddd | @@ -380,20 +407,21 @@ describe('api/buf', function() yyy | {3:[No Name] [+] }| | - ]]} + ]], + } end) end) it('handles clearing out non-current buffer #24911', function() - local buf = meths.get_current_buf() - meths.buf_set_lines(buf, 0, -1, true, {"aaa", "bbb", "ccc"}) - command("new") + local buf = meths.get_current_buf() + meths.buf_set_lines(buf, 0, -1, true, { 'aaa', 'bbb', 'ccc' }) + command('new') - meths.buf_set_lines(0, 0, -1, true, {"xxx", "yyy", "zzz"}) + meths.buf_set_lines(0, 0, -1, true, { 'xxx', 'yyy', 'zzz' }) - meths.buf_set_lines(buf, 0, -1, true, {}) - eq({"xxx", "yyy", "zzz"}, meths.buf_get_lines(0, 0, -1, true)) - eq({''}, meths.buf_get_lines(buf, 0, -1, true)) + meths.buf_set_lines(buf, 0, -1, true, {}) + eq({ 'xxx', 'yyy', 'zzz' }, meths.buf_get_lines(0, 0, -1, true)) + eq({ '' }, meths.buf_get_lines(buf, 0, -1, true)) end) end) @@ -431,8 +459,8 @@ describe('api/buf', function() describe('deprecated: {get,set}_line_slice', function() it('get_line_slice: out-of-bounds returns empty array', function() - curbuf_depr('set_line_slice', 0, 0, true, true, {'a', 'b', 'c'}) - eq({'a', 'b', 'c'}, curbuf_depr('get_line_slice', 0, 2, true, true)) --sanity + curbuf_depr('set_line_slice', 0, 0, true, true, { 'a', 'b', 'c' }) + eq({ 'a', 'b', 'c' }, curbuf_depr('get_line_slice', 0, 2, true, true)) --sanity eq({}, curbuf_depr('get_line_slice', 2, 3, false, true)) eq({}, curbuf_depr('get_line_slice', 3, 9, true, true)) @@ -442,37 +470,36 @@ describe('api/buf', function() end) it('set_line_slice: out-of-bounds extends past end', function() - curbuf_depr('set_line_slice', 0, 0, true, true, {'a', 'b', 'c'}) - eq({'a', 'b', 'c'}, curbuf_depr('get_line_slice', 0, 2, true, true)) --sanity + curbuf_depr('set_line_slice', 0, 0, true, true, { 'a', 'b', 'c' }) + eq({ 'a', 'b', 'c' }, curbuf_depr('get_line_slice', 0, 2, true, true)) --sanity - eq({'c'}, curbuf_depr('get_line_slice', -1, 4, true, true)) - eq({'a', 'b', 'c'}, curbuf_depr('get_line_slice', 0, 5, true, true)) - curbuf_depr('set_line_slice', 4, 5, true, true, {'d'}) - eq({'a', 'b', 'c', 'd'}, curbuf_depr('get_line_slice', 0, 5, true, true)) - curbuf_depr('set_line_slice', -4, -5, true, true, {'e'}) - eq({'e', 'a', 'b', 'c', 'd'}, curbuf_depr('get_line_slice', 0, 5, true, true)) + eq({ 'c' }, curbuf_depr('get_line_slice', -1, 4, true, true)) + eq({ 'a', 'b', 'c' }, curbuf_depr('get_line_slice', 0, 5, true, true)) + curbuf_depr('set_line_slice', 4, 5, true, true, { 'd' }) + eq({ 'a', 'b', 'c', 'd' }, curbuf_depr('get_line_slice', 0, 5, true, true)) + curbuf_depr('set_line_slice', -4, -5, true, true, { 'e' }) + eq({ 'e', 'a', 'b', 'c', 'd' }, curbuf_depr('get_line_slice', 0, 5, true, true)) end) it('works', function() - eq({''}, curbuf_depr('get_line_slice', 0, -1, true, true)) + eq({ '' }, curbuf_depr('get_line_slice', 0, -1, true, true)) -- Replace buffer - curbuf_depr('set_line_slice', 0, -1, true, true, {'a', 'b', 'c'}) - eq({'a', 'b', 'c'}, curbuf_depr('get_line_slice', 0, -1, true, true)) - eq({'b', 'c'}, curbuf_depr('get_line_slice', 1, -1, true, true)) - eq({'b'}, curbuf_depr('get_line_slice', 1, 2, true, false)) + curbuf_depr('set_line_slice', 0, -1, true, true, { 'a', 'b', 'c' }) + eq({ 'a', 'b', 'c' }, curbuf_depr('get_line_slice', 0, -1, true, true)) + eq({ 'b', 'c' }, curbuf_depr('get_line_slice', 1, -1, true, true)) + eq({ 'b' }, curbuf_depr('get_line_slice', 1, 2, true, false)) eq({}, curbuf_depr('get_line_slice', 1, 1, true, false)) - eq({'a', 'b'}, curbuf_depr('get_line_slice', 0, -1, true, false)) - eq({'b'}, curbuf_depr('get_line_slice', 1, -1, true, false)) - eq({'b', 'c'}, curbuf_depr('get_line_slice', -2, -1, true, true)) - curbuf_depr('set_line_slice', 1, 2, true, false, {'a', 'b', 'c'}) - eq({'a', 'a', 'b', 'c', 'c'}, curbuf_depr('get_line_slice', 0, -1, true, true)) - curbuf_depr('set_line_slice', -1, -1, true, true, {'a', 'b', 'c'}) - eq({'a', 'a', 'b', 'c', 'a', 'b', 'c'}, - curbuf_depr('get_line_slice', 0, -1, true, true)) + eq({ 'a', 'b' }, curbuf_depr('get_line_slice', 0, -1, true, false)) + eq({ 'b' }, curbuf_depr('get_line_slice', 1, -1, true, false)) + eq({ 'b', 'c' }, curbuf_depr('get_line_slice', -2, -1, true, true)) + curbuf_depr('set_line_slice', 1, 2, true, false, { 'a', 'b', 'c' }) + eq({ 'a', 'a', 'b', 'c', 'c' }, curbuf_depr('get_line_slice', 0, -1, true, true)) + curbuf_depr('set_line_slice', -1, -1, true, true, { 'a', 'b', 'c' }) + eq({ 'a', 'a', 'b', 'c', 'a', 'b', 'c' }, curbuf_depr('get_line_slice', 0, -1, true, true)) curbuf_depr('set_line_slice', 0, -3, true, false, {}) - eq({'a', 'b', 'c'}, curbuf_depr('get_line_slice', 0, -1, true, true)) + eq({ 'a', 'b', 'c' }, curbuf_depr('get_line_slice', 0, -1, true, true)) curbuf_depr('set_line_slice', 0, -1, true, true, {}) - eq({''}, curbuf_depr('get_line_slice', 0, -1, true, true)) + eq({ '' }, curbuf_depr('get_line_slice', 0, -1, true, true)) end) end) @@ -483,21 +510,25 @@ describe('api/buf', function() it('fails correctly when input is not valid', function() eq(1, api.curbufmeths.get_number()) - eq([['replacement string' item contains newlines]], - pcall_err(bufmeths.set_lines, 1, 1, 2, false, {'b\na'})) + eq( + [['replacement string' item contains newlines]], + pcall_err(bufmeths.set_lines, 1, 1, 2, false, { 'b\na' }) + ) end) it("fails if 'nomodifiable'", function() command('set nomodifiable') - eq([[Buffer is not 'modifiable']], - pcall_err(api.bufmeths.set_lines, 1, 1, 2, false, {'a','b'})) + eq( + [[Buffer is not 'modifiable']], + pcall_err(api.bufmeths.set_lines, 1, 1, 2, false, { 'a', 'b' }) + ) end) it('has correct line_count when inserting and deleting', function() eq(1, line_count()) - set_lines(-1, -1, true, {'line'}) + set_lines(-1, -1, true, { 'line' }) eq(2, line_count()) - set_lines(-1, -1, true, {'line'}) + set_lines(-1, -1, true, { 'line' }) eq(3, line_count()) set_lines(-2, -1, true, {}) eq(2, line_count()) @@ -508,81 +539,80 @@ describe('api/buf', function() end) it('can get, set and delete a single line', function() - eq({''}, get_lines(0, 1, true)) - set_lines(0, 1, true, {'line1'}) - eq({'line1'}, get_lines(0, 1, true)) - set_lines(0, 1, true, {'line2'}) - eq({'line2'}, get_lines(0, 1, true)) + eq({ '' }, get_lines(0, 1, true)) + set_lines(0, 1, true, { 'line1' }) + eq({ 'line1' }, get_lines(0, 1, true)) + set_lines(0, 1, true, { 'line2' }) + eq({ 'line2' }, get_lines(0, 1, true)) set_lines(0, 1, true, {}) - eq({''}, get_lines(0, 1, true)) + eq({ '' }, get_lines(0, 1, true)) end) it('can get a single line with strict indexing', function() - set_lines(0, 1, true, {'line1.a'}) + set_lines(0, 1, true, { 'line1.a' }) eq(1, line_count()) -- sanity eq('Index out of bounds', pcall_err(get_lines, 1, 2, true)) eq('Index out of bounds', pcall_err(get_lines, -3, -2, true)) end) it('can get a single line with non-strict indexing', function() - set_lines(0, 1, true, {'line1.a'}) + set_lines(0, 1, true, { 'line1.a' }) eq(1, line_count()) -- sanity eq({}, get_lines(1, 2, false)) eq({}, get_lines(-3, -2, false)) end) it('can set and delete a single line with strict indexing', function() - set_lines(0, 1, true, {'line1.a'}) - eq('Index out of bounds', pcall_err(set_lines, 1, 2, true, {'line1.b'})) - eq('Index out of bounds', pcall_err(set_lines, -3, -2, true, {'line1.c'})) - eq({'line1.a'}, get_lines(0, -1, true)) + set_lines(0, 1, true, { 'line1.a' }) + eq('Index out of bounds', pcall_err(set_lines, 1, 2, true, { 'line1.b' })) + eq('Index out of bounds', pcall_err(set_lines, -3, -2, true, { 'line1.c' })) + eq({ 'line1.a' }, get_lines(0, -1, true)) eq('Index out of bounds', pcall_err(set_lines, 1, 2, true, {})) eq('Index out of bounds', pcall_err(set_lines, -3, -2, true, {})) - eq({'line1.a'}, get_lines(0, -1, true)) + eq({ 'line1.a' }, get_lines(0, -1, true)) end) it('can set and delete a single line with non-strict indexing', function() - set_lines(0, 1, true, {'line1.a'}) - set_lines(1, 2, false, {'line1.b'}) - set_lines(-4, -3, false, {'line1.c'}) - eq({'line1.c', 'line1.a', 'line1.b'}, get_lines(0, -1, true)) + set_lines(0, 1, true, { 'line1.a' }) + set_lines(1, 2, false, { 'line1.b' }) + set_lines(-4, -3, false, { 'line1.c' }) + eq({ 'line1.c', 'line1.a', 'line1.b' }, get_lines(0, -1, true)) set_lines(3, 4, false, {}) set_lines(-5, -4, false, {}) - eq({'line1.c', 'line1.a', 'line1.b'}, get_lines(0, -1, true)) + eq({ 'line1.c', 'line1.a', 'line1.b' }, get_lines(0, -1, true)) end) it('can handle NULs', function() - set_lines(0, 1, true, {'ab\0cd'}) - eq({'ab\0cd'}, get_lines(0, -1, true)) + set_lines(0, 1, true, { 'ab\0cd' }) + eq({ 'ab\0cd' }, get_lines(0, -1, true)) end) it('works with multiple lines', function() - eq({''}, get_lines(0, -1, true)) + eq({ '' }, get_lines(0, -1, true)) -- Replace buffer - for _, mode in pairs({false, true}) do - set_lines(0, -1, mode, {'a', 'b', 'c'}) - eq({'a', 'b', 'c'}, get_lines(0, -1, mode)) - eq({'b', 'c'}, get_lines(1, -1, mode)) - eq({'b'}, get_lines(1, 2, mode)) + for _, mode in pairs({ false, true }) do + set_lines(0, -1, mode, { 'a', 'b', 'c' }) + eq({ 'a', 'b', 'c' }, get_lines(0, -1, mode)) + eq({ 'b', 'c' }, get_lines(1, -1, mode)) + eq({ 'b' }, get_lines(1, 2, mode)) eq({}, get_lines(1, 1, mode)) - eq({'a', 'b'}, get_lines(0, -2, mode)) - eq({'b'}, get_lines(1, -2, mode)) - eq({'b', 'c'}, get_lines(-3, -1, mode)) - set_lines(1, 2, mode, {'a', 'b', 'c'}) - eq({'a', 'a', 'b', 'c', 'c'}, get_lines(0, -1, mode)) - set_lines(-2, -1, mode, {'a', 'b', 'c'}) - eq({'a', 'a', 'b', 'c', 'a', 'b', 'c'}, - get_lines(0, -1, mode)) + eq({ 'a', 'b' }, get_lines(0, -2, mode)) + eq({ 'b' }, get_lines(1, -2, mode)) + eq({ 'b', 'c' }, get_lines(-3, -1, mode)) + set_lines(1, 2, mode, { 'a', 'b', 'c' }) + eq({ 'a', 'a', 'b', 'c', 'c' }, get_lines(0, -1, mode)) + set_lines(-2, -1, mode, { 'a', 'b', 'c' }) + eq({ 'a', 'a', 'b', 'c', 'a', 'b', 'c' }, get_lines(0, -1, mode)) set_lines(0, -4, mode, {}) - eq({'a', 'b', 'c'}, get_lines(0, -1, mode)) + eq({ 'a', 'b', 'c' }, get_lines(0, -1, mode)) set_lines(0, -1, mode, {}) - eq({''}, get_lines(0, -1, mode)) + eq({ '' }, get_lines(0, -1, mode)) end end) it('can get line ranges with non-strict indexing', function() - set_lines(0, -1, true, {'a', 'b', 'c'}) - eq({'a', 'b', 'c'}, get_lines(0, -1, true)) --sanity + set_lines(0, -1, true, { 'a', 'b', 'c' }) + eq({ 'a', 'b', 'c' }, get_lines(0, -1, true)) --sanity eq({}, get_lines(3, 4, false)) eq({}, get_lines(3, 10, false)) @@ -592,8 +622,8 @@ describe('api/buf', function() end) it('can get line ranges with strict indexing', function() - set_lines(0, -1, true, {'a', 'b', 'c'}) - eq({'a', 'b', 'c'}, get_lines(0, -1, true)) --sanity + set_lines(0, -1, true, { 'a', 'b', 'c' }) + eq({ 'a', 'b', 'c' }, get_lines(0, -1, true)) --sanity eq('Index out of bounds', pcall_err(get_lines, 3, 4, true)) eq('Index out of bounds', pcall_err(get_lines, 3, 10, true)) @@ -604,20 +634,20 @@ describe('api/buf', function() end) it('set_lines: out-of-bounds can extend past end', function() - set_lines(0, -1, true, {'a', 'b', 'c'}) - eq({'a', 'b', 'c'}, get_lines(0, -1, true)) --sanity + set_lines(0, -1, true, { 'a', 'b', 'c' }) + eq({ 'a', 'b', 'c' }, get_lines(0, -1, true)) --sanity - eq({'c'}, get_lines(-2, 5, false)) - eq({'a', 'b', 'c'}, get_lines(0, 6, false)) - eq('Index out of bounds', pcall_err(set_lines, 4, 6, true, {'d'})) - set_lines(4, 6, false, {'d'}) - eq({'a', 'b', 'c', 'd'}, get_lines(0, -1, true)) - eq('Index out of bounds', pcall_err(set_lines, -6, -6, true, {'e'})) - set_lines(-6, -6, false, {'e'}) - eq({'e', 'a', 'b', 'c', 'd'}, get_lines(0, -1, true)) + eq({ 'c' }, get_lines(-2, 5, false)) + eq({ 'a', 'b', 'c' }, get_lines(0, 6, false)) + eq('Index out of bounds', pcall_err(set_lines, 4, 6, true, { 'd' })) + set_lines(4, 6, false, { 'd' }) + eq({ 'a', 'b', 'c', 'd' }, get_lines(0, -1, true)) + eq('Index out of bounds', pcall_err(set_lines, -6, -6, true, { 'e' })) + set_lines(-6, -6, false, { 'e' }) + eq({ 'e', 'a', 'b', 'c', 'd' }, get_lines(0, -1, true)) end) - it("set_lines on alternate buffer does not access invalid line (E315)", function() + it('set_lines on alternate buffer does not access invalid line (E315)', function() feed_command('set hidden') insert('Initial file') command('enew') @@ -637,8 +667,8 @@ describe('api/buf', function() it("set_lines of invisible buffer doesn't move cursor in current window", function() local screen = Screen.new(20, 5) screen:set_default_attr_ids({ - [1] = {bold = true, foreground = Screen.colors.Blue1}, - [2] = {bold = true}, + [1] = { bold = true, foreground = Screen.colors.Blue1 }, + [2] = { bold = true }, }) screen:attach() @@ -646,7 +676,7 @@ describe('api/buf', function() Who would win? A real window with proper text]]) - local buf = api.meths.create_buf(false,true) + local buf = api.meths.create_buf(false, true) screen:expect([[ Who would win? | A real window | @@ -655,7 +685,7 @@ describe('api/buf', function() | ]]) - api.meths.buf_set_lines(buf, 0, -1, true, {'or some', 'scratchy text'}) + api.meths.buf_set_lines(buf, 0, -1, true, { 'or some', 'scratchy text' }) feed('i') -- provoke redraw screen:expect([[ Who would win? | @@ -671,32 +701,31 @@ describe('api/buf', function() visible buffer line 1 line 2 ]]) - local hiddenbuf = api.meths.create_buf(false,true) + local hiddenbuf = api.meths.create_buf(false, true) command('vsplit') command('vsplit') feed('lll') eq(3, funcs.winnr()) feed('h') eq(2, funcs.winnr()) - api.meths.buf_set_lines(hiddenbuf, 0, -1, true, - {'hidden buffer line 1', 'line 2'}) + api.meths.buf_set_lines(hiddenbuf, 0, -1, true, { 'hidden buffer line 1', 'line 2' }) feed('p') eq(3, funcs.winnr()) end) it('set_lines on unloaded buffer #8659 #22670', function() local bufnr = curbuf('get_number') - meths.buf_set_lines(bufnr, 0, -1, false, {'a', 'b', 'c'}) + meths.buf_set_lines(bufnr, 0, -1, false, { 'a', 'b', 'c' }) meths.buf_set_name(bufnr, 'set_lines') finally(function() os.remove('set_lines') end) command('write!') command('new') - command('bunload! '..bufnr) + command('bunload! ' .. bufnr) local new_bufnr = funcs.bufnr('set_lines', true) meths.buf_set_lines(new_bufnr, 0, -1, false, {}) - eq({''}, meths.buf_get_lines(new_bufnr, 0, -1, false)) + eq({ '' }, meths.buf_get_lines(new_bufnr, 0, -1, false)) end) end) @@ -709,70 +738,69 @@ describe('api/buf', function() text ]]) - eq({'hello foo!'}, get_lines(0, 1, true)) - + eq({ 'hello foo!' }, get_lines(0, 1, true)) -- can replace a single word - set_text(0, 6, 0, 9, {'world'}) - eq({'hello world!', 'text'}, get_lines(0, 2, true)) + set_text(0, 6, 0, 9, { 'world' }) + eq({ 'hello world!', 'text' }, get_lines(0, 2, true)) -- can insert text - set_text(0, 0, 0, 0, {'well '}) - eq({'well hello world!', 'text'}, get_lines(0, 2, true)) + set_text(0, 0, 0, 0, { 'well ' }) + eq({ 'well hello world!', 'text' }, get_lines(0, 2, true)) -- can delete text - set_text(0, 0, 0, 5, {''}) - eq({'hello world!', 'text'}, get_lines(0, 2, true)) + set_text(0, 0, 0, 5, { '' }) + eq({ 'hello world!', 'text' }, get_lines(0, 2, true)) -- can replace with multiple lines - set_text(0, 6, 0, 11, {'foo', 'wo', 'more'}) - eq({'hello foo', 'wo', 'more!', 'text'}, get_lines(0, 4, true)) + set_text(0, 6, 0, 11, { 'foo', 'wo', 'more' }) + eq({ 'hello foo', 'wo', 'more!', 'text' }, get_lines(0, 4, true)) -- will join multiple lines if needed - set_text(0, 6, 3, 4, {'bar'}) - eq({'hello bar'}, get_lines(0, 1, true)) + set_text(0, 6, 3, 4, { 'bar' }) + eq({ 'hello bar' }, get_lines(0, 1, true)) -- can use negative line numbers - set_text(-2, 0, -2, 5, {'goodbye'}) - eq({'goodbye bar', ''}, get_lines(0, -1, true)) + set_text(-2, 0, -2, 5, { 'goodbye' }) + eq({ 'goodbye bar', '' }, get_lines(0, -1, true)) - set_text(-1, 0, -1, 0, {'text'}) - eq({'goodbye bar', 'text'}, get_lines(0, 2, true)) + set_text(-1, 0, -1, 0, { 'text' }) + eq({ 'goodbye bar', 'text' }, get_lines(0, 2, true)) -- can append to a line - set_text(1, 4, -1, 4, {' and', 'more'}) - eq({'goodbye bar', 'text and', 'more'}, get_lines(0, 3, true)) + set_text(1, 4, -1, 4, { ' and', 'more' }) + eq({ 'goodbye bar', 'text and', 'more' }, get_lines(0, 3, true)) -- can use negative column numbers - set_text(0, -5, 0, -1, {'!'}) - eq({'goodbye!'}, get_lines(0, 1, true)) + set_text(0, -5, 0, -1, { '!' }) + eq({ 'goodbye!' }, get_lines(0, 1, true)) end) it('works with undo', function() - insert([[ + insert([[ hello world! foo bar ]]) - -- setting text - set_text(0, 0, 0, 0, {'well '}) - feed('u') - eq({'hello world!'}, get_lines(0, 1, true)) + -- setting text + set_text(0, 0, 0, 0, { 'well ' }) + feed('u') + eq({ 'hello world!' }, get_lines(0, 1, true)) - -- deleting text - set_text(0, 0, 0, 6, {''}) - feed('u') - eq({'hello world!'}, get_lines(0, 1, true)) + -- deleting text + set_text(0, 0, 0, 6, { '' }) + feed('u') + eq({ 'hello world!' }, get_lines(0, 1, true)) - -- inserting newlines - set_text(0, 0, 0, 0, {'hello', 'mr '}) - feed('u') - eq({'hello world!'}, get_lines(0, 1, true)) + -- inserting newlines + set_text(0, 0, 0, 0, { 'hello', 'mr ' }) + feed('u') + eq({ 'hello world!' }, get_lines(0, 1, true)) - -- deleting newlines - set_text(0, 0, 1, 4, {'hello'}) - feed('u') - eq({'hello world!'}, get_lines(0, 1, true)) + -- deleting newlines + set_text(0, 0, 1, 4, { 'hello' }) + feed('u') + eq({ 'hello world!' }, get_lines(0, 1, true)) end) it('updates the cursor position', function() @@ -781,12 +809,12 @@ describe('api/buf', function() ]]) -- position the cursor on `!` - curwin('set_cursor', {1, 11}) + curwin('set_cursor', { 1, 11 }) -- replace 'world' with 'foo' - set_text(0, 6, 0, 11, {'foo'}) + set_text(0, 6, 0, 11, { 'foo' }) eq('hello foo!', curbuf_depr('get_line', 0)) -- cursor should be moved left by two columns (replacement is shorter by 2 chars) - eq({1, 9}, curwin('get_cursor')) + eq({ 1, 9 }, curwin('get_cursor')) end) it('updates the cursor position in non-current window', function() @@ -794,18 +822,18 @@ describe('api/buf', function() hello world!]]) -- position the cursor on `!` - meths.win_set_cursor(0, {1, 11}) + meths.win_set_cursor(0, { 1, 11 }) local win = meths.get_current_win() local buf = meths.get_current_buf() - command("new") + command('new') -- replace 'world' with 'foo' - meths.buf_set_text(buf, 0, 6, 0, 11, {'foo'}) - eq({'hello foo!'}, meths.buf_get_lines(buf, 0, -1, true)) + meths.buf_set_text(buf, 0, 6, 0, 11, { 'foo' }) + eq({ 'hello foo!' }, meths.buf_get_lines(buf, 0, -1, true)) -- cursor should be moved left by two columns (replacement is shorter by 2 chars) - eq({1, 9}, meths.win_get_cursor(win)) + eq({ 1, 9 }, meths.win_get_cursor(win)) end) it('updates the cursor position in TWO non-current windows', function() @@ -813,24 +841,24 @@ describe('api/buf', function() hello world!]]) -- position the cursor on `!` - meths.win_set_cursor(0, {1, 11}) + meths.win_set_cursor(0, { 1, 11 }) local win = meths.get_current_win() local buf = meths.get_current_buf() - command("split") + command('split') local win2 = meths.get_current_win() -- position the cursor on `w` - meths.win_set_cursor(0, {1, 6}) + meths.win_set_cursor(0, { 1, 6 }) - command("new") + command('new') -- replace 'hello' with 'foo' - meths.buf_set_text(buf, 0, 0, 0, 5, {'foo'}) - eq({'foo world!'}, meths.buf_get_lines(buf, 0, -1, true)) + meths.buf_set_text(buf, 0, 0, 0, 5, { 'foo' }) + eq({ 'foo world!' }, meths.buf_get_lines(buf, 0, -1, true)) -- both cursors should be moved left by two columns (replacement is shorter by 2 chars) - eq({1, 9}, meths.win_get_cursor(win)) - eq({1, 4}, meths.win_get_cursor(win2)) + eq({ 1, 9 }, meths.win_get_cursor(win)) + eq({ 1, 4 }, meths.win_get_cursor(win2)) end) describe('when text is being added right at cursor position #22526', function() @@ -839,12 +867,12 @@ describe('api/buf', function() abcd]]) -- position the cursor on 'c' - curwin('set_cursor', {1, 2}) + curwin('set_cursor', { 1, 2 }) -- add 'xxx' before 'c' - set_text(0, 2, 0, 2, {'xxx'}) - eq({'abxxxcd'}, get_lines(0, -1, true)) + set_text(0, 2, 0, 2, { 'xxx' }) + eq({ 'abxxxcd' }, get_lines(0, -1, true)) -- cursor should be on 'c' - eq({1, 5}, curwin('get_cursor')) + eq({ 1, 5 }, curwin('get_cursor')) end) it('updates the cursor position only in non-current window when in INSERT mode', function() @@ -852,23 +880,23 @@ describe('api/buf', function() abcd]]) -- position the cursor on 'c' - curwin('set_cursor', {1, 2}) + curwin('set_cursor', { 1, 2 }) -- open vertical split feed('v') -- get into INSERT mode to treat cursor -- as being after 'b', not on 'c' feed('i') -- add 'xxx' between 'b' and 'c' - set_text(0, 2, 0, 2, {'xxx'}) - eq({'abxxxcd'}, get_lines(0, -1, true)) + set_text(0, 2, 0, 2, { 'xxx' }) + eq({ 'abxxxcd' }, get_lines(0, -1, true)) -- in the current window cursor should stay after 'b' - eq({1, 2}, curwin('get_cursor')) + eq({ 1, 2 }, curwin('get_cursor')) -- quit INSERT mode feed('') -- close current window feed('c') -- in another window cursor should be on 'c' - eq({1, 5}, curwin('get_cursor')) + eq({ 1, 5 }, curwin('get_cursor')) end) end) @@ -878,20 +906,20 @@ describe('api/buf', function() abcd]]) -- position the cursor on 'b' - curwin('set_cursor', {1, 1}) + curwin('set_cursor', { 1, 1 }) -- delete 'b' set_text(0, 1, 0, 2, {}) - eq({'acd'}, get_lines(0, -1, true)) + eq({ 'acd' }, get_lines(0, -1, true)) -- cursor is now on 'c' - eq({1, 1}, curwin('get_cursor')) + eq({ 1, 1 }, curwin('get_cursor')) end) - it('leaves cursor at the same position in INSERT mode in current and non-current window', function() + it('maintains INSERT-mode cursor position current/non-current window', function() insert([[ abcd]]) -- position the cursor on 'b' - curwin('set_cursor', {1, 1}) + curwin('set_cursor', { 1, 1 }) -- open vertical split feed('v') -- get into INSERT mode to treat cursor @@ -899,27 +927,27 @@ describe('api/buf', function() feed('i') -- delete 'b' set_text(0, 1, 0, 2, {}) - eq({'acd'}, get_lines(0, -1, true)) + eq({ 'acd' }, get_lines(0, -1, true)) -- cursor in the current window should stay after 'a' - eq({1, 1}, curwin('get_cursor')) + eq({ 1, 1 }, curwin('get_cursor')) -- quit INSERT mode feed('') -- close current window feed('c') -- cursor in non-current window should stay on 'c' - eq({1, 1}, curwin('get_cursor')) + eq({ 1, 1 }, curwin('get_cursor')) end) end) describe('when cursor is inside replaced row range', function() - it('keeps cursor at the same position if cursor is at start_row, but before start_col', function() + it('maintains cursor position if at start_row, but before start_col', function() insert([[ This should be first then there is a line we do not want and finally the last one]]) -- position the cursor on ' ' before 'first' - curwin('set_cursor', {1, 14}) + curwin('set_cursor', { 1, 14 }) set_text(0, 15, 2, 11, { 'the line we do not want', @@ -931,17 +959,17 @@ describe('api/buf', function() 'but hopefully the last one', }, get_lines(0, -1, true)) -- cursor should stay at the same position - eq({1, 14}, curwin('get_cursor')) + eq({ 1, 14 }, curwin('get_cursor')) end) - it('keeps cursor at the same position if cursor is at start_row and column is still valid', function() + it('maintains cursor position if at start_row and column is still valid', function() insert([[ This should be first then there is a line we do not want and finally the last one]]) -- position the cursor on 'f' in 'first' - curwin('set_cursor', {1, 15}) + curwin('set_cursor', { 1, 15 }) set_text(0, 15, 2, 11, { 'the line we do not want', @@ -953,7 +981,7 @@ describe('api/buf', function() 'but hopefully the last one', }, get_lines(0, -1, true)) -- cursor should stay at the same position - eq({1, 15}, curwin('get_cursor')) + eq({ 1, 15 }, curwin('get_cursor')) end) it('adjusts cursor column to keep it valid if start_row got smaller', function() @@ -963,7 +991,7 @@ describe('api/buf', function() and finally the last one]]) -- position the cursor on 't' in 'first' - curwin('set_cursor', {1, 19}) + curwin('set_cursor', { 1, 19 }) local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 15, 2, 24, {'last'}) @@ -972,19 +1000,19 @@ describe('api/buf', function() eq({ 'This should be last' }, get_lines(0, -1, true)) -- cursor should end up on 't' in 'last' - eq({1, 18}, curwin('get_cursor')) + eq({ 1, 18 }, curwin('get_cursor')) -- immediate call to nvim_win_get_cursor should have returned the same position - eq({1, 18}, cursor) + eq({ 1, 18 }, cursor) end) - it('adjusts cursor column to keep it valid if start_row got smaller in INSERT mode', function() + it('adjusts cursor column to keep it valid if start_row decreased in INSERT mode', function() insert([[ This should be first then there is a line we do not want and finally the last one]]) -- position the cursor on 't' in 'first' - curwin('set_cursor', {1, 19}) + curwin('set_cursor', { 1, 19 }) -- enter INSERT mode to treat cursor as being after 't' feed('a') @@ -995,19 +1023,19 @@ describe('api/buf', function() eq({ 'This should be last' }, get_lines(0, -1, true)) -- cursor should end up after 't' in 'last' - eq({1, 19}, curwin('get_cursor')) + eq({ 1, 19 }, curwin('get_cursor')) -- immediate call to nvim_win_get_cursor should have returned the same position - eq({1, 19}, cursor) + eq({ 1, 19 }, cursor) end) - it('adjusts cursor column to keep it valid in a row after start_row if it got smaller', function() + it('adjusts cursor to valid column in row after start_row if it got smaller', function() insert([[ This should be first then there is a line we do not want and finally the last one]]) -- position the cursor on 'w' in 'want' - curwin('set_cursor', {2, 31}) + curwin('set_cursor', { 2, 31 }) local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 15, 2, 11, { @@ -1024,23 +1052,25 @@ describe('api/buf', function() 'and then the last one', }, get_lines(0, -1, true)) -- cursor column should end up at the end of a row - eq({2, 5}, curwin('get_cursor')) + eq({ 2, 5 }, curwin('get_cursor')) -- immediate call to nvim_win_get_cursor should have returned the same position - eq({2, 5}, cursor) + eq({ 2, 5 }, cursor) end) - it('adjusts cursor column to keep it valid in a row after start_row if it got smaller in INSERT mode', function() - insert([[ + it( + 'adjusts cursor to valid column in row after start_row if it got smaller in INSERT mode', + function() + insert([[ This should be first then there is a line we do not want and finally the last one]]) - -- position the cursor on 'w' in 'want' - curwin('set_cursor', {2, 31}) - -- enter INSERT mode - feed('a') + -- position the cursor on 'w' in 'want' + curwin('set_cursor', { 2, 31 }) + -- enter INSERT mode + feed('a') - local cursor = exec_lua([[ + local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 15, 2, 11, { '1', 'then 2', @@ -1049,16 +1079,17 @@ describe('api/buf', function() return vim.api.nvim_win_get_cursor(0) ]]) - eq({ - 'This should be 1', - 'then 2', - 'and then the last one', - }, get_lines(0, -1, true)) - -- cursor column should end up at the end of a row - eq({2, 6}, curwin('get_cursor')) - -- immediate call to nvim_win_get_cursor should have returned the same position - eq({2, 6}, cursor) - end) + eq({ + 'This should be 1', + 'then 2', + 'and then the last one', + }, get_lines(0, -1, true)) + -- cursor column should end up at the end of a row + eq({ 2, 6 }, curwin('get_cursor')) + -- immediate call to nvim_win_get_cursor should have returned the same position + eq({ 2, 6 }, cursor) + end + ) it('adjusts cursor line and column to keep it inside replacement range', function() insert([[ @@ -1067,7 +1098,7 @@ describe('api/buf', function() and finally the last one]]) -- position the cursor on 'n' in 'finally' - curwin('set_cursor', {3, 6}) + curwin('set_cursor', { 3, 6 }) local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 15, 2, 11, { @@ -1083,9 +1114,9 @@ describe('api/buf', function() }, get_lines(0, -1, true)) -- cursor should end up on 'y' in 'hopefully' -- to stay in the range, because it got smaller - eq({2, 12}, curwin('get_cursor')) + eq({ 2, 12 }, curwin('get_cursor')) -- immediate call to nvim_win_get_cursor should have returned the same position - eq({2, 12}, cursor) + eq({ 2, 12 }, cursor) end) it('adjusts cursor line and column if replacement is empty', function() @@ -1095,7 +1126,7 @@ describe('api/buf', function() and finally the last one]]) -- position the cursor on 'r' in 'there' - curwin('set_cursor', {2, 8}) + curwin('set_cursor', { 2, 8 }) local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 15, 2, 12, {}) @@ -1104,9 +1135,9 @@ describe('api/buf', function() eq({ 'This should be the last one' }, get_lines(0, -1, true)) -- cursor should end up on the next column after deleted range - eq({1, 15}, curwin('get_cursor')) + eq({ 1, 15 }, curwin('get_cursor')) -- immediate call to nvim_win_get_cursor should have returned the same position - eq({1, 15}, cursor) + eq({ 1, 15 }, cursor) end) it('adjusts cursor line and column if replacement is empty and start_col == 0', function() @@ -1116,7 +1147,7 @@ describe('api/buf', function() and finally the last one]]) -- position the cursor on 'r' in 'there' - curwin('set_cursor', {2, 8}) + curwin('set_cursor', { 2, 8 }) local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 0, 2, 4, {}) @@ -1125,9 +1156,9 @@ describe('api/buf', function() eq({ 'finally the last one' }, get_lines(0, -1, true)) -- cursor should end up in column 0 - eq({1, 0}, curwin('get_cursor')) + eq({ 1, 0 }, curwin('get_cursor')) -- immediate call to nvim_win_get_cursor should have returned the same position - eq({1, 0}, cursor) + eq({ 1, 0 }, cursor) end) it('adjusts cursor column if replacement ends at cursor row, after cursor column', function() @@ -1137,7 +1168,7 @@ describe('api/buf', function() and finally the last one]]) -- position the cursor on 'y' in 'finally' - curwin('set_cursor', {3, 10}) + curwin('set_cursor', { 3, 10 }) set_text(0, 15, 2, 11, { '1', 'this 2', 'and then' }) eq({ @@ -1146,29 +1177,32 @@ describe('api/buf', function() 'and then the last one', }, get_lines(0, -1, true)) -- cursor should end up on 'n' in 'then' - eq({3, 7}, curwin('get_cursor')) + eq({ 3, 7 }, curwin('get_cursor')) end) - it('adjusts cursor column if replacement ends at cursor row, at cursor column in INSERT mode', function() - insert([[ + it( + 'adjusts cursor column if replacement ends at cursor row, at cursor column in INSERT mode', + function() + insert([[ This should be first then there is a line we do not want and finally the last one]]) - -- position the cursor on 'y' at 'finally' - curwin('set_cursor', {3, 10}) - -- enter INSERT mode to treat cursor as being between 'l' and 'y' - feed('i') - set_text(0, 15, 2, 11, { '1', 'this 2', 'and then' }) + -- position the cursor on 'y' at 'finally' + curwin('set_cursor', { 3, 10 }) + -- enter INSERT mode to treat cursor as being between 'l' and 'y' + feed('i') + set_text(0, 15, 2, 11, { '1', 'this 2', 'and then' }) - eq({ - 'This should be 1', - 'this 2', - 'and then the last one', - }, get_lines(0, -1, true)) - -- cursor should end up after 'n' in 'then' - eq({3, 8}, curwin('get_cursor')) - end) + eq({ + 'This should be 1', + 'this 2', + 'and then the last one', + }, get_lines(0, -1, true)) + -- cursor should end up after 'n' in 'then' + eq({ 3, 8 }, curwin('get_cursor')) + end + ) it('adjusts cursor column if replacement is inside of a single line', function() insert([[ @@ -1177,7 +1211,7 @@ describe('api/buf', function() and finally the last one]]) -- position the cursor on 'y' in 'finally' - curwin('set_cursor', {3, 10}) + curwin('set_cursor', { 3, 10 }) set_text(2, 4, 2, 11, { 'then' }) eq({ @@ -1186,7 +1220,7 @@ describe('api/buf', function() 'and then the last one', }, get_lines(0, -1, true)) -- cursor should end up on 'n' in 'then' - eq({3, 7}, curwin('get_cursor')) + eq({ 3, 7 }, curwin('get_cursor')) end) it('does not move cursor column after end of a line', function() @@ -1195,7 +1229,7 @@ describe('api/buf', function() !!!]]) -- position cursor on the last '1' - curwin('set_cursor', {2, 2}) + curwin('set_cursor', { 2, 2 }) local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 33, 1, 3, {}) @@ -1204,16 +1238,16 @@ describe('api/buf', function() eq({ 'This should be the only line here' }, get_lines(0, -1, true)) -- cursor should end up on '!' - eq({1, 32}, curwin('get_cursor')) + eq({ 1, 32 }, curwin('get_cursor')) -- immediate call to nvim_win_get_cursor should have returned the same position - eq({1, 32}, cursor) + eq({ 1, 32 }, cursor) end) it('does not move cursor column before start of a line', function() insert('\n!!!') -- position cursor on the last '1' - curwin('set_cursor', {2, 2}) + curwin('set_cursor', { 2, 2 }) local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 0, 1, 3, {}) @@ -1222,20 +1256,20 @@ describe('api/buf', function() eq({ '' }, get_lines(0, -1, true)) -- cursor should end up on '!' - eq({1, 0}, curwin('get_cursor')) + eq({ 1, 0 }, curwin('get_cursor')) -- immediate call to nvim_win_get_cursor should have returned the same position - eq({1, 0}, cursor) + eq({ 1, 0 }, cursor) end) describe('with virtualedit', function() - it('adjusts cursor line and column to keep it inside replacement range if cursor is not after eol', function() + it('adjusts cursor line/col to keep inside replacement range if not after eol', function() insert([[ This should be first then there is a line we do not want and finally the last one]]) -- position cursor on 't' in 'want' - curwin('set_cursor', {2, 34}) + curwin('set_cursor', { 2, 34 }) -- turn on virtualedit command('set virtualedit=all') @@ -1253,23 +1287,26 @@ describe('api/buf', function() }, get_lines(0, -1, true)) -- cursor should end up on 'y' in 'hopefully' -- to stay in the range - eq({2, 12}, curwin('get_cursor')) + eq({ 2, 12 }, curwin('get_cursor')) -- immediate call to nvim_win_get_cursor should have returned the same position - eq({2, 12}, cursor) + eq({ 2, 12 }, cursor) -- coladd should be 0 - eq(0, exec_lua([[ + eq( + 0, + exec_lua([[ return vim.fn.winsaveview().coladd - ]])) + ]]) + ) end) - it('does not change cursor screen column when cursor is after eol and row got shorter', function() + it('does not change cursor screen column when cursor >EOL and row got shorter', function() insert([[ This should be first then there is a line we do not want and finally the last one]]) -- position cursor on 't' in 'want' - curwin('set_cursor', {2, 34}) + curwin('set_cursor', { 2, 34 }) -- turn on virtualedit command('set virtualedit=all') -- move cursor after eol @@ -1290,31 +1327,36 @@ describe('api/buf', function() 'but hopefully the last one', }, get_lines(0, -1, true)) -- cursor should end up at eol of a new row - eq({2, 26}, curwin('get_cursor')) + eq({ 2, 26 }, curwin('get_cursor')) -- immediate call to nvim_win_get_cursor should have returned the same position - eq({2, 26}, cursor) + eq({ 2, 26 }, cursor) -- coladd should be increased so that cursor stays in the same screen column - eq(13, exec_lua([[ + eq( + 13, + exec_lua([[ return vim.fn.winsaveview().coladd - ]])) + ]]) + ) end) - it('does not change cursor screen column when cursor is after eol and row got longer', function() - insert([[ + it( + 'does not change cursor screen column when cursor is after eol and row got longer', + function() + insert([[ This should be first then there is a line we do not want and finally the last one]]) - -- position cursor on 't' in 'first' - curwin('set_cursor', {1, 19}) - -- turn on virtualedit - command('set virtualedit=all') - -- move cursor after eol - exec_lua([[ + -- position cursor on 't' in 'first' + curwin('set_cursor', { 1, 19 }) + -- turn on virtualedit + command('set virtualedit=all') + -- move cursor after eol + exec_lua([[ vim.fn.winrestview({ coladd = 21 }) ]]) - local cursor = exec_lua([[ + local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 15, 2, 11, { 'the line we do not want', 'but hopefully', @@ -1322,36 +1364,42 @@ describe('api/buf', function() return vim.api.nvim_win_get_cursor(0) ]]) - eq({ - 'This should be the line we do not want', - 'but hopefully the last one', - }, get_lines(0, -1, true)) - -- cursor should end up at eol of a new row - eq({1, 38}, curwin('get_cursor')) - -- immediate call to nvim_win_get_cursor should have returned the same position - eq({1, 38}, cursor) - -- coladd should be increased so that cursor stays in the same screen column - eq(2, exec_lua([[ + eq({ + 'This should be the line we do not want', + 'but hopefully the last one', + }, get_lines(0, -1, true)) + -- cursor should end up at eol of a new row + eq({ 1, 38 }, curwin('get_cursor')) + -- immediate call to nvim_win_get_cursor should have returned the same position + eq({ 1, 38 }, cursor) + -- coladd should be increased so that cursor stays in the same screen column + eq( + 2, + exec_lua([[ return vim.fn.winsaveview().coladd - ]])) - end) + ]]) + ) + end + ) - it('does not change cursor screen column when cursor is after eol and row extended past cursor column', function() - insert([[ + it( + 'does not change cursor screen column when cursor is after eol and row extended past cursor column', + function() + insert([[ This should be first then there is a line we do not want and finally the last one]]) - -- position cursor on 't' in 'first' - curwin('set_cursor', {1, 19}) - -- turn on virtualedit - command('set virtualedit=all') - -- move cursor after eol just a bit - exec_lua([[ + -- position cursor on 't' in 'first' + curwin('set_cursor', { 1, 19 }) + -- turn on virtualedit + command('set virtualedit=all') + -- move cursor after eol just a bit + exec_lua([[ vim.fn.winrestview({ coladd = 3 }) ]]) - local cursor = exec_lua([[ + local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 15, 2, 11, { 'the line we do not want', 'but hopefully', @@ -1359,37 +1407,43 @@ describe('api/buf', function() return vim.api.nvim_win_get_cursor(0) ]]) - eq({ - 'This should be the line we do not want', - 'but hopefully the last one', - }, get_lines(0, -1, true)) - -- cursor should stay at the same screen column - eq({1, 22}, curwin('get_cursor')) - -- immediate call to nvim_win_get_cursor should have returned the same position - eq({1, 22}, cursor) - -- coladd should become 0 - eq(0, exec_lua([[ + eq({ + 'This should be the line we do not want', + 'but hopefully the last one', + }, get_lines(0, -1, true)) + -- cursor should stay at the same screen column + eq({ 1, 22 }, curwin('get_cursor')) + -- immediate call to nvim_win_get_cursor should have returned the same position + eq({ 1, 22 }, cursor) + -- coladd should become 0 + eq( + 0, + exec_lua([[ return vim.fn.winsaveview().coladd - ]])) - end) + ]]) + ) + end + ) - it('does not change cursor screen column when cursor is after eol and row range decreased', function() - insert([[ + it( + 'does not change cursor screen column when cursor is after eol and row range decreased', + function() + insert([[ This should be first then there is a line we do not want and one more and finally the last one]]) - -- position cursor on 'e' in 'more' - curwin('set_cursor', {3, 11}) - -- turn on virtualedit - command('set virtualedit=all') - -- move cursor after eol - exec_lua([[ + -- position cursor on 'e' in 'more' + curwin('set_cursor', { 3, 11 }) + -- turn on virtualedit + command('set virtualedit=all') + -- move cursor after eol + exec_lua([[ vim.fn.winrestview({ coladd = 28 }) ]]) - local cursor = exec_lua([[ + local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 15, 3, 11, { 'the line we do not want', 'but hopefully', @@ -1397,19 +1451,23 @@ describe('api/buf', function() return vim.api.nvim_win_get_cursor(0) ]]) - eq({ - 'This should be the line we do not want', - 'but hopefully the last one', - }, get_lines(0, -1, true)) - -- cursor should end up at eol of a new row - eq({2, 26}, curwin('get_cursor')) - -- immediate call to nvim_win_get_cursor should have returned the same position - eq({2, 26}, cursor) - -- coladd should be increased so that cursor stays in the same screen column - eq(13, exec_lua([[ + eq({ + 'This should be the line we do not want', + 'but hopefully the last one', + }, get_lines(0, -1, true)) + -- cursor should end up at eol of a new row + eq({ 2, 26 }, curwin('get_cursor')) + -- immediate call to nvim_win_get_cursor should have returned the same position + eq({ 2, 26 }, cursor) + -- coladd should be increased so that cursor stays in the same screen column + eq( + 13, + exec_lua([[ return vim.fn.winsaveview().coladd - ]])) - end) + ]]) + ) + end + ) end) end) @@ -1421,80 +1479,86 @@ describe('api/buf', function() line]]) -- position the cursor on 'i' - curwin('set_cursor', {3, 2}) + curwin('set_cursor', { 3, 2 }) set_text(1, 6, 2, 0, {}) - eq({'first line', 'second line'}, get_lines(0, -1, true)) + eq({ 'first line', 'second line' }, get_lines(0, -1, true)) -- cursor should stay on 'i' - eq({2, 8}, curwin('get_cursor')) + eq({ 2, 8 }, curwin('get_cursor')) -- add a newline back - set_text(1, 6, 1, 6, {'', ''}) - eq({'first line', 'second', ' line'}, get_lines(0, -1, true)) + set_text(1, 6, 1, 6, { '', '' }) + eq({ 'first line', 'second', ' line' }, get_lines(0, -1, true)) -- cursor should return back to the original position - eq({3, 2}, curwin('get_cursor')) + eq({ 3, 2 }, curwin('get_cursor')) end) - it('adjusts cursor column if the range is not bound to either start or end of a line', function() - insert([[ + it( + 'adjusts cursor column if the range is not bound to either start or end of a line', + function() + insert([[ This should be first then there is a line we do not want and finally the last one]]) - -- position the cursor on 'h' in 'the' - curwin('set_cursor', {3, 13}) - set_text(0, 14, 2, 11, {}) - eq({'This should be the last one'}, get_lines(0, -1, true)) - -- cursor should stay on 'h' - eq({1, 16}, curwin('get_cursor')) - -- add deleted lines back - set_text(0, 14, 0, 14, { - ' first', - 'then there is a line we do not want', - 'and finally', - }) - eq({ - 'This should be first', - 'then there is a line we do not want', - 'and finally the last one', - }, get_lines(0, -1, true)) - -- cursor should return back to the original position - eq({3, 13}, curwin('get_cursor')) - end) + -- position the cursor on 'h' in 'the' + curwin('set_cursor', { 3, 13 }) + set_text(0, 14, 2, 11, {}) + eq({ 'This should be the last one' }, get_lines(0, -1, true)) + -- cursor should stay on 'h' + eq({ 1, 16 }, curwin('get_cursor')) + -- add deleted lines back + set_text(0, 14, 0, 14, { + ' first', + 'then there is a line we do not want', + 'and finally', + }) + eq({ + 'This should be first', + 'then there is a line we do not want', + 'and finally the last one', + }, get_lines(0, -1, true)) + -- cursor should return back to the original position + eq({ 3, 13 }, curwin('get_cursor')) + end + ) - it('adjusts cursor column if replacing lines in range, not just deleting and adding', function() - insert([[ + it( + 'adjusts cursor column if replacing lines in range, not just deleting and adding', + function() + insert([[ This should be first then there is a line we do not want and finally the last one]]) - -- position the cursor on 's' in 'last' - curwin('set_cursor', {3, 18}) - set_text(0, 15, 2, 11, { - 'the line we do not want', - 'but hopefully', - }) + -- position the cursor on 's' in 'last' + curwin('set_cursor', { 3, 18 }) + set_text(0, 15, 2, 11, { + 'the line we do not want', + 'but hopefully', + }) - eq({ - 'This should be the line we do not want', - 'but hopefully the last one', - }, get_lines(0, -1, true)) - -- cursor should stay on 's' - eq({2, 20}, curwin('get_cursor')) + eq({ + 'This should be the line we do not want', + 'but hopefully the last one', + }, get_lines(0, -1, true)) + -- cursor should stay on 's' + eq({ 2, 20 }, curwin('get_cursor')) - set_text(0, 15, 1, 13, { - 'first', - 'then there is a line we do not want', - 'and finally', - }) + set_text(0, 15, 1, 13, { + 'first', + 'then there is a line we do not want', + 'and finally', + }) - eq({ - 'This should be first', - 'then there is a line we do not want', - 'and finally the last one', - }, get_lines(0, -1, true)) - -- cursor should return back to the original position - eq({3, 18}, curwin('get_cursor')) - end) + eq({ + 'This should be first', + 'then there is a line we do not want', + 'and finally the last one', + }, get_lines(0, -1, true)) + -- cursor should return back to the original position + eq({ 3, 18 }, curwin('get_cursor')) + end + ) it('does not move cursor column after end of a line', function() insert([[ @@ -1502,7 +1566,7 @@ describe('api/buf', function() ]]) -- position cursor at the empty line - curwin('set_cursor', {2, 0}) + curwin('set_cursor', { 2, 0 }) local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 33, 1, 0, {'!'}) @@ -1511,9 +1575,9 @@ describe('api/buf', function() eq({ 'This should be the only line here!' }, get_lines(0, -1, true)) -- cursor should end up on '!' - eq({1, 33}, curwin('get_cursor')) + eq({ 1, 33 }, curwin('get_cursor')) -- immediate call to nvim_win_get_cursor should have returned the same position - eq({1, 33}, cursor) + eq({ 1, 33 }, cursor) end) it('does not move cursor column before start of a line', function() @@ -1522,7 +1586,7 @@ describe('api/buf', function() eq({ '', '' }, get_lines(0, -1, true)) -- position cursor on the last '1' - curwin('set_cursor', {2, 2}) + curwin('set_cursor', { 2, 2 }) local cursor = exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 0, 1, 0, {''}) @@ -1531,19 +1595,19 @@ describe('api/buf', function() eq({ '' }, get_lines(0, -1, true)) -- cursor should end up on '!' - eq({1, 0}, curwin('get_cursor')) + eq({ 1, 0 }, curwin('get_cursor')) -- immediate call to nvim_win_get_cursor should have returned the same position - eq({1, 0}, cursor) + eq({ 1, 0 }, cursor) end) end) it('can handle NULs', function() - set_text(0, 0, 0, 0, {'ab\0cd'}) + set_text(0, 0, 0, 0, { 'ab\0cd' }) eq('ab\0cd', curbuf_depr('get_line', 0)) end) it('adjusts extmarks', function() - local ns = request('nvim_create_namespace', "my-fancy-plugin") + local ns = request('nvim_create_namespace', 'my-fancy-plugin') insert([[ foo bar baz @@ -1551,41 +1615,41 @@ describe('api/buf', function() local id1 = curbufmeths.set_extmark(ns, 0, 1, {}) local id2 = curbufmeths.set_extmark(ns, 0, 7, {}) local id3 = curbufmeths.set_extmark(ns, 1, 1, {}) - set_text(0, 4, 0, 7, {"q"}) + set_text(0, 4, 0, 7, { 'q' }) - eq({'foo q', 'baz'}, get_lines(0, 2, true)) + eq({ 'foo q', 'baz' }, get_lines(0, 2, true)) -- mark before replacement point is unaffected - eq({0, 1}, curbufmeths.get_extmark_by_id(ns, id1, {})) + eq({ 0, 1 }, curbufmeths.get_extmark_by_id(ns, id1, {})) -- mark gets shifted back because the replacement was shorter - eq({0, 5}, curbufmeths.get_extmark_by_id(ns, id2, {})) + eq({ 0, 5 }, curbufmeths.get_extmark_by_id(ns, id2, {})) -- mark on the next line is unaffected - eq({1, 1}, curbufmeths.get_extmark_by_id(ns, id3, {})) + eq({ 1, 1 }, curbufmeths.get_extmark_by_id(ns, id3, {})) -- replacing the text spanning two lines will adjust the mark on the next line - set_text(0, 3, 1, 3, {"qux"}) - eq({'fooqux', ''}, get_lines(0, 2, true)) - eq({0, 6}, curbufmeths.get_extmark_by_id(ns, id3, {})) + set_text(0, 3, 1, 3, { 'qux' }) + eq({ 'fooqux', '' }, get_lines(0, 2, true)) + eq({ 0, 6 }, curbufmeths.get_extmark_by_id(ns, id3, {})) -- but mark before replacement point is still unaffected - eq({0, 1}, curbufmeths.get_extmark_by_id(ns, id1, {})) + eq({ 0, 1 }, curbufmeths.get_extmark_by_id(ns, id1, {})) -- and the mark in the middle was shifted to the end of the insertion - eq({0, 6}, curbufmeths.get_extmark_by_id(ns, id2, {})) + eq({ 0, 6 }, curbufmeths.get_extmark_by_id(ns, id2, {})) -- marks should be put back into the same place after undoing - set_text(0, 0, 0, 2, {''}) + set_text(0, 0, 0, 2, { '' }) feed('u') - eq({0, 1}, curbufmeths.get_extmark_by_id(ns, id1, {})) - eq({0, 6}, curbufmeths.get_extmark_by_id(ns, id2, {})) - eq({0, 6}, curbufmeths.get_extmark_by_id(ns, id3, {})) + eq({ 0, 1 }, curbufmeths.get_extmark_by_id(ns, id1, {})) + eq({ 0, 6 }, curbufmeths.get_extmark_by_id(ns, id2, {})) + eq({ 0, 6 }, curbufmeths.get_extmark_by_id(ns, id3, {})) -- marks should be shifted over by the correct number of bytes for multibyte -- chars - set_text(0, 0, 0, 0, {'Ø'}) - eq({0, 3}, curbufmeths.get_extmark_by_id(ns, id1, {})) - eq({0, 8}, curbufmeths.get_extmark_by_id(ns, id2, {})) - eq({0, 8}, curbufmeths.get_extmark_by_id(ns, id3, {})) + set_text(0, 0, 0, 0, { 'Ø' }) + eq({ 0, 3 }, curbufmeths.get_extmark_by_id(ns, id1, {})) + eq({ 0, 8 }, curbufmeths.get_extmark_by_id(ns, id2, {})) + eq({ 0, 8 }, curbufmeths.get_extmark_by_id(ns, id3, {})) end) - it("correctly marks changed region for redraw #13890", function() + it('correctly marks changed region for redraw #13890', function() local screen = Screen.new(20, 5) screen:attach() @@ -1594,7 +1658,7 @@ describe('api/buf', function() BBB ]]) - curbufmeths.set_text(0, 0, 1, 3, {'XXX', 'YYY'}) + curbufmeths.set_text(0, 0, 1, 3, { 'XXX', 'YYY' }) screen:expect([[ XXX | @@ -1627,14 +1691,14 @@ describe('api/buf', function() end) it('no heap-use-after-free when called consecutively #19643', function() - set_text(0, 0, 0, 0, {'one', '', '', 'two'}) - eq({'one', '', '', 'two'}, get_lines(0, 4, true)) - meths.win_set_cursor(0, {1, 0}) + set_text(0, 0, 0, 0, { 'one', '', '', 'two' }) + eq({ 'one', '', '', 'two' }, get_lines(0, 4, true)) + meths.win_set_cursor(0, { 1, 0 }) exec_lua([[ vim.api.nvim_buf_set_text(0, 0, 3, 1, 0, {''}) vim.api.nvim_buf_set_text(0, 0, 3, 1, 0, {''}) ]]) - eq({'one', 'two'}, get_lines(0, 2, true)) + eq({ 'one', 'two' }, get_lines(0, 2, true)) end) describe('handles topline', function() @@ -1642,12 +1706,12 @@ describe('api/buf', function() before_each(function() screen = Screen.new(20, 12) screen:set_default_attr_ids { - [1] = {bold = true, foreground = Screen.colors.Blue1}; - [2] = {reverse = true, bold = true}; - [3] = {reverse = true}; + [1] = { bold = true, foreground = Screen.colors.Blue1 }, + [2] = { reverse = true, bold = true }, + [3] = { reverse = true }, } screen:attach() - meths.buf_set_lines(0, 0, -1, 1, {"aaa", "bbb", "ccc", "ddd", "www", "xxx", "yyy", "zzz"}) + meths.buf_set_lines(0, 0, -1, 1, { 'aaa', 'bbb', 'ccc', 'ddd', 'www', 'xxx', 'yyy', 'zzz' }) meths.set_option_value('modified', false, {}) end) @@ -1656,9 +1720,10 @@ describe('api/buf', function() local buf = meths.get_current_buf() command('new | wincmd w') - meths.win_set_cursor(win, {8,0}) + meths.win_set_cursor(win, { 8, 0 }) - screen:expect{grid=[[ + screen:expect { + grid = [[ | {1:~ }|*4 {3:[No Name] }| @@ -1668,10 +1733,12 @@ describe('api/buf', function() ^zzz | {2:[No Name] }| | - ]]} - meths.buf_set_text(buf, 0,3, 1,0, {"X"}) + ]], + } + meths.buf_set_text(buf, 0, 3, 1, 0, { 'X' }) - screen:expect{grid=[[ + screen:expect { + grid = [[ | {1:~ }|*4 {3:[No Name] }| @@ -1681,7 +1748,8 @@ describe('api/buf', function() ^zzz | {2:[No Name] [+] }| | - ]]} + ]], + } end) it('of non-current window', function() @@ -1689,9 +1757,10 @@ describe('api/buf', function() local buf = meths.get_current_buf() command('new') - meths.win_set_cursor(win, {8,0}) + meths.win_set_cursor(win, { 8, 0 }) - screen:expect{grid=[[ + screen:expect { + grid = [[ ^ | {1:~ }|*4 {2:[No Name] }| @@ -1701,10 +1770,12 @@ describe('api/buf', function() zzz | {3:[No Name] }| | - ]]} + ]], + } - meths.buf_set_text(buf, 0,3, 1,0, {"X"}) - screen:expect{grid=[[ + meths.buf_set_text(buf, 0, 3, 1, 0, { 'X' }) + screen:expect { + grid = [[ ^ | {1:~ }|*4 {2:[No Name] }| @@ -1714,7 +1785,8 @@ describe('api/buf', function() zzz | {3:[No Name] [+] }| | - ]]} + ]], + } end) it('of split windows with same buffer', function() @@ -1722,10 +1794,11 @@ describe('api/buf', function() local buf = meths.get_current_buf() command('split') - meths.win_set_cursor(win, {8,0}) - meths.win_set_cursor(0, {1,1}) + meths.win_set_cursor(win, { 8, 0 }) + meths.win_set_cursor(0, { 1, 1 }) - screen:expect{grid=[[ + screen:expect { + grid = [[ a^aa | bbb | ccc | @@ -1738,10 +1811,12 @@ describe('api/buf', function() zzz | {3:[No Name] }| | - ]]} - meths.buf_set_text(buf, 0,3, 1,0, {"X"}) + ]], + } + meths.buf_set_text(buf, 0, 3, 1, 0, { 'X' }) - screen:expect{grid=[[ + screen:expect { + grid = [[ a^aaXbbb | ccc | ddd | @@ -1754,7 +1829,8 @@ describe('api/buf', function() zzz | {3:[No Name] [+] }| | - ]]} + ]], + } end) end) end) @@ -1769,14 +1845,14 @@ describe('api/buf', function() end) it('works', function() - eq({'hello'}, get_text(0, 0, 0, 5, {})) - eq({'hello foo!'}, get_text(0, 0, 0, 42, {})) - eq({'foo!'}, get_text(0, 6, 0, 10, {})) - eq({'foo!', 'tex'}, get_text(0, 6, 1, 3, {})) - eq({'foo!', 'tex'}, get_text(-3, 6, -2, 3, {})) - eq({''}, get_text(0, 18, 0, 20, {})) - eq({'ext'}, get_text(-2, 1, -2, 4, {})) - eq({'hello foo!', 'text', 'm'}, get_text(0, 0, 2, 1, {})) + eq({ 'hello' }, get_text(0, 0, 0, 5, {})) + eq({ 'hello foo!' }, get_text(0, 0, 0, 42, {})) + eq({ 'foo!' }, get_text(0, 6, 0, 10, {})) + eq({ 'foo!', 'tex' }, get_text(0, 6, 1, 3, {})) + eq({ 'foo!', 'tex' }, get_text(-3, 6, -2, 3, {})) + eq({ '' }, get_text(0, 18, 0, 20, {})) + eq({ 'ext' }, get_text(-2, 1, -2, 4, {})) + eq({ 'hello foo!', 'text', 'm' }, get_text(0, 0, 2, 1, {})) end) it('errors on out-of-range', function() @@ -1797,7 +1873,7 @@ describe('api/buf', function() describe('nvim_buf_get_offset', function() local get_offset = curbufmeths.get_offset it('works', function() - curbufmeths.set_lines(0,-1,true,{'Some\r','exa\000mple', '', 'buf\rfer', 'text'}) + curbufmeths.set_lines(0, -1, true, { 'Some\r', 'exa\000mple', '', 'buf\rfer', 'text' }) eq(5, curbufmeths.line_count()) eq(0, get_offset(0)) eq(6, get_offset(1)) @@ -1823,12 +1899,12 @@ describe('api/buf', function() meths.set_option_value('eol', true, {}) eq(29, get_offset(5)) - command("set hidden") - command("enew") - eq(6, bufmeths.get_offset(1,1)) - command("bunload! 1") - eq(-1, bufmeths.get_offset(1,1)) - eq(-1, bufmeths.get_offset(1,0)) + command('set hidden') + command('enew') + eq(6, bufmeths.get_offset(1, 1)) + command('bunload! 1') + eq(-1, bufmeths.get_offset(1, 1)) + eq(-1, bufmeths.get_offset(1, 0)) end) it('works in empty buffer', function() @@ -1846,43 +1922,41 @@ describe('api/buf', function() describe('nvim_buf_get_var, nvim_buf_set_var, nvim_buf_del_var', function() it('works', function() - curbuf('set_var', 'lua', {1, 2, {['3'] = 1}}) - eq({1, 2, {['3'] = 1}}, curbuf('get_var', 'lua')) - eq({1, 2, {['3'] = 1}}, nvim('eval', 'b:lua')) + curbuf('set_var', 'lua', { 1, 2, { ['3'] = 1 } }) + eq({ 1, 2, { ['3'] = 1 } }, curbuf('get_var', 'lua')) + eq({ 1, 2, { ['3'] = 1 } }, nvim('eval', 'b:lua')) eq(1, funcs.exists('b:lua')) curbufmeths.del_var('lua') eq(0, funcs.exists('b:lua')) - eq( 'Key not found: lua', pcall_err(curbufmeths.del_var, 'lua')) + eq('Key not found: lua', pcall_err(curbufmeths.del_var, 'lua')) curbufmeths.set_var('lua', 1) command('lockvar b:lua') eq('Key is locked: lua', pcall_err(curbufmeths.del_var, 'lua')) eq('Key is locked: lua', pcall_err(curbufmeths.set_var, 'lua', 1)) - eq('Key is read-only: changedtick', - pcall_err(curbufmeths.del_var, 'changedtick')) - eq('Key is read-only: changedtick', - pcall_err(curbufmeths.set_var, 'changedtick', 1)) + eq('Key is read-only: changedtick', pcall_err(curbufmeths.del_var, 'changedtick')) + eq('Key is read-only: changedtick', pcall_err(curbufmeths.set_var, 'changedtick', 1)) end) end) describe('nvim_buf_get_changedtick', function() it('works', function() eq(2, curbufmeths.get_changedtick()) - curbufmeths.set_lines(0, 1, false, {'abc\0', '\0def', 'ghi'}) + curbufmeths.set_lines(0, 1, false, { 'abc\0', '\0def', 'ghi' }) eq(3, curbufmeths.get_changedtick()) eq(3, curbufmeths.get_var('changedtick')) end) it('buffer_set_var returns the old value', function() - local val1 = {1, 2, {['3'] = 1}} - local val2 = {4, 7} + local val1 = { 1, 2, { ['3'] = 1 } } + local val2 = { 4, 7 } eq(NIL, request('buffer_set_var', 0, 'lua', val1)) eq(val1, request('buffer_set_var', 0, 'lua', val2)) end) it('buffer_del_var returns the old value', function() - local val1 = {1, 2, {['3'] = 1}} - local val2 = {4, 7} - eq(NIL, request('buffer_set_var', 0, 'lua', val1)) + local val1 = { 1, 2, { ['3'] = 1 } } + local val2 = { 4, 7 } + eq(NIL, request('buffer_set_var', 0, 'lua', val1)) eq(val1, request('buffer_set_var', 0, 'lua', val2)) eq(val2, request('buffer_del_var', 0, 'lua')) end) @@ -1894,17 +1968,17 @@ describe('api/buf', function() nvim('set_option_value', 'shiftwidth', 4, {}) eq(4, nvim('get_option_value', 'shiftwidth', {})) -- global-local option - nvim('set_option_value', 'define', 'test', {buf = 0}) - eq('test', nvim('get_option_value', 'define', {buf = 0})) + nvim('set_option_value', 'define', 'test', { buf = 0 }) + eq('test', nvim('get_option_value', 'define', { buf = 0 })) -- Doesn't change the global value - eq("", nvim('get_option_value', 'define', {scope='global'})) + eq('', nvim('get_option_value', 'define', { scope = 'global' })) end) it('returns values for unset local options', function() -- 'undolevels' is only set to its "unset" value when a new buffer is -- created command('enew') - eq(-123456, nvim('get_option_value', 'undolevels', {buf=0})) + eq(-123456, nvim('get_option_value', 'undolevels', { buf = 0 })) end) end) @@ -1929,17 +2003,17 @@ describe('api/buf', function() ok(buffer('is_loaded', bufnr)) -- hide the current buffer by switching to a new empty buffer -- Careful! we need to modify the buffer first or vim will just reuse it - buffer('set_lines', bufnr, 0, -1, 1, {'line1'}) + buffer('set_lines', bufnr, 0, -1, 1, { 'line1' }) command('hide enew') -- confirm the buffer is hidden, but still loaded - local infolist = nvim('eval', 'getbufinfo('..bufnr..')') + local infolist = nvim('eval', 'getbufinfo(' .. bufnr .. ')') eq(1, #infolist) eq(1, infolist[1].hidden) eq(1, infolist[1].loaded) -- now force unload the buffer - command('bunload! '..bufnr) + command('bunload! ' .. bufnr) -- confirm the buffer is unloaded - infolist = nvim('eval', 'getbufinfo('..bufnr..')') + infolist = nvim('eval', 'getbufinfo(' .. bufnr .. ')') eq(0, infolist[1].loaded) -- nvim_buf_is_loaded() should also report the buffer as unloaded eq(false, buffer('is_loaded', bufnr)) @@ -1978,25 +2052,25 @@ describe('api/buf', function() describe('nvim_buf_get_mark', function() it('works', function() - curbuf('set_lines', -1, -1, true, {'a', 'bit of', 'text'}) - curwin('set_cursor', {3, 4}) + curbuf('set_lines', -1, -1, true, { 'a', 'bit of', 'text' }) + curwin('set_cursor', { 3, 4 }) nvim('command', 'mark v') - eq({3, 0}, curbuf('get_mark', 'v')) + eq({ 3, 0 }, curbuf('get_mark', 'v')) end) end) describe('nvim_buf_set_mark', function() it('works with buffer local marks', function() - curbufmeths.set_lines(-1, -1, true, {'a', 'bit of', 'text'}) + curbufmeths.set_lines(-1, -1, true, { 'a', 'bit of', 'text' }) eq(true, curbufmeths.set_mark('z', 1, 1, {})) - eq({1, 1}, curbufmeths.get_mark('z')) - eq({0, 1, 2, 0}, funcs.getpos("'z")) + eq({ 1, 1 }, curbufmeths.get_mark('z')) + eq({ 0, 1, 2, 0 }, funcs.getpos("'z")) end) it('works with file/uppercase marks', function() - curbufmeths.set_lines(-1, -1, true, {'a', 'bit of', 'text'}) + curbufmeths.set_lines(-1, -1, true, { 'a', 'bit of', 'text' }) eq(true, curbufmeths.set_mark('Z', 3, 2, {})) - eq({3, 2}, curbufmeths.get_mark('Z')) - eq({curbuf().id, 3, 3, 0}, funcs.getpos("'Z")) + eq({ 3, 2 }, curbufmeths.get_mark('Z')) + eq({ curbuf().id, 3, 3, 0 }, funcs.getpos("'Z")) end) it('fails when invalid marks names are used', function() eq(false, pcall(curbufmeths.set_mark, '!', 1, 0, {})) @@ -2009,29 +2083,29 @@ describe('api/buf', function() describe('nvim_buf_del_mark', function() it('works with buffer local marks', function() - curbufmeths.set_lines(-1, -1, true, {'a', 'bit of', 'text'}) + curbufmeths.set_lines(-1, -1, true, { 'a', 'bit of', 'text' }) curbufmeths.set_mark('z', 3, 1, {}) eq(true, curbufmeths.del_mark('z')) - eq({0, 0}, curbufmeths.get_mark('z')) + eq({ 0, 0 }, curbufmeths.get_mark('z')) end) it('works with file/uppercase marks', function() - curbufmeths.set_lines(-1, -1, true, {'a', 'bit of', 'text'}) + curbufmeths.set_lines(-1, -1, true, { 'a', 'bit of', 'text' }) curbufmeths.set_mark('Z', 3, 3, {}) eq(true, curbufmeths.del_mark('Z')) - eq({0, 0}, curbufmeths.get_mark('Z')) + eq({ 0, 0 }, curbufmeths.get_mark('Z')) end) it('returns false in marks not set in this buffer', function() - local abuf = meths.create_buf(false,true) - bufmeths.set_lines(abuf, -1, -1, true, {'a', 'bit of', 'text'}) + local abuf = meths.create_buf(false, true) + bufmeths.set_lines(abuf, -1, -1, true, { 'a', 'bit of', 'text' }) bufmeths.set_mark(abuf, 'A', 2, 2, {}) eq(false, curbufmeths.del_mark('A')) - eq({2, 2}, bufmeths.get_mark(abuf, 'A')) + eq({ 2, 2 }, bufmeths.get_mark(abuf, 'A')) end) it('returns false if mark was not deleted', function() - curbufmeths.set_lines(-1, -1, true, {'a', 'bit of', 'text'}) + curbufmeths.set_lines(-1, -1, true, { 'a', 'bit of', 'text' }) curbufmeths.set_mark('z', 3, 1, {}) eq(true, curbufmeths.del_mark('z')) - eq(false, curbufmeths.del_mark('z')) -- Mark was already deleted + eq(false, curbufmeths.del_mark('z')) -- Mark was already deleted end) it('fails when invalid marks names are used', function() eq(false, pcall(curbufmeths.del_mark, '!')) diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua index 104ffd7d6c..ce2838879b 100644 --- a/test/functional/api/vim_spec.lua +++ b/test/functional/api/vim_spec.lua @@ -3,6 +3,7 @@ local Screen = require('test.functional.ui.screen') local luv = require('luv') local fmt = string.format +local dedent = helpers.dedent local assert_alive = helpers.assert_alive local NIL = helpers.NIL local clear, nvim, eq, neq = helpers.clear, helpers.nvim, helpers.eq, helpers.neq @@ -41,32 +42,41 @@ describe('API', function() it('validates requests', function() -- RPC - matches('Invalid method: bogus$', - pcall_err(request, 'bogus')) - matches('Invalid method: … の り 。…$', - pcall_err(request, '… の り 。…')) - matches('Invalid method: $', - pcall_err(request, '')) + matches('Invalid method: bogus$', pcall_err(request, 'bogus')) + matches('Invalid method: … の り 。…$', pcall_err(request, '… の り 。…')) + matches('Invalid method: $', pcall_err(request, '')) -- Non-RPC: rpcrequest(v:servername) uses internal channel. - matches('Invalid method: … の り 。…$', - pcall_err(request, 'nvim_eval', - [=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), '… の り 。…')]=])) - matches('Invalid method: bogus$', - pcall_err(request, 'nvim_eval', - [=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), 'bogus')]=])) + matches( + 'Invalid method: … の り 。…$', + pcall_err( + request, + 'nvim_eval', + [=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), '… の り 。…')]=] + ) + ) + matches( + 'Invalid method: bogus$', + pcall_err( + request, + 'nvim_eval', + [=[rpcrequest(sockconnect('pipe', v:servername, {'rpc':1}), 'bogus')]=] + ) + ) -- XXX: This must be the last one, else next one will fail: -- "Packer instance already working. Use another Packer ..." - matches("can't serialize object of type .$", - pcall_err(request, nil)) + matches("can't serialize object of type .$", pcall_err(request, nil)) end) it('handles errors in async requests', function() local error_types = meths.get_api_info()[2].error_types nvim_async('bogus') - eq({'notification', 'nvim_error_event', - {error_types.Exception.id, 'Invalid method: nvim_bogus'}}, next_msg()) + eq({ + 'notification', + 'nvim_error_event', + { error_types.Exception.id, 'Invalid method: nvim_bogus' }, + }, next_msg()) -- error didn't close channel. assert_alive() end) @@ -74,9 +84,11 @@ describe('API', function() it('failed async request emits nvim_error_event', function() local error_types = meths.get_api_info()[2].error_types nvim_async('command', 'bogus') - eq({'notification', 'nvim_error_event', - {error_types.Exception.id, 'Vim:E492: Not an editor command: bogus'}}, - next_msg()) + eq({ + 'notification', + 'nvim_error_event', + { error_types.Exception.id, 'Vim:E492: Not an editor command: bogus' }, + }, next_msg()) -- error didn't close channel. assert_alive() end) @@ -85,7 +97,7 @@ describe('API', function() nvim('command', 'split') nvim('command', 'autocmd WinEnter * startinsert') nvim('command', 'wincmd w') - eq({mode='i', blocking=false}, nvim("get_mode")) + eq({ mode = 'i', blocking = false }, nvim('get_mode')) end) describe('nvim_exec2', function() @@ -109,23 +121,31 @@ describe('API', function() it(':verbose set {option}?', function() nvim('exec2', 'set nowrap', { output = false }) - eq({ output = 'nowrap\n\tLast set from anonymous :source' }, - nvim('exec2', 'verbose set wrap?', { output = true })) + eq( + { output = 'nowrap\n\tLast set from anonymous :source' }, + nvim('exec2', 'verbose set wrap?', { output = true }) + ) -- Using script var to force creation of a script item - nvim('exec2', [[ + nvim( + 'exec2', + [[ let s:a = 1 set nowrap - ]], { output = false }) - eq({ output = 'nowrap\n\tLast set from anonymous :source (script id 1)' }, - nvim('exec2', 'verbose set wrap?', { output = true })) + ]], + { output = false } + ) + eq( + { output = 'nowrap\n\tLast set from anonymous :source (script id 1)' }, + nvim('exec2', 'verbose set wrap?', { output = true }) + ) end) it('multiline input', function() -- Heredoc + empty lines. nvim('exec2', "let x2 = 'a'\n", { output = false }) eq('a', nvim('get_var', 'x2')) - nvim('exec2','lua <avast_ye_hades('ahoy!') - ]], { output = true })) + ]], + { output = true } + ) + ) - eq({ output = "{'output': 'ahoy! script-scoped varrrrr'}" }, nvim('exec2', [[ + eq( + { output = "{'output': 'ahoy! script-scoped varrrrr'}" }, + nvim( + 'exec2', + [[ let s:pirate = 'script-scoped varrrrr' function! Avast_ye_hades(s) abort return a:s .. ' ' .. s:pirate endfunction echo nvim_exec2('echo Avast_ye_hades(''ahoy!'')', {'output': v:true}) - ]], { output = true })) + ]], + { output = true } + ) + ) - matches('Vim%(echo%):E121: Undefined variable: s:pirate$', - pcall_err(request, 'nvim_exec2', [[ + matches( + 'Vim%(echo%):E121: Undefined variable: s:pirate$', + pcall_err( + request, + 'nvim_exec2', + [[ let s:pirate = 'script-scoped varrrrr' call nvim_exec2('echo s:pirate', {'output': v:true}) - ]], { output = false })) + ]], + { output = false } + ) + ) -- Script items are created only on script var access - eq({ output = '1\n0' }, nvim('exec2', [[ + eq( + { output = '1\n0' }, + nvim( + 'exec2', + [[ echo expand("")->empty() let s:a = 123 echo expand("")->empty() - ]], { output = true })) + ]], + { output = true } + ) + ) - eq({ output = '1\n0' }, nvim('exec2', [[ + eq( + { output = '1\n0' }, + nvim( + 'exec2', + [[ echo expand("")->empty() function s:a() abort endfunction echo expand("")->empty() - ]], { output = true })) + ]], + { output = true } + ) + ) end) it('non-ASCII input', function() - nvim('exec2', [=[ + nvim( + 'exec2', + [=[ new exe "normal! i ax \n Ax " :%s/ax/--a1234--/g | :%s/Ax/--A1234--/g - ]=], { output = false }) + ]=], + { output = false } + ) nvim('command', '1') eq(' --a1234-- ', nvim('get_current_line')) nvim('command', '2') eq(' --A1234-- ', nvim('get_current_line')) - nvim('exec2', [[ + nvim( + 'exec2', + [[ new call setline(1,['xxx']) call feedkeys('r') call feedkeys('ñ', 'xt') - ]], { output = false }) + ]], + { output = false } + ) eq('ñxx', nvim('get_current_line')) end) it('execution error', function() - eq('nvim_exec2(): Vim:E492: Not an editor command: bogus_command', - pcall_err(request, 'nvim_exec2', 'bogus_command', {})) - eq('', nvim('eval', 'v:errmsg')) -- v:errmsg was not updated. + eq( + 'nvim_exec2(): Vim:E492: Not an editor command: bogus_command', + pcall_err(request, 'nvim_exec2', 'bogus_command', {}) + ) + eq('', nvim('eval', 'v:errmsg')) -- v:errmsg was not updated. eq('', eval('v:exception')) - eq('nvim_exec2(): Vim(buffer):E86: Buffer 23487 does not exist', - pcall_err(request, 'nvim_exec2', 'buffer 23487', {})) - eq('', eval('v:errmsg')) -- v:errmsg was not updated. + eq( + 'nvim_exec2(): Vim(buffer):E86: Buffer 23487 does not exist', + pcall_err(request, 'nvim_exec2', 'buffer 23487', {}) + ) + eq('', eval('v:errmsg')) -- v:errmsg was not updated. eq('', eval('v:exception')) end) @@ -240,7 +311,7 @@ describe('API', function() request('nvim_exec2', [[ let x2 = substitute('foo','o','X','g') let x4 = 'should be overwritten' - call nvim_exec2("source ]]..fname..[[\nlet x3 = substitute('foo','foo','set by recursive nvim_exec2','g')\nlet x5='overwritten'\nlet x4=x5\n", {'output': v:false}) + call nvim_exec2("source ]] .. fname .. [[\nlet x3 = substitute('foo','foo','set by recursive nvim_exec2','g')\nlet x5='overwritten'\nlet x4=x5\n", {'output': v:false}) ]], { output = false }) eq('set from :source file', request('nvim_get_var', 'x1')) eq('fXX', request('nvim_get_var', 'x2')) @@ -254,24 +325,38 @@ describe('API', function() local fname = tmpname() write_file(fname, 'echo "hello"\n') local sourcing_fname = tmpname() - write_file(sourcing_fname, 'call nvim_exec2("source '..fname..'", {"output": v:false})\n') + write_file(sourcing_fname, 'call nvim_exec2("source ' .. fname .. '", {"output": v:false})\n') meths.exec2('set verbose=2', { output = false }) - local traceback_output = 'line 0: sourcing "'..sourcing_fname..'"\n'.. - 'line 0: sourcing "'..fname..'"\n'.. - 'hello\n'.. - 'finished sourcing '..fname..'\n'.. - 'continuing in nvim_exec2() called at '..sourcing_fname..':1\n'.. - 'finished sourcing '..sourcing_fname..'\n'.. - 'continuing in nvim_exec2() called at nvim_exec2():0' - eq({ output = traceback_output }, - meths.exec2('call nvim_exec2("source '..sourcing_fname..'", {"output": v:false})', { output = true })) + local traceback_output = dedent([[ + line 0: sourcing "%s" + line 0: sourcing "%s" + hello + finished sourcing %s + continuing in nvim_exec2() called at %s:1 + finished sourcing %s + continuing in nvim_exec2() called at nvim_exec2():0]]):format( + sourcing_fname, + fname, + fname, + sourcing_fname, + sourcing_fname + ) + eq( + { output = traceback_output }, + meths.exec2( + 'call nvim_exec2("source ' .. sourcing_fname .. '", {"output": v:false})', + { output = true } + ) + ) os.remove(fname) os.remove(sourcing_fname) end) it('returns output', function() - eq({ output = 'this is spinal tap' }, - nvim('exec2', 'lua <]]) - screen:expect{grid=[[ + screen:expect { + grid = [[ ^ | {0:~ }|*4 15 | - ]]} + ]], + } end) end) @@ -320,7 +411,7 @@ describe('API', function() it('works', function() local fname = tmpname() nvim('command', 'new') - nvim('command', 'edit '..fname) + nvim('command', 'edit ' .. fname) nvim('command', 'normal itesting\napi') nvim('command', 'w') local f = assert(io.open(fname)) @@ -334,49 +425,49 @@ describe('API', function() end) it('Vimscript validation error: fails with specific error', function() - local status, rv = pcall(nvim, "command", "bogus_command") - eq(false, status) -- nvim_command() failed. - eq("E492:", string.match(rv, "E%d*:")) -- Vimscript error was returned. - eq('', nvim('eval', 'v:errmsg')) -- v:errmsg was not updated. + local status, rv = pcall(nvim, 'command', 'bogus_command') + eq(false, status) -- nvim_command() failed. + eq('E492:', string.match(rv, 'E%d*:')) -- Vimscript error was returned. + eq('', nvim('eval', 'v:errmsg')) -- v:errmsg was not updated. eq('', eval('v:exception')) end) it('Vimscript execution error: fails with specific error', function() - local status, rv = pcall(nvim, "command", "buffer 23487") - eq(false, status) -- nvim_command() failed. - eq("E86: Buffer 23487 does not exist", string.match(rv, "E%d*:.*")) - eq('', eval('v:errmsg')) -- v:errmsg was not updated. + local status, rv = pcall(nvim, 'command', 'buffer 23487') + eq(false, status) -- nvim_command() failed. + eq('E86: Buffer 23487 does not exist', string.match(rv, 'E%d*:.*')) + eq('', eval('v:errmsg')) -- v:errmsg was not updated. eq('', eval('v:exception')) end) it('gives E493 instead of prompting on backwards range', function() command('split') - eq('Vim(windo):E493: Backwards range given: 2,1windo echo', - pcall_err(command, '2,1windo echo')) + eq( + 'Vim(windo):E493: Backwards range given: 2,1windo echo', + pcall_err(command, '2,1windo echo') + ) end) end) describe('nvim_command_output', function() it('does not induce hit-enter prompt', function() - nvim("ui_attach", 80, 20, {}) + nvim('ui_attach', 80, 20, {}) -- Induce a hit-enter prompt use nvim_input (non-blocking). nvim('command', 'set cmdheight=1') nvim('input', [[:echo "hi\nhi2"]]) -- Verify hit-enter prompt. - eq({mode='r', blocking=true}, nvim("get_mode")) + eq({ mode = 'r', blocking = true }, nvim('get_mode')) nvim('input', [[]]) -- Verify NO hit-enter prompt. nvim('command_output', [[echo "hi\nhi2"]]) - eq({mode='n', blocking=false}, nvim("get_mode")) + eq({ mode = 'n', blocking = false }, nvim('get_mode')) end) it('captures command output', function() - eq('this is\nspinal tap', - nvim('command_output', [[echo "this is\nspinal tap"]])) - eq('no line ending!', - nvim('command_output', [[echon "no line ending!"]])) + eq('this is\nspinal tap', nvim('command_output', [[echo "this is\nspinal tap"]])) + eq('no line ending!', nvim('command_output', [[echon "no line ending!"]])) end) it('captures empty command output', function() @@ -388,49 +479,51 @@ describe('API', function() end) it('captures multiple commands', function() - eq('foo\n 1 %a "[No Name]" line 1', - nvim('command_output', 'echo "foo" | ls')) + eq( + 'foo\n 1 %a "[No Name]" line 1', + nvim('command_output', 'echo "foo" | ls') + ) end) it('captures nested execute()', function() - eq('\nnested1\nnested2\n 1 %a "[No Name]" line 1', - nvim('command_output', - [[echo execute('echo "nested1\nnested2"') | ls]])) + eq( + '\nnested1\nnested2\n 1 %a "[No Name]" line 1', + nvim('command_output', [[echo execute('echo "nested1\nnested2"') | ls]]) + ) end) it('captures nested nvim_command_output()', function() - eq('nested1\nnested2\n 1 %a "[No Name]" line 1', - nvim('command_output', - [[echo nvim_command_output('echo "nested1\nnested2"') | ls]])) + eq( + 'nested1\nnested2\n 1 %a "[No Name]" line 1', + nvim('command_output', [[echo nvim_command_output('echo "nested1\nnested2"') | ls]]) + ) end) it('returns shell |:!| output', function() local win_lf = is_os('win') and '\r' or '' - eq(':!echo foo\r\n\nfoo'..win_lf..'\n', nvim('command_output', [[!echo foo]])) + eq(':!echo foo\r\n\nfoo' .. win_lf .. '\n', nvim('command_output', [[!echo foo]])) end) it('Vimscript validation error: fails with specific error', function() - local status, rv = pcall(nvim, "command_output", "bogus commannnd") - eq(false, status) -- nvim_command_output() failed. - eq("E492: Not an editor command: bogus commannnd", - string.match(rv, "E%d*:.*")) - eq('', eval('v:errmsg')) -- v:errmsg was not updated. + local status, rv = pcall(nvim, 'command_output', 'bogus commannnd') + eq(false, status) -- nvim_command_output() failed. + eq('E492: Not an editor command: bogus commannnd', string.match(rv, 'E%d*:.*')) + eq('', eval('v:errmsg')) -- v:errmsg was not updated. -- Verify NO hit-enter prompt. - eq({mode='n', blocking=false}, nvim("get_mode")) + eq({ mode = 'n', blocking = false }, nvim('get_mode')) end) it('Vimscript execution error: fails with specific error', function() - local status, rv = pcall(nvim, "command_output", "buffer 42") - eq(false, status) -- nvim_command_output() failed. - eq("E86: Buffer 42 does not exist", string.match(rv, "E%d*:.*")) - eq('', eval('v:errmsg')) -- v:errmsg was not updated. + local status, rv = pcall(nvim, 'command_output', 'buffer 42') + eq(false, status) -- nvim_command_output() failed. + eq('E86: Buffer 42 does not exist', string.match(rv, 'E%d*:.*')) + eq('', eval('v:errmsg')) -- v:errmsg was not updated. -- Verify NO hit-enter prompt. - eq({mode='n', blocking=false}, nvim("get_mode")) + eq({ mode = 'n', blocking = false }, nvim('get_mode')) end) it('does not cause heap buffer overflow with large output', function() - eq(eval('string(range(1000000))'), - nvim('command_output', 'echo range(1000000)')) + eq(eval('string(range(1000000))'), nvim('command_output', 'echo range(1000000)')) end) end) @@ -438,22 +531,21 @@ describe('API', function() it('works', function() nvim('command', 'let g:v1 = "a"') nvim('command', 'let g:v2 = [1, 2, {"v3": 3}]') - eq({v1 = 'a', v2 = { 1, 2, { v3 = 3 } } }, nvim('eval', 'g:')) + eq({ v1 = 'a', v2 = { 1, 2, { v3 = 3 } } }, nvim('eval', 'g:')) end) it('handles NULL-initialized strings correctly', function() - eq(1, nvim('eval',"matcharg(1) == ['', '']")) - eq({'', ''}, nvim('eval','matcharg(1)')) + eq(1, nvim('eval', "matcharg(1) == ['', '']")) + eq({ '', '' }, nvim('eval', 'matcharg(1)')) end) it('works under deprecated name', function() - eq(2, request("vim_eval", "1+1")) + eq(2, request('vim_eval', '1+1')) end) - it("Vimscript error: returns error details, does NOT update v:errmsg", function() - eq('Vim:E121: Undefined variable: bogus', - pcall_err(request, 'nvim_eval', 'bogus expression')) - eq('', eval('v:errmsg')) -- v:errmsg was not updated. + it('Vimscript error: returns error details, does NOT update v:errmsg', function() + eq('Vim:E121: Undefined variable: bogus', pcall_err(request, 'nvim_eval', 'bogus expression')) + eq('', eval('v:errmsg')) -- v:errmsg was not updated. end) end) @@ -461,31 +553,41 @@ describe('API', function() it('works', function() nvim('call_function', 'setqflist', { { { filename = 'something', lnum = 17 } }, 'r' }) eq(17, nvim('call_function', 'getqflist', {})[1].lnum) - eq(17, nvim('call_function', 'eval', {17})) - eq('foo', nvim('call_function', 'simplify', {'this/./is//redundant/../../../foo'})) + eq(17, nvim('call_function', 'eval', { 17 })) + eq('foo', nvim('call_function', 'simplify', { 'this/./is//redundant/../../../foo' })) end) - it("Vimscript validation error: returns specific error, does NOT update v:errmsg", function() - eq('Vim:E117: Unknown function: bogus function', - pcall_err(request, 'nvim_call_function', 'bogus function', {'arg1'})) - eq('Vim:E119: Not enough arguments for function: atan', - pcall_err(request, 'nvim_call_function', 'atan', {})) + it('Vimscript validation error: returns specific error, does NOT update v:errmsg', function() + eq( + 'Vim:E117: Unknown function: bogus function', + pcall_err(request, 'nvim_call_function', 'bogus function', { 'arg1' }) + ) + eq( + 'Vim:E119: Not enough arguments for function: atan', + pcall_err(request, 'nvim_call_function', 'atan', {}) + ) eq('', eval('v:exception')) - eq('', eval('v:errmsg')) -- v:errmsg was not updated. + eq('', eval('v:errmsg')) -- v:errmsg was not updated. end) - it("Vimscript error: returns error details, does NOT update v:errmsg", function() - eq('Vim:E808: Number or Float required', - pcall_err(request, 'nvim_call_function', 'atan', {'foo'})) - eq('Vim:Invalid channel stream "xxx"', - pcall_err(request, 'nvim_call_function', 'chanclose', {999, 'xxx'})) - eq('Vim:E900: Invalid channel id', - pcall_err(request, 'nvim_call_function', 'chansend', {999, 'foo'})) + it('Vimscript error: returns error details, does NOT update v:errmsg', function() + eq( + 'Vim:E808: Number or Float required', + pcall_err(request, 'nvim_call_function', 'atan', { 'foo' }) + ) + eq( + 'Vim:Invalid channel stream "xxx"', + pcall_err(request, 'nvim_call_function', 'chanclose', { 999, 'xxx' }) + ) + eq( + 'Vim:E900: Invalid channel id', + pcall_err(request, 'nvim_call_function', 'chansend', { 999, 'foo' }) + ) eq('', eval('v:exception')) - eq('', eval('v:errmsg')) -- v:errmsg was not updated. + eq('', eval('v:errmsg')) -- v:errmsg was not updated. end) - it("Vimscript exception: returns exception details, does NOT update v:errmsg", function() + it('Vimscript exception: returns exception details, does NOT update v:errmsg', function() source([[ function! Foo() abort throw 'wtf' @@ -493,10 +595,11 @@ describe('API', function() ]]) eq('function Foo, line 1: wtf', pcall_err(request, 'nvim_call_function', 'Foo', {})) eq('', eval('v:exception')) - eq('', eval('v:errmsg')) -- v:errmsg was not updated. + eq('', eval('v:errmsg')) -- v:errmsg was not updated. end) it('validation', function() + -- stylua: ignore local too_many_args = { 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x' } source([[ function! Foo(...) abort @@ -504,8 +607,10 @@ describe('API', function() endfunction ]]) -- E740 - eq('Function called with too many arguments', - pcall_err(request, 'nvim_call_function', 'Foo', too_many_args)) + eq( + 'Function called with too many arguments', + pcall_err(request, 'nvim_call_function', 'Foo', too_many_args) + ) end) end) @@ -524,40 +629,55 @@ describe('API', function() ]]) -- :help Dictionary-function - eq('Hello, World!', nvim('call_dict_function', 'g:test_dict_fn', 'F', {'World'})) + eq('Hello, World!', nvim('call_dict_function', 'g:test_dict_fn', 'F', { 'World' })) -- Funcref is sent as NIL over RPC. eq({ greeting = 'Hello', F = NIL }, nvim('get_var', 'test_dict_fn')) -- :help numbered-function - eq('Hi, Moon ...', nvim('call_dict_function', 'g:test_dict_fn2', 'F2', {'Moon'})) + eq('Hi, Moon ...', nvim('call_dict_function', 'g:test_dict_fn2', 'F2', { 'Moon' })) -- Funcref is sent as NIL over RPC. eq({ greeting = 'Hi', F2 = NIL }, nvim('get_var', 'test_dict_fn2')) -- Function specified via RPC dict. source('function! G() dict\n return "@".(self.result)."@"\nendfunction') - eq('@it works@', nvim('call_dict_function', { result = 'it works', G = 'G'}, 'G', {})) + eq('@it works@', nvim('call_dict_function', { result = 'it works', G = 'G' }, 'G', {})) end) it('validation', function() command('let g:d={"baz":"zub","meep":[]}') - eq('Not found: bogus', - pcall_err(request, 'nvim_call_dict_function', 'g:d', 'bogus', {1,2})) - eq('Not a function: baz', - pcall_err(request, 'nvim_call_dict_function', 'g:d', 'baz', {1,2})) - eq('Not a function: meep', - pcall_err(request, 'nvim_call_dict_function', 'g:d', 'meep', {1,2})) - eq('Vim:E117: Unknown function: f', - pcall_err(request, 'nvim_call_dict_function', { f = '' }, 'f', {1,2})) - eq('Not a function: f', - pcall_err(request, 'nvim_call_dict_function', "{ 'f': '' }", 'f', {1,2})) - eq('dict argument type must be String or Dictionary', - pcall_err(request, 'nvim_call_dict_function', 42, 'f', {1,2})) - eq('Failed to evaluate dict expression', - pcall_err(request, 'nvim_call_dict_function', 'foo', 'f', {1,2})) - eq('dict not found', - pcall_err(request, 'nvim_call_dict_function', '42', 'f', {1,2})) - eq('Invalid (empty) function name', - pcall_err(request, 'nvim_call_dict_function', "{ 'f': '' }", '', {1,2})) + eq( + 'Not found: bogus', + pcall_err(request, 'nvim_call_dict_function', 'g:d', 'bogus', { 1, 2 }) + ) + eq( + 'Not a function: baz', + pcall_err(request, 'nvim_call_dict_function', 'g:d', 'baz', { 1, 2 }) + ) + eq( + 'Not a function: meep', + pcall_err(request, 'nvim_call_dict_function', 'g:d', 'meep', { 1, 2 }) + ) + eq( + 'Vim:E117: Unknown function: f', + pcall_err(request, 'nvim_call_dict_function', { f = '' }, 'f', { 1, 2 }) + ) + eq( + 'Not a function: f', + pcall_err(request, 'nvim_call_dict_function', "{ 'f': '' }", 'f', { 1, 2 }) + ) + eq( + 'dict argument type must be String or Dictionary', + pcall_err(request, 'nvim_call_dict_function', 42, 'f', { 1, 2 }) + ) + eq( + 'Failed to evaluate dict expression', + pcall_err(request, 'nvim_call_dict_function', 'foo', 'f', { 1, 2 }) + ) + eq('dict not found', pcall_err(request, 'nvim_call_dict_function', '42', 'f', { 1, 2 })) + eq( + 'Invalid (empty) function name', + pcall_err(request, 'nvim_call_dict_function', "{ 'f': '' }", '', { 1, 2 }) + ) end) end) @@ -565,21 +685,21 @@ describe('API', function() local start_dir before_each(function() - funcs.mkdir("Xtestdir") + funcs.mkdir('Xtestdir') start_dir = funcs.getcwd() end) after_each(function() - helpers.rmdir("Xtestdir") + helpers.rmdir('Xtestdir') end) it('works', function() - meths.set_current_dir("Xtestdir") - eq(funcs.getcwd(), start_dir .. helpers.get_pathsep() .. "Xtestdir") + meths.set_current_dir('Xtestdir') + eq(funcs.getcwd(), start_dir .. helpers.get_pathsep() .. 'Xtestdir') end) it('sets previous directory', function() - meths.set_current_dir("Xtestdir") + meths.set_current_dir('Xtestdir') command('cd -') eq(funcs.getcwd(), start_dir) end) @@ -590,60 +710,67 @@ describe('API', function() meths.exec_lua('vim.api.nvim_set_var("test", 3)', {}) eq(3, meths.get_var('test')) - eq(17, meths.exec_lua('a, b = ...\nreturn a + b', {10,7})) + eq(17, meths.exec_lua('a, b = ...\nreturn a + b', { 10, 7 })) - eq(NIL, meths.exec_lua('function xx(a,b)\nreturn a..b\nend',{})) - eq("xy", meths.exec_lua('return xx(...)', {'x','y'})) + eq(NIL, meths.exec_lua('function xx(a,b)\nreturn a..b\nend', {})) + eq('xy', meths.exec_lua('return xx(...)', { 'x', 'y' })) -- Deprecated name: nvim_execute_lua. - eq("xy", meths.execute_lua('return xx(...)', {'x','y'})) + eq('xy', meths.execute_lua('return xx(...)', { 'x', 'y' })) end) it('reports errors', function() - eq([[Error loading lua: [string ""]:0: '=' expected near '+']], - pcall_err(meths.exec_lua, 'a+*b', {})) + eq( + [[Error loading lua: [string ""]:0: '=' expected near '+']], + pcall_err(meths.exec_lua, 'a+*b', {}) + ) - eq([[Error loading lua: [string ""]:0: unexpected symbol near '1']], - pcall_err(meths.exec_lua, '1+2', {})) + eq( + [[Error loading lua: [string ""]:0: unexpected symbol near '1']], + pcall_err(meths.exec_lua, '1+2', {}) + ) - eq([[Error loading lua: [string ""]:0: unexpected symbol]], - pcall_err(meths.exec_lua, 'aa=bb\0', {})) + eq( + [[Error loading lua: [string ""]:0: unexpected symbol]], + pcall_err(meths.exec_lua, 'aa=bb\0', {}) + ) - eq([[attempt to call global 'bork' (a nil value)]], - pcall_err(meths.exec_lua, 'bork()', {})) + eq([[attempt to call global 'bork' (a nil value)]], pcall_err(meths.exec_lua, 'bork()', {})) - eq('did\nthe\nfail', - pcall_err(meths.exec_lua, 'error("did\\nthe\\nfail")', {})) + eq('did\nthe\nfail', pcall_err(meths.exec_lua, 'error("did\\nthe\\nfail")', {})) end) it('uses native float values', function() - eq(2.5, meths.exec_lua("return select(1, ...)", {2.5})) - eq("2.5", meths.exec_lua("return vim.inspect(...)", {2.5})) + eq(2.5, meths.exec_lua('return select(1, ...)', { 2.5 })) + eq('2.5', meths.exec_lua('return vim.inspect(...)', { 2.5 })) -- "special" float values are still accepted as return values. eq(2.5, meths.exec_lua("return vim.api.nvim_eval('2.5')", {})) - eq("{\n [false] = 2.5,\n [true] = 3\n}", meths.exec_lua("return vim.inspect(vim.api.nvim_eval('2.5'))", {})) + eq( + '{\n [false] = 2.5,\n [true] = 3\n}', + meths.exec_lua("return vim.inspect(vim.api.nvim_eval('2.5'))", {}) + ) end) end) describe('nvim_notify', function() it('can notify a info message', function() - nvim("notify", "hello world", 2, {}) + nvim('notify', 'hello world', 2, {}) end) it('can be overridden', function() - command("lua vim.notify = function(...) return 42 end") + command('lua vim.notify = function(...) return 42 end') eq(42, meths.exec_lua("return vim.notify('Hello world')", {})) - nvim("notify", "hello world", 4, {}) + nvim('notify', 'hello world', 4, {}) end) end) describe('nvim_input', function() - it("Vimscript error: does NOT fail, updates v:errmsg", function() - local status, _ = pcall(nvim, "input", ":call bogus_fn()") - local v_errnum = string.match(nvim("eval", "v:errmsg"), "E%d*:") - eq(true, status) -- nvim_input() did not fail. - eq("E117:", v_errnum) -- v:errmsg was updated. + it('Vimscript error: does NOT fail, updates v:errmsg', function() + local status, _ = pcall(nvim, 'input', ':call bogus_fn()') + local v_errnum = string.match(nvim('eval', 'v:errmsg'), 'E%d*:') + eq(true, status) -- nvim_input() did not fail. + eq('E117:', v_errnum) -- v:errmsg was updated. end) it('does not crash even if trans_special result is largest #11788, #12287', function() @@ -654,10 +781,8 @@ describe('API', function() describe('nvim_paste', function() it('validation', function() - eq("Invalid 'phase': -2", - pcall_err(request, 'nvim_paste', 'foo', true, -2)) - eq("Invalid 'phase': 4", - pcall_err(request, 'nvim_paste', 'foo', true, 4)) + eq("Invalid 'phase': -2", pcall_err(request, 'nvim_paste', 'foo', true, -2)) + eq("Invalid 'phase': 4", pcall_err(request, 'nvim_paste', 'foo', true, 4)) end) local function run_streamed_paste_tests() it('stream: multiple chunks form one undo-block', function() @@ -686,7 +811,7 @@ describe('API', function() 2/chunk 3 2/chunk 4 (end) ]]) - feed('u') -- Undo. + feed('u') -- Undo. expect(expected1) end) it('stream: Insert mode', function() @@ -1036,7 +1161,7 @@ describe('API', function() line 2 line 3 ]]) - eq({0,4,1,0}, funcs.getpos('.')) -- Cursor follows the paste. + eq({ 0, 4, 1, 0 }, funcs.getpos('.')) -- Cursor follows the paste. eq(false, nvim('get_option_value', 'paste', {})) command('%delete _') -- Without final "\n". @@ -1045,7 +1170,7 @@ describe('API', function() line 1 line 2 line 3]]) - eq({0,3,6,0}, funcs.getpos('.')) + eq({ 0, 3, 6, 0 }, funcs.getpos('.')) command('%delete _') -- CRLF #10872 nvim('paste', 'line 1\r\nline 2\r\nline 3\r\n', true, -1) @@ -1054,7 +1179,7 @@ describe('API', function() line 2 line 3 ]]) - eq({0,4,1,0}, funcs.getpos('.')) + eq({ 0, 4, 1, 0 }, funcs.getpos('.')) command('%delete _') -- CRLF without final "\n". nvim('paste', 'line 1\r\nline 2\r\nline 3\r', true, -1) @@ -1063,7 +1188,7 @@ describe('API', function() line 2 line 3 ]]) - eq({0,4,1,0}, funcs.getpos('.')) + eq({ 0, 4, 1, 0 }, funcs.getpos('.')) command('%delete _') -- CRLF without final "\r\n". nvim('paste', 'line 1\r\nline 2\r\nline 3', true, -1) @@ -1071,17 +1196,17 @@ describe('API', function() line 1 line 2 line 3]]) - eq({0,3,6,0}, funcs.getpos('.')) + eq({ 0, 3, 6, 0 }, funcs.getpos('.')) command('%delete _') -- Various other junk. nvim('paste', 'line 1\r\n\r\rline 2\nline 3\rline 4\r', true, -1) expect('line 1\n\n\nline 2\nline 3\nline 4\n') - eq({0,7,1,0}, funcs.getpos('.')) + eq({ 0, 7, 1, 0 }, funcs.getpos('.')) eq(false, nvim('get_option_value', 'paste', {})) end) it('Replace-mode', function() -- Within single line - nvim('put', {'aabbccdd', 'eeffgghh', 'iijjkkll'}, "c", true, false) + nvim('put', { 'aabbccdd', 'eeffgghh', 'iijjkkll' }, 'c', true, false) command('normal l') command('startreplace') nvim('paste', '123456', true, -1) @@ -1091,7 +1216,7 @@ describe('API', function() iijjkkll]]) command('%delete _') -- Across lines - nvim('put', {'aabbccdd', 'eeffgghh', 'iijjkkll'}, "c", true, false) + nvim('put', { 'aabbccdd', 'eeffgghh', 'iijjkkll' }, 'c', true, false) command('normal l') command('startreplace') nvim('paste', '123\n456', true, -1) @@ -1147,101 +1272,103 @@ describe('API', function() it('crlf=false does not break lines at CR, CRLF', function() nvim('paste', 'line 1\r\n\r\rline 2\nline 3\rline 4\r', false, -1) expect('line 1\r\n\r\rline 2\nline 3\rline 4\r') - eq({0,3,14,0}, funcs.getpos('.')) + eq({ 0, 3, 14, 0 }, funcs.getpos('.')) end) it('vim.paste() failure', function() nvim('exec_lua', 'vim.paste = (function(lines, phase) error("fake fail") end)', {}) - eq('fake fail', - pcall_err(request, 'nvim_paste', 'line 1\nline 2\nline 3', false, 1)) + eq('fake fail', pcall_err(request, 'nvim_paste', 'line 1\nline 2\nline 3', false, 1)) end) end) describe('nvim_put', function() it('validation', function() - eq("Invalid 'line': expected String, got Integer", - pcall_err(request, 'nvim_put', {42}, 'l', false, false)) - eq("Invalid 'type': 'x'", - pcall_err(request, 'nvim_put', {'foo'}, 'x', false, false)) + eq( + "Invalid 'line': expected String, got Integer", + pcall_err(request, 'nvim_put', { 42 }, 'l', false, false) + ) + eq("Invalid 'type': 'x'", pcall_err(request, 'nvim_put', { 'foo' }, 'x', false, false)) end) it("fails if 'nomodifiable'", function() command('set nomodifiable') - eq([[Vim:E21: Cannot make changes, 'modifiable' is off]], - pcall_err(request, 'nvim_put', {'a','b'}, 'l', true, true)) + eq( + [[Vim:E21: Cannot make changes, 'modifiable' is off]], + pcall_err(request, 'nvim_put', { 'a', 'b' }, 'l', true, true) + ) end) it('inserts text', function() -- linewise - nvim('put', {'line 1','line 2','line 3'}, 'l', true, true) + nvim('put', { 'line 1', 'line 2', 'line 3' }, 'l', true, true) expect([[ line 1 line 2 line 3]]) - eq({0,4,1,0}, funcs.getpos('.')) + eq({ 0, 4, 1, 0 }, funcs.getpos('.')) command('%delete _') -- charwise - nvim('put', {'line 1','line 2','line 3'}, 'c', true, false) + nvim('put', { 'line 1', 'line 2', 'line 3' }, 'c', true, false) expect([[ line 1 line 2 line 3]]) - eq({0,1,1,0}, funcs.getpos('.')) -- follow=false + eq({ 0, 1, 1, 0 }, funcs.getpos('.')) -- follow=false -- blockwise - nvim('put', {'AA','BB'}, 'b', true, true) + nvim('put', { 'AA', 'BB' }, 'b', true, true) expect([[ lAAine 1 lBBine 2 line 3]]) - eq({0,2,4,0}, funcs.getpos('.')) + eq({ 0, 2, 4, 0 }, funcs.getpos('.')) command('%delete _') -- Empty lines list. nvim('put', {}, 'c', true, true) - eq({0,1,1,0}, funcs.getpos('.')) + eq({ 0, 1, 1, 0 }, funcs.getpos('.')) expect([[]]) -- Single empty line. - nvim('put', {''}, 'c', true, true) - eq({0,1,1,0}, funcs.getpos('.')) + nvim('put', { '' }, 'c', true, true) + eq({ 0, 1, 1, 0 }, funcs.getpos('.')) expect([[ ]]) - nvim('put', {'AB'}, 'c', true, true) + nvim('put', { 'AB' }, 'c', true, true) -- after=false, follow=true - nvim('put', {'line 1','line 2'}, 'c', false, true) + nvim('put', { 'line 1', 'line 2' }, 'c', false, true) expect([[ Aline 1 line 2B]]) - eq({0,2,7,0}, funcs.getpos('.')) + eq({ 0, 2, 7, 0 }, funcs.getpos('.')) command('%delete _') - nvim('put', {'AB'}, 'c', true, true) + nvim('put', { 'AB' }, 'c', true, true) -- after=false, follow=false - nvim('put', {'line 1','line 2'}, 'c', false, false) + nvim('put', { 'line 1', 'line 2' }, 'c', false, false) expect([[ Aline 1 line 2B]]) - eq({0,1,2,0}, funcs.getpos('.')) + eq({ 0, 1, 2, 0 }, funcs.getpos('.')) eq('', nvim('eval', 'v:errmsg')) end) it('detects charwise/linewise text (empty {type})', function() -- linewise (final item is empty string) - nvim('put', {'line 1','line 2','line 3',''}, '', true, true) + nvim('put', { 'line 1', 'line 2', 'line 3', '' }, '', true, true) expect([[ line 1 line 2 line 3]]) - eq({0,4,1,0}, funcs.getpos('.')) + eq({ 0, 4, 1, 0 }, funcs.getpos('.')) command('%delete _') -- charwise (final item is non-empty) - nvim('put', {'line 1','line 2','line 3'}, '', true, true) + nvim('put', { 'line 1', 'line 2', 'line 3' }, '', true, true) expect([[ line 1 line 2 line 3]]) - eq({0,3,6,0}, funcs.getpos('.')) + eq({ 0, 3, 6, 0 }, funcs.getpos('.')) end) it('allows block width', function() -- behave consistently with setreg(); support "\022{NUM}" return by getregtype() - meths.put({'line 1','line 2','line 3'}, 'l', false, false) + meths.put({ 'line 1', 'line 2', 'line 3' }, 'l', false, false) expect([[ line 1 line 2 @@ -1249,23 +1376,21 @@ describe('API', function() ]]) -- larger width create spaces - meths.put({'a', 'bc'}, 'b3', false, false) + meths.put({ 'a', 'bc' }, 'b3', false, false) expect([[ a line 1 bc line 2 line 3 ]]) -- smaller width is ignored - meths.put({'xxx', 'yyy'}, '\0221', false, true) + meths.put({ 'xxx', 'yyy' }, '\0221', false, true) expect([[ xxxa line 1 yyybc line 2 line 3 ]]) - eq("Invalid 'type': 'bx'", - pcall_err(meths.put, {'xxx', 'yyy'}, 'bx', false, true)) - eq("Invalid 'type': 'b3x'", - pcall_err(meths.put, {'xxx', 'yyy'}, 'b3x', false, true)) + eq("Invalid 'type': 'bx'", pcall_err(meths.put, { 'xxx', 'yyy' }, 'bx', false, true)) + eq("Invalid 'type': 'b3x'", pcall_err(meths.put, { 'xxx', 'yyy' }, 'b3x', false, true)) end) end) @@ -1297,18 +1422,18 @@ describe('API', function() end) it('nvim_get_var, nvim_set_var, nvim_del_var', function() - nvim('set_var', 'lua', {1, 2, {['3'] = 1}}) - eq({1, 2, {['3'] = 1}}, nvim('get_var', 'lua')) - eq({1, 2, {['3'] = 1}}, nvim('eval', 'g:lua')) + nvim('set_var', 'lua', { 1, 2, { ['3'] = 1 } }) + eq({ 1, 2, { ['3'] = 1 } }, nvim('get_var', 'lua')) + eq({ 1, 2, { ['3'] = 1 } }, nvim('eval', 'g:lua')) eq(1, funcs.exists('g:lua')) meths.del_var('lua') eq(0, funcs.exists('g:lua')) - eq("Key not found: lua", pcall_err(meths.del_var, 'lua')) + eq('Key not found: lua', pcall_err(meths.del_var, 'lua')) meths.set_var('lua', 1) -- Empty keys are allowed in Vim dicts (and msgpack). - nvim('set_var', 'dict_empty_key', {[''] = 'empty key'}) - eq({[''] = 'empty key'}, nvim('get_var', 'dict_empty_key')) + nvim('set_var', 'dict_empty_key', { [''] = 'empty key' }) + eq({ [''] = 'empty key' }, nvim('get_var', 'dict_empty_key')) -- Set locked g: var. command('lockvar lua') @@ -1330,12 +1455,12 @@ describe('API', function() local pathsep = helpers.get_pathsep() local xconfig = 'Xhome' .. pathsep .. 'Xconfig' local xdata = 'Xhome' .. pathsep .. 'Xdata' - local autoload_folder = table.concat({xconfig, 'nvim', 'autoload'}, pathsep) - local autoload_file = table.concat({autoload_folder , 'testload.vim'}, pathsep) + local autoload_folder = table.concat({ xconfig, 'nvim', 'autoload' }, pathsep) + local autoload_file = table.concat({ autoload_folder, 'testload.vim' }, pathsep) mkdir_p(autoload_folder) - write_file(autoload_file , [[let testload#value = 2]]) + write_file(autoload_file, [[let testload#value = 2]]) - clear{ args_rm={'-u'}, env={ XDG_CONFIG_HOME=xconfig, XDG_DATA_HOME=xdata } } + clear { args_rm = { '-u' }, env = { XDG_CONFIG_HOME = xconfig, XDG_DATA_HOME = xdata } } eq(2, meths.get_var('testload#value')) rmdir('Xhome') end) @@ -1355,58 +1480,64 @@ describe('API', function() eq({}, eval('v:oldfiles')) feed('i foo foo foo0/foo') - eq({1, 1}, meths.win_get_cursor(0)) + eq({ 1, 1 }, meths.win_get_cursor(0)) eq(1, eval('v:searchforward')) feed('n') - eq({1, 5}, meths.win_get_cursor(0)) + eq({ 1, 5 }, meths.win_get_cursor(0)) meths.set_vvar('searchforward', 0) eq(0, eval('v:searchforward')) feed('n') - eq({1, 1}, meths.win_get_cursor(0)) + eq({ 1, 1 }, meths.win_get_cursor(0)) meths.set_vvar('searchforward', 1) eq(1, eval('v:searchforward')) feed('n') - eq({1, 5}, meths.win_get_cursor(0)) + eq({ 1, 5 }, meths.win_get_cursor(0)) local screen = Screen.new(60, 3) screen:set_default_attr_ids({ - [0] = {bold = true, foreground = Screen.colors.Blue}, - [1] = {background = Screen.colors.Yellow}, + [0] = { bold = true, foreground = Screen.colors.Blue }, + [1] = { background = Screen.colors.Yellow }, }) screen:attach() eq(1, eval('v:hlsearch')) - screen:expect{grid=[[ + screen:expect { + grid = [[ {1:foo} {1:^foo} {1:foo} | {0:~ }| | - ]]} + ]], + } meths.set_vvar('hlsearch', 0) eq(0, eval('v:hlsearch')) - screen:expect{grid=[[ + screen:expect { + grid = [[ foo ^foo foo | {0:~ }| | - ]]} + ]], + } meths.set_vvar('hlsearch', 1) eq(1, eval('v:hlsearch')) - screen:expect{grid=[[ + screen:expect { + grid = [[ {1:foo} {1:^foo} {1:foo} | {0:~ }| | - ]]} + ]], + } end) it('vim_set_var returns the old value', function() - local val1 = {1, 2, {['3'] = 1}} - local val2 = {4, 7} + local val1 = { 1, 2, { ['3'] = 1 } } + local val2 = { 4, 7 } eq(NIL, request('vim_set_var', 'lua', val1)) eq(val1, request('vim_set_var', 'lua', val2)) end) it('vim_del_var returns the old value', function() - local val1 = {1, 2, {['3'] = 1}} - local val2 = {4, 7} - eq(NIL, request('vim_set_var', 'lua', val1)) + local val1 = { 1, 2, { ['3'] = 1 } } + local val2 = { 4, 7 } + eq(NIL, request('vim_set_var', 'lua', val1)) eq(val1, request('vim_set_var', 'lua', val2)) eq(val2, request('vim_del_var', 'lua')) end) @@ -1430,27 +1561,26 @@ describe('API', function() end) it('works to set global value of local options', function() - nvim('set_option_value', 'lisp', true, {scope='global'}) - eq(true, nvim('get_option_value', 'lisp', {scope='global'})) + nvim('set_option_value', 'lisp', true, { scope = 'global' }) + eq(true, nvim('get_option_value', 'lisp', { scope = 'global' })) eq(false, nvim('get_option_value', 'lisp', {})) eq(nil, nvim('command_output', 'setglobal lisp?'):match('nolisp')) eq('nolisp', nvim('command_output', 'setlocal lisp?'):match('nolisp')) - nvim('set_option_value', 'shiftwidth', 20, {scope='global'}) + nvim('set_option_value', 'shiftwidth', 20, { scope = 'global' }) eq('20', nvim('command_output', 'setglobal shiftwidth?'):match('%d+')) eq('8', nvim('command_output', 'setlocal shiftwidth?'):match('%d+')) end) it('updates where the option was last set from', function() nvim('set_option_value', 'equalalways', false, {}) - local status, rv = pcall(nvim, 'command_output', - 'verbose set equalalways?') + local status, rv = pcall(nvim, 'command_output', 'verbose set equalalways?') eq(true, status) - ok(nil ~= string.find(rv, 'noequalalways\n'.. - '\tLast set from API client %(channel id %d+%)')) + ok( + nil ~= string.find(rv, 'noequalalways\n' .. '\tLast set from API client %(channel id %d+%)') + ) nvim('exec_lua', 'vim.api.nvim_set_option_value("equalalways", true, {})', {}) - status, rv = pcall(nvim, 'command_output', - 'verbose set equalalways?') + status, rv = pcall(nvim, 'command_output', 'verbose set equalalways?') eq(true, status) eq(' equalalways\n\tLast set from Lua', rv) end) @@ -1470,37 +1600,49 @@ describe('API', function() end) it('validation', function() - eq("Invalid 'scope': expected 'local' or 'global'", - pcall_err(nvim, 'get_option_value', 'scrolloff', {scope = 'bogus'})) - eq("Invalid 'scope': expected 'local' or 'global'", - pcall_err(nvim, 'set_option_value', 'scrolloff', 1, {scope = 'bogus'})) - eq("Invalid 'scope': expected String, got Integer", - pcall_err(nvim, 'get_option_value', 'scrolloff', {scope = 42})) - eq("Invalid 'value': expected valid option type, got Array", - pcall_err(nvim, 'set_option_value', 'scrolloff', {}, {})) - eq("Invalid value for option 'scrolloff': expected number, got boolean true", - pcall_err(nvim, 'set_option_value', 'scrolloff', true, {})) - eq("Invalid value for option 'scrolloff': expected number, got string \"wrong\"", - pcall_err(nvim, 'set_option_value', 'scrolloff', 'wrong', {})) + eq( + "Invalid 'scope': expected 'local' or 'global'", + pcall_err(nvim, 'get_option_value', 'scrolloff', { scope = 'bogus' }) + ) + eq( + "Invalid 'scope': expected 'local' or 'global'", + pcall_err(nvim, 'set_option_value', 'scrolloff', 1, { scope = 'bogus' }) + ) + eq( + "Invalid 'scope': expected String, got Integer", + pcall_err(nvim, 'get_option_value', 'scrolloff', { scope = 42 }) + ) + eq( + "Invalid 'value': expected valid option type, got Array", + pcall_err(nvim, 'set_option_value', 'scrolloff', {}, {}) + ) + eq( + "Invalid value for option 'scrolloff': expected number, got boolean true", + pcall_err(nvim, 'set_option_value', 'scrolloff', true, {}) + ) + eq( + 'Invalid value for option \'scrolloff\': expected number, got string "wrong"', + pcall_err(nvim, 'set_option_value', 'scrolloff', 'wrong', {}) + ) end) it('can get local values when global value is set', function() eq(0, nvim('get_option_value', 'scrolloff', {})) - eq(-1, nvim('get_option_value', 'scrolloff', {scope = 'local'})) + eq(-1, nvim('get_option_value', 'scrolloff', { scope = 'local' })) end) it('can set global and local values', function() nvim('set_option_value', 'makeprg', 'hello', {}) eq('hello', nvim('get_option_value', 'makeprg', {})) - eq('', nvim('get_option_value', 'makeprg', {scope = 'local'})) - nvim('set_option_value', 'makeprg', 'world', {scope = 'local'}) - eq('world', nvim('get_option_value', 'makeprg', {scope = 'local'})) - nvim('set_option_value', 'makeprg', 'goodbye', {scope = 'global'}) - eq('goodbye', nvim('get_option_value', 'makeprg', {scope = 'global'})) + eq('', nvim('get_option_value', 'makeprg', { scope = 'local' })) + nvim('set_option_value', 'makeprg', 'world', { scope = 'local' }) + eq('world', nvim('get_option_value', 'makeprg', { scope = 'local' })) + nvim('set_option_value', 'makeprg', 'goodbye', { scope = 'global' }) + eq('goodbye', nvim('get_option_value', 'makeprg', { scope = 'global' })) nvim('set_option_value', 'makeprg', 'hello', {}) - eq('hello', nvim('get_option_value', 'makeprg', {scope = 'global'})) + eq('hello', nvim('get_option_value', 'makeprg', { scope = 'global' })) eq('hello', nvim('get_option_value', 'makeprg', {})) - eq('', nvim('get_option_value', 'makeprg', {scope = 'local'})) + eq('', nvim('get_option_value', 'makeprg', { scope = 'local' })) end) it('clears the local value of an option with nil', function() @@ -1509,63 +1651,63 @@ describe('API', function() eq(42, nvim('get_option_value', 'shiftwidth', {})) -- Set local value - nvim('set_option_value', 'shiftwidth', 8, {scope = 'local'}) + nvim('set_option_value', 'shiftwidth', 8, { scope = 'local' }) eq(8, nvim('get_option_value', 'shiftwidth', {})) - eq(8, nvim('get_option_value', 'shiftwidth', {scope = 'local'})) - eq(42, nvim('get_option_value', 'shiftwidth', {scope = 'global'})) + eq(8, nvim('get_option_value', 'shiftwidth', { scope = 'local' })) + eq(42, nvim('get_option_value', 'shiftwidth', { scope = 'global' })) -- Clear value without scope nvim('set_option_value', 'shiftwidth', NIL, {}) eq(42, nvim('get_option_value', 'shiftwidth', {})) - eq(42, nvim('get_option_value', 'shiftwidth', {scope = 'local'})) + eq(42, nvim('get_option_value', 'shiftwidth', { scope = 'local' })) -- Clear value with explicit scope - nvim('set_option_value', 'shiftwidth', 8, {scope = 'local'}) - nvim('set_option_value', 'shiftwidth', NIL, {scope = 'local'}) + nvim('set_option_value', 'shiftwidth', 8, { scope = 'local' }) + nvim('set_option_value', 'shiftwidth', NIL, { scope = 'local' }) eq(42, nvim('get_option_value', 'shiftwidth', {})) - eq(42, nvim('get_option_value', 'shiftwidth', {scope = 'local'})) + eq(42, nvim('get_option_value', 'shiftwidth', { scope = 'local' })) -- Now try with options with a special "local is unset" value (e.g. 'undolevels') nvim('set_option_value', 'undolevels', 1000, {}) - nvim('set_option_value', 'undolevels', 1200, {scope = 'local'}) - eq(1200, nvim('get_option_value', 'undolevels', {scope = 'local'})) - nvim('set_option_value', 'undolevels', NIL, {scope = 'local'}) - eq(-123456, nvim('get_option_value', 'undolevels', {scope = 'local'})) + nvim('set_option_value', 'undolevels', 1200, { scope = 'local' }) + eq(1200, nvim('get_option_value', 'undolevels', { scope = 'local' })) + nvim('set_option_value', 'undolevels', NIL, { scope = 'local' }) + eq(-123456, nvim('get_option_value', 'undolevels', { scope = 'local' })) eq(1000, nvim('get_option_value', 'undolevels', {})) nvim('set_option_value', 'autoread', true, {}) - nvim('set_option_value', 'autoread', false, {scope = 'local'}) - eq(false, nvim('get_option_value', 'autoread', {scope = 'local'})) - nvim('set_option_value', 'autoread', NIL, {scope = 'local'}) - eq(NIL, nvim('get_option_value', 'autoread', {scope = 'local'})) + nvim('set_option_value', 'autoread', false, { scope = 'local' }) + eq(false, nvim('get_option_value', 'autoread', { scope = 'local' })) + nvim('set_option_value', 'autoread', NIL, { scope = 'local' }) + eq(NIL, nvim('get_option_value', 'autoread', { scope = 'local' })) eq(true, nvim('get_option_value', 'autoread', {})) end) it('set window options', function() nvim('set_option_value', 'colorcolumn', '4,3', {}) - eq('4,3', nvim('get_option_value', 'colorcolumn', {scope = 'local'})) - command("set modified hidden") - command("enew") -- edit new buffer, window option is preserved - eq('4,3', nvim('get_option_value', 'colorcolumn', {scope = 'local'})) + eq('4,3', nvim('get_option_value', 'colorcolumn', { scope = 'local' })) + command('set modified hidden') + command('enew') -- edit new buffer, window option is preserved + eq('4,3', nvim('get_option_value', 'colorcolumn', { scope = 'local' })) end) it('set local window options', function() - nvim('set_option_value', 'colorcolumn', '4,3', {win=0, scope='local'}) - eq('4,3', nvim('get_option_value', 'colorcolumn', {win = 0, scope = 'local'})) - command("set modified hidden") - command("enew") -- edit new buffer, window option is reset - eq('', nvim('get_option_value', 'colorcolumn', {win = 0, scope = 'local'})) + nvim('set_option_value', 'colorcolumn', '4,3', { win = 0, scope = 'local' }) + eq('4,3', nvim('get_option_value', 'colorcolumn', { win = 0, scope = 'local' })) + command('set modified hidden') + command('enew') -- edit new buffer, window option is reset + eq('', nvim('get_option_value', 'colorcolumn', { win = 0, scope = 'local' })) end) it('get buffer or window-local options', function() nvim('command', 'new') local buf = nvim('get_current_buf').id - nvim('set_option_value', 'tagfunc', 'foobar', {buf=buf}) - eq('foobar', nvim('get_option_value', 'tagfunc', {buf = buf})) + nvim('set_option_value', 'tagfunc', 'foobar', { buf = buf }) + eq('foobar', nvim('get_option_value', 'tagfunc', { buf = buf })) local win = nvim('get_current_win').id - nvim('set_option_value', 'number', true, {win=win}) - eq(true, nvim('get_option_value', 'number', {win = win})) + nvim('set_option_value', 'number', true, { win = win }) + eq(true, nvim('get_option_value', 'number', { win = win })) end) it('getting current buffer option does not adjust cursor #19381', function() @@ -1574,9 +1716,9 @@ describe('API', function() local win = nvim('get_current_win').id insert('some text') feed('0v$') - eq({1, 9}, nvim('win_get_cursor', win)) - nvim('get_option_value', 'filetype', {buf = buf}) - eq({1, 9}, nvim('win_get_cursor', win)) + eq({ 1, 9 }, nvim('win_get_cursor', win)) + nvim('get_option_value', 'filetype', { buf = buf }) + eq({ 1, 9 }, nvim('win_get_cursor', win)) end) it('can get default option values for filetypes', function() @@ -1584,23 +1726,25 @@ describe('API', function() for ft, opts in pairs { lua = { commentstring = '-- %s' }, vim = { commentstring = '"%s' }, - man = { tagfunc = 'v:lua.require\'man\'.goto_tag' }, - xml = { formatexpr = 'xmlformat#Format()' } + man = { tagfunc = "v:lua.require'man'.goto_tag" }, + xml = { formatexpr = 'xmlformat#Format()' }, } do for option, value in pairs(opts) do eq(value, nvim('get_option_value', option, { filetype = ft })) end end - command'au FileType lua setlocal commentstring=NEW\\ %s' + command 'au FileType lua setlocal commentstring=NEW\\ %s' eq('NEW %s', nvim('get_option_value', 'commentstring', { filetype = 'lua' })) end) it('errors for bad FileType autocmds', function() - command'au FileType lua setlocal commentstring=BAD' - eq([[FileType Autocommands for "lua": Vim(setlocal):E537: 'commentstring' must be empty or contain %s: commentstring=BAD]], - pcall_err(nvim, 'get_option_value', 'commentstring', { filetype = 'lua' })) + command 'au FileType lua setlocal commentstring=BAD' + eq( + [[FileType Autocommands for "lua": Vim(setlocal):E537: 'commentstring' must be empty or contain %s: commentstring=BAD]], + pcall_err(nvim, 'get_option_value', 'commentstring', { filetype = 'lua' }) + ) end) it("value of 'modified' is always false for scratch buffers", function() @@ -1659,83 +1803,83 @@ describe('API', function() end) describe('nvim_get_mode', function() - it("during normal-mode `g` returns blocking=true", function() - nvim("input", "o") -- add a line - eq({mode='i', blocking=false}, nvim("get_mode")) - nvim("input", [[]]) - eq(2, nvim("eval", "line('.')")) - eq({mode='n', blocking=false}, nvim("get_mode")) + it('during normal-mode `g` returns blocking=true', function() + nvim('input', 'o') -- add a line + eq({ mode = 'i', blocking = false }, nvim('get_mode')) + nvim('input', [[]]) + eq(2, nvim('eval', "line('.')")) + eq({ mode = 'n', blocking = false }, nvim('get_mode')) - nvim("input", "g") - eq({mode='n', blocking=true}, nvim("get_mode")) + nvim('input', 'g') + eq({ mode = 'n', blocking = true }, nvim('get_mode')) - nvim("input", "k") -- complete the operator - eq(1, nvim("eval", "line('.')")) -- verify the completed operator - eq({mode='n', blocking=false}, nvim("get_mode")) + nvim('input', 'k') -- complete the operator + eq(1, nvim('eval', "line('.')")) -- verify the completed operator + eq({ mode = 'n', blocking = false }, nvim('get_mode')) end) - it("returns the correct result multiple consecutive times", function() - for _ = 1,5 do - eq({mode='n', blocking=false}, nvim("get_mode")) + it('returns the correct result multiple consecutive times', function() + for _ = 1, 5 do + eq({ mode = 'n', blocking = false }, nvim('get_mode')) end - nvim("input", "g") - for _ = 1,4 do - eq({mode='n', blocking=true}, nvim("get_mode")) + nvim('input', 'g') + for _ = 1, 4 do + eq({ mode = 'n', blocking = true }, nvim('get_mode')) end - nvim("input", "g") - for _ = 1,7 do - eq({mode='n', blocking=false}, nvim("get_mode")) + nvim('input', 'g') + for _ = 1, 7 do + eq({ mode = 'n', blocking = false }, nvim('get_mode')) end end) - it("during normal-mode CTRL-W, returns blocking=true", function() - nvim("input", "") - eq({mode='n', blocking=true}, nvim("get_mode")) + it('during normal-mode CTRL-W, returns blocking=true', function() + nvim('input', '') + eq({ mode = 'n', blocking = true }, nvim('get_mode')) - nvim("input", "s") -- complete the operator - eq(2, nvim("eval", "winnr('$')")) -- verify the completed operator - eq({mode='n', blocking=false}, nvim("get_mode")) + nvim('input', 's') -- complete the operator + eq(2, nvim('eval', "winnr('$')")) -- verify the completed operator + eq({ mode = 'n', blocking = false }, nvim('get_mode')) end) - it("during press-enter prompt without UI returns blocking=false", function() - eq({mode='n', blocking=false}, nvim("get_mode")) + it('during press-enter prompt without UI returns blocking=false', function() + eq({ mode = 'n', blocking = false }, nvim('get_mode')) command("echom 'msg1'") command("echom 'msg2'") command("echom 'msg3'") command("echom 'msg4'") command("echom 'msg5'") - eq({mode='n', blocking=false}, nvim("get_mode")) - nvim("input", ":messages") - eq({mode='n', blocking=false}, nvim("get_mode")) + eq({ mode = 'n', blocking = false }, nvim('get_mode')) + nvim('input', ':messages') + eq({ mode = 'n', blocking = false }, nvim('get_mode')) end) - it("during press-enter prompt returns blocking=true", function() - nvim("ui_attach", 80, 20, {}) - eq({mode='n', blocking=false}, nvim("get_mode")) + it('during press-enter prompt returns blocking=true', function() + nvim('ui_attach', 80, 20, {}) + eq({ mode = 'n', blocking = false }, nvim('get_mode')) command("echom 'msg1'") command("echom 'msg2'") command("echom 'msg3'") command("echom 'msg4'") command("echom 'msg5'") - eq({mode='n', blocking=false}, nvim("get_mode")) - nvim("input", ":messages") - eq({mode='r', blocking=true}, nvim("get_mode")) + eq({ mode = 'n', blocking = false }, nvim('get_mode')) + nvim('input', ':messages') + eq({ mode = 'r', blocking = true }, nvim('get_mode')) end) - it("during getchar() returns blocking=false", function() - nvim("input", ":let g:test_input = nr2char(getchar())") + it('during getchar() returns blocking=false', function() + nvim('input', ':let g:test_input = nr2char(getchar())') -- Events are enabled during getchar(), RPC calls are *not* blocked. #5384 - eq({mode='n', blocking=false}, nvim("get_mode")) - eq(0, nvim("eval", "exists('g:test_input')")) - nvim("input", "J") - eq("J", nvim("eval", "g:test_input")) - eq({mode='n', blocking=false}, nvim("get_mode")) + eq({ mode = 'n', blocking = false }, nvim('get_mode')) + eq(0, nvim('eval', "exists('g:test_input')")) + nvim('input', 'J') + eq('J', nvim('eval', 'g:test_input')) + eq({ mode = 'n', blocking = false }, nvim('get_mode')) end) -- TODO: bug #6247#issuecomment-286403810 - it("batched with input", function() - nvim("ui_attach", 80, 20, {}) - eq({mode='n', blocking=false}, nvim("get_mode")) + it('batched with input', function() + nvim('ui_attach', 80, 20, {}) + eq({ mode = 'n', blocking = false }, nvim('get_mode')) command("echom 'msg1'") command("echom 'msg2'") command("echom 'msg3'") @@ -1743,44 +1887,48 @@ describe('API', function() command("echom 'msg5'") local req = { - {'nvim_get_mode', {}}, - {'nvim_input', {':messages'}}, - {'nvim_get_mode', {}}, - {'nvim_eval', {'1'}}, + { 'nvim_get_mode', {} }, + { 'nvim_input', { ':messages' } }, + { 'nvim_get_mode', {} }, + { 'nvim_eval', { '1' } }, } - eq({ { {mode='n', blocking=false}, - 13, - {mode='n', blocking=false}, -- TODO: should be blocked=true ? - 1 }, - NIL}, meths.call_atomic(req)) - eq({mode='r', blocking=true}, nvim("get_mode")) + eq({ + { + { mode = 'n', blocking = false }, + 13, + { mode = 'n', blocking = false }, -- TODO: should be blocked=true ? + 1, + }, + NIL, + }, meths.call_atomic(req)) + eq({ mode = 'r', blocking = true }, nvim('get_mode')) end) - it("during insert-mode map-pending, returns blocking=true #6166", function() - command("inoremap xx foo") - nvim("input", "ix") - eq({mode='i', blocking=true}, nvim("get_mode")) + it('during insert-mode map-pending, returns blocking=true #6166', function() + command('inoremap xx foo') + nvim('input', 'ix') + eq({ mode = 'i', blocking = true }, nvim('get_mode')) end) - it("during normal-mode gU, returns blocking=false #6166", function() - nvim("input", "gu") - eq({mode='no', blocking=false}, nvim("get_mode")) + it('during normal-mode gU, returns blocking=false #6166', function() + nvim('input', 'gu') + eq({ mode = 'no', blocking = false }, nvim('get_mode')) end) it("at '-- More --' prompt returns blocking=true #11899", function() command('set more') feed(':digraphs') - eq({mode='rm', blocking=true}, nvim("get_mode")) + eq({ mode = 'rm', blocking = true }, nvim('get_mode')) end) it('after mapping returns blocking=false #17257', function() command('nnoremap ') feed('') - eq({mode='n', blocking=false}, nvim("get_mode")) + eq({ mode = 'n', blocking = false }, nvim('get_mode')) end) it('after empty string mapping returns blocking=false #17257', function() command('nnoremap ""') feed('') - eq({mode='n', blocking=false}, nvim("get_mode")) + eq({ mode = 'n', blocking = false }, nvim('get_mode')) end) end) @@ -1856,64 +2004,67 @@ describe('API', function() it('does not interrupt Insert mode i_CTRL-O #10035', function() feed('iHello World') - eq({mode='niI', blocking=false}, meths.get_mode()) -- fast event - eq(2, eval('1+1')) -- causes K_EVENT key - eq({mode='niI', blocking=false}, meths.get_mode()) -- still in ctrl-o mode + eq({ mode = 'niI', blocking = false }, meths.get_mode()) -- fast event + eq(2, eval('1+1')) -- causes K_EVENT key + eq({ mode = 'niI', blocking = false }, meths.get_mode()) -- still in ctrl-o mode feed('dd') - eq({mode='i', blocking=false}, meths.get_mode()) -- left ctrl-o mode + eq({ mode = 'i', blocking = false }, meths.get_mode()) -- left ctrl-o mode expect('') -- executed the command end) it('does not interrupt Select mode v_CTRL-O #15688', function() feed('iHello Worldgh') - eq({mode='vs', blocking=false}, meths.get_mode()) -- fast event - eq({mode='vs', blocking=false}, meths.get_mode()) -- again #15288 - eq(2, eval('1+1')) -- causes K_EVENT key - eq({mode='vs', blocking=false}, meths.get_mode()) -- still in ctrl-o mode + eq({ mode = 'vs', blocking = false }, meths.get_mode()) -- fast event + eq({ mode = 'vs', blocking = false }, meths.get_mode()) -- again #15288 + eq(2, eval('1+1')) -- causes K_EVENT key + eq({ mode = 'vs', blocking = false }, meths.get_mode()) -- still in ctrl-o mode feed('^') - eq({mode='s', blocking=false}, meths.get_mode()) -- left ctrl-o mode + eq({ mode = 's', blocking = false }, meths.get_mode()) -- left ctrl-o mode feed('h') - eq({mode='i', blocking=false}, meths.get_mode()) -- entered insert mode - expect('h') -- selection is the whole line and is replaced + eq({ mode = 'i', blocking = false }, meths.get_mode()) -- entered insert mode + expect('h') -- selection is the whole line and is replaced end) it('does not interrupt Insert mode i_0_CTRL-D #13997', function() command('set timeoutlen=9999') feed('ia0') - eq(2, eval('1+1')) -- causes K_EVENT key + eq(2, eval('1+1')) -- causes K_EVENT key feed('') - expect('a') -- recognized i_0_CTRL-D + expect('a') -- recognized i_0_CTRL-D end) it("does not interrupt with 'digraph'", function() command('set digraph') feed('i,') - eq(2, eval('1+1')) -- causes K_EVENT key + eq(2, eval('1+1')) -- causes K_EVENT key feed('') - eq(2, eval('1+1')) -- causes K_EVENT key + eq(2, eval('1+1')) -- causes K_EVENT key feed('.') - expect('…') -- digraph ",." worked + expect('…') -- digraph ",." worked feed('') feed(':,') - eq(2, eval('1+1')) -- causes K_EVENT key + eq(2, eval('1+1')) -- causes K_EVENT key feed('') - eq(2, eval('1+1')) -- causes K_EVENT key + eq(2, eval('1+1')) -- causes K_EVENT key feed('.') - eq('…', funcs.getcmdline()) -- digraph ",." worked + eq('…', funcs.getcmdline()) -- digraph ",." worked end) end) describe('nvim_get_context', function() it('validation', function() - eq("Invalid key: 'blah'", - pcall_err(nvim, 'get_context', {blah={}})) - eq("Invalid 'types': expected Array, got Integer", - pcall_err(nvim, 'get_context', {types=42})) - eq("Invalid 'type': 'zub'", - pcall_err(nvim, 'get_context', {types={'jumps', 'zub', 'zam',}})) + eq("Invalid key: 'blah'", pcall_err(nvim, 'get_context', { blah = {} })) + eq( + "Invalid 'types': expected Array, got Integer", + pcall_err(nvim, 'get_context', { types = 42 }) + ) + eq( + "Invalid 'type': 'zub'", + pcall_err(nvim, 'get_context', { types = { 'jumps', 'zub', 'zam' } }) + ) end) it('returns map of current editor state', function() - local opts = {types={'regs', 'jumps', 'bufs', 'gvars'}} + local opts = { types = { 'regs', 'jumps', 'bufs', 'gvars' } } eq({}, parse_context(nvim('get_context', {}))) feed('i123ddddddqahjklquuu') @@ -1927,10 +2078,10 @@ describe('API', function() local expected_ctx = { ['regs'] = { - {['rt'] = 1, ['rc'] = {'1'}, ['n'] = 49, ['ru'] = true}, - {['rt'] = 1, ['rc'] = {'2'}, ['n'] = 50}, - {['rt'] = 1, ['rc'] = {'3'}, ['n'] = 51}, - {['rc'] = {'hjkl'}, ['n'] = 97}, + { ['rt'] = 1, ['rc'] = { '1' }, ['n'] = 49, ['ru'] = true }, + { ['rt'] = 1, ['rc'] = { '2' }, ['n'] = 50 }, + { ['rt'] = 1, ['rc'] = { '3' }, ['n'] = 51 }, + { ['rc'] = { 'hjkl' }, ['n'] = 97 }, }, ['jumps'] = eval(([[ @@ -1945,18 +2096,18 @@ describe('API', function() filter(map(getbufinfo(), '{ "f": v:val.name }'), '!empty(v:val.f)') ]]), - ['gvars'] = {{'one', 1}, {'Two', 2}, {'THREE', 3}}, + ['gvars'] = { { 'one', 1 }, { 'Two', 2 }, { 'THREE', 3 } }, } eq(expected_ctx, parse_context(nvim('get_context', opts))) eq(expected_ctx, parse_context(nvim('get_context', {}))) - eq(expected_ctx, parse_context(nvim('get_context', {types={}}))) + eq(expected_ctx, parse_context(nvim('get_context', { types = {} }))) end) end) describe('nvim_load_context', function() it('sets current editor state to given context dictionary', function() - local opts = {types={'regs', 'jumps', 'bufs', 'gvars'}} + local opts = { types = { 'regs', 'jumps', 'bufs', 'gvars' } } eq({}, parse_context(nvim('get_context', opts))) nvim('set_var', 'one', 1) @@ -1966,16 +2117,20 @@ describe('API', function() nvim('set_var', 'one', 'a') nvim('set_var', 'Two', 'b') nvim('set_var', 'THREE', 'c') - eq({'a', 'b' ,'c'}, eval('[g:one, g:Two, g:THREE]')) + eq({ 'a', 'b', 'c' }, eval('[g:one, g:Two, g:THREE]')) nvim('load_context', ctx) - eq({1, 2 ,3}, eval('[g:one, g:Two, g:THREE]')) + eq({ 1, 2, 3 }, eval('[g:one, g:Two, g:THREE]')) end) it('errors when context dictionary is invalid', function() - eq('E474: Failed to convert list to msgpack string buffer', - pcall_err(nvim, 'load_context', { regs = { {} }, jumps = { {} } })) - eq('E474: Failed to convert list to msgpack string buffer', - pcall_err(nvim, 'load_context', { regs = { { [''] = '' } } })) + eq( + 'E474: Failed to convert list to msgpack string buffer', + pcall_err(nvim, 'load_context', { regs = { {} }, jumps = { {} } }) + ) + eq( + 'E474: Failed to convert list to msgpack string buffer', + pcall_err(nvim, 'load_context', { regs = { { [''] = '' } } }) + ) end) end) @@ -1996,18 +2151,21 @@ describe('API', function() -- K_SPECIAL KS_EXTRA KE_LEFTMOUSE -- 0x80 0xfd 0x2c -- 128 253 44 - eq('\128\253\44', helpers.nvim('replace_termcodes', - '', true, true, true)) + eq('\128\253\44', helpers.nvim('replace_termcodes', '', true, true, true)) end) it('converts keycodes', function() - eq('\nx\27x\rxxxxx', true, true, true)) + eq( + '\nx\27x\rxxxxx', true, true, true) + ) end) it('does not convert keycodes if special=false', function() - eq('xxxx', helpers.nvim('replace_termcodes', - 'xxxx', true, true, false)) + eq( + 'xxxx', + helpers.nvim('replace_termcodes', 'xxxx', true, true, false) + ) end) it('does not crash when transforming an empty string', function() @@ -2036,11 +2194,11 @@ describe('API', function() -- Both nvim_replace_termcodes and nvim_feedkeys escape \x80 local inp = helpers.nvim('replace_termcodes', ':let x2="…"', true, true, true) - nvim('feedkeys', inp, '', true) -- escape_ks=true + nvim('feedkeys', inp, '', true) -- escape_ks=true -- nvim_feedkeys with K_SPECIAL escaping disabled inp = helpers.nvim('replace_termcodes', ':let x3="…"', true, true, true) - nvim('feedkeys', inp, '', false) -- escape_ks=false + nvim('feedkeys', inp, '', false) -- escape_ks=false helpers.stop() end @@ -2062,10 +2220,10 @@ describe('API', function() screen = Screen.new(40, 8) screen:attach() screen:set_default_attr_ids({ - [0] = {bold = true, foreground = Screen.colors.Blue}, - [1] = {bold = true, foreground = Screen.colors.SeaGreen}, - [2] = {bold = true, reverse = true}, - [3] = {foreground = Screen.colors.Blue}, + [0] = { bold = true, foreground = Screen.colors.Blue }, + [1] = { bold = true, foreground = Screen.colors.SeaGreen }, + [2] = { bold = true, reverse = true }, + [3] = { foreground = Screen.colors.Blue }, }) end) @@ -2091,17 +2249,20 @@ describe('API', function() it('blank line in message', function() feed([[:call nvim_out_write("\na\n")]]) - screen:expect{grid=[[ + screen:expect { + grid = [[ | {0:~ }|*3 {2: }| | a | {1:Press ENTER or type command to continue}^ | - ]]} + ]], + } feed('') feed([[:call nvim_out_write("b\n\nc\n")]]) - screen:expect{grid=[[ + screen:expect { + grid = [[ | {0:~ }|*2 {2: }| @@ -2109,19 +2270,22 @@ describe('API', function() | c | {1:Press ENTER or type command to continue}^ | - ]]} + ]], + } end) it('NUL bytes in message', function() feed([[:lua vim.api.nvim_out_write('aaa\0bbb\0\0ccc\nddd\0\0\0eee\n')]]) - screen:expect{grid=[[ + screen:expect { + grid = [[ | {0:~ }|*3 {2: }| aaa{3:^@}bbb{3:^@^@}ccc | ddd{3:^@^@^@}eee | {1:Press ENTER or type command to continue}^ | - ]]} + ]], + } end) end) @@ -2132,10 +2296,10 @@ describe('API', function() screen = Screen.new(40, 8) screen:attach() screen:set_default_attr_ids({ - [0] = {bold=true, foreground=Screen.colors.Blue}, - [1] = {foreground = Screen.colors.White, background = Screen.colors.Red}, - [2] = {bold = true, foreground = Screen.colors.SeaGreen}, - [3] = {bold = true, reverse = true}, + [0] = { bold = true, foreground = Screen.colors.Blue }, + [1] = { foreground = Screen.colors.White, background = Screen.colors.Red }, + [2] = { bold = true, foreground = Screen.colors.SeaGreen }, + [3] = { bold = true, reverse = true }, }) end) @@ -2195,19 +2359,21 @@ describe('API', function() {1:too fail} | {2:Press ENTER or type command to continue}^ | ]]) - feed('') -- exit the press ENTER screen + feed('') -- exit the press ENTER screen end) it('NUL bytes in message', function() nvim_async('err_write', 'aaa\0bbb\0\0ccc\nddd\0\0\0eee\n') - screen:expect{grid=[[ + screen:expect { + grid = [[ | {0:~ }|*3 {3: }| {1:aaa^@bbb^@^@ccc} | {1:ddd^@^@^@eee} | {2:Press ENTER or type command to continue}^ | - ]]} + ]], + } end) end) @@ -2218,10 +2384,10 @@ describe('API', function() screen = Screen.new(40, 8) screen:attach() screen:set_default_attr_ids({ - [0] = {bold=true, foreground=Screen.colors.Blue}, - [1] = {foreground = Screen.colors.White, background = Screen.colors.Red}, - [2] = {bold = true, foreground = Screen.colors.SeaGreen}, - [3] = {bold = true, reverse = true}, + [0] = { bold = true, foreground = Screen.colors.Blue }, + [1] = { foreground = Screen.colors.White, background = Screen.colors.Red }, + [2] = { bold = true, foreground = Screen.colors.SeaGreen }, + [3] = { bold = true, reverse = true }, }) end) @@ -2271,29 +2437,31 @@ describe('API', function() end) it('stream=stdio channel', function() - eq({[1]=testinfo,[2]=stderr}, meths.list_chans()) + eq({ [1] = testinfo, [2] = stderr }, meths.list_chans()) eq(testinfo, meths.get_chan_info(1)) eq(stderr, meths.get_chan_info(2)) - meths.set_client_info("functionaltests", - {major=0, minor=3, patch=17}, - 'ui', - {do_stuff={n_args={2,3}}}, - {license= 'Apache2'}) + meths.set_client_info( + 'functionaltests', + { major = 0, minor = 3, patch = 17 }, + 'ui', + { do_stuff = { n_args = { 2, 3 } } }, + { license = 'Apache2' } + ) local info = { stream = 'stdio', id = 1, mode = 'rpc', client = { - name='functionaltests', - version={major=0, minor=3, patch=17}, - type='ui', - methods={do_stuff={n_args={2,3}}}, - attributes={license='Apache2'}, + name = 'functionaltests', + version = { major = 0, minor = 3, patch = 17 }, + type = 'ui', + methods = { do_stuff = { n_args = { 2, 3 } } }, + attributes = { license = 'Apache2' }, }, } - eq({info=info}, meths.get_var("info_event")) - eq({[1]=info, [2]=stderr}, meths.list_chans()) + eq({ info = info }, meths.get_var('info_event')) + eq({ [1] = info, [2] = stderr }, meths.list_chans()) eq(info, meths.get_chan_info(1)) end) @@ -2301,83 +2469,85 @@ describe('API', function() eq(3, eval("jobstart(['cat'], {'rpc': v:true})")) local catpath = eval('exepath("cat")') local info = { - stream='job', - id=3, - argv={ catpath }, - mode='rpc', - client={}, + stream = 'job', + id = 3, + argv = { catpath }, + mode = 'rpc', + client = {}, } - eq({info=info}, meths.get_var("opened_event")) - eq({[1]=testinfo,[2]=stderr,[3]=info}, meths.list_chans()) + eq({ info = info }, meths.get_var('opened_event')) + eq({ [1] = testinfo, [2] = stderr, [3] = info }, meths.list_chans()) eq(info, meths.get_chan_info(3)) - eval('rpcrequest(3, "nvim_set_client_info", "amazing-cat", {}, "remote",'.. - '{"nvim_command":{"n_args":1}},'.. -- and so on - '{"description":"The Amazing Cat"})') + eval( + 'rpcrequest(3, "nvim_set_client_info", "amazing-cat", {}, "remote",' + .. '{"nvim_command":{"n_args":1}},' -- and so on + .. '{"description":"The Amazing Cat"})' + ) info = { - stream='job', - id=3, - argv={ catpath }, - mode='rpc', + stream = 'job', + id = 3, + argv = { catpath }, + mode = 'rpc', client = { - name='amazing-cat', - version={major=0}, - type='remote', - methods={nvim_command={n_args=1}}, - attributes={description="The Amazing Cat"}, + name = 'amazing-cat', + version = { major = 0 }, + type = 'remote', + methods = { nvim_command = { n_args = 1 } }, + attributes = { description = 'The Amazing Cat' }, }, } - eq({info=info}, meths.get_var("info_event")) - eq({[1]=testinfo,[2]=stderr,[3]=info}, meths.list_chans()) + eq({ info = info }, meths.get_var('info_event')) + eq({ [1] = testinfo, [2] = stderr, [3] = info }, meths.list_chans()) - eq("Vim:Error invoking 'nvim_set_current_buf' on channel 3 (amazing-cat):\nWrong type for argument 1 when calling nvim_set_current_buf, expecting Buffer", - pcall_err(eval, 'rpcrequest(3, "nvim_set_current_buf", -1)')) + eq( + "Vim:Error invoking 'nvim_set_current_buf' on channel 3 (amazing-cat):\nWrong type for argument 1 when calling nvim_set_current_buf, expecting Buffer", + pcall_err(eval, 'rpcrequest(3, "nvim_set_current_buf", -1)') + ) end) it('stream=job :terminal channel', function() command(':terminal') - eq({id=1}, meths.get_current_buf()) - eq(3, meths.get_option_value('channel', {buf=1})) + eq({ id = 1 }, meths.get_current_buf()) + eq(3, meths.get_option_value('channel', { buf = 1 })) local info = { - stream='job', - id=3, - argv={ eval('exepath(&shell)') }, - mode='terminal', + stream = 'job', + id = 3, + argv = { eval('exepath(&shell)') }, + mode = 'terminal', buffer = 1, - pty='?', + pty = '?', } - local event = meths.get_var("opened_event") + local event = meths.get_var('opened_event') if not is_os('win') then info.pty = event.info.pty - neq(nil, string.match(info.pty, "^/dev/")) + neq(nil, string.match(info.pty, '^/dev/')) end - eq({info=info}, event) - info.buffer = {id=1} - eq({[1]=testinfo,[2]=stderr,[3]=info}, meths.list_chans()) + eq({ info = info }, event) + info.buffer = { id = 1 } + eq({ [1] = testinfo, [2] = stderr, [3] = info }, meths.list_chans()) eq(info, meths.get_chan_info(3)) -- :terminal with args + running process. command('enew') local progpath_esc = eval('shellescape(v:progpath)') funcs.termopen(('%s -u NONE -i NONE'):format(progpath_esc), { - env = { VIMRUNTIME = os.getenv('VIMRUNTIME') } + env = { VIMRUNTIME = os.getenv('VIMRUNTIME') }, }) - eq(-1, eval('jobwait([&channel], 0)[0]')) -- Running? + eq(-1, eval('jobwait([&channel], 0)[0]')) -- Running? local expected2 = { stream = 'job', id = 4, - argv = ( - is_os('win') and { - eval('&shell'), - '/s', - '/c', - fmt('"%s -u NONE -i NONE"', progpath_esc), - } or { - eval('&shell'), - eval('&shellcmdflag'), - fmt('%s -u NONE -i NONE', progpath_esc), - } - ), + argv = (is_os('win') and { + eval('&shell'), + '/s', + '/c', + fmt('"%s -u NONE -i NONE"', progpath_esc), + } or { + eval('&shell'), + eval('&shellcmdflag'), + fmt('%s -u NONE -i NONE', progpath_esc), + }), mode = 'terminal', buffer = 2, pty = '?', @@ -2388,74 +2558,82 @@ describe('API', function() -- :terminal with args + stopped process. eq(1, eval('jobstop(&channel)')) - eval('jobwait([&channel], 1000)') -- Wait. - expected2.pty = (is_os('win') and '?' or '') -- pty stream was closed. + eval('jobwait([&channel], 1000)') -- Wait. + expected2.pty = (is_os('win') and '?' or '') -- pty stream was closed. eq(expected2, eval('nvim_get_chan_info(&channel)')) end) end) describe('nvim_call_atomic', function() it('works', function() - meths.buf_set_lines(0, 0, -1, true, {'first'}) + meths.buf_set_lines(0, 0, -1, true, { 'first' }) local req = { - {'nvim_get_current_line', {}}, - {'nvim_set_current_line', {'second'}}, + { 'nvim_get_current_line', {} }, + { 'nvim_set_current_line', { 'second' } }, } - eq({{'first', NIL}, NIL}, meths.call_atomic(req)) - eq({'second'}, meths.buf_get_lines(0, 0, -1, true)) + eq({ { 'first', NIL }, NIL }, meths.call_atomic(req)) + eq({ 'second' }, meths.buf_get_lines(0, 0, -1, true)) end) it('allows multiple return values', function() local req = { - {'nvim_set_var', {'avar', true}}, - {'nvim_set_var', {'bvar', 'string'}}, - {'nvim_get_var', {'avar'}}, - {'nvim_get_var', {'bvar'}}, + { 'nvim_set_var', { 'avar', true } }, + { 'nvim_set_var', { 'bvar', 'string' } }, + { 'nvim_get_var', { 'avar' } }, + { 'nvim_get_var', { 'bvar' } }, } - eq({{NIL, NIL, true, 'string'}, NIL}, meths.call_atomic(req)) + eq({ { NIL, NIL, true, 'string' }, NIL }, meths.call_atomic(req)) end) it('is aborted by errors in call', function() local error_types = meths.get_api_info()[2].error_types local req = { - {'nvim_set_var', {'one', 1}}, - {'nvim_buf_set_lines', {}}, - {'nvim_set_var', {'two', 2}}, + { 'nvim_set_var', { 'one', 1 } }, + { 'nvim_buf_set_lines', {} }, + { 'nvim_set_var', { 'two', 2 } }, } - eq({{NIL}, {1, error_types.Exception.id, - 'Wrong number of arguments: expecting 5 but got 0'}}, - meths.call_atomic(req)) + eq({ + { NIL }, + { + 1, + error_types.Exception.id, + 'Wrong number of arguments: expecting 5 but got 0', + }, + }, meths.call_atomic(req)) eq(1, meths.get_var('one')) eq(false, pcall(meths.get_var, 'two')) -- still returns all previous successful calls req = { - {'nvim_set_var', {'avar', 5}}, - {'nvim_set_var', {'bvar', 'string'}}, - {'nvim_get_var', {'avar'}}, - {'nvim_buf_get_lines', {0, 10, 20, true}}, - {'nvim_get_var', {'bvar'}}, + { 'nvim_set_var', { 'avar', 5 } }, + { 'nvim_set_var', { 'bvar', 'string' } }, + { 'nvim_get_var', { 'avar' } }, + { 'nvim_buf_get_lines', { 0, 10, 20, true } }, + { 'nvim_get_var', { 'bvar' } }, } - eq({{NIL, NIL, 5}, {3, error_types.Validation.id, 'Index out of bounds'}}, - meths.call_atomic(req)) + eq( + { { NIL, NIL, 5 }, { 3, error_types.Validation.id, 'Index out of bounds' } }, + meths.call_atomic(req) + ) req = { - {'i_am_not_a_method', {'xx'}}, - {'nvim_set_var', {'avar', 10}}, + { 'i_am_not_a_method', { 'xx' } }, + { 'nvim_set_var', { 'avar', 10 } }, } - eq({{}, {0, error_types.Exception.id, 'Invalid method: i_am_not_a_method'}}, - meths.call_atomic(req)) + eq( + { {}, { 0, error_types.Exception.id, 'Invalid method: i_am_not_a_method' } }, + meths.call_atomic(req) + ) eq(5, meths.get_var('avar')) end) it('validation', function() local req = { - {'nvim_set_var', {'avar', 1}}, - {'nvim_set_var'}, - {'nvim_set_var', {'avar', 2}}, + { 'nvim_set_var', { 'avar', 1 } }, + { 'nvim_set_var' }, + { 'nvim_set_var', { 'avar', 2 } }, } - eq("Invalid 'calls' item: expected 2-item Array", - pcall_err(meths.call_atomic, req)) + eq("Invalid 'calls' item: expected 2-item Array", pcall_err(meths.call_atomic, req)) -- call before was done, but not after eq(1, meths.get_var('avar')) @@ -2463,27 +2641,25 @@ describe('API', function() { 'nvim_set_var', { 'bvar', { 2, 3 } } }, 12, } - eq("Invalid 'calls' item: expected Array, got Integer", - pcall_err(meths.call_atomic, req)) - eq({2,3}, meths.get_var('bvar')) + eq("Invalid 'calls' item: expected Array, got Integer", pcall_err(meths.call_atomic, req)) + eq({ 2, 3 }, meths.get_var('bvar')) req = { - {'nvim_set_current_line', 'little line'}, - {'nvim_set_var', {'avar', 3}}, + { 'nvim_set_current_line', 'little line' }, + { 'nvim_set_var', { 'avar', 3 } }, } - eq("Invalid call args: expected Array, got String", - pcall_err(meths.call_atomic, req)) + eq('Invalid call args: expected Array, got String', pcall_err(meths.call_atomic, req)) -- call before was done, but not after eq(1, meths.get_var('avar')) - eq({''}, meths.buf_get_lines(0, 0, -1, true)) + eq({ '' }, meths.buf_get_lines(0, 0, -1, true)) end) end) describe('nvim_list_runtime_paths', function() setup(function() local pathsep = helpers.get_pathsep() - mkdir_p('Xtest'..pathsep..'a') - mkdir_p('Xtest'..pathsep..'b') + mkdir_p('Xtest' .. pathsep .. 'a') + mkdir_p('Xtest' .. pathsep .. 'b') end) teardown(function() rmdir 'Xtest' @@ -2498,22 +2674,22 @@ describe('API', function() end) it('returns single runtimepath', function() meths.set_option_value('runtimepath', 'a', {}) - eq({'a'}, meths.list_runtime_paths()) + eq({ 'a' }, meths.list_runtime_paths()) end) it('returns two runtimepaths', function() meths.set_option_value('runtimepath', 'a,b', {}) - eq({'a', 'b'}, meths.list_runtime_paths()) + eq({ 'a', 'b' }, meths.list_runtime_paths()) end) it('returns empty strings when appropriate', function() meths.set_option_value('runtimepath', 'a,,b', {}) - eq({'a', '', 'b'}, meths.list_runtime_paths()) + eq({ 'a', '', 'b' }, meths.list_runtime_paths()) meths.set_option_value('runtimepath', ',a,b', {}) - eq({'', 'a', 'b'}, meths.list_runtime_paths()) + eq({ '', 'a', 'b' }, meths.list_runtime_paths()) -- Trailing "," is ignored. Use ",," if you really really want CWD. meths.set_option_value('runtimepath', 'a,b,', {}) - eq({'a', 'b'}, meths.list_runtime_paths()) + eq({ 'a', 'b' }, meths.list_runtime_paths()) meths.set_option_value('runtimepath', 'a,b,,', {}) - eq({'a', 'b', ''}, meths.list_runtime_paths()) + eq({ 'a', 'b', '' }, meths.list_runtime_paths()) end) it('truncates too long paths', function() local long_path = ('/a'):rep(8192) @@ -2530,16 +2706,19 @@ describe('API', function() end) it('does not truncate error message <1 MB #5984', function() - local very_long_name = 'A'..('x'):rep(10000)..'Z' + local very_long_name = 'A' .. ('x'):rep(10000) .. 'Z' local status, err = pcall(nvim, 'get_option_value', very_long_name, {}) eq(false, status) eq(very_long_name, err:match('Ax+Z?')) end) - it("does not leak memory on incorrect argument types", function() - local status, err = pcall(nvim, 'set_current_dir',{'not', 'a', 'dir'}) + it('does not leak memory on incorrect argument types', function() + local status, err = pcall(nvim, 'set_current_dir', { 'not', 'a', 'dir' }) eq(false, status) - ok(err:match(': Wrong type for argument 1 when calling nvim_set_current_dir, expecting String') ~= nil) + ok( + err:match(': Wrong type for argument 1 when calling nvim_set_current_dir, expecting String') + ~= nil + ) end) describe('nvim_parse_expression', function() @@ -2558,21 +2737,26 @@ describe('API', function() end local typ = east_api_node.type if typ == 'Register' then - typ = typ .. ('(name=%s)'):format( - tostring(intchar2lua(east_api_node.name))) + typ = typ .. ('(name=%s)'):format(tostring(intchar2lua(east_api_node.name))) east_api_node.name = nil elseif typ == 'PlainIdentifier' then - typ = typ .. ('(scope=%s,ident=%s)'):format( - tostring(intchar2lua(east_api_node.scope)), east_api_node.ident) + typ = typ + .. ('(scope=%s,ident=%s)'):format( + tostring(intchar2lua(east_api_node.scope)), + east_api_node.ident + ) east_api_node.scope = nil east_api_node.ident = nil elseif typ == 'PlainKey' then typ = typ .. ('(key=%s)'):format(east_api_node.ident) east_api_node.ident = nil elseif typ == 'Comparison' then - typ = typ .. ('(type=%s,inv=%u,ccs=%s)'):format( - east_api_node.cmp_type, east_api_node.invert and 1 or 0, - east_api_node.ccs_strategy) + typ = typ + .. ('(type=%s,inv=%u,ccs=%s)'):format( + east_api_node.cmp_type, + east_api_node.invert and 1 or 0, + east_api_node.ccs_strategy + ) east_api_node.ccs_strategy = nil east_api_node.cmp_type = nil east_api_node.invert = nil @@ -2589,7 +2773,8 @@ describe('API', function() typ = ('%s(scope=%s,ident=%s)'):format( typ, tostring(intchar2lua(east_api_node.scope)), - east_api_node.ident) + east_api_node.ident + ) east_api_node.ident = nil east_api_node.scope = nil elseif typ == 'Environment' then @@ -2597,24 +2782,30 @@ describe('API', function() east_api_node.ident = nil elseif typ == 'Assignment' then local aug = east_api_node.augmentation - if aug == '' then aug = 'Plain' end + if aug == '' then + aug = 'Plain' + end typ = ('%s(%s)'):format(typ, aug) east_api_node.augmentation = nil end typ = ('%s:%u:%u:%s'):format( - typ, east_api_node.start[1], east_api_node.start[2], - line:sub(east_api_node.start[2] + 1, - east_api_node.start[2] + 1 + east_api_node.len - 1)) + typ, + east_api_node.start[1], + east_api_node.start[2], + line:sub(east_api_node.start[2] + 1, east_api_node.start[2] + 1 + east_api_node.len - 1) + ) assert(east_api_node.start[2] + east_api_node.len - 1 <= #line) for k, _ in pairs(east_api_node.start) do - assert(({true, true})[k]) + assert(({ true, true })[k]) end east_api_node.start = nil east_api_node.type = nil east_api_node.len = nil local can_simplify = true for _, _ in pairs(east_api_node) do - if can_simplify then can_simplify = false end + if can_simplify then + can_simplify = false + end end if can_simplify then return typ @@ -2631,7 +2822,7 @@ describe('API', function() east_api.err.message = nil end if east_api.ast then - east_api.ast = {simplify_east_api_node(line, east_api.ast)} + east_api.ast = { simplify_east_api_node(line, east_api.ast) } if #east_api.ast == 0 then east_api.ast = nil end @@ -2643,26 +2834,21 @@ describe('API', function() end local function simplify_east_hl(line, east_hl) for i, v in ipairs(east_hl) do - east_hl[i] = ('%s:%u:%u:%s'):format( - v[4], - v[1], - v[2], - line:sub(v[2] + 1, v[3])) + east_hl[i] = ('%s:%u:%u:%s'):format(v[4], v[1], v[2], line:sub(v[2] + 1, v[3])) end return east_hl end local FLAGS_TO_STR = { - [0] = "", - [1] = "m", - [2] = "E", - [3] = "mE", - [4] = "l", - [5] = "lm", - [6] = "lE", - [7] = "lmE", + [0] = '', + [1] = 'm', + [2] = 'E', + [3] = 'mE', + [4] = 'l', + [5] = 'lm', + [6] = 'lE', + [7] = 'lmE', } - local function _check_parsing(opts, str, exp_ast, exp_highlighting_fs, - nz_flags_exps) + local function _check_parsing(opts, str, exp_ast, exp_highlighting_fs, nz_flags_exps) if type(str) ~= 'string' then return end @@ -2703,37 +2889,39 @@ describe('API', function() end) if not err then if type(msg) == 'table' then - local merr, new_msg = pcall( - format_string, 'table error:\n%s\n\n(%r)', msg.message, msg) + local merr, new_msg = pcall(format_string, 'table error:\n%s\n\n(%r)', msg.message, msg) if merr then msg = new_msg else - msg = format_string('table error without .message:\n(%r)', - msg) + msg = format_string('table error without .message:\n(%r)', msg) end elseif type(msg) ~= 'string' then msg = format_string('non-string non-table error:\n%r', msg) end - error(format_string('Error while processing test (%r, %s):\n%s', - str, FLAGS_TO_STR[flags], msg)) + error( + format_string( + 'Error while processing test (%r, %s):\n%s', + str, + FLAGS_TO_STR[flags], + msg + ) + ) end end end local function hl(group, str, shift) return function(next_col) local col = next_col + (shift or 0) - return (('%s:%u:%u:%s'):format( - 'Nvim' .. group, - 0, - col, - str)), (col + #str) + return (('%s:%u:%u:%s'):format('Nvim' .. group, 0, col, str)), (col + #str) end end local function fmtn(typ, args, rest) - if (typ == 'UnknownFigure' - or typ == 'DictLiteral' - or typ == 'CurlyBracesIdentifier' - or typ == 'Lambda') then + if + typ == 'UnknownFigure' + or typ == 'DictLiteral' + or typ == 'CurlyBracesIdentifier' + or typ == 'Lambda' + then return ('%s%s'):format(typ, rest) elseif typ == 'DoubleQuotedString' or typ == 'SingleQuotedString' then if args:sub(-4) == 'NULL' then @@ -2742,18 +2930,17 @@ describe('API', function() return ('%s(%s)%s'):format(typ, args, rest) end end - require('test.unit.viml.expressions.parser_tests')( - it, _check_parsing, hl, fmtn) + require('test.unit.viml.expressions.parser_tests')(it, _check_parsing, hl, fmtn) end) describe('nvim_list_uis', function() it('returns empty if --headless', function() -- Test runner defaults to --headless. - eq({}, nvim("list_uis")) + eq({}, nvim('list_uis')) end) it('returns attached UIs', function() local screen = Screen.new(20, 4) - screen:attach({override=true}) + screen:attach({ override = true }) local expected = { { chan = 1, @@ -2775,10 +2962,10 @@ describe('API', function() term_colors = 0, term_name = '', width = 20, - } + }, } - eq(expected, nvim("list_uis")) + eq(expected, nvim('list_uis')) screen:detach() screen = Screen.new(44, 99) @@ -2787,64 +2974,69 @@ describe('API', function() expected[1].override = false expected[1].width = 44 expected[1].height = 99 - eq(expected, nvim("list_uis")) + eq(expected, nvim('list_uis')) end) end) describe('nvim_create_namespace', function() it('works', function() eq({}, meths.get_namespaces()) - eq(1, meths.create_namespace("ns-1")) - eq(2, meths.create_namespace("ns-2")) - eq(1, meths.create_namespace("ns-1")) - eq({["ns-1"]=1, ["ns-2"]=2}, meths.get_namespaces()) - eq(3, meths.create_namespace("")) - eq(4, meths.create_namespace("")) - eq({["ns-1"]=1, ["ns-2"]=2}, meths.get_namespaces()) + eq(1, meths.create_namespace('ns-1')) + eq(2, meths.create_namespace('ns-2')) + eq(1, meths.create_namespace('ns-1')) + eq({ ['ns-1'] = 1, ['ns-2'] = 2 }, meths.get_namespaces()) + eq(3, meths.create_namespace('')) + eq(4, meths.create_namespace('')) + eq({ ['ns-1'] = 1, ['ns-2'] = 2 }, meths.get_namespaces()) end) end) describe('nvim_create_buf', function() it('works', function() - eq({id=2}, meths.create_buf(true, false)) - eq({id=3}, meths.create_buf(false, false)) - eq(' 1 %a "[No Name]" line 1\n'.. - ' 2 h "[No Name]" line 0', - meths.command_output("ls")) + eq({ id = 2 }, meths.create_buf(true, false)) + eq({ id = 3 }, meths.create_buf(false, false)) + eq( + ' 1 %a "[No Name]" line 1\n' + .. ' 2 h "[No Name]" line 0', + meths.command_output('ls') + ) -- current buffer didn't change - eq({id=1}, meths.get_current_buf()) + eq({ id = 1 }, meths.get_current_buf()) local screen = Screen.new(20, 4) screen:attach() - meths.buf_set_lines(2, 0, -1, true, {"some text"}) + meths.buf_set_lines(2, 0, -1, true, { 'some text' }) meths.set_current_buf(2) - screen:expect([[ + screen:expect( + [[ ^some text | {1:~ }|*2 | - ]], { - [1] = {bold = true, foreground = Screen.colors.Blue1}, - }) + ]], + { + [1] = { bold = true, foreground = Screen.colors.Blue1 }, + } + ) end) it('can change buftype before visiting', function() - meths.set_option_value("hidden", false, {}) - eq({id=2}, meths.create_buf(true, false)) - meths.set_option_value("buftype", "nofile", {buf=2}) - meths.buf_set_lines(2, 0, -1, true, {"test text"}) - command("split | buffer 2") - eq({id=2}, meths.get_current_buf()) + meths.set_option_value('hidden', false, {}) + eq({ id = 2 }, meths.create_buf(true, false)) + meths.set_option_value('buftype', 'nofile', { buf = 2 }) + meths.buf_set_lines(2, 0, -1, true, { 'test text' }) + command('split | buffer 2') + eq({ id = 2 }, meths.get_current_buf()) -- if the buf_set_option("buftype") didn't work, this would error out. - command("close") - eq({id=1}, meths.get_current_buf()) + command('close') + eq({ id = 1 }, meths.get_current_buf()) end) - it("does not trigger BufEnter, BufWinEnter", function() - command("let g:fired = v:false") - command("au BufEnter,BufWinEnter * let g:fired = v:true") + it('does not trigger BufEnter, BufWinEnter', function() + command('let g:fired = v:false') + command('au BufEnter,BufWinEnter * let g:fired = v:true') - eq({id=2}, meths.create_buf(true, false)) - meths.buf_set_lines(2, 0, -1, true, {"test", "text"}) + eq({ id = 2 }, meths.create_buf(true, false)) + meths.buf_set_lines(2, 0, -1, true, { 'test', 'text' }) eq(false, eval('g:fired')) end) @@ -2852,7 +3044,7 @@ describe('API', function() it('TextChanged and TextChangedI do not trigger without changes', function() local buf = meths.create_buf(true, false) command([[let g:changed = '']]) - meths.create_autocmd({'TextChanged', 'TextChangedI'}, { + meths.create_autocmd({ 'TextChanged', 'TextChangedI' }, { buffer = buf, command = 'let g:changed ..= mode()', }) @@ -2862,20 +3054,22 @@ describe('API', function() end) it('scratch-buffer', function() - eq({id=2}, meths.create_buf(false, true)) - eq({id=3}, meths.create_buf(true, true)) - eq({id=4}, meths.create_buf(true, true)) + eq({ id = 2 }, meths.create_buf(false, true)) + eq({ id = 3 }, meths.create_buf(true, true)) + eq({ id = 4 }, meths.create_buf(true, true)) local scratch_bufs = { 2, 3, 4 } - eq(' 1 %a "[No Name]" line 1\n'.. - ' 3 h "[Scratch]" line 0\n'.. - ' 4 h "[Scratch]" line 0', - exec_capture('ls')) + eq( + ' 1 %a "[No Name]" line 1\n' + .. ' 3 h "[Scratch]" line 0\n' + .. ' 4 h "[Scratch]" line 0', + exec_capture('ls') + ) -- current buffer didn't change - eq({id=1}, meths.get_current_buf()) + eq({ id = 1 }, meths.get_current_buf()) local screen = Screen.new(20, 4) screen:set_default_attr_ids({ - [1] = {bold = true, foreground = Screen.colors.Blue1}, + [1] = { bold = true, foreground = Screen.colors.Blue1 }, }) screen:attach() @@ -2883,12 +3077,12 @@ describe('API', function() -- Editing a scratch-buffer does NOT change its properties. -- local edited_buf = 2 - meths.buf_set_lines(edited_buf, 0, -1, true, {"some text"}) - for _,b in ipairs(scratch_bufs) do - eq('nofile', meths.get_option_value('buftype', {buf=b})) - eq('hide', meths.get_option_value('bufhidden', {buf=b})) - eq(false, meths.get_option_value('swapfile', {buf=b})) - eq(false, meths.get_option_value('modeline', {buf=b})) + meths.buf_set_lines(edited_buf, 0, -1, true, { 'some text' }) + for _, b in ipairs(scratch_bufs) do + eq('nofile', meths.get_option_value('buftype', { buf = b })) + eq('hide', meths.get_option_value('bufhidden', { buf = b })) + eq(false, meths.get_option_value('swapfile', { buf = b })) + eq(false, meths.get_option_value('modeline', { buf = b })) end -- @@ -2900,10 +3094,10 @@ describe('API', function() {1:~ }|*2 | ]]) - eq('nofile', meths.get_option_value('buftype', {buf=edited_buf})) - eq('hide', meths.get_option_value('bufhidden', {buf=edited_buf})) - eq(false, meths.get_option_value('swapfile', {buf=edited_buf})) - eq(false, meths.get_option_value('modeline', {buf=edited_buf})) + eq('nofile', meths.get_option_value('buftype', { buf = edited_buf })) + eq('hide', meths.get_option_value('bufhidden', { buf = edited_buf })) + eq(false, meths.get_option_value('swapfile', { buf = edited_buf })) + eq(false, meths.get_option_value('modeline', { buf = edited_buf })) -- Scratch buffer can be wiped without error. command('bwipe') @@ -2925,51 +3119,55 @@ describe('API', function() describe('nvim_get_runtime_file', function() local p = helpers.alter_slashes it('can find files', function() - eq({}, meths.get_runtime_file("bork.borkbork", false)) - eq({}, meths.get_runtime_file("bork.borkbork", true)) - eq(1, #meths.get_runtime_file("autoload/msgpack.vim", false)) - eq(1, #meths.get_runtime_file("autoload/msgpack.vim", true)) - local val = meths.get_runtime_file("autoload/remote/*.vim", true) + eq({}, meths.get_runtime_file('bork.borkbork', false)) + eq({}, meths.get_runtime_file('bork.borkbork', true)) + eq(1, #meths.get_runtime_file('autoload/msgpack.vim', false)) + eq(1, #meths.get_runtime_file('autoload/msgpack.vim', true)) + local val = meths.get_runtime_file('autoload/remote/*.vim', true) eq(2, #val) - if endswith(val[1], "define.vim") then - ok(endswith(val[1], p"autoload/remote/define.vim")) - ok(endswith(val[2], p"autoload/remote/host.vim")) + if endswith(val[1], 'define.vim') then + ok(endswith(val[1], p 'autoload/remote/define.vim')) + ok(endswith(val[2], p 'autoload/remote/host.vim')) else - ok(endswith(val[1], p"autoload/remote/host.vim")) - ok(endswith(val[2], p"autoload/remote/define.vim")) + ok(endswith(val[1], p 'autoload/remote/host.vim')) + ok(endswith(val[2], p 'autoload/remote/define.vim')) end - val = meths.get_runtime_file("autoload/remote/*.vim", false) + val = meths.get_runtime_file('autoload/remote/*.vim', false) eq(1, #val) - ok(endswith(val[1], p"autoload/remote/define.vim") - or endswith(val[1], p"autoload/remote/host.vim")) + ok( + endswith(val[1], p 'autoload/remote/define.vim') + or endswith(val[1], p 'autoload/remote/host.vim') + ) - val = meths.get_runtime_file("lua", true) + val = meths.get_runtime_file('lua', true) eq(1, #val) - ok(endswith(val[1], p"lua")) + ok(endswith(val[1], p 'lua')) - val = meths.get_runtime_file("lua/vim", true) + val = meths.get_runtime_file('lua/vim', true) eq(1, #val) - ok(endswith(val[1], p"lua/vim")) + ok(endswith(val[1], p 'lua/vim')) end) it('can find directories', function() - local val = meths.get_runtime_file("lua/", true) + local val = meths.get_runtime_file('lua/', true) eq(1, #val) - ok(endswith(val[1], p"lua/")) + ok(endswith(val[1], p 'lua/')) - val = meths.get_runtime_file("lua/vim/", true) + val = meths.get_runtime_file('lua/vim/', true) eq(1, #val) - ok(endswith(val[1], p"lua/vim/")) + ok(endswith(val[1], p 'lua/vim/')) - eq({}, meths.get_runtime_file("foobarlang/", true)) + eq({}, meths.get_runtime_file('foobarlang/', true)) end) it('can handle bad patterns', function() skip(is_os('win')) - eq("Vim:E220: Missing }.", pcall_err(meths.get_runtime_file, "{", false)) + eq('Vim:E220: Missing }.', pcall_err(meths.get_runtime_file, '{', false)) - eq('Vim(echo):E5555: API call: Vim:E220: Missing }.', - exc_exec("echo nvim_get_runtime_file('{', v:false)")) + eq( + 'Vim(echo):E5555: API call: Vim:E220: Missing }.', + exc_exec("echo nvim_get_runtime_file('{', v:false)") + ) end) end) @@ -2979,11 +3177,11 @@ describe('API', function() neq(nil, options_info.listchars) neq(nil, options_info.tabstop) - eq(meths.get_option_info'winhighlight', options_info.winhighlight) + eq(meths.get_option_info 'winhighlight', options_info.winhighlight) end) it('should not crash when echoed', function() - meths.exec2("echo nvim_get_all_options_info()", { output = true }) + meths.exec2('echo nvim_get_all_options_info()', { output = true }) end) end) @@ -2993,43 +3191,43 @@ describe('API', function() end) it('should return the same options for short and long name', function() - eq(meths.get_option_info'winhl', meths.get_option_info'winhighlight') + eq(meths.get_option_info 'winhl', meths.get_option_info 'winhighlight') end) it('should have information about window options', function() eq({ allows_duplicates = false, - commalist = true; - default = ""; - flaglist = false; - global_local = false; - last_set_chan = 0; - last_set_linenr = 0; - last_set_sid = 0; - name = "winhighlight"; - scope = "win"; - shortname = "winhl"; - type = "string"; - was_set = false; - }, meths.get_option_info'winhl') + commalist = true, + default = '', + flaglist = false, + global_local = false, + last_set_chan = 0, + last_set_linenr = 0, + last_set_sid = 0, + name = 'winhighlight', + scope = 'win', + shortname = 'winhl', + type = 'string', + was_set = false, + }, meths.get_option_info 'winhl') end) it('should have information about buffer options', function() eq({ allows_duplicates = true, commalist = false, - default = "", + default = '', flaglist = false, global_local = false, last_set_chan = 0, last_set_linenr = 0, last_set_sid = 0, - name = "filetype", - scope = "buf", - shortname = "ft", - type = "string", - was_set = false - }, meths.get_option_info'filetype') + name = 'filetype', + scope = 'buf', + shortname = 'ft', + type = 'string', + was_set = false, + }, meths.get_option_info 'filetype') end) it('should have information about global options', function() @@ -3046,12 +3244,12 @@ describe('API', function() last_set_chan = 0, last_set_linenr = 0, last_set_sid = -2, - name = "showcmd", - scope = "global", - shortname = "sc", - type = "boolean", - was_set = true - }, meths.get_option_info'showcmd') + name = 'showcmd', + scope = 'global', + shortname = 'sc', + type = 'boolean', + was_set = true, + }, meths.get_option_info 'showcmd') meths.set_option_value('showcmd', true, {}) @@ -3064,12 +3262,12 @@ describe('API', function() last_set_chan = 1, last_set_linenr = 0, last_set_sid = -9, - name = "showcmd", - scope = "global", - shortname = "sc", - type = "boolean", - was_set = true - }, meths.get_option_info'showcmd') + name = 'showcmd', + scope = 'global', + shortname = 'sc', + type = 'boolean', + was_set = true, + }, meths.get_option_info 'showcmd') end) end) @@ -3080,7 +3278,9 @@ describe('API', function() before_each(function() fname = tmpname() - write_file(fname, [[ + write_file( + fname, + [[ setglobal dictionary=mydict " 1, global-local (buffer) setlocal formatprg=myprg " 2, global-local (buffer) setglobal equalprg=prg1 " 3, global-local (buffer) @@ -3090,7 +3290,8 @@ describe('API', function() setglobal showbreak=aaa " 7, global-local (window) setlocal showbreak=bbb " 8, global-local (window) setglobal completeopt=menu " 9, global - ]]) + ]] + ) exec_lua 'vim.cmd.vsplit()' meths.create_buf(false, false) @@ -3112,12 +3313,13 @@ describe('API', function() end) it('should return option information', function() - eq(meths.get_option_info('dictionary'), meths.get_option_info2('dictionary', {})) -- buffer - eq(meths.get_option_info('fillchars'), meths.get_option_info2('fillchars', {})) -- window + eq(meths.get_option_info('dictionary'), meths.get_option_info2('dictionary', {})) -- buffer + eq(meths.get_option_info('fillchars'), meths.get_option_info2('fillchars', {})) -- window eq(meths.get_option_info('completeopt'), meths.get_option_info2('completeopt', {})) -- global end) describe('last set', function() + -- stylua: ignore local tests = { {desc="(buf option, global requested, global set) points to global", linenr=1, sid=1, args={'dictionary', {scope='global'}}}, {desc="(buf option, global requested, local set) is not set", linenr=0, sid=0, args={'formatprg', {scope='global'}}}, @@ -3153,13 +3355,13 @@ describe('API', function() end it('is provided for cross-buffer requests', function() - local info = meths.get_option_info2('formatprg', {buf=bufs[2].id}) + local info = meths.get_option_info2('formatprg', { buf = bufs[2].id }) eq(2, info.last_set_linenr) eq(1, info.last_set_sid) end) it('is provided for cross-window requests', function() - local info = meths.get_option_info2('listchars', {win=wins[2].id}) + local info = meths.get_option_info2('listchars', { win = wins[2].id }) eq(6, info.last_set_linenr) eq(1, info.last_set_sid) end) @@ -3173,11 +3375,11 @@ describe('API', function() screen = Screen.new(40, 8) screen:attach() screen:set_default_attr_ids({ - [0] = {bold = true, foreground = Screen.colors.Blue}, - [1] = {bold = true, foreground = Screen.colors.SeaGreen}, - [2] = {bold = true, reverse = true}, - [3] = {foreground = Screen.colors.Brown, bold = true}, -- Statement - [4] = {foreground = Screen.colors.SlateBlue}, -- Special + [0] = { bold = true, foreground = Screen.colors.Blue }, + [1] = { bold = true, foreground = Screen.colors.SeaGreen }, + [2] = { bold = true, reverse = true }, + [3] = { foreground = Screen.colors.Brown, bold = true }, -- Statement + [4] = { foreground = Screen.colors.SlateBlue }, -- Special }) command('highlight Statement gui=bold guifg=Brown') command('highlight Special guifg=SlateBlue') @@ -3185,48 +3387,58 @@ describe('API', function() it('should clear cmdline message before echo', function() feed(':call nvim_echo([["msg"]], v:false, {})') - screen:expect{grid=[[ + screen:expect { + grid = [[ ^ | {0:~ }|*6 msg | - ]]} + ]], + } end) it('can show highlighted line', function() - nvim_async("echo", {{"msg_a"}, {"msg_b", "Statement"}, {"msg_c", "Special"}}, true, {}) - screen:expect{grid=[[ + nvim_async( + 'echo', + { { 'msg_a' }, { 'msg_b', 'Statement' }, { 'msg_c', 'Special' } }, + true, + {} + ) + screen:expect { + grid = [[ ^ | {0:~ }|*6 msg_a{3:msg_b}{4:msg_c} | - ]]} + ]], + } end) it('can show highlighted multiline', function() - nvim_async("echo", {{"msg_a\nmsg_a", "Statement"}, {"msg_b", "Special"}}, true, {}) - screen:expect{grid=[[ + nvim_async('echo', { { 'msg_a\nmsg_a', 'Statement' }, { 'msg_b', 'Special' } }, true, {}) + screen:expect { + grid = [[ | {0:~ }|*3 {2: }| {3:msg_a} | {3:msg_a}{4:msg_b} | {1:Press ENTER or type command to continue}^ | - ]]} + ]], + } end) it('can save message history', function() nvim('command', 'set cmdheight=2') -- suppress Press ENTER - nvim("echo", {{"msg\nmsg"}, {"msg"}}, true, {}) - eq("msg\nmsgmsg", exec_capture('messages')) + nvim('echo', { { 'msg\nmsg' }, { 'msg' } }, true, {}) + eq('msg\nmsgmsg', exec_capture('messages')) end) it('can disable saving message history', function() nvim('command', 'set cmdheight=2') -- suppress Press ENTER - nvim_async("echo", {{"msg\nmsg"}, {"msg"}}, false, {}) - eq("", exec_capture('messages')) + nvim_async('echo', { { 'msg\nmsg' }, { 'msg' } }, false, {}) + eq('', exec_capture('messages')) end) end) - describe('nvim_open_term', function() local screen @@ -3234,24 +3446,33 @@ describe('API', function() screen = Screen.new(100, 35) screen:attach() screen:set_default_attr_ids({ - [0] = {bold=true, foreground=Screen.colors.Blue}, - [1] = {background = Screen.colors.Plum1}; - [2] = {background = tonumber('0xffff40'), bg_indexed = true}; - [3] = {background = Screen.colors.Plum1, fg_indexed = true, foreground = tonumber('0x00e000')}; - [4] = {bold = true, reverse = true, background = Screen.colors.Plum1}; - [5] = {foreground = Screen.colors.Blue, background = Screen.colors.LightMagenta, bold = true}; - [6] = {bold = true}; - [7] = {reverse = true, background = Screen.colors.LightMagenta}; + [0] = { bold = true, foreground = Screen.colors.Blue }, + [1] = { background = Screen.colors.Plum1 }, + [2] = { background = tonumber('0xffff40'), bg_indexed = true }, + [3] = { + background = Screen.colors.Plum1, + fg_indexed = true, + foreground = tonumber('0x00e000'), + }, + [4] = { bold = true, reverse = true, background = Screen.colors.Plum1 }, + [5] = { + foreground = Screen.colors.Blue, + background = Screen.colors.LightMagenta, + bold = true, + }, + [6] = { bold = true }, + [7] = { reverse = true, background = Screen.colors.LightMagenta }, }) end) it('can batch process sequences', function() - local b = meths.create_buf(true,true) - meths.open_win(b, false, {width=79, height=31, row=1, col=1, relative='editor'}) + local b = meths.create_buf(true, true) + meths.open_win(b, false, { width = 79, height = 31, row = 1, col = 1, relative = 'editor' }) local t = meths.open_term(b, {}) - meths.chan_send(t, io.open("test/functional/fixtures/smile2.cat", "r"):read("*a")) - screen:expect{grid=[[ + meths.chan_send(t, io.open('test/functional/fixtures/smile2.cat', 'r'):read('*a')) + screen:expect { + grid = [[ ^ | {0:~}{1::smile }{0: }| {0:~}{1: }{2:oooo$$$$$$$$$$$$oooo}{1: }{0: }| @@ -3286,12 +3507,15 @@ describe('API', function() {0:~}{1::call nvim__screenshot("smile2.cat") }{0: }| {0:~ }|*2 | - ]]} + ]], + } end) it('can handle input', function() screen:try_resize(50, 10) - eq({3, 2}, exec_lua [[ + eq( + { 3, 2 }, + exec_lua [[ buf = vim.api.nvim_create_buf(1,1) stream = '' @@ -3307,49 +3531,56 @@ describe('API', function() term = vim.api.nvim_open_term(buf, {on_input=input}) vim.api.nvim_open_win(buf, true, {width=40, height=5, row=1, col=1, relative='editor'}) return {term, buf} - ]]) + ]] + ) - screen:expect{grid=[[ + screen:expect { + grid = [[ | {0:~}{1:^ }{0: }| {0:~}{1: }{0: }|*4 {0:~ }|*3 | - ]]} + ]], + } feed 'ibabla' - screen:expect{grid=[[ + screen:expect { + grid = [[ | {0:~}{7: }{1: }{0: }| {0:~}{1: }{0: }|*4 {0:~ }|*3 {6:-- TERMINAL --} | - ]]} + ]], + } eq('ba\024bla', exec_lua [[ return stream ]]) - eq({3,2}, exec_lua [[ return vals ]]) + eq({ 3, 2 }, exec_lua [[ return vals ]]) exec_lua [[ do_the_echo = true ]] feed 'herrejösses!' - screen:expect{grid=[[ + screen:expect { + grid = [[ | {0:~}{1:herrejösses!}{7: }{1: }{0: }| {0:~}{1: }{0: }|*4 {0:~ }|*3 {6:-- TERMINAL --} | - ]]} + ]], + } eq('ba\024blaherrejösses!', exec_lua [[ return stream ]]) end) end) describe('nvim_del_mark', function() it('works', function() - local buf = meths.create_buf(false,true) - meths.buf_set_lines(buf, -1, -1, true, {'a', 'bit of', 'text'}) + local buf = meths.create_buf(false, true) + meths.buf_set_lines(buf, -1, -1, true, { 'a', 'bit of', 'text' }) eq(true, meths.buf_set_mark(buf, 'F', 2, 2, {})) eq(true, meths.del_mark('F')) - eq({0, 0}, meths.buf_get_mark(buf, 'F')) + eq({ 0, 0 }, meths.buf_get_mark(buf, 'F')) end) it('validation', function() eq("Invalid mark name (must be file/uppercase): 'f'", pcall_err(meths.del_mark, 'f')) @@ -3359,14 +3590,14 @@ describe('API', function() end) describe('nvim_get_mark', function() it('works', function() - local buf = meths.create_buf(false,true) - meths.buf_set_lines(buf, -1, -1, true, {'a', 'bit of', 'text'}) + local buf = meths.create_buf(false, true) + meths.buf_set_lines(buf, -1, -1, true, { 'a', 'bit of', 'text' }) meths.buf_set_mark(buf, 'F', 2, 2, {}) - meths.buf_set_name(buf, "mybuf") + meths.buf_set_name(buf, 'mybuf') local mark = meths.get_mark('F', {}) -- Compare the path tail only - assert(string.find(mark[4], "mybuf$")) - eq({2, 2, buf.id, mark[4]}, mark) + assert(string.find(mark[4], 'mybuf$')) + eq({ 2, 2, buf.id, mark[4] }, mark) end) it('validation', function() eq("Invalid mark name (must be file/uppercase): 'f'", pcall_err(meths.get_mark, 'f', {})) @@ -3375,17 +3606,17 @@ describe('API', function() end) it('returns the expected when mark is not set', function() eq(true, meths.del_mark('A')) - eq({0, 0, 0, ''}, meths.get_mark('A', {})) + eq({ 0, 0, 0, '' }, meths.get_mark('A', {})) end) it('works with deleted buffers', function() local fname = tmpname() write_file(fname, 'a\nbit of\text') - nvim("command", "edit " .. fname) + nvim('command', 'edit ' .. fname) local buf = meths.get_current_buf() meths.buf_set_mark(buf, 'F', 2, 2, {}) - nvim("command", "new") -- Create new buf to avoid :bd failing - nvim("command", "bd! " .. buf.id) + nvim('command', 'new') -- Create new buf to avoid :bd failing + nvim('command', 'bd! ' .. buf.id) os.remove(fname) local mark = meths.get_mark('F', {}) @@ -3394,144 +3625,156 @@ describe('API', function() local tail_patt = [[[\/][^\/]*$]] -- tail of paths should be equals eq(fname:match(tail_patt), mfname:match(tail_patt)) - eq({2, 2, buf.id, mark[4]}, mark) + eq({ 2, 2, buf.id, mark[4] }, mark) end) end) describe('nvim_eval_statusline', function() it('works', function() eq({ - str = '%StatusLineStringWithHighlights', - width = 31 - }, - meths.eval_statusline( - '%%StatusLineString%#WarningMsg#WithHighlights', - {})) + str = '%StatusLineStringWithHighlights', + width = 31, + }, meths.eval_statusline('%%StatusLineString%#WarningMsg#WithHighlights', {})) end) - it('doesn\'t exceed maxwidth', function() + it("doesn't exceed maxwidth", function() eq({ - str = 'Should be trun>', - width = 15 - }, - meths.eval_statusline( - 'Should be truncated%<', - { maxwidth = 15 })) + str = 'Should be trun>', + width = 15, + }, meths.eval_statusline('Should be truncated%<', { maxwidth = 15 })) end) it('supports ASCII fillchar', function() - eq({ str = 'a~~~b', width = 5 }, - meths.eval_statusline('a%=b', { fillchar = '~', maxwidth = 5 })) + eq( + { str = 'a~~~b', width = 5 }, + meths.eval_statusline('a%=b', { fillchar = '~', maxwidth = 5 }) + ) end) it('supports single-width multibyte fillchar', function() - eq({ str = 'a━━━b', width = 5 }, - meths.eval_statusline('a%=b', { fillchar = '━', maxwidth = 5 })) + eq( + { str = 'a━━━b', width = 5 }, + meths.eval_statusline('a%=b', { fillchar = '━', maxwidth = 5 }) + ) end) it('treats double-width fillchar as single-width', function() - eq({ str = 'a哦哦哦b', width = 5 }, - meths.eval_statusline('a%=b', { fillchar = '哦', maxwidth = 5 })) + eq( + { str = 'a哦哦哦b', width = 5 }, + meths.eval_statusline('a%=b', { fillchar = '哦', maxwidth = 5 }) + ) end) it('treats control character fillchar as single-width', function() - eq({ str = 'a\031\031\031b', width = 5 }, - meths.eval_statusline('a%=b', { fillchar = '\031', maxwidth = 5 })) + eq( + { str = 'a\031\031\031b', width = 5 }, + meths.eval_statusline('a%=b', { fillchar = '\031', maxwidth = 5 }) + ) end) it('rejects multiple-character fillchar', function() - eq("Invalid 'fillchar': expected single character", - pcall_err(meths.eval_statusline, '', { fillchar = 'aa' })) + eq( + "Invalid 'fillchar': expected single character", + pcall_err(meths.eval_statusline, '', { fillchar = 'aa' }) + ) end) it('rejects empty string fillchar', function() - eq("Invalid 'fillchar': expected single character", - pcall_err(meths.eval_statusline, '', { fillchar = '' })) + eq( + "Invalid 'fillchar': expected single character", + pcall_err(meths.eval_statusline, '', { fillchar = '' }) + ) end) it('rejects non-string fillchar', function() - eq("Invalid 'fillchar': expected String, got Integer", - pcall_err(meths.eval_statusline, '', { fillchar = 1 })) + eq( + "Invalid 'fillchar': expected String, got Integer", + pcall_err(meths.eval_statusline, '', { fillchar = 1 }) + ) end) it('rejects invalid string', function() - eq('E539: Illegal character <}>', - pcall_err(meths.eval_statusline, '%{%}', {})) + eq('E539: Illegal character <}>', pcall_err(meths.eval_statusline, '%{%}', {})) end) it('supports various items', function() - eq({ str = '0', width = 1 }, - meths.eval_statusline('%l', { maxwidth = 5 })) + eq({ str = '0', width = 1 }, meths.eval_statusline('%l', { maxwidth = 5 })) command('set readonly') - eq({ str = '[RO]', width = 4 }, - meths.eval_statusline('%r', { maxwidth = 5 })) + eq({ str = '[RO]', width = 4 }, meths.eval_statusline('%r', { maxwidth = 5 })) local screen = Screen.new(80, 24) screen:attach() command('set showcmd') feed('1234') - screen:expect({any = '1234'}) - eq({ str = '1234', width = 4 }, - meths.eval_statusline('%S', { maxwidth = 5 })) + screen:expect({ any = '1234' }) + eq({ str = '1234', width = 4 }, meths.eval_statusline('%S', { maxwidth = 5 })) feed('56') - screen:expect({any = '123456'}) - eq({ str = '<3456', width = 5 }, - meths.eval_statusline('%S', { maxwidth = 5 })) + screen:expect({ any = '123456' }) + eq({ str = '<3456', width = 5 }, meths.eval_statusline('%S', { maxwidth = 5 })) end) describe('highlight parsing', function() it('works', function() - eq({ - str = "TextWithWarningHighlightTextWithUserHighlight", + eq( + { + str = 'TextWithWarningHighlightTextWithUserHighlight', width = 45, highlights = { { start = 0, group = 'WarningMsg' }, - { start = 24, group = 'User1' } + { start = 24, group = 'User1' }, }, }, meths.eval_statusline( '%#WarningMsg#TextWithWarningHighlight%1*TextWithUserHighlight', - { highlights = true })) + { highlights = true } + ) + ) end) it('works with no highlight', function() eq({ - str = "TextWithNoHighlight", - width = 19, - highlights = { - { start = 0, group = 'StatusLine' }, - }, + str = 'TextWithNoHighlight', + width = 19, + highlights = { + { start = 0, group = 'StatusLine' }, }, - meths.eval_statusline( - 'TextWithNoHighlight', - { highlights = true })) + }, meths.eval_statusline('TextWithNoHighlight', { highlights = true })) end) it('works with inactive statusline', function() command('split') - eq({ + eq( + { str = 'TextWithNoHighlightTextWithWarningHighlight', width = 43, highlights = { { start = 0, group = 'StatusLineNC' }, - { start = 19, group = 'WarningMsg' } - } + { start = 19, group = 'WarningMsg' }, + }, }, meths.eval_statusline( 'TextWithNoHighlight%#WarningMsg#TextWithWarningHighlight', - { winid = meths.list_wins()[2].id, highlights = true })) + { winid = meths.list_wins()[2].id, highlights = true } + ) + ) end) it('works with tabline', function() - eq({ + eq( + { str = 'TextWithNoHighlightTextWithWarningHighlight', width = 43, highlights = { { start = 0, group = 'TabLineFill' }, - { start = 19, group = 'WarningMsg' } - } + { start = 19, group = 'WarningMsg' }, + }, }, meths.eval_statusline( 'TextWithNoHighlight%#WarningMsg#TextWithWarningHighlight', - { use_tabline = true, highlights = true })) + { use_tabline = true, highlights = true } + ) + ) end) it('works with winbar', function() - eq({ + eq( + { str = 'TextWithNoHighlightTextWithWarningHighlight', width = 43, highlights = { { start = 0, group = 'WinBar' }, - { start = 19, group = 'WarningMsg' } - } + { start = 19, group = 'WarningMsg' }, + }, }, meths.eval_statusline( 'TextWithNoHighlight%#WarningMsg#TextWithWarningHighlight', - { use_winbar = true, highlights = true })) + { use_winbar = true, highlights = true } + ) + ) end) it('works with statuscolumn', function() exec([[ @@ -3553,28 +3796,27 @@ describe('API', function() { group = 'Normal', start = 6 }, { group = 'IncSearch', start = 6 }, { group = 'ErrorMsg', start = 8 }, - { group = 'Normal', start = 10 } - } + { group = 'Normal', start = 10 }, + }, }, meths.eval_statusline('%C%s%=%l ', { use_statuscol_lnum = 4, highlights = true })) eq({ - str = '3 ' , + str = '3 ', width = 2, highlights = { { group = 'LineNr', start = 0 }, - { group = 'ErrorMsg', start = 1 } - } - }, meths.eval_statusline('%l%#ErrorMsg# ', { use_statuscol_lnum = 3, highlights = true })) + { group = 'ErrorMsg', start = 1 }, + }, + }, meths.eval_statusline( + '%l%#ErrorMsg# ', + { use_statuscol_lnum = 3, highlights = true } + )) end) it('no memory leak with click functions', function() meths.eval_statusline('%@ClickFunc@StatusLineStringWithClickFunc%T', {}) eq({ - str = 'StatusLineStringWithClickFunc', - width = 29 - }, - meths.eval_statusline( - '%@ClickFunc@StatusLineStringWithClickFunc%T', - {}) - ) + str = 'StatusLineStringWithClickFunc', + width = 29, + }, meths.eval_statusline('%@ClickFunc@StatusLineStringWithClickFunc%T', {})) end) end) end) @@ -3587,8 +3829,8 @@ describe('API', function() bang = false, addr = 'none', magic = { - file = false, - bar = false + file = false, + bar = false, }, nargs = '*', nextcmd = '', @@ -3597,8 +3839,8 @@ describe('API', function() confirm = false, emsg_silent = false, filter = { - pattern = "", - force = false + pattern = '', + force = false, }, hide = false, horizontal = false, @@ -3611,12 +3853,12 @@ describe('API', function() noswapfile = false, sandbox = false, silent = false, - split = "", + split = '', tab = -1, unsilent = false, verbose = -1, vertical = false, - } + }, }, meths.parse_cmd('echo foo', {})) end) it('works with ranges', function() @@ -3627,8 +3869,8 @@ describe('API', function() range = { 4, 6 }, addr = 'line', magic = { - file = false, - bar = false + file = false, + bar = false, }, nargs = '*', nextcmd = '', @@ -3637,8 +3879,8 @@ describe('API', function() confirm = false, emsg_silent = false, filter = { - pattern = "", - force = false + pattern = '', + force = false, }, hide = false, horizontal = false, @@ -3651,12 +3893,12 @@ describe('API', function() noswapfile = false, sandbox = false, silent = false, - split = "", + split = '', tab = -1, unsilent = false, verbose = -1, vertical = false, - } + }, }, meths.parse_cmd('4,6s/math.random/math.max/', {})) end) it('works with count', function() @@ -3668,8 +3910,8 @@ describe('API', function() count = 1, addr = 'buf', magic = { - file = false, - bar = true + file = false, + bar = true, }, nargs = '*', nextcmd = '', @@ -3678,8 +3920,8 @@ describe('API', function() confirm = false, emsg_silent = false, filter = { - pattern = "", - force = false + pattern = '', + force = false, }, hide = false, horizontal = false, @@ -3692,12 +3934,12 @@ describe('API', function() noswapfile = false, sandbox = false, silent = false, - split = "", + split = '', tab = -1, unsilent = false, verbose = -1, vertical = false, - } + }, }, meths.parse_cmd('buffer 1', {})) end) it('works with register', function() @@ -3709,8 +3951,8 @@ describe('API', function() reg = '+', addr = 'line', magic = { - file = false, - bar = true + file = false, + bar = true, }, nargs = '0', nextcmd = '', @@ -3719,8 +3961,8 @@ describe('API', function() confirm = false, emsg_silent = false, filter = { - pattern = "", - force = false + pattern = '', + force = false, }, hide = false, horizontal = false, @@ -3733,12 +3975,12 @@ describe('API', function() noswapfile = false, sandbox = false, silent = false, - split = "", + split = '', tab = -1, unsilent = false, verbose = -1, vertical = false, - } + }, }, meths.parse_cmd('put +', {})) eq({ cmd = 'put', @@ -3748,8 +3990,8 @@ describe('API', function() reg = '', addr = 'line', magic = { - file = false, - bar = true + file = false, + bar = true, }, nargs = '0', nextcmd = '', @@ -3758,8 +4000,8 @@ describe('API', function() confirm = false, emsg_silent = false, filter = { - pattern = "", - force = false + pattern = '', + force = false, }, hide = false, horizontal = false, @@ -3772,12 +4014,12 @@ describe('API', function() noswapfile = false, sandbox = false, silent = false, - split = "", + split = '', tab = -1, unsilent = false, verbose = -1, vertical = false, - } + }, }, meths.parse_cmd('put', {})) end) it('works with range, count and register', function() @@ -3790,8 +4032,8 @@ describe('API', function() reg = '*', addr = 'line', magic = { - file = false, - bar = true + file = false, + bar = true, }, nargs = '0', nextcmd = '', @@ -3800,8 +4042,8 @@ describe('API', function() confirm = false, emsg_silent = false, filter = { - pattern = "", - force = false + pattern = '', + force = false, }, hide = false, horizontal = false, @@ -3814,12 +4056,12 @@ describe('API', function() noswapfile = false, sandbox = false, silent = false, - split = "", + split = '', tab = -1, unsilent = false, verbose = -1, vertical = false, - } + }, }, meths.parse_cmd('1,3delete * 5', {})) end) it('works with bang', function() @@ -3830,8 +4072,8 @@ describe('API', function() range = {}, addr = 'line', magic = { - file = true, - bar = true + file = true, + bar = true, }, nargs = '?', nextcmd = '', @@ -3840,8 +4082,8 @@ describe('API', function() confirm = false, emsg_silent = false, filter = { - pattern = "", - force = false + pattern = '', + force = false, }, hide = false, horizontal = false, @@ -3854,7 +4096,7 @@ describe('API', function() noswapfile = false, sandbox = false, silent = false, - split = "", + split = '', tab = -1, unsilent = false, verbose = -1, @@ -3870,8 +4112,8 @@ describe('API', function() range = {}, addr = '?', magic = { - file = true, - bar = true + file = true, + bar = true, }, nargs = '?', nextcmd = '', @@ -3880,8 +4122,8 @@ describe('API', function() confirm = false, emsg_silent = true, filter = { - pattern = "foo", - force = false + pattern = 'foo', + force = false, }, hide = false, horizontal = true, @@ -3894,13 +4136,16 @@ describe('API', function() noswapfile = false, sandbox = false, silent = true, - split = "topleft", + split = 'topleft', tab = 1, unsilent = false, verbose = 15, vertical = false, }, - }, meths.parse_cmd('15verbose silent! horizontal topleft tab filter /foo/ split foo.txt', {})) + }, meths.parse_cmd( + '15verbose silent! horizontal topleft tab filter /foo/ split foo.txt', + {} + )) eq({ cmd = 'split', args = { 'foo.txt' }, @@ -3908,8 +4153,8 @@ describe('API', function() range = {}, addr = '?', magic = { - file = true, - bar = true + file = true, + bar = true, }, nargs = '?', nextcmd = '', @@ -3918,8 +4163,8 @@ describe('API', function() confirm = true, emsg_silent = false, filter = { - pattern = "foo", - force = true + pattern = 'foo', + force = true, }, hide = false, horizontal = false, @@ -3932,13 +4177,16 @@ describe('API', function() noswapfile = false, sandbox = false, silent = false, - split = "botright", + split = 'botright', tab = 0, unsilent = true, verbose = 0, vertical = false, }, - }, meths.parse_cmd('0verbose unsilent botright 0tab confirm filter! /foo/ split foo.txt', {})) + }, meths.parse_cmd( + '0verbose unsilent botright 0tab confirm filter! /foo/ split foo.txt', + {} + )) end) it('works with user commands', function() command('command -bang -nargs=+ -range -addr=lines MyCommand echo foo') @@ -3949,8 +4197,8 @@ describe('API', function() range = { 4, 6 }, addr = 'line', magic = { - file = false, - bar = false + file = false, + bar = false, }, nargs = '+', nextcmd = '', @@ -3959,8 +4207,8 @@ describe('API', function() confirm = false, emsg_silent = false, filter = { - pattern = "", - force = false + pattern = '', + force = false, }, hide = false, horizontal = false, @@ -3973,12 +4221,12 @@ describe('API', function() noswapfile = false, sandbox = false, silent = false, - split = "", + split = '', tab = -1, unsilent = false, verbose = -1, vertical = false, - } + }, }, meths.parse_cmd('4,6MyCommand! test it', {})) end) it('works for commands separated by bar', function() @@ -3989,8 +4237,8 @@ describe('API', function() range = {}, addr = 'arg', magic = { - file = true, - bar = true + file = true, + bar = true, }, nargs = '*', nextcmd = 'argadd b.txt', @@ -3999,8 +4247,8 @@ describe('API', function() confirm = false, emsg_silent = false, filter = { - pattern = "", - force = false + pattern = '', + force = false, }, hide = false, horizontal = false, @@ -4013,12 +4261,12 @@ describe('API', function() noswapfile = false, sandbox = false, silent = false, - split = "", + split = '', tab = -1, unsilent = false, verbose = -1, vertical = false, - } + }, }, meths.parse_cmd('argadd a.txt | argadd b.txt', {})) end) it('works for nargs=1', function() @@ -4029,8 +4277,8 @@ describe('API', function() bang = false, addr = 'none', magic = { - file = false, - bar = false + file = false, + bar = false, }, nargs = '1', nextcmd = '', @@ -4039,8 +4287,8 @@ describe('API', function() confirm = false, emsg_silent = false, filter = { - pattern = "", - force = false + pattern = '', + force = false, }, hide = false, horizontal = false, @@ -4053,33 +4301,41 @@ describe('API', function() noswapfile = false, sandbox = false, silent = false, - split = "", + split = '', tab = -1, unsilent = false, verbose = -1, vertical = false, - } + }, }, meths.parse_cmd('MyCommand test it', {})) end) it('validates command', function() eq('Error while parsing command line', pcall_err(meths.parse_cmd, '', {})) eq('Error while parsing command line', pcall_err(meths.parse_cmd, '" foo', {})) - eq('Error while parsing command line: E492: Not an editor command: Fubar', - pcall_err(meths.parse_cmd, 'Fubar', {})) + eq( + 'Error while parsing command line: E492: Not an editor command: Fubar', + pcall_err(meths.parse_cmd, 'Fubar', {}) + ) command('command! Fubar echo foo') - eq('Error while parsing command line: E477: No ! allowed', - pcall_err(meths.parse_cmd, 'Fubar!', {})) - eq('Error while parsing command line: E481: No range allowed', - pcall_err(meths.parse_cmd, '4,6Fubar', {})) + eq( + 'Error while parsing command line: E477: No ! allowed', + pcall_err(meths.parse_cmd, 'Fubar!', {}) + ) + eq( + 'Error while parsing command line: E481: No range allowed', + pcall_err(meths.parse_cmd, '4,6Fubar', {}) + ) command('command! Foobar echo foo') - eq('Error while parsing command line: E464: Ambiguous use of user-defined command', - pcall_err(meths.parse_cmd, 'F', {})) + eq( + 'Error while parsing command line: E464: Ambiguous use of user-defined command', + pcall_err(meths.parse_cmd, 'F', {}) + ) end) it('does not interfere with printing line in Ex mode #19400', function() local screen = Screen.new(60, 7) screen:set_default_attr_ids({ - [0] = {bold = true, foreground = Screen.colors.Blue}, -- NonText - [1] = {bold = true, reverse = true}, -- MsgSeparator + [0] = { bold = true, foreground = Screen.colors.Blue }, -- NonText + [1] = { bold = true, reverse = true }, -- MsgSeparator }) screen:attach() insert([[ @@ -4107,16 +4363,16 @@ describe('API', function() ]]) end) it('does not move cursor or change search history/pattern #19878 #19890', function() - meths.buf_set_lines(0, 0, -1, true, {'foo', 'bar', 'foo', 'bar'}) - eq({1, 0}, meths.win_get_cursor(0)) + meths.buf_set_lines(0, 0, -1, true, { 'foo', 'bar', 'foo', 'bar' }) + eq({ 1, 0 }, meths.win_get_cursor(0)) eq('', funcs.getreg('/')) eq('', funcs.histget('search')) - feed(':') -- call the API in cmdline mode to test whether it changes search history + feed(':') -- call the API in cmdline mode to test whether it changes search history eq({ cmd = 'normal', - args = {'x'}, + args = { 'x' }, bang = true, - range = {3, 4}, + range = { 3, 4 }, addr = 'line', magic = { file = false, @@ -4129,7 +4385,7 @@ describe('API', function() confirm = false, emsg_silent = false, filter = { - pattern = "", + pattern = '', force = false, }, hide = false, @@ -4143,101 +4399,131 @@ describe('API', function() noswapfile = false, sandbox = false, silent = false, - split = "", + split = '', tab = -1, unsilent = false, verbose = -1, vertical = false, - } + }, }, meths.parse_cmd('+2;/bar/normal! x', {})) - eq({1, 0}, meths.win_get_cursor(0)) + eq({ 1, 0 }, meths.win_get_cursor(0)) eq('', funcs.getreg('/')) eq('', funcs.histget('search')) end) it('result can be used directly by nvim_cmd #20051', function() - eq("foo", meths.cmd(meths.parse_cmd('echo "foo"', {}), { output = true })) - meths.cmd(meths.parse_cmd("set cursorline", {}), {}) - eq(true, meths.get_option_value("cursorline", {})) + eq('foo', meths.cmd(meths.parse_cmd('echo "foo"', {}), { output = true })) + meths.cmd(meths.parse_cmd('set cursorline', {}), {}) + eq(true, meths.get_option_value('cursorline', {})) end) it('no side-effects (error messages) in pcall() #20339', function() - eq({ false, 'Error while parsing command line: E16: Invalid range' }, - exec_lua([=[return {pcall(vim.api.nvim_parse_cmd, "'<,'>n", {})}]=])) + eq( + { false, 'Error while parsing command line: E16: Invalid range' }, + exec_lua([=[return {pcall(vim.api.nvim_parse_cmd, "'<,'>n", {})}]=]) + ) eq('', eval('v:errmsg')) end) end) describe('nvim_cmd', function() - it('works', function () - meths.cmd({ cmd = "set", args = { "cursorline" } }, {}) - eq(true, meths.get_option_value("cursorline", {})) + it('works', function() + meths.cmd({ cmd = 'set', args = { 'cursorline' } }, {}) + eq(true, meths.get_option_value('cursorline', {})) end) it('validation', function() - eq("Invalid 'cmd': expected non-empty String", - pcall_err(meths.cmd, { cmd = ""}, {})) - eq("Invalid 'cmd': expected String, got Array", - pcall_err(meths.cmd, { cmd = {}}, {})) - eq("Invalid 'args': expected Array, got Boolean", - pcall_err(meths.cmd, { cmd = "set", args = true }, {})) - eq("Invalid command arg: expected non-whitespace", - pcall_err(meths.cmd, { cmd = "set", args = {' '}, }, {})) - eq("Invalid command arg: expected valid type, got Array", - pcall_err(meths.cmd, { cmd = "set", args = {{}}, }, {})) - eq("Wrong number of arguments", - pcall_err(meths.cmd, { cmd = "aboveleft", args = {}, }, {})) - eq("Command cannot accept bang: print", - pcall_err(meths.cmd, { cmd = "print", args = {}, bang = true }, {})) + eq("Invalid 'cmd': expected non-empty String", pcall_err(meths.cmd, { cmd = '' }, {})) + eq("Invalid 'cmd': expected String, got Array", pcall_err(meths.cmd, { cmd = {} }, {})) + eq( + "Invalid 'args': expected Array, got Boolean", + pcall_err(meths.cmd, { cmd = 'set', args = true }, {}) + ) + eq( + 'Invalid command arg: expected non-whitespace', + pcall_err(meths.cmd, { cmd = 'set', args = { ' ' } }, {}) + ) + eq( + 'Invalid command arg: expected valid type, got Array', + pcall_err(meths.cmd, { cmd = 'set', args = { {} } }, {}) + ) + eq('Wrong number of arguments', pcall_err(meths.cmd, { cmd = 'aboveleft', args = {} }, {})) + eq( + 'Command cannot accept bang: print', + pcall_err(meths.cmd, { cmd = 'print', args = {}, bang = true }, {}) + ) - eq("Command cannot accept range: set", - pcall_err(meths.cmd, { cmd = "set", args = {}, range = {1} }, {})) - eq("Invalid 'range': expected Array, got Boolean", - pcall_err(meths.cmd, { cmd = "print", args = {}, range = true }, {})) - eq("Invalid 'range': expected <=2 elements", - pcall_err(meths.cmd, { cmd = "print", args = {}, range = {1,2,3,4} }, {})) - eq("Invalid range element: expected non-negative Integer", - pcall_err(meths.cmd, { cmd = "print", args = {}, range = {-1} }, {})) + eq( + 'Command cannot accept range: set', + pcall_err(meths.cmd, { cmd = 'set', args = {}, range = { 1 } }, {}) + ) + eq( + "Invalid 'range': expected Array, got Boolean", + pcall_err(meths.cmd, { cmd = 'print', args = {}, range = true }, {}) + ) + eq( + "Invalid 'range': expected <=2 elements", + pcall_err(meths.cmd, { cmd = 'print', args = {}, range = { 1, 2, 3, 4 } }, {}) + ) + eq( + 'Invalid range element: expected non-negative Integer', + pcall_err(meths.cmd, { cmd = 'print', args = {}, range = { -1 } }, {}) + ) - eq("Command cannot accept count: set", - pcall_err(meths.cmd, { cmd = "set", args = {}, count = 1 }, {})) - eq("Invalid 'count': expected Integer, got Boolean", - pcall_err(meths.cmd, { cmd = "print", args = {}, count = true }, {})) - eq("Invalid 'count': expected non-negative Integer", - pcall_err(meths.cmd, { cmd = "print", args = {}, count = -1 }, {})) + eq( + 'Command cannot accept count: set', + pcall_err(meths.cmd, { cmd = 'set', args = {}, count = 1 }, {}) + ) + eq( + "Invalid 'count': expected Integer, got Boolean", + pcall_err(meths.cmd, { cmd = 'print', args = {}, count = true }, {}) + ) + eq( + "Invalid 'count': expected non-negative Integer", + pcall_err(meths.cmd, { cmd = 'print', args = {}, count = -1 }, {}) + ) - eq("Command cannot accept register: set", - pcall_err(meths.cmd, { cmd = "set", args = {}, reg = 'x' }, {})) - eq('Cannot use register "=', - pcall_err(meths.cmd, { cmd = "put", args = {}, reg = '=' }, {})) - eq("Invalid 'reg': expected single character, got xx", - pcall_err(meths.cmd, { cmd = "put", args = {}, reg = 'xx' }, {})) + eq( + 'Command cannot accept register: set', + pcall_err(meths.cmd, { cmd = 'set', args = {}, reg = 'x' }, {}) + ) + eq('Cannot use register "=', pcall_err(meths.cmd, { cmd = 'put', args = {}, reg = '=' }, {})) + eq( + "Invalid 'reg': expected single character, got xx", + pcall_err(meths.cmd, { cmd = 'put', args = {}, reg = 'xx' }, {}) + ) -- #20681 - eq('Invalid command: "win_getid"', pcall_err(meths.cmd, { cmd = 'win_getid'}, {})) - eq('Invalid command: "echo "hi""', pcall_err(meths.cmd, { cmd = 'echo "hi"'}, {})) + eq('Invalid command: "win_getid"', pcall_err(meths.cmd, { cmd = 'win_getid' }, {})) + eq('Invalid command: "echo "hi""', pcall_err(meths.cmd, { cmd = 'echo "hi"' }, {})) eq('Invalid command: "win_getid"', pcall_err(exec_lua, [[return vim.cmd.win_getid{}]])) -- Lua call allows empty {} for dict item. eq('', exec_lua([[return vim.cmd{ cmd = "set", args = {}, magic = {} }]])) eq('', exec_lua([[return vim.cmd{ cmd = "set", args = {}, mods = {} }]])) - eq('', meths.cmd({ cmd = "set", args = {}, magic = {} }, {})) + eq('', meths.cmd({ cmd = 'set', args = {}, magic = {} }, {})) -- Lua call does not allow non-empty list-like {} for dict item. - eq("Invalid 'magic': Expected Dict-like Lua table", - pcall_err(exec_lua, [[return vim.cmd{ cmd = "set", args = {}, magic = { 'a' } }]])) - eq("Invalid key: 'bogus'", - pcall_err(exec_lua, [[return vim.cmd{ cmd = "set", args = {}, magic = { bogus = true } }]])) - eq("Invalid key: 'bogus'", - pcall_err(exec_lua, [[return vim.cmd{ cmd = "set", args = {}, mods = { bogus = true } }]])) + eq( + "Invalid 'magic': Expected Dict-like Lua table", + pcall_err(exec_lua, [[return vim.cmd{ cmd = "set", args = {}, magic = { 'a' } }]]) + ) + eq( + "Invalid key: 'bogus'", + pcall_err(exec_lua, [[return vim.cmd{ cmd = "set", args = {}, magic = { bogus = true } }]]) + ) + eq( + "Invalid key: 'bogus'", + pcall_err(exec_lua, [[return vim.cmd{ cmd = "set", args = {}, mods = { bogus = true } }]]) + ) end) it('captures output', function() - eq("foo", meths.cmd({ cmd = "echo", args = { '"foo"' } }, { output = true })) + eq('foo', meths.cmd({ cmd = 'echo', args = { '"foo"' } }, { output = true })) end) it('sets correct script context', function() - meths.cmd({ cmd = "set", args = { "cursorline" } }, {}) + meths.cmd({ cmd = 'set', args = { 'cursorline' } }, {}) local str = exec_capture([[verbose set cursorline?]]) - neq(nil, str:find("cursorline\n\tLast set from API client %(channel id %d+%)")) + neq(nil, str:find('cursorline\n\tLast set from API client %(channel id %d+%)')) end) it('works with range', function() @@ -4250,7 +4536,7 @@ describe('API', function() line5 line6 ]] - meths.cmd({ cmd = "del", range = {2, 4} }, {}) + meths.cmd({ cmd = 'del', range = { 2, 4 } }, {}) expect [[ line1 you didn't expect this @@ -4268,7 +4554,7 @@ describe('API', function() line5 line6 ]] - meths.cmd({ cmd = "del", range = { 2 }, count = 4 }, {}) + meths.cmd({ cmd = 'del', range = { 2 }, count = 4 }, {}) expect [[ line1 line5 @@ -4285,7 +4571,7 @@ describe('API', function() line5 line6 ]] - meths.cmd({ cmd = "del", range = { 2, 4 }, reg = 'a' }, {}) + meths.cmd({ cmd = 'del', range = { 2, 4 }, reg = 'a' }, {}) command('1put a') expect [[ line1 @@ -4297,41 +4583,55 @@ describe('API', function() line6 ]] end) - it('works with bang', function () - meths.create_user_command("Foo", 'echo ""', { bang = true }) - eq("!", meths.cmd({ cmd = "Foo", bang = true }, { output = true })) - eq("", meths.cmd({ cmd = "Foo", bang = false }, { output = true })) + it('works with bang', function() + meths.create_user_command('Foo', 'echo ""', { bang = true }) + eq('!', meths.cmd({ cmd = 'Foo', bang = true }, { output = true })) + eq('', meths.cmd({ cmd = 'Foo', bang = false }, { output = true })) end) it('works with modifiers', function() -- with silent = true output is still captured - eq('1', - meths.cmd({ cmd = 'echomsg', args = { '1' }, mods = { silent = true } }, - { output = true })) + eq( + '1', + meths.cmd({ cmd = 'echomsg', args = { '1' }, mods = { silent = true } }, { output = true }) + ) -- but message isn't added to message history eq('', meths.cmd({ cmd = 'messages' }, { output = true })) - meths.create_user_command("Foo", 'set verbose', {}) - eq(" verbose=1", meths.cmd({ cmd = "Foo", mods = { verbose = 1 } }, { output = true })) + meths.create_user_command('Foo', 'set verbose', {}) + eq(' verbose=1', meths.cmd({ cmd = 'Foo', mods = { verbose = 1 } }, { output = true })) - meths.create_user_command("Mods", "echo ''", {}) - eq('keepmarks keeppatterns silent 3verbose aboveleft horizontal', - meths.cmd({ cmd = "Mods", mods = { - horizontal = true, - keepmarks = true, - keeppatterns = true, - silent = true, - split = 'aboveleft', - verbose = 3, - } }, { output = true })) - eq(0, meths.get_option_value("verbose", {})) + meths.create_user_command('Mods', "echo ''", {}) + eq( + 'keepmarks keeppatterns silent 3verbose aboveleft horizontal', + meths.cmd({ + cmd = 'Mods', + mods = { + horizontal = true, + keepmarks = true, + keeppatterns = true, + silent = true, + split = 'aboveleft', + verbose = 3, + }, + }, { output = true }) + ) + eq(0, meths.get_option_value('verbose', {})) command('edit foo.txt | edit bar.txt') - eq(' 1 #h "foo.txt" line 1', - meths.cmd({ cmd = "buffers", mods = { filter = { pattern = "foo", force = false } } }, - { output = true })) - eq(' 2 %a "bar.txt" line 1', - meths.cmd({ cmd = "buffers", mods = { filter = { pattern = "foo", force = true } } }, - { output = true })) + eq( + ' 1 #h "foo.txt" line 1', + meths.cmd( + { cmd = 'buffers', mods = { filter = { pattern = 'foo', force = false } } }, + { output = true } + ) + ) + eq( + ' 2 %a "bar.txt" line 1', + meths.cmd( + { cmd = 'buffers', mods = { filter = { pattern = 'foo', force = true } } }, + { output = true } + ) + ) -- with emsg_silent = true error is suppressed feed([[:lua vim.api.nvim_cmd({ cmd = 'call', mods = { emsg_silent = true } }, {})]]) @@ -4346,9 +4646,10 @@ describe('API', function() vim.api.nvim_echo({{ opts.fargs[1] }}, false, {}) end, { nargs = 1 }) ]]) - eq(luv.cwd(), - meths.cmd({ cmd = "Foo", args = { '%:p:h' }, magic = { file = true } }, - { output = true })) + eq( + luv.cwd(), + meths.cmd({ cmd = 'Foo', args = { '%:p:h' }, magic = { file = true } }, { output = true }) + ) end) it('splits arguments correctly', function() exec([[ @@ -4356,67 +4657,92 @@ describe('API', function() echo a:000 endfunction ]]) - meths.create_user_command("Foo", "call FooFunc()", { nargs = '+' }) - eq([=[['a quick', 'brown fox', 'jumps over the', 'lazy dog']]=], - meths.cmd({ cmd = "Foo", args = { "a quick", "brown fox", "jumps over the", "lazy dog"}}, - { output = true })) - eq([=[['test \ \\ \"""\', 'more\ tests\" ']]=], - meths.cmd({ cmd = "Foo", args = { [[test \ \\ \"""\]], [[more\ tests\" ]] } }, - { output = true })) + meths.create_user_command('Foo', 'call FooFunc()', { nargs = '+' }) + eq( + [=[['a quick', 'brown fox', 'jumps over the', 'lazy dog']]=], + meths.cmd( + { cmd = 'Foo', args = { 'a quick', 'brown fox', 'jumps over the', 'lazy dog' } }, + { output = true } + ) + ) + eq( + [=[['test \ \\ \"""\', 'more\ tests\" ']]=], + meths.cmd( + { cmd = 'Foo', args = { [[test \ \\ \"""\]], [[more\ tests\" ]] } }, + { output = true } + ) + ) end) it('splits arguments correctly for Lua callback', function() - meths.exec_lua([[ + meths.exec_lua( + [[ local function FooFunc(opts) vim.print(opts.fargs) end vim.api.nvim_create_user_command("Foo", FooFunc, { nargs = '+' }) - ]], {}) - eq([[{ "a quick", "brown fox", "jumps over the", "lazy dog" }]], - meths.cmd({ cmd = "Foo", args = { "a quick", "brown fox", "jumps over the", "lazy dog"}}, - { output = true })) - eq([[{ 'test \\ \\\\ \\"""\\', 'more\\ tests\\" ' }]], - meths.cmd({ cmd = "Foo", args = { [[test \ \\ \"""\]], [[more\ tests\" ]] } }, - { output = true })) + ]], + {} + ) + eq( + [[{ "a quick", "brown fox", "jumps over the", "lazy dog" }]], + meths.cmd( + { cmd = 'Foo', args = { 'a quick', 'brown fox', 'jumps over the', 'lazy dog' } }, + { output = true } + ) + ) + eq( + [[{ 'test \\ \\\\ \\"""\\', 'more\\ tests\\" ' }]], + meths.cmd( + { cmd = 'Foo', args = { [[test \ \\ \"""\]], [[more\ tests\" ]] } }, + { output = true } + ) + ) end) it('works with buffer names', function() - command("edit foo.txt | edit bar.txt") - meths.cmd({ cmd = "buffer", args = { "foo.txt" } }, {}) - eq("foo.txt", funcs.fnamemodify(meths.buf_get_name(0), ":t")) - meths.cmd({ cmd = "buffer", args = { "bar.txt" } }, {}) - eq("bar.txt", funcs.fnamemodify(meths.buf_get_name(0), ":t")) + command('edit foo.txt | edit bar.txt') + meths.cmd({ cmd = 'buffer', args = { 'foo.txt' } }, {}) + eq('foo.txt', funcs.fnamemodify(meths.buf_get_name(0), ':t')) + meths.cmd({ cmd = 'buffer', args = { 'bar.txt' } }, {}) + eq('bar.txt', funcs.fnamemodify(meths.buf_get_name(0), ':t')) end) it('triggers CmdUndefined event if command is not found', function() - meths.exec_lua([[ + meths.exec_lua( + [[ vim.api.nvim_create_autocmd("CmdUndefined", { pattern = "Foo", callback = function() vim.api.nvim_create_user_command("Foo", "echo 'foo'", {}) end }) - ]], {}) - eq("foo", meths.cmd({ cmd = "Foo" }, { output = true })) + ]], + {} + ) + eq('foo', meths.cmd({ cmd = 'Foo' }, { output = true })) end) it('errors if command is not implemented', function() - eq("Command not implemented: winpos", pcall_err(meths.cmd, { cmd = "winpos" }, {})) + eq('Command not implemented: winpos', pcall_err(meths.cmd, { cmd = 'winpos' }, {})) end) it('works with empty arguments list', function() - meths.cmd({ cmd = "update" }, {}) - meths.cmd({ cmd = "buffer", count = 0 }, {}) + meths.cmd({ cmd = 'update' }, {}) + meths.cmd({ cmd = 'buffer', count = 0 }, {}) end) - it('doesn\'t suppress errors when used in keymapping', function() - meths.exec_lua([[ + it("doesn't suppress errors when used in keymapping", function() + meths.exec_lua( + [[ vim.keymap.set("n", "[l", function() vim.api.nvim_cmd({ cmd = "echo", args = {"foo"} }, {}) end) - ]], {}) - feed("[l") - neq(nil, string.find(eval("v:errmsg"), "E5108:")) + ]], + {} + ) + feed('[l') + neq(nil, string.find(eval('v:errmsg'), 'E5108:')) end) it('handles 0 range #19608', function() - meths.buf_set_lines(0, 0, -1, false, { "aa" }) + meths.buf_set_lines(0, 0, -1, false, { 'aa' }) meths.cmd({ cmd = 'delete', range = { 0 } }, {}) command('undo') - eq({'aa'}, meths.buf_get_lines(0, 0, 1, false)) + eq({ 'aa' }, meths.buf_get_lines(0, 0, 1, false)) assert_alive() end) it('supports filename expansion', function() @@ -4427,63 +4753,72 @@ describe('API', function() it("'make' command works when argument count isn't 1 #19696", function() command('set makeprg=echo') command('set shellquote=') - matches('^:!echo ', - meths.cmd({ cmd = 'make' }, { output = true })) + matches('^:!echo ', meths.cmd({ cmd = 'make' }, { output = true })) assert_alive() - matches('^:!echo foo bar', - meths.cmd({ cmd = 'make', args = { 'foo', 'bar' } }, { output = true })) + matches( + '^:!echo foo bar', + meths.cmd({ cmd = 'make', args = { 'foo', 'bar' } }, { output = true }) + ) assert_alive() local arg_pesc = pesc(funcs.expand('%:p:h:t')) - matches(('^:!echo %s %s'):format(arg_pesc, arg_pesc), - meths.cmd({ cmd = 'make', args = { '%:p:h:t', '%:p:h:t' } }, { output = true })) + matches( + ('^:!echo %s %s'):format(arg_pesc, arg_pesc), + meths.cmd({ cmd = 'make', args = { '%:p:h:t', '%:p:h:t' } }, { output = true }) + ) assert_alive() end) - it('doesn\'t display messages when output=true', function() + it("doesn't display messages when output=true", function() local screen = Screen.new(40, 6) screen:attach() screen:set_default_attr_ids({ - [0] = {bold=true, foreground=Screen.colors.Blue}, + [0] = { bold = true, foreground = Screen.colors.Blue }, }) - meths.cmd({cmd = 'echo', args = {[['hello']]}}, {output = true}) - screen:expect{grid=[[ + meths.cmd({ cmd = 'echo', args = { [['hello']] } }, { output = true }) + screen:expect { + grid = [[ ^ | {0:~ }|*4 | - ]]} + ]], + } exec([[ func Print() call nvim_cmd(#{cmd: 'echo', args: ['"hello"']}, #{output: v:true}) endfunc ]]) feed([[:echon 1 | call Print() | echon 5]]) - screen:expect{grid=[[ + screen:expect { + grid = [[ ^ | {0:~ }|*4 15 | - ]]} + ]], + } end) it('works with non-String args', function() - eq('2', meths.cmd({cmd = 'echo', args = {2}}, {output = true})) - eq('1', meths.cmd({cmd = 'echo', args = {true}}, {output = true})) + eq('2', meths.cmd({ cmd = 'echo', args = { 2 } }, { output = true })) + eq('1', meths.cmd({ cmd = 'echo', args = { true } }, { output = true })) end) describe('first argument as count', function() it('works', function() command('vsplit | enew') - meths.cmd({cmd = 'bdelete', args = {meths.get_current_buf()}}, {}) + meths.cmd({ cmd = 'bdelete', args = { meths.get_current_buf() } }, {}) eq(1, meths.get_current_buf().id) end) it('works with :sleep using milliseconds', function() local start = luv.now() - meths.cmd({cmd = 'sleep', args = {'100m'}}, {}) + meths.cmd({ cmd = 'sleep', args = { '100m' } }, {}) ok(luv.now() - start <= 300) end) end) it(':call with unknown function does not crash #26289', function() - eq('Vim:E117: Unknown function: UnknownFunc', - pcall_err(meths.cmd, {cmd = 'call', args = {'UnknownFunc()'}}, {})) + eq( + 'Vim:E117: Unknown function: UnknownFunc', + pcall_err(meths.cmd, { cmd = 'call', args = { 'UnknownFunc()' } }, {}) + ) end) it(':throw does not crash #24556', function() - eq('42', pcall_err(meths.cmd, {cmd = 'throw', args = {'42'}}, {})) + eq('42', pcall_err(meths.cmd, { cmd = 'throw', args = { '42' } }, {})) end) it('can use :return #24556', function() exec([[ @@ -4495,7 +4830,7 @@ describe('API', function() let g:result = Foo() ]]) eq('before', meths.get_var('pos')) - eq({1, 2, 3}, meths.get_var('result')) + eq({ 1, 2, 3 }, meths.get_var('result')) end) end) end) diff --git a/test/functional/core/spellfile_spec.lua b/test/functional/core/spellfile_spec.lua index e3a59085cf..60cdf88fe3 100644 --- a/test/functional/core/spellfile_spec.lua +++ b/test/functional/core/spellfile_spec.lua @@ -25,6 +25,7 @@ describe('spellfile', function() local spellheader = 'VIMspell\050' it('errors out when prefcond section is truncated', function() meths.set_option_value('runtimepath', testdir, {}) + -- stylua: ignore write_file(testdir .. '/spell/en.ascii.spl', -- ┌ Section identifier (#SN_PREFCOND) -- │ ┌ Section flags (#SNF_REQUIRED or zero) @@ -35,11 +36,11 @@ describe('spellfile', function() -- │ │ ┌ Condition regex (missing!) .. '\000\001\001') meths.set_option_value('spelllang', 'en', {}) - eq('Vim(set):E758: Truncated spell file', - exc_exec('set spell')) + eq('Vim(set):E758: Truncated spell file', exc_exec('set spell')) end) it('errors out when prefcond regexp contains NUL byte', function() meths.set_option_value('runtimepath', testdir, {}) + -- stylua: ignore write_file(testdir .. '/spell/en.ascii.spl', -- ┌ Section identifier (#SN_PREFCOND) -- │ ┌ Section flags (#SNF_REQUIRED or zero) @@ -55,11 +56,11 @@ describe('spellfile', function() -- │ │ ┌ PREFIXTREE tree length .. '\000\000\000\000\000\000\000\000\000\000\000\000') meths.set_option_value('spelllang', 'en', {}) - eq('Vim(set):E759: Format error in spell file', - exc_exec('set spell')) + eq('Vim(set):E759: Format error in spell file', exc_exec('set spell')) end) it('errors out when region contains NUL byte', function() meths.set_option_value('runtimepath', testdir, {}) + -- stylua: ignore write_file(testdir .. '/spell/en.ascii.spl', -- ┌ Section identifier (#SN_REGION) -- │ ┌ Section flags (#SNF_REQUIRED or zero) @@ -72,11 +73,11 @@ describe('spellfile', function() -- │ │ ┌ PREFIXTREE tree length .. '\000\000\000\000\000\000\000\000\000\000\000\000') meths.set_option_value('spelllang', 'en', {}) - eq('Vim(set):E759: Format error in spell file', - exc_exec('set spell')) + eq('Vim(set):E759: Format error in spell file', exc_exec('set spell')) end) it('errors out when SAL section contains NUL byte', function() meths.set_option_value('runtimepath', testdir, {}) + -- stylua: ignore write_file(testdir .. '/spell/en.ascii.spl', -- ┌ Section identifier (#SN_SAL) -- │ ┌ Section flags (#SNF_REQUIRED or zero) @@ -96,15 +97,12 @@ describe('spellfile', function() -- │ │ ┌ PREFIXTREE tree length .. '\000\000\000\000\000\000\000\000\000\000\000\000') meths.set_option_value('spelllang', 'en', {}) - eq('Vim(set):E759: Format error in spell file', - exc_exec('set spell')) + eq('Vim(set):E759: Format error in spell file', exc_exec('set spell')) end) it('errors out when spell header contains NUL bytes', function() meths.set_option_value('runtimepath', testdir, {}) - write_file(testdir .. '/spell/en.ascii.spl', - spellheader:sub(1, -3) .. '\000\000') + write_file(testdir .. '/spell/en.ascii.spl', spellheader:sub(1, -3) .. '\000\000') meths.set_option_value('spelllang', 'en', {}) - eq('Vim(set):E757: This does not look like a spell file', - exc_exec('set spell')) + eq('Vim(set):E757: This does not look like a spell file', exc_exec('set spell')) end) end) diff --git a/test/functional/vimscript/msgpack_functions_spec.lua b/test/functional/vimscript/msgpack_functions_spec.lua index de5a721efe..824c1e8751 100644 --- a/test/functional/vimscript/msgpack_functions_spec.lua +++ b/test/functional/vimscript/msgpack_functions_spec.lua @@ -20,17 +20,18 @@ describe('msgpack*() functions', function() -- Regression test: msgpack_list_write was failing to write buffer with zero -- length. - obj_test('are able to dump and restore {"file": ""}', {{file=''}}) + obj_test('are able to dump and restore {"file": ""}', { { file = '' } }) -- Regression test: msgpack_list_write was failing to write buffer with NL at -- the end. - obj_test('are able to dump and restore {0, "echo mpack"}', {{0, 'echo mpack'}}) - obj_test('are able to dump and restore "Test\\n"', {'Test\n'}) + obj_test('are able to dump and restore {0, "echo mpack"}', { { 0, 'echo mpack' } }) + obj_test('are able to dump and restore "Test\\n"', { 'Test\n' }) -- Regression test: msgpack_list_write was failing to write buffer with NL -- inside. - obj_test('are able to dump and restore "Test\\nTest 2"', {'Test\nTest 2'}) + obj_test('are able to dump and restore "Test\\nTest 2"', { 'Test\nTest 2' }) -- Test that big objects (requirement: dump to something that is bigger then -- IOSIZE) are also fine. This particular object is obtained by concatenating -- 5 identical shada files. + -- stylua: ignore local big_obj = { 1, 1436711454, 78, { encoding="utf-8", @@ -330,19 +331,18 @@ describe('msgpack*() functions', function() } obj_test('are able to dump and restore rather big object', big_obj) - obj_test('are able to dump and restore floating-point value', {0.125}) + obj_test('are able to dump and restore floating-point value', { 0.125 }) it('can restore and dump UINT64_MAX', function() command('let dumped = ["\\xCF" . repeat("\\xFF", 8)]') command('let parsed = msgpackparse(dumped)') command('let dumped2 = msgpackdump(parsed)') - eq(1, eval('type(parsed[0]) == type(0) ' .. - '|| parsed[0]._TYPE is v:msgpack_types.integer')) + eq(1, eval('type(parsed[0]) == type(0) ' .. '|| parsed[0]._TYPE is v:msgpack_types.integer')) if eval('type(parsed[0]) == type(0)') == 1 then command('call assert_equal(0xFFFFFFFFFFFFFFFF, parsed[0])') eq({}, eval('v:errors')) else - eq({_TYPE={}, _VAL={1, 3, 0x7FFFFFFF, 0x7FFFFFFF}}, eval('parsed[0]')) + eq({ _TYPE = {}, _VAL = { 1, 3, 0x7FFFFFFF, 0x7FFFFFFF } }, eval('parsed[0]')) end eq(1, eval('dumped ==# dumped2')) end) @@ -351,13 +351,12 @@ describe('msgpack*() functions', function() command('let dumped = ["\\xD3\\x80" . repeat("\\n", 7)]') command('let parsed = msgpackparse(dumped)') command('let dumped2 = msgpackdump(parsed)') - eq(1, eval('type(parsed[0]) == type(0) ' .. - '|| parsed[0]._TYPE is v:msgpack_types.integer')) + eq(1, eval('type(parsed[0]) == type(0) ' .. '|| parsed[0]._TYPE is v:msgpack_types.integer')) if eval('type(parsed[0]) == type(0)') == 1 then command('call assert_equal(-0x7fffffffffffffff - 1, parsed[0])') eq({}, eval('v:errors')) else - eq({_TYPE={}, _VAL={-1, 2, 0, 0}}, eval('parsed[0]')) + eq({ _TYPE = {}, _VAL = { -1, 2, 0, 0 } }, eval('parsed[0]')) end eq(1, eval('dumped ==# dumped2')) end) @@ -366,7 +365,7 @@ describe('msgpack*() functions', function() command('let dumped = ["\\xC4\\x01\\n"]') command('let parsed = msgpackparse(dumped)') command('let dumped2 = msgpackdump(parsed)') - eq({'\000'}, eval('parsed')) + eq({ '\000' }, eval('parsed')) eq(1, eval('dumped ==# dumped2')) end) @@ -374,7 +373,7 @@ describe('msgpack*() functions', function() command('let dumped = ["\\xA1\\n"]') command('let parsed = msgpackparse(dumped)') command('let dumped2 = msgpackdump(parsed)') - eq({{_TYPE={}, _VAL={'\n'}}}, eval('parsed')) + eq({ { _TYPE = {}, _VAL = { '\n' } } }, eval('parsed')) eq(1, eval('parsed[0]._TYPE is v:msgpack_types.string')) eq(1, eval('dumped ==# dumped2')) end) @@ -383,19 +382,19 @@ describe('msgpack*() functions', function() command('let dumped = ["\\xC4\\x01", ""]') command('let parsed = msgpackparse(dumped)') command('let dumped2 = msgpackdump(parsed)') - eq({"\n"}, eval('parsed')) + eq({ '\n' }, eval('parsed')) eq(1, eval('dumped ==# dumped2')) end) it('dump and restore special mapping with floating-point value', function() command('let todump = {"_TYPE": v:msgpack_types.float, "_VAL": 0.125}') - eq({0.125}, eval('msgpackparse(msgpackdump([todump]))')) + eq({ 0.125 }, eval('msgpackparse(msgpackdump([todump]))')) end) end) local blobstr = function(list) local l = {} - for i,v in ipairs(list) do + for i, v in ipairs(list) do l[i] = v:gsub('\n', '\000') end return table.concat(l, '\n') @@ -403,9 +402,10 @@ end -- Test msgpackparse() with a readfile()-style list and a blob argument local parse_eq = function(expect, list_arg) - local blob_expr = '0z' .. blobstr(list_arg):gsub('(.)', function(c) - return ('%.2x'):format(c:byte()) - end) + local blob_expr = '0z' + .. blobstr(list_arg):gsub('(.)', function(c) + return ('%.2x'):format(c:byte()) + end) eq(expect, funcs.msgpackparse(list_arg)) command('let g:parsed = msgpackparse(' .. blob_expr .. ')') eq(expect, eval('g:parsed')) @@ -415,33 +415,33 @@ describe('msgpackparse() function', function() before_each(clear) it('restores nil as v:null', function() - parse_eq(eval('[v:null]'), {'\192'}) + parse_eq(eval('[v:null]'), { '\192' }) end) it('restores boolean false as v:false', function() - parse_eq({false}, {'\194'}) + parse_eq({ false }, { '\194' }) end) it('restores boolean true as v:true', function() - parse_eq({true}, {'\195'}) + parse_eq({ true }, { '\195' }) end) it('restores FIXSTR as special dict', function() - parse_eq({{_TYPE={}, _VAL={'ab'}}}, {'\162ab'}) + parse_eq({ { _TYPE = {}, _VAL = { 'ab' } } }, { '\162ab' }) eq(1, eval('g:parsed[0]._TYPE is v:msgpack_types.string')) end) it('restores BIN 8 as string', function() - parse_eq({'ab'}, {'\196\002ab'}) + parse_eq({ 'ab' }, { '\196\002ab' }) end) it('restores FIXEXT1 as special dictionary', function() - parse_eq({{_TYPE={}, _VAL={0x10, {"", ""}}}}, {'\212\016', ''}) + parse_eq({ { _TYPE = {}, _VAL = { 0x10, { '', '' } } } }, { '\212\016', '' }) eq(1, eval('g:parsed[0]._TYPE is v:msgpack_types.ext')) end) it('restores MAP with BIN key as special dictionary', function() - parse_eq({{_TYPE={}, _VAL={{'a', ''}}}}, {'\129\196\001a\196\n'}) + parse_eq({ { _TYPE = {}, _VAL = { { 'a', '' } } } }, { '\129\196\001a\196\n' }) eq(1, eval('g:parsed[0]._TYPE is v:msgpack_types.map')) end) @@ -449,72 +449,93 @@ describe('msgpackparse() function', function() command('let dumped = ["\\x82\\xA1a\\xC4\\n\\xA1a\\xC4\\n"]') -- FIXME Internal error bug, can't use parse_eq() here command('silent! let parsed = msgpackparse(dumped)') - eq({{_TYPE={}, _VAL={ {{_TYPE={}, _VAL={'a'}}, ''}, - {{_TYPE={}, _VAL={'a'}}, ''}}} }, eval('parsed')) + eq({ + { + _TYPE = {}, + _VAL = { + { { _TYPE = {}, _VAL = { 'a' } }, '' }, + { { _TYPE = {}, _VAL = { 'a' } }, '' }, + }, + }, + }, eval('parsed')) eq(1, eval('g:parsed[0]._TYPE is v:msgpack_types.map')) eq(1, eval('g:parsed[0]._VAL[0][0]._TYPE is v:msgpack_types.string')) eq(1, eval('g:parsed[0]._VAL[1][0]._TYPE is v:msgpack_types.string')) end) it('restores MAP with MAP key as special dictionary', function() - parse_eq({{_TYPE={}, _VAL={{{}, ''}}}}, {'\129\128\196\n'}) + parse_eq({ { _TYPE = {}, _VAL = { { {}, '' } } } }, { '\129\128\196\n' }) eq(1, eval('g:parsed[0]._TYPE is v:msgpack_types.map')) end) it('msgpackparse(systemlist(...)) does not segfault. #3135', function() - local cmd = "sort(keys(msgpackparse(systemlist('" - ..helpers.nvim_prog.." --api-info'))[0]))" + local cmd = "sort(keys(msgpackparse(systemlist('" .. helpers.nvim_prog .. " --api-info'))[0]))" eval(cmd) - eval(cmd) -- do it again (try to force segfault) - local api_info = eval(cmd) -- do it again + eval(cmd) -- do it again (try to force segfault) + local api_info = eval(cmd) -- do it again if is_os('win') then helpers.assert_alive() pending('msgpackparse() has a bug on windows') return end - eq({'error_types', 'functions', 'types', - 'ui_events', 'ui_options', 'version'}, api_info) + eq({ 'error_types', 'functions', 'types', 'ui_events', 'ui_options', 'version' }, api_info) end) it('fails when called with no arguments', function() - eq('Vim(call):E119: Not enough arguments for function: msgpackparse', - exc_exec('call msgpackparse()')) + eq( + 'Vim(call):E119: Not enough arguments for function: msgpackparse', + exc_exec('call msgpackparse()') + ) end) it('fails when called with two arguments', function() - eq('Vim(call):E118: Too many arguments for function: msgpackparse', - exc_exec('call msgpackparse(["", ""], 1)')) + eq( + 'Vim(call):E118: Too many arguments for function: msgpackparse', + exc_exec('call msgpackparse(["", ""], 1)') + ) end) it('fails to parse a string', function() - eq('Vim(call):E899: Argument of msgpackparse() must be a List or Blob', - exc_exec('call msgpackparse("abcdefghijklmnopqrstuvwxyz")')) + eq( + 'Vim(call):E899: Argument of msgpackparse() must be a List or Blob', + exc_exec('call msgpackparse("abcdefghijklmnopqrstuvwxyz")') + ) end) it('fails to parse a number', function() - eq('Vim(call):E899: Argument of msgpackparse() must be a List or Blob', - exc_exec('call msgpackparse(127)')) + eq( + 'Vim(call):E899: Argument of msgpackparse() must be a List or Blob', + exc_exec('call msgpackparse(127)') + ) end) it('fails to parse a dictionary', function() - eq('Vim(call):E899: Argument of msgpackparse() must be a List or Blob', - exc_exec('call msgpackparse({})')) + eq( + 'Vim(call):E899: Argument of msgpackparse() must be a List or Blob', + exc_exec('call msgpackparse({})') + ) end) it('fails to parse a funcref', function() - eq('Vim(call):E899: Argument of msgpackparse() must be a List or Blob', - exc_exec('call msgpackparse(function("tr"))')) + eq( + 'Vim(call):E899: Argument of msgpackparse() must be a List or Blob', + exc_exec('call msgpackparse(function("tr"))') + ) end) it('fails to parse a partial', function() command('function T() dict\nendfunction') - eq('Vim(call):E899: Argument of msgpackparse() must be a List or Blob', - exc_exec('call msgpackparse(function("T", [1, 2], {}))')) + eq( + 'Vim(call):E899: Argument of msgpackparse() must be a List or Blob', + exc_exec('call msgpackparse(function("T", [1, 2], {}))') + ) end) it('fails to parse a float', function() - eq('Vim(call):E899: Argument of msgpackparse() must be a List or Blob', - exc_exec('call msgpackparse(0.0)')) + eq( + 'Vim(call):E899: Argument of msgpackparse() must be a List or Blob', + exc_exec('call msgpackparse(0.0)') + ) end) it('fails on incomplete msgpack string', function() @@ -541,11 +562,11 @@ describe('msgpackdump() function', function() end it('dumps string as BIN 8', function() - dump_eq({'\196\004Test'}, '["Test"]') + dump_eq({ '\196\004Test' }, '["Test"]') end) it('dumps blob as BIN 8', function() - dump_eq({'\196\005Bl\nb!'}, '[0z426c006221]') + dump_eq({ '\196\005Bl\nb!' }, '[0z426c006221]') end) it('can dump generic mapping with generic mapping keys and values', function() @@ -553,209 +574,245 @@ describe('msgpackdump() function', function() command('let todumpv1 = {"_TYPE": v:msgpack_types.map, "_VAL": []}') command('let todumpv2 = {"_TYPE": v:msgpack_types.map, "_VAL": []}') command('call add(todump._VAL, [todumpv1, todumpv2])') - dump_eq({'\129\128\128'}, '[todump]') + dump_eq({ '\129\128\128' }, '[todump]') end) it('can dump v:true', function() - dump_eq({'\195'}, '[v:true]') + dump_eq({ '\195' }, '[v:true]') end) it('can dump v:false', function() - dump_eq({'\194'}, '[v:false]') + dump_eq({ '\194' }, '[v:false]') end) it('can dump v:null', function() - dump_eq({'\192'}, '[v:null]') + dump_eq({ '\192' }, '[v:null]') end) it('can dump special bool mapping (true)', function() command('let todump = {"_TYPE": v:msgpack_types.boolean, "_VAL": 1}') - dump_eq({'\195'}, '[todump]') + dump_eq({ '\195' }, '[todump]') end) it('can dump special bool mapping (false)', function() command('let todump = {"_TYPE": v:msgpack_types.boolean, "_VAL": 0}') - dump_eq({'\194'}, '[todump]') + dump_eq({ '\194' }, '[todump]') end) it('can dump special nil mapping', function() command('let todump = {"_TYPE": v:msgpack_types.nil, "_VAL": 0}') - dump_eq({'\192'}, '[todump]') + dump_eq({ '\192' }, '[todump]') end) it('can dump special ext mapping', function() command('let todump = {"_TYPE": v:msgpack_types.ext, "_VAL": [5, ["",""]]}') - dump_eq({'\212\005', ''}, '[todump]') + dump_eq({ '\212\005', '' }, '[todump]') end) it('can dump special array mapping', function() command('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": [5, [""]]}') - dump_eq({'\146\005\145\196\n'}, '[todump]') + dump_eq({ '\146\005\145\196\n' }, '[todump]') end) it('can dump special UINT64_MAX mapping', function() command('let todump = {"_TYPE": v:msgpack_types.integer}') command('let todump._VAL = [1, 3, 0x7FFFFFFF, 0x7FFFFFFF]') - dump_eq({'\207\255\255\255\255\255\255\255\255'}, '[todump]') + dump_eq({ '\207\255\255\255\255\255\255\255\255' }, '[todump]') end) it('can dump special INT64_MIN mapping', function() command('let todump = {"_TYPE": v:msgpack_types.integer}') command('let todump._VAL = [-1, 2, 0, 0]') - dump_eq({'\211\128\n\n\n\n\n\n\n'}, '[todump]') + dump_eq({ '\211\128\n\n\n\n\n\n\n' }, '[todump]') end) it('fails to dump a function reference', function() command('let Todump = function("tr")') - eq('Vim(call):E5004: Error while dumping msgpackdump() argument, index 0, itself: attempt to dump function reference', - exc_exec('call msgpackdump([Todump])')) + eq( + 'Vim(call):E5004: Error while dumping msgpackdump() argument, index 0, itself: attempt to dump function reference', + exc_exec('call msgpackdump([Todump])') + ) end) it('fails to dump a partial', function() command('function T() dict\nendfunction') command('let Todump = function("T", [1, 2], {})') - eq('Vim(call):E5004: Error while dumping msgpackdump() argument, index 0, itself: attempt to dump function reference', - exc_exec('call msgpackdump([Todump])')) + eq( + 'Vim(call):E5004: Error while dumping msgpackdump() argument, index 0, itself: attempt to dump function reference', + exc_exec('call msgpackdump([Todump])') + ) end) it('fails to dump a function reference in a list', function() command('let todump = [function("tr")]') - eq('Vim(call):E5004: Error while dumping msgpackdump() argument, index 0, index 0: attempt to dump function reference', - exc_exec('call msgpackdump([todump])')) + eq( + 'Vim(call):E5004: Error while dumping msgpackdump() argument, index 0, index 0: attempt to dump function reference', + exc_exec('call msgpackdump([todump])') + ) end) it('fails to dump a recursive list', function() command('let todump = [[[]]]') command('call add(todump[0][0], todump)') - eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in index 0, index 0, index 0', - exc_exec('call msgpackdump([todump])')) + eq( + 'Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in index 0, index 0, index 0', + exc_exec('call msgpackdump([todump])') + ) end) it('fails to dump a recursive dict', function() command('let todump = {"d": {"d": {}}}') command('call extend(todump.d.d, {"d": todump})') - eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in key \'d\', key \'d\', key \'d\'', - exc_exec('call msgpackdump([todump])')) + eq( + "Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in key 'd', key 'd', key 'd'", + exc_exec('call msgpackdump([todump])') + ) end) it('can dump dict with two same dicts inside', function() command('let inter = {}') command('let todump = {"a": inter, "b": inter}') - dump_eq({"\130\161a\128\161b\128"}, '[todump]') + dump_eq({ '\130\161a\128\161b\128' }, '[todump]') end) it('can dump list with two same lists inside', function() command('let inter = []') command('let todump = [inter, inter]') - dump_eq({"\146\144\144"}, '[todump]') + dump_eq({ '\146\144\144' }, '[todump]') end) it('fails to dump a recursive list in a special dict', function() command('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": []}') command('call add(todump._VAL, todump)') - eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in index 0', - exc_exec('call msgpackdump([todump])')) + eq( + 'Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in index 0', + exc_exec('call msgpackdump([todump])') + ) end) it('fails to dump a recursive (key) map in a special dict', function() command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": []}') command('call add(todump._VAL, [todump, 0])') - eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in index 0', - exc_exec('call msgpackdump([todump])')) + eq( + 'Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in index 0', + exc_exec('call msgpackdump([todump])') + ) end) it('fails to dump a recursive (val) map in a special dict', function() command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": []}') command('call add(todump._VAL, [0, todump])') - eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in key 0 at index 0 from special map', - exc_exec('call msgpackdump([todump])')) + eq( + 'Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in key 0 at index 0 from special map', + exc_exec('call msgpackdump([todump])') + ) end) it('fails to dump a recursive (key) map in a special dict, _VAL reference', function() command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[[], []]]}') command('call add(todump._VAL[0][0], todump._VAL)') - eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in key [[[[...@0], []]]] at index 0 from special map, index 0', - exc_exec('call msgpackdump([todump])')) + eq( + 'Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in key [[[[...@0], []]]] at index 0 from special map, index 0', + exc_exec('call msgpackdump([todump])') + ) end) it('fails to dump a recursive (val) map in a special dict, _VAL reference', function() command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[[], []]]}') command('call add(todump._VAL[0][1], todump._VAL)') - eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in key [] at index 0 from special map, index 0', - exc_exec('call msgpackdump([todump])')) + eq( + 'Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in key [] at index 0 from special map, index 0', + exc_exec('call msgpackdump([todump])') + ) end) - it('fails to dump a recursive (val) special list in a special dict', - function() + it('fails to dump a recursive (val) special list in a special dict', function() command('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": []}') command('call add(todump._VAL, [0, todump._VAL])') - eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in index 0, index 1', - exc_exec('call msgpackdump([todump])')) + eq( + 'Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in index 0, index 1', + exc_exec('call msgpackdump([todump])') + ) end) it('fails when called with no arguments', function() - eq('Vim(call):E119: Not enough arguments for function: msgpackdump', - exc_exec('call msgpackdump()')) + eq( + 'Vim(call):E119: Not enough arguments for function: msgpackdump', + exc_exec('call msgpackdump()') + ) end) it('fails when called with three arguments', function() - eq('Vim(call):E118: Too many arguments for function: msgpackdump', - exc_exec('call msgpackdump(["", ""], 1, 2)')) + eq( + 'Vim(call):E118: Too many arguments for function: msgpackdump', + exc_exec('call msgpackdump(["", ""], 1, 2)') + ) end) it('fails to dump a string', function() - eq('Vim(call):E686: Argument of msgpackdump() must be a List', - exc_exec('call msgpackdump("abcdefghijklmnopqrstuvwxyz")')) + eq( + 'Vim(call):E686: Argument of msgpackdump() must be a List', + exc_exec('call msgpackdump("abcdefghijklmnopqrstuvwxyz")') + ) end) it('fails to dump a number', function() - eq('Vim(call):E686: Argument of msgpackdump() must be a List', - exc_exec('call msgpackdump(127)')) + eq( + 'Vim(call):E686: Argument of msgpackdump() must be a List', + exc_exec('call msgpackdump(127)') + ) end) it('fails to dump a dictionary', function() - eq('Vim(call):E686: Argument of msgpackdump() must be a List', - exc_exec('call msgpackdump({})')) + eq('Vim(call):E686: Argument of msgpackdump() must be a List', exc_exec('call msgpackdump({})')) end) it('fails to dump a funcref', function() - eq('Vim(call):E686: Argument of msgpackdump() must be a List', - exc_exec('call msgpackdump(function("tr"))')) + eq( + 'Vim(call):E686: Argument of msgpackdump() must be a List', + exc_exec('call msgpackdump(function("tr"))') + ) end) it('fails to dump a partial', function() command('function T() dict\nendfunction') - eq('Vim(call):E686: Argument of msgpackdump() must be a List', - exc_exec('call msgpackdump(function("T", [1, 2], {}))')) + eq( + 'Vim(call):E686: Argument of msgpackdump() must be a List', + exc_exec('call msgpackdump(function("T", [1, 2], {}))') + ) end) it('fails to dump a float', function() - eq('Vim(call):E686: Argument of msgpackdump() must be a List', - exc_exec('call msgpackdump(0.0)')) + eq( + 'Vim(call):E686: Argument of msgpackdump() must be a List', + exc_exec('call msgpackdump(0.0)') + ) end) it('fails to dump special value', function() - for _, val in ipairs({'v:true', 'v:false', 'v:null'}) do - eq('Vim(call):E686: Argument of msgpackdump() must be a List', - exc_exec('call msgpackdump(' .. val .. ')')) + for _, val in ipairs({ 'v:true', 'v:false', 'v:null' }) do + eq( + 'Vim(call):E686: Argument of msgpackdump() must be a List', + exc_exec('call msgpackdump(' .. val .. ')') + ) end end) it('can dump NULL string', function() - dump_eq({'\196\n'}, '[$XXX_UNEXISTENT_VAR_XXX]') - dump_eq({'\196\n'}, '[{"_TYPE": v:msgpack_types.binary, "_VAL": [$XXX_UNEXISTENT_VAR_XXX]}]') - dump_eq({'\160'}, '[{"_TYPE": v:msgpack_types.string, "_VAL": [$XXX_UNEXISTENT_VAR_XXX]}]') + dump_eq({ '\196\n' }, '[$XXX_UNEXISTENT_VAR_XXX]') + dump_eq({ '\196\n' }, '[{"_TYPE": v:msgpack_types.binary, "_VAL": [$XXX_UNEXISTENT_VAR_XXX]}]') + dump_eq({ '\160' }, '[{"_TYPE": v:msgpack_types.string, "_VAL": [$XXX_UNEXISTENT_VAR_XXX]}]') end) it('can dump NULL blob', function() - eq({'\196\n'}, eval('msgpackdump([v:_null_blob])')) + eq({ '\196\n' }, eval('msgpackdump([v:_null_blob])')) end) it('can dump NULL list', function() - eq({'\144'}, eval('msgpackdump([v:_null_list])')) + eq({ '\144' }, eval('msgpackdump([v:_null_list])')) end) it('can dump NULL dictionary', function() - eq({'\128'}, eval('msgpackdump([v:_null_dict])')) + eq({ '\128' }, eval('msgpackdump([v:_null_dict])')) end) end)