DEV Community: Eric Wong

Multiple cursor support in SpaceVim

Eric Wong — Fri, 08 Apr 2022 14:42:26 +0000

SpaceVim is a preconfigured configuration for Vim and Neovim. It provides multiple cursor supportting via iedit plugin which just same as iedit-mode of emacs.

The default key binding of iedit is SPC s e, SPC is <Space>. There are two mode of iedit, iedit-normal mode and iedit-insert mode. Here are the key bindings of these two modes.

iedit states key bindings

State transitions:

Key Bindings	From	to
`SPC s e`	normal or visual	iedit-Normal

In iedit-Normal mode:

iedit-Normal mode inherits from Normal mode, the following key bindings are specific to iedit-Normal mode.

Key Binding	Descriptions
`<Esc>`	go back to `Normal` mode
`i`	switch to `iedit-Insert` mode, same as `i` in `Normal` model
`a`	switch to `iedit-Insert` mode, same as `a` in `Normal` model
`I`	go to the beginning of the current occurrence and switch to `iedit-Insert` mode, same as `I` in `Normal` model
`A`	go to the end of the current occurrence and switch to `iedit-Insert` mode, same as `A` in `Normal` model
`<Left>`/`h`	Move cursor to left, same as `h` in `Normal` model
`<Right>`/`l`	Move cursor to right, same as `l` in `Normal` model
`0`/`<Home>`	go to the beginning of the current occurrence, same as `0` in `Normal` model
`$`/`<End>`	go to the end of the current occurrence, same as `$` in `Normal` model
`C`	delete the characters from the cursor to the end in all occurrences and switch to iedit-Insert mode, same as `C` in `Normal` model
`D`	delete the occurrences, same as `D` in `Normal` model
`s`	delete the character under cursor and switch to iedit-Insert mode, same as `s` in `Normal` model
`S`	delete the occurrences and switch to iedit-Insert mode, same as `S` in `Normal` model
`x`	delete the character under cursor in all the occurrences, same as `x` in `Normal` model
`X`	delete the character before cursor in all the occurrences, same as `X` in `Normal` model
`gg`	go to first occurrence, same as `gg` in `Normal` model
`G`	go to last occurrence, same as `G` in `Normal` model
`f{char}`	Move the cursor to the right where the `{char}` first appears in all the occurrences
`n`	go to next occurrence
`N`	go to previous occurrence
`p`	replace occurrences with last yanked (copied) text
`<Tab>`	toggle current occurrence

In iedit-Insert mode:

Key Bindings	Descriptions
`Ctrl-g` / `<Esc>`	go back to `iedit-Normal` mode
`Ctrl-b` / `<Left>`	move cursor to left
`Ctrl-f` / `<Right>`	move cursor to right
`Ctrl-a` / `<Home>`	moves the cursor to the beginning of the current occurrence
`Ctrl-e` / `<End>`	moves the cursor to the end of the current occurrence
`Ctrl-w`	delete word before cursor
`Ctrl-k`	delete all words after cursor
`Ctrl-u`	delete all characters before cursor
`Ctrl-h` / `<Backspace>`	delete character before cursor
`<Delete>`	delete character after cursor

The SPC s e will select all matchs by default, if you want to select the matchs one by one, you can use SPC s E key binding and Ctrl-n to select next one.

Tasks manager within SpaceVim

Eric Wong — Sat, 22 Feb 2020 08:38:12 +0000

Tasks

To integrate with external tools, SpaceVim introduce a task manager system,
which is similar to vscode tasks-manager. There are two kinds of task configuration
file: global tasks configuration(~/.SpaceVim.d/tasks.toml) and local configuration(.SpaceVim.d/tasks.toml).

Key Bindings	Descriptions
`SPC p t e`	edit tasks configuration file
`SPC p t r`	select task to run

Task auto-detection

SpaceVim currently auto-detects tasks for npm.
the tasks manager will paser the package.json file for npm systems.
If you have cloned the eslint-starter example,
then pressing SPC p t r shows the following list:

Custom tasks

this is basic task configuration for running echo hello world, and print results to runner windows.

[my-task]
    command = 'echo'
    args = ['hello world']

To run task in the background, you need to set isBackground to true:

[my-task]
    command = 'echo'
    args = ['hello world']
    isBackground = true

The task's properties have the following semantic:

command: the actual command to execute.
args: the arguments passed to the command. can be omitted.
options: override the defaults for cwd,env or shell.

SpaceVim supports variable substitution in task, The following predefined variables are supported:

${workspaceFolder}: - the project root directory
${workspaceFolderBasename}: - the parent directory name of current project root
${file}: - the path of current file
${relativeFile}: - the current file relative to project root
${relativeFileDirname}: - the current file's dirname relative to workspaceFolder
${fileBasename}: - the current file's basename
${fileBasenameNoExtension}: - the current file's basename without file extension
${fileDirname}: - the current file's dirname
${fileExtname}: - the current file's extension
${cwd}: - the task runner's current working directory on startup
${lineNumber}: - the current selected line number in the active file

for example: Supposing that you have the following requirements:

A file located at /home/your-username/your-project/folder/file.ext opened in your editor;
The directory /home/your-username/your-project opened as your root workspace.
So you will have the following values for each variable:

${workspaceFolder}: - /home/your-username/your-project/
${workspaceFolderBasename}: - your-project
${file}: - /home/your-username/your-project/folder/file.ext
${relativeFile}: - folder/file.ext
${relativeFileDirname}: - folder/
${fileBasename}: - file.ext
${fileBasenameNoExtension}: - file
${fileDirname}: - /home/your-username/your-project/folder/
${fileExtname}: - .ext
${lineNumber}: - line number of the cursor

Use Vim as a Java IDE

Eric Wong — Mon, 24 Jun 2019 12:30:04 +0000

Use Vim as a Java IDE

why canonical_url do not word?!
the origin URL is https://spacevim.org/use-vim-as-a-java-ide/

This is a general guide for using SpaceVim as a Java IDE, including layer configuration and usage.
Each of the following sections will be covered:

Installation
Language server
Code completion
Code outline
Rename symbol
Javadoc hovers
Syntax lint
Import packages
Jump to test file
running code
Code formatting
REPL

Installation

SpaceVim is a Vim and neovim configuration, so you need to install vim or neovim,
here are two guides for installing neovim and vim8 with +python3 feature.
following the quick start guide to install SpaceVim.

SpaceVim do not enable language layer by default, so you need to enable lang#java layer.
Press SPC f v d to open SpaceVim configuration file, and add following section:

[[layers]]
  name = "lang#java"

Language server

To enable language server protocol support, you may need to enable lsp layer.

[[layers]]
  name = "lsp"
  filetypes = [
    "java"
  ]
  [layers.override_cmd]
    java = [
    "java",
    "-Declipse.application=org.eclipse.jdt.ls.core.id1",
    "-Dosgi.bundles.defaultStartLevel=4",
    "-Declipse.product=org.eclipse.jdt.ls.core.product",
    "-Dlog.protocol=true",
    "-Dlog.level=NONE",
    "-noverify",
    "-Xmx1G",
    "-jar",
    "D:\\dev\\jdt-language-server-latest\\plugins\\org.eclipse.equinox.launcher_1.5.200.v20180922-1751.jar",
    "-configuration",
    "D:\\dev\\jdt-language-server-latest\\config_win",
    "-data",
    "C:\\Users\\Administrator\\.cache\\javalsp"
    ]

You need to replace D:\dev\jdt-language-server-latest\plugins\org.eclipse.equinox.launcher_1.5.200.v20180922-1751.jar with the actual name of the org.eclipse.equinox.launcher jar

The configuration flag can point to either:

config_win, for Windows
config_mac, for MacOS
config_linux, for Linux

The data flag value should be the absolute path to the working directory of the server.
This should be different from the path of the user's project files (which is sent during the initialize handshake).

Code completion

javacomplete2 which has been included in lang#java layer provides omnifunc for java file and deoplete source.
with this plugin and autocomplete layer, the completion popup menu will be opened automatically。

Code outline

The default outline plugin is tagbar, and the key binding is F2. This key binding will open an outline sidebar on the left.

To fuzzy find outline in current buffer, you need to enable a fuzzy find layer, for example denite layer,
then press Leader f o:

Rename symbol

After enable lsp layer for java, you can use SPC l e to rename symbol under the cursor:

Javadoc hovers

The default key binding to get doc of cursor symbol is SPC l d or K:

Syntax lint

checkers layer provides asynchronous linting feature, this layer use neomake by default.
neomake support maven, gradle and eclipse project. it will generate classpath automatically for these project.

within above picture, we can see the checkers layer provides following feature:

list errors and warnings in quickfix windows
sign error and warning position on the left side
show numbers of errors and warnings on statusline
show cursor error and warning information below current line

Import packages

There are two kind features for importing packages, import packages automatically and manually. SpaceVim will import the packages after selecting the class name on popmenu.
Also, you can use key binding <F4> to import the class at the cursor point. If there are more than one class, a menu will be shown below current windows.

Jump to test file

SpaceVim use vim-project to manager the files in a project, you can add a .projections.json to the root of your project with following content:

{
  "src/main/java/*.java": {"alternate": "src/test/java/{dirname}/Test{basename}.java"},
  "src/test/java/**/Test*.java": {"alternate": "src/main/java/{}.java"}
}

with this configuration, you can jump between the source code and test file via command :A

running code

Base on JavaUnite, you can use SPC l r c to run current function or use SPC l r m to run the main function of current Class.

Code formatting

For formatting java code, you also nEed have uncrustify or astyle in your PATH.
BTW, the google's java formatter also works well with neoformat.

REPL

you need to install jdk9 which provide a build-in tools jshell, and SpaceVim use the jshell as default inferior REPL process:

Use Vim as a C/C++ IDE

Eric Wong — Fri, 10 May 2019 00:00:00 +0000

Use Vim as a C/C++ IDE

This is a general guide for using SpaceVim as a C/C++ IDE, including layer configuration and usage. Each of the following sections will be covered:

Enable language layer
code completion
alternate file jumping
code running
code format
REPL support  ### Enable language layer

To add C/C++ language support in SpaceVim, you need to enable the lang#c layer. Press SPC f v d to openSpaceVim configuration file, and add following configuration:

[[layers]]
  name = "lang#c"

for more info, you can read the lang#c layer documentation.

code completion

By default the autocomplete layer has been enabled, so after loading lang#c layer, the code completionfor C/C++ language should works well.

alternate file jumping

To manage the alternate file for a project, you may need to create a .project_alt.json file in the root of yourproject.

for exmaple, add following content into the .project_alt.json file:

{
  "*.c": {"alternate": "{}.h"},
  "*.h": {"alternate": "{}.c"}
}

with this configuration, you can jump between the alternate file via command :A

code running

The default code running key binding is SPC l r. It will compile and run current file asynchronously.And the stdout will be shown on a runner buffer.

code format

The format layer use neoformat as default tool to format code, it will format current file.And the default key binding is SPC b f.

[[layers]]
  name = "format"

REPL support

Start a igcc inferior REPL process with SPC l s i. After the REPL process being started, you cansend code to inferior process, all key bindings prefix with SPC l s, including sending line, sending selection or evensend whole buffer.

Use Vim as a PHP IDE

Eric Wong — Wed, 08 May 2019 00:00:00 +0000

Use Vim as a PHP IDE

This is a general guide for using SpaceVim as a PHP IDE, including layer configuration and usage. Each of the following sections will be covered:

Enable language layer
Code completion
Syntax linting
Jump to test file
running code
Code formatting
REPL support  ### Enable language layer

To add PHP language support in SpaceVim, you need to enable the lang#php layer. Press SPC f v d to openSpaceVim configuration file, and add the following snippet:

[[layers]]
  name = "lang#php"

For more info, you can read the lang#php layer documentation.

Code completion

lang#php layer will load the PHP plugin automatically, unless it’s overriden in your init.toml.The completion menu will be opened as you type.

Syntax linting

The checkers layer is enabled by default. This layer provides asynchronous syntax linting via neomake.It will run psalm asynchronously.

To install psalm, you may need to run:

composer require --dev vimeo/psalm

Jump to test file

To manage the alternate file for a project, you may need to create a .project_alt.json file in the root of yourproject.

for exmaple, add following content into the .project_alt.json file:

{
  "src/*.php": {"alternate": "test/{}.php"},
  "test/*.php": {"alternate": "src/{}.php"}
}

with this configuration, you can jump between the source code and test file via command :A

running code

To run current script, you can press SPC l r, and a split windowwill be openen, the output of the script will be shown in this window.It is running asynchronously, and will not block your Vim.

Code formatting

The format layer is also enabled by default. With this layer you can use key binding SPC b f to format current buffer.Before using this feature, please install php_beautifier:

pear install PHP_Beautifier

REPL support

Start a php -a inferior REPL process with SPC l s i. After the REPL process being started, you cansend code to inferior process. All key bindings prefix with SPC l s, including sending line, sending selection or evensend whole buffer.

Use Vim as a Ruby IDE

Eric Wong — Mon, 18 Feb 2019 00:00:00 +0000

Use Vim as a Ruby IDE

This is a general guide for using SpaceVim as a Ruby IDE, including layer configuration and usage.Each of the following sections will be covered:

Enable language layer
Code completion
Syntax linting
Jump to test file
running code
Code formatting
REPL support  ### Enable language layer

To add Ruby language support in SpaceVim, you need to enable the lang#ruby layer. Press SPC f v d to openSpaceVim configuration file, and add the following snippet:

[[layers]]
  name = "lang#ruby"

For more info, you can read the lang#ruby layer documentation.

Code completion

lang#ruby layer will load the Ruby plugin automatically, unless it’s overriden in your init.toml.The completion menu will be opened as you type.

Syntax linting

The checkers layer is enabled by default. This layer provides asynchronous syntax linting via neomake.It will run rubocop asynchronously.

Install rubocop via gem:

gem install rubocop

Jump to test file

SpaceVim use built-in plugin to manager the files in a project, you can add a .project_alt.json to the root of your project with the following content:

{
  "src/*.rb": {"alternate": "test/{}.rb"},
  "test/*.rb": {"alternate": "src/{}.rb"}
}

With this configuration, you can jump between the source code and test file via command :A

running code

To run current script, you can press SPC l r, and a split windowwill be openen, the output of the script will be shown in this window.It is running asynchronously, and will not block your Vim.

Code formatting

The format layer is also enabled by default. With this layer you can use key binding SPC b f to format current buffer.Before using this feature, please install rufo:

gem install rufo

REPL support

Start a irb inferior REPL process with SPC l s i. After the REPL process being started, you cansend code to inferior process. All key bindings prefix with SPC l s, including sending line, sending selection or evensend whole buffer.

Use Vim as a Perl IDE

Eric Wong — Tue, 12 Feb 2019 00:00:00 +0000

Use Vim as a Perl IDE

This is a general guide for using SpaceVim as a perl IDE, including layer configuration and usage. Each of the following sections will be covered:

Enable language layer
Code completion
Syntax linting
Jump to test file
running code
Code formatting
REPL support  ### Enable language layer

To add perl language support in SpaceVim, you need to enable the lang#perl layer. Press SPC f v d to openSpaceVim configuration file, and add following configuration:

[[layers]]
  name = "lang#perl"

for more info, you can read the lang#perl layer documentation.

Code completion

lang#perl layer will load the perl plugin automatically, unless overriden in your init.toml.The completion menu will be opened as you type.

Syntax linting

The checkers layer is enabled by default. This layer provides asynchronous syntax linting via neomake.It will run perl and perlcritic asynchronously.

Install perlcritic via cpan:

cpanm Perl::Critic

Jump to test file

SpaceVim use built-in plugin to manager the files in a project, you can add a .project_alt.json to the root of your project with following content:

{
  "src/*.pl": {"alternate": "test/{}.pl"},
  "test/*.pl": {"alternate": "src/{}.pl"}
}

with this configuration, you can jump between the source code and test file via command :A

running code

To run current script, you can press SPC l r, and a split windowswill be openen, the output of the script will be shown in this windows.It is running asynchronously, and will not block your vim.

Code formatting

The format layer is also enabled by default, with this layer you can use key binding SPC b f to format current buffer.Before using this feature, please install perltidy:

cpanm Perl::Tidy

REPL support

Start a perli or perl -del inferior REPL process with SPC l s i. After the REPL process has been started. you can send code to inferior process, all key bindings are begin with SPC l s prefix, including sending line, sending selection or evensend whole buffer.

Use Vim as a CoffeeScript IDE

Eric Wong — Mon, 28 Jan 2019 00:00:00 +0000

Blogs » Use Vim as a CoffeeScript IDE

This is a general guide for using SpaceVim as a CoffeeScript IDE, including layer configuration and usage. Each of the following sections will be covered:

Enable language layer
Code completion
Syntax linting
Jump to test file
running code
Code formatting  ### Enable language layer

By default lang#coffeescript layer is not loaded. To add CoffeeScript language support in SpaceVim,you need to enable the lang#coffeescript layer. Press SPC f v d to openSpaceVim configuration file, and add following configuration:

[[layers]]
  name = "lang#coffeescript"

for more info, you can read the lang#coffeescript layer documentation.

Code completion

lang#coffeescript layer will load the vim-coffeescript plugin automatically, unless overriden in your init.toml.The completion menu will be opened as you type.

Syntax linting

The checkers layer is enabled by default. This layer provides asynchronous syntax linting via neomake.It will run coffeelint asynchronously.

The coffeelint is command line lint for coffeescript, currently is maintained by Shuan Wang.To install coffeelint, just run following command in terminal.

npm install -g coffeelint

Note: if no coffeelint is installed, neomake will ues default command coffee.

Jump to test file

SpaceVim use built-in plugin to manager the files in a project,you can add a .project_alt.json to the root of your project with following content:

{
  "src/*.coffee": {"alternate": "test/{}.coffee"},
  "test/*.coffee": {"alternate": "src/{}.coffee"}
}

with this configuration, you can jump between the source code and test file via command :A.

running code

To run current script, you can press SPC l r, and a split windowswill be openen, the output of the script will be shown in this windows.It is running asynchronously, and will not block your vim.

Code formatting

The format layer is also enabled by default, with this layer you can use key binding SPC b f to format current buffer.Before using this feature, please install coffee-fmt.

npm install -g coffee-fmt

Use Vim as a Python IDE

Eric Wong — Thu, 27 Sep 2018 00:00:00 +0000

Use Vim as a Python IDE

This is a general guide for using SpaceVim as a python IDE, including layer configuration and usage. Each of the following sections will be covered:

Enable language layer
Code completion
Syntax lint
Import packages
Jump to test file
running code
Code formatting
REPL
Debug  ### Enable language layer

To add python language support in SpaceVim, you need to enable lang#python layer. Just press SPC f v d to openSpaceVim configuration file, and add following configuration:

[[layers]]
  name = "lang#python"

for more info, you can read the lang#python layer documentation.

Code completion

Base on which completion engine is used, lang#python layer load the jedi plugin automatically.The completion menu will be opened as you type.

Syntax lint

neomake - Asynchronous linting and make framework for Neovim/Vim

I am maintainer of javac maker in neomake, the javac maker support maven project, gradle project or eclipse project.also you can set the classpath.

Import packages

When edit python file, you can import the package automatically, remove unused package and format package list.

pip install --user isort

Jump to test file

SpaceVim use vim-project to manager the files in a project, you can add a .projections.json to the root of your project with following content:

{
  "src/*.py": {"alternate": "test/{dirname}/{basename}Test.py"},
  "test/**/Test*.py": {"alternate": "src/{}.py"}
}

with this configuration, you can jump between the source code and test file via command :A

running code

To run current script, you can press SPC l r, and a split windowswill be openen, the output of the script will be shown in this windows.It is running asynchronously, and will not block your vim.

Code formatting

neoformat - A (Neo)vim plugin for formatting code.

For formatting java code, you also nEed have uncrustify or astyle in your PATH.BTW, the google’s java formatter also works well with neoformat.

REPL

you need to install jdk9 which provide a build-in tools jshell, and SpaceVim use the jshell as default inferior REPL process:

Debug

Grep on the fly in SpaceVim

Eric Wong — Tue, 23 Jan 2018 00:00:00 +0000

Asynchronous grep on the fly

FlyGrep means grep on the fly , it will update the result as you type. Of course, it is runningasynchronously. Before using this feature, you need to install a searching tool. FlyGrep worksthrough search tools: ag, rg, ack, pt and grep, Choose one you like.

This ia a built-in plugin in SpaceVim, and we also separated a plugin : FlyGrep.vim

Features

Search in a project

In SpaceVim, you can use SPC s p or SPC s / to search in the current project.

Search in current file

You can use SPC s s to search in the current file. To search word under the cursor, you can press SPC s S.

Search in all loaded buffers

To searching in all loaded buffers, you need to press SPC s b, and you can also use SPC s B to search word under the point.

Search in an arbitrary directory

If you want to searching in a different directory instead of current directory, you canuse SPC s f. Then insert the path of the arbitrary directory.

Search in a project in the background

If you need background searching, you can press SPC s j, after searching is done, the index will be displayed on statusline. you can use SPC s l to list all the search results.

Key bindings

The search commands in SpaceVim are organized under the SPC s prefix with the next key is the tool to use and the last key is the scope. For instance SPC s a b will search in all opened buffers using ag.

If the last key (determining the scope) is uppercase then the current word under the cursor is used as default input for the search. For instance SPC s a B will search with word under cursor.

If the tool key is omitted then a default tool will be automatically selected for the search. This tool corresponds to the first tool found on the system of the list g:spacevim_search_tools, the default calling sequence is rg, ag, pt, ack then grep. For instance SPC s b will search in the opened buffers using pt if rg and ag have not been found on the system.

The tool keys are:

Tool	Key
ag	a
grep	g
ack	k
rg	r
pt	t

The available scopes and corresponding keys are:

Scope	Key
opened buffers	b
files in a given directory	f
current project	p

Within FlyGrep buffer:

Key Binding	Description
`<Esc>`	close FlyGrep buffer
`<Enter>`	open file at the cursor line
`<Tab>`	move cursor line down
`<C-j>`	move cursor line down
`<S-Tab>`	move cursor line up
`<C-k>`	move cursor line up
`<Bs>`	remove last character
`<C-w>`	remove the word before the cursor
`<C-u>`	remove the line before the cursor
`<C-k>`	remove the line after the cursor
`<C-a>`/`<Home>`	Go to the beginning of the line
`<C-e>`/`<End>`	Go to the end of the line