Forem: jovica

Editing remote files with Vim

jovica — Mon, 30 Mar 2020 09:31:30 +0000

One of the lesser known features of Vim is the ability to edit files remotely, over the network.

This feature comes with the netrw plugin. To achieve this, netrw uses the SSH protocol, and manages remote files via the scp command.

Here’s how to do it:

vim scp://user@myserver[:port]//path/to/file.txt

Note the double / for the directory on the remote host, which is needed to correctly resolve the absolute path. [:port] is optional.

So with the command above you can open a file located on a remote host for editing.

What actually happens in the background is that Vim uses scp to download the requested file from a remote machine to a local /tmp directory, and then opens it for editing.

When you save your changes to the file, the changes are first applied to a local copy in /tmp directory. After that, the file is uploaded via scp to the remote host.

If you open a directory on a remote host, you could also use netrw to browse through remote files and directories. The important thing is to always specify the directory path with / at the end.

Of course, it’s recommended that you use SSH keys for authentication. Otherwise, you might be asked for the SSH password too often.

Beside SSH, there are other protocols supported such as sftp, ftp, dav, etc.

For example, to open a file on a remote FTP server, you could run a command like:

vim ftp://hostname/path/to/file

Netrw offers lots of options and possibilities for remote editing, so for more information on this, take a look at :help scp.

What you've just read is an a section of CHAPTER 6. WORKING WITH FILES from the book Mastering Vim Quickly.

The "dot" Command in Vim

jovica — Fri, 18 Oct 2019 09:59:41 +0000

I believe you have already heard of the principle Don’t Repeat Yourself.

In software engineering, this is a principle of software development where your focus is on reducing repetition of all kinds. As you'll see throughout the book, Vim has many ways and commands to automate different kinds of tasks, so you don't have to repeat your actions.

One of the most powerful Vim command when it comes to avoiding repetition is the . ("the dot") command.

Hitting . in Normal mode will repeat the last native Vim command you've executed.

Let's say you want to delete 5 words from the cursor forward. As you already know, you could press 5dw and it's done. However, sometimes it's not convenient to mentally count the number of words.

An alternative would be to use dw to delete one word. And then press .... to call the dot command four times. In this case, you would repeat the latest, dw command, four more times, and in this way achieve the same effect without counting the words.

If you used dd to delete a line, and you want to delete 4 more lines, you could also execute 4. instead of pressing .... . That also works.

It's very important to understand what is actually repeatable by the dot command. For example, if you have a sample code like this:

my $i
my $learn
my $quickly

and your cursor is positioned on the first line. You want to append ; to all three lines. You could run a command like: A;<Esc>j

• A – would place your cursor at the end of the first line in Insert mode.
• ; – you press to actually insert it, and then you press Esc to get back to Normal mode.
• j – to move one line down

Now, your cursor is at the second line. If you then press . to repeat the change in next (second) line, this won't work. Here's what you'd get:

my $i;
my $learn;
my $quickly

Your cursor will still be at the second line rather than on the third line, but ; will be appended.

This brings us to conclusion that only this part of our original command was repeated: A;<Esc>.

Now, why is this the case?

It’s important to remember that with the dot command, you can repeat the commands which change the contents of the buffer.

A change is any command which you can use to modify your text. In our example, we had the case that command j wasn't repeated, and our cursor wasn't moved to the third line.

Commands like j are called motions (or nouns)—and they don't affect the text itself. Command j just moves the cursor, but doesn't change text anyhow, so it can't be repeated.

Think in terms of the grammar of your native language: Not nouns, but verbs are used to express some sort of action. The same is true in Vim: nouns (or motions) can't affect the text, so they can't be repeated with the dot command.

To see all the commands which can affect the text in a buffer, take a look at :help change.txt

Of course, if you'd like to repeat multiple changes, or a combination of movements and changes, you can easily record those into a macro.

You can learn all you need on macros from Macros chapter (free to download) of my book Mastering Vim Quickly: From WTF to OMG in no time.

Still reading?

Every Tuesday I send awesome tips on Vim to 6K+ Vim fans, subscribers of my Mastering Vim Quickly Newsletter. Join us for free.

This post was originally published on my blog.

3 Little Known But Useful Vim Tips

jovica — Mon, 26 Nov 2018 15:35:05 +0000

I'll show you three tips which can be incredibly useful, yet, they are very little known.

Tip #1 - Open/edit/save archives

Running a command like:

$ vim archive.tar.gz

will open the archive.tar.gz, and list the contents of the archive. From there, you can open, edit and save changes in these files, without the need to extract them first.

How cool is that? :)

Supported archives: tar.gz, tgz, zip, jar, etc.

Tip #2 - Edit files remotely

Vim has the ability to edit files remotely, over the network. This feature comes with the netrw plugin. To achieve this, netrw uses the SSH protocol, and manages remote files via the scp command.

Here's how to do it:

vim scp://user@myserver[:port]//path/to/file.txt

Note the double / for the directory on the remote host, which is needed to correctly resolve the absolute path. [:port] is optional.

So with the command above you can open a file located on a remote host for editing.

What actually happens in the background is that Vim uses scp to download the requested file from a remote machine to a local /tmp directory, and then opens it for editing.

When you save your changes to the file, the changes are first applied to a local copy in /tmp directory. After that, the file is uploaded via scp to the remote host.

Tip #3 - Magic

Did you know that you can open the last edited file on the machine with cursor on the latest location?

Just start Vim, hit Ctrl+o+o - and there you go.

Keep hitting o and see what happens ;)

Now, if you wanna discover more Vim tips you've never heard of, take a look at my book Mastering Vim Quickly: From WTF to OMG in no time

The Vim Trick Which Will Save Your Time and Nerves

jovica — Tue, 11 Sep 2018 13:31:45 +0000

Whether you're beginner or advanced Vim user, I'm sure you've seen this at least once:

E45: 'readonly' option is set (add ! to override)

It usually goes like this:

You open a file with Vim and make some changes. When you try to save the file and see the message above.

Then you realize that you didn’t run Vim with sudo?! Argh, so annoying isn't it?

Today, you're gonna learn how to solve this easily, and once for all.

It's very simple, all you need to do is to add this line to your .vimrc:

cnoremap w!! execute 'silent! write !sudo tee % >/dev/null' <bar> edit!

When you get to the same situation again and you can't save your file, simply run :w!! command, and your changes will be saved!

Now, how this works:

cnoremap - tells Vim that the following mappings that is used when in command-line mode
w!! - the mapping (shortcut) itself.
execute '<command>' - executes a command between the quotes
silent! - run it silently
write !sudo tee % >/dev/null - the magic trick which would take another post to explain
<bar> edit! - this calls the edit command to reload the buffer and then avoid messages such as "the buffer has changed".

Hint: you need to type :w!! fast, so it expands into the full command. Typing these four strings slowly and hitting Enter won't work.

I share tips like this at Mastering Vim Quickly Newsletter.

I also wrote a book Mastering Vim Quickly: From WTF to OMG in no time

You can also get the best Vim tips by following @MasteringVim

A Simple (Yet Powerful) Tip on Git and Vim

jovica — Tue, 31 Jul 2018 20:35:57 +0000

Here's a tip you might find useful if you work with git and you use Vim. I recently came up with it.

For example, I want to see a file in different branch while staying in my current branch(so without changing the branch). I could use command like:

git show branch_name:/path/to/file.pl

But what if I want to see this file in Vim? It's easy, I could run a command like:

git show branch_name:/path/to/file.pl | vim -

However, this way there's no syntax highlight, so we can fix this:

git show branch_name:/path/to/file.pl | vim - -c 'set syntax=perl'

That's nice :) now my Perl file is properly highlighted.

Okay, but what if I work with Perl, and Python, and Bash, etc. It's not very handy to type all of this every time.

Here's one solution - you could create aliases:

alias vim.py="vim - -c 'set syntax=python'"
alias vim.pl="vim - -c 'set syntax=perl'"

So next time you need to see a Python file in different branch than your current one, you could run:

git show branch_name:/path/to/file.py | vim.py

I hope you find this useful.

I share tips like this in Mastering Vim Quickly newsletter at http://masteringvim.com.