Meet Gor - Tag: vim

Format JSON in Vim with JQ

Sat, 05 Apr 2025 00:00:00 UTC

We can use

:%!jq .

To instantly format a json file opened in vim/neovim. I relied on online foramtter and opening vscode for formatting. But this quick tool just saves a lot of hassle. Opening VS Co** == shutting down the laptop, it clogs the memory badly, so I avoid opening VS Co** as much as possible.

Yes, to use this, you need to have jq installed on your system.

If you are elsewhere and want to format json file using jq, you can quickly do this:

jq . input.json | sponge input.json

# OR

jq . input.json > tmp.json && mv tmp.json input.json

If you are in Vim and want to format other file, just add ! at the start of the command and that will run in the shell for you, so you don't have to exit vim.

Map Vimscript Keymaps to Lua with a single function

Mon, 11 Jul 2022 00:00:00 UTC

## Introduction Are you bored of writing all the keymaps from vimscript to lua? Try the below function to create all your keymaps to lua equivalent maps in Neovim. Take your vimscript keymaps and put them in lua don't write any lua for it ;) ## The Lua Function The below-provided snippet is a lua function that takes in a table of strings(list of strings), the strings will be your keymaps. The function then maps these keymaps using lua functions. You don't have to type out all the keymaps by yourself. It can also print out the lua equivalent function calls required to map the existing keymaps from vimscript to lua runtime in Neovim. Though it won't handle all the options, we have passed in a default value to the keymap. ```lua function key_mapper(keymaps) for _, keymap in ipairs(keymaps) do local mode = keymap:sub(1,1) local delimiter = " " local lhs = '' local rhs_parts = {} local m = 0 local options = {noremap = true} for matches in (keymap..delimiter):gmatch("(.-)"..delimiter) do if m == 1 then lhs = matches end if m >= 2 then table.insert(rhs_parts, matches) end m = m + 1 end rhs = '' for _, p in ipairs(rhs_parts) do rhs = rhs .. " " .. p end --print("vim.keymap.set(".."\'"..mode.."\'"..", ".."\'"..lhs.."\'"..", ".."\'"..rhs.."\'"..", "..vim.inspect(options)..")") vim.keymap.set(mode, lhs, rhs, options) end end ``` You can uncomment the print statement **once** to grab the keymaps and paste them into the config file. If you leave it uncommented, it might print every time you open up a new neovim instance. The function can be called like below: ```lua key_mapper({ 'nnoremap cpp :!c++ % -o %:r && %:ri', 'nnoremap c, :!gcc % -o %:r && %:r', 'nnoremap py :!python %', 'nnoremap go :!go run %', 'nnoremap sh :!bash %' }) ``` ![Keymapper demonstration](https://res.cloudinary.com/techstructive-blog/image/upload/v1657559501/blog-media/neovim-lua-keymapper.gif) We pass in a table of strings, these strings are just the vimscript keymaps. This function call will then map the keymaps into equivalent lua maps. You can customize it as per your needs. For further references, you can check out my [dotfiles](https://github.com/Mr-Destructive/dotfiles) on GitHub. ## How the function works The function is simply a text scrapping from lua strings. We extract the first character in the string for the mode, grab the strings which are space-separated and finally sort out which are lhs and rhs sides of the maps. We iterate over the table in lua with the help of ipairs function which allows us to iterate over an ordered list of items in a table. Using the gmatch function, we find a pattern to split the string with the space as the delimiter. Thereby, we can have separate sets of strings identified as rhs and lhs. We can store them in variables as strings as the lua functions require them as strings. We simply add those variables into the [vim.keymap.set](https://neovim.io/doc/user/lua.html#:~:text=set(%7Bmode%7D%2C%20%7Blhs%7D%2C%20%7Brhs%7D%2C%20%7Bopts%7D)%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20*vim.keymap.set()*) or [vim.api.nvim_set_keymap](https://neovim.io/doc/user/api.html#nvim_set_keymap():~:text=nvim_set_keymap(%7Bmode%7D%2C%20%7Blhs%7D%2C%20%7Brhs%7D%2C%20%7B*opts%7D)%20%20%20%20%20%20%20%20%20%20%20%20%20*nvim_set_keymap()*) functions. We by default set the value of `{noremap: True}` to avoid teh recursive mapping of the keys. These option parameter is the one which needs to be a bit more dynamic in terms of wide variety of keymaps. So, this is how we can convert the vimscript keymaps to lua in Neovim. Hope you found this useful. Thanks for reading. Happy Viming :)

Autoformat Python file with Black after saving in Vim

Tue, 29 Mar 2022 00:00:00 UTC

If you are like me who writes Python very badly, it has empty lines with whitespaces, no proper format in assigning variables, not formatted according to [PEP 8](https://peps.python.org/pep-0008/) standards, and you use Vim as your text editor then my friend you need a autocmd badly for it. ## Install Black in Python Install the [black](https://pypi.org/project/black/) package in python globally or locally as per your preferences. ``` pip install black ``` OR with pipx ``` pipx install black ``` For a detailed guide about running packages with pipx head toward my article on [pipx](https://mr-destructive.github.io/techstructive-blog/pipx-intro/). ## Set up Autocmd in Vim We can set up a autocmd. What is a autocmd? It is about running commands when certain events occur like running a command when a file is saved, a buffer is opened or closed, and so on. What we want is to run the black command from the shell when the current file is saved. So, we can create a autocmd as follows: ```vimscript autocmd BufWritePost * !black % ``` Now, this will run when any type of file is saved, so we will make it specific to python by adding a `*.py` to add in the autocmd. ```vimscript autocmd BufWritePost *.py !black % ``` This works, but it gives a prompt after the command has been executed, to run the command silently we can simply add the silent keyword before the execution of the command from the shell. ```vimscript autocmd BufWritePost *.py silent !black % ``` This looks perfect! But still, we need to add a auto-group(`augroup`) that groups the autocmds and by adding `autocmd!` it will clear all the commands from the group. ```vimscript augroup python_format autocmd! autocmd BufWritePost *.py silent !black % augroup end ``` We can now add it to the vimrc to work all the time. ## Using pipx If you have used pipx to install black, you need to setup the autocmd a bit differently. ```vimscript autocmd BufWritePost *.py silent !pipx run black % ``` It might be a bit slower than running with global installation, but it is a neat way to run python package. So, that's it we can now write clean and safe python code without breaking a sweat in Vim. Happy Coding :)

Why use Vim ?

Sun, 05 Sep 2021 00:00:00 UTC

## Introduction So, Why would one use Vim? As Vim being the most complicated Text editor when it comes to **closing it**!! Also, people think it's not worth the time or it's just not their type of Text Editor. Well, that's true, I am not forcing anyone to use Vim, just to tell the reasons why people use Vim. Again, it's not to show off to anyone that I use Vim, just to appreciate the power of Vim and its community, it's just amazing!! Vim is not a text editor just for anyone, it can be daunting initially but the more you use it, the more you love it. There is nothing called a time-wastage in learning Vim, if you think learning something is waste of time, just don't learn it! To have understood and got good at something you need to dedicate time and effort to it, there's no shortcut. When it comes to shortcuts, Vim is the fairyland of it, just use one or create your own. That's how cool Vim can be when used properly. Some of the most important and crucial reasons why people use Vim are: ## Vim is Speed! Vim can be opened from the terminal, and that itself can speak that it is lightweight and uses lower system resources and hence causing minimal lag. This might not be an issue for high-end computers but when it comes to low-end machines, Vim behaves as a life-saver. Using certain commands feels so wicked fast and intuitive. Certain commands such as `t` or `f`, `u`, and many others are really powerful when it comes to editing in Vim. When you don't have to think about what keys you should type, you are really getting faster in Vim. ![](https://s6.gifyu.com/images/screenrecording.gif) The above screencast is from my article [Vim: Set up for Python](https://mr-destructive.github.io/techstructive-blog/python/vim/2021/06/06/Vim-for-Python.html), which uses some key mappings to run python code directly from Vim itself by executing the shell commands from Vim's Command mode. A simple map can save a lot of time. ``` nnoremap py :!python % ``` ## Number of Commands/shortcuts When it comes to using key-bindings and shortcuts, there is no shortage of them. You can spend days, weeks, months, years but still, there will be some or the other thing to learn in Vim. That can be very intimidating to some people but that's how life is. **You cannot get perfect at anything but surely better is the word to focus on.** There is a good little cheatsheet at [devhints](https://devhints.io/vim) for beginners to quickly get started. Also, you can follow with the Youtuber- [ThePrimeagen](https://www.youtube.com/channel/UC8ENHE5xdFSwx71u3fDH5Xw), who focuses on switching and using Vim. Vim is has a robust set of command and key-bindings by far compared to other tex-editors. Here are some of my daily used [editing commands](https://mr-destructive.github.io/techstructive-blog/vim/2021/07/18/Vim-Enhancing-Editing-speed.html) and [navigation commands](https://mr-destructive.github.io/techstructive-blog/vim/2021/06/26/Vim-Enhancing-Movement-speed.html). ## Power to use it as an IDE Vim provides some awesome features such as [terminal integration](https://mr-destructive.github.io/techstructive-blog/vim/2021/06/29/Vim-Terminal.html), [Key-mappings](https://mr-destructive.github.io/techstructive-blog/vim/2021/06/14/Vim-Keymapping.html), [Window Splits](https://mr-destructive.github.io/techstructive-blog/vim/2021/08/06/Vim-Window-Splits.html), etc to take text-editing and developer environment to a next-level. You can literally use Vim as an IDE for many of the programming languages like C/C++, Python, Java, Javascript, GO, etc. Though it can't replace entire IDE-like features, it is indeed powerful enough to add features in making a custom IDE experience. It might require some time and research to configure it to use it as a full-blown IDE, but it might be a very useful and self-motivating experience. There are definitely many articles, tutorials out to guide you in configuring the editor to an IDE. People might not use Vim for the features it has but also for the lightweights as compared to other IDEs such as Visual Studio, Android Studio, Eclipse, IntelliJ IDEA, etc. ![image.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1630827706766/cdN6GdnhH.png) From, the above screenshot, we can see that I have configured Vim almost like VSCode, Ok! Just the look of it is similar but ya we have the file manager as [NERDTree](https://mr-destructive.github.io/techstructive-blog/vim/2021/08/31/Vim-NERDTree.html), integrated Terminal, and the buffer opened as the editor. You can even add more functionality like autocomplete, keymaps to compile/run/build the code. There is are infinite possibilities when it comes to customization in Vim and to make it a full-blown IDE. OH! And by the way my Vim look changes from time to time XD ## Available almost everywhere As said, Vim can be opened via the terminal, and hence it is quite viable when it comes to accessibility. It is pre-installed in almost every Linux-distributions, macOS, FreeBSD, etc. Hence it is quite reliable when it comes to compatibility and cross-platform support. You can start editing in any environment in Vim, so it becomes a good reason to learn to use Vim at least basic editing and opening, closing, etc. Vim being minimal and lightweight, it just becomes easy to work with servers. Production-environment, etc. It also isn't that complicated once you make your head around it. Being available in almost every Operating System has some value to it like it is the most dependable editor out there. Even after 30 years, yes Vim was released in 1991, it is still maintained by its producer [Brain Moolenaar](https://en.wikipedia.org/wiki/Bram_Moolenaar). That is mind-boggling, Vim is truly a vintage text editor silently but widely dominated in terms of its reach in Computing. ## The Level of Customization/Configuration It's kind of a double-sided sword for some people as it can be daunting to customize from scratch and also, it could be a rewarding and pleasurable experience of having the personalized experience. With the number of plugins, custom vimrc and color schemes, etc Vim is very prone to personalization. It is **Open Source**, so we also have it's distributions such as [SpaceVim](https://github.com/SpaceVim/SpaceVim), [SPF-13](https://github.com/spf13/spf13-vim), etc. Some more distribution can be found [here](https://dev.to/ajeebkp23/some-popular-vim-distributions-a68). Some Distribution is pref-configured with some basic stuff and is ready to use, so they are quite beginner-friendly and introduce them to Vim in a better way. NeoVim which is an evolution of Vim written in Lua is much more powerful and provides even more customization keeping the basic key-bindings in mind. Editing Vimrc is quite an amazing and intuitive experience as it allows to add functionality or enhance the existing features in Vim. ## Conclusion > Text Editors don't matter, what matters are the problem-solving skills Vim is a simple and minimal text editor, everyone can use it but not everyone finds the need to use it, that's fine. It might be ideal for me to use Vim than other editors but it might not be for you. But there is nothing to lose in knowing some basics of Vim. It might be useful somewhere, you never know! And if your favorite editor is not available, Vim might prove to be a great quick solution. Thanks for reading. Happing Coding :)