DEV Community: Async hronous

What's nvim-treesitter?

Async hronous — Sat, 25 Feb 2023 01:10:15 +0000

(Don't mind the cover image, I'm testing out stuff :P)

👋 Introduction

Do you don't like these default Neovim's Treesitter syntax?

Do you want it to look like:

To:
?

I'm not explaining why it's better. Mainly because it's smarter. (wow, that didn't make sense)

alright' nuf' talkin' and let's start 👷‍♀️ configuring!

🤨 Installing nvim-treesitter

If you've been following along your file structure should look like...

~/.config/nvim/
├── init.lua
└── lua/
    ├── core/
    │   ├── init.lua
    │   └── options.lua
    └── keymaps/
        └── movement.lua
        └── ...
    └── plugins/
        └── colorscheme.lua
        └── ...

Now we're going to create a new configs directory. (in the lua directory) and in the configs directory, we're going to create sub directories for each "category" of a plugin's configuration. (e.g: UI related configurations in the configs.ui directory, editor related configurations in the configs.editor directory.)

So now our file structure should look like:

~/.config/nvim/
├── init.lua
└── lua/
    ├── core/
    │   ├── init.lua
    │   └── options.lua
    └── keymaps/
        └── movement.lua
        └── ...
    └── plugins/
        └── colorscheme.lua
        └── treesitter.lua
        └── ...
    └── configs/ <- This!
        └── ui/
        └── editor/
        └── ...

Alright. Now just create a new module in out plugins/ directory named treesitter.lua (it could be anything)
And in it:

return {
  "nvim-treesitter/nvim-treesitter.lua",
  config = require("configs.editor.treesitter"),
  event = "BufReadPost"
}

👷‍♀️ Configuring

And in our configs/editor directory create a new treesitter.lua module (again)
In it SLAM this in:

return function()
  local status, treesitter = pcall(require, "nvim-treesitter.configs")
  if not status then return end

  treesitter.setup({
    auto_install = true, -- Auto-install missing parsers. (once you open a file that requires it.)
    highlight = {
      enable = true -- Enable beautiful syntax highlighting!!!
    }
  })
end

Let's break this down. It pcalls a require statement that, wants a module called nvim-treesitter more specifically, nvim-treesitter.configs. It assigns it a local variable called treesitter.

Then it setups nvim-treesitter with some configuration.

Now quit Neovim (if you can) using :wqa (Of course, if you can.)
And BAM, SUPER smart, beautiful syntax highlighting with the catppuccin colorscheme! Wait... Did you say "catppuccin"?
Alright kthxbye, imma get some catppuccin-mocha. :wqa

Quick Plug

Using lazy.nvim 💤 in our Neovim configuration

Async hronous — Fri, 24 Feb 2023 13:38:57 +0000

👋 Introduction

Alright! If you've been following along, we've configured some options and keymaps.
Next, we're going to use lazy.nvim!
It has:

💤 Auto-magic lazy loading
🔒 Lock files to keep track of plugin versions
💪 Modular plugin structure
😮 ... and more!

🏗 HOWTO: Bootstrap.

It's quite easy to bootstrap lazy.nvim
Create a new module named lazy.lua and SLAM this code in it.

local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable", -- latest stable release
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

Just that!
Now quit Neovim (if you can) and, start it back again. It should automatically install lazy.nvim.

⁉ Question of the day!

Q. 🤨 How do I install plugins?
A. Just follow this crash course!

require("lazy").setup(plugins, opts)

plugins would be an table of plugins and, opts would be a table of options.
ok kthxbye/

I meant...

Crash course vII: Install the catppuccin colorscheme.

I love catppuccin. So let's get some mocha!

Create a new directory in lua named plugins. And in /plugins/ make a new module named colorscheme.lua

So, our file thing should look like:

~/.config/nvim/
├── init.lua
└── lua/
    ├── core/
    │   ├── init.lua
    │   └── options.lua
    └── keymaps/
        └── movement.lua
        └── ...
    └── plugins/
        └── colorscheme.lua
        └── ...

In colorscheme.lua it should look like:

return {
    "catppuccin/nvim"
}

This code should be self-explanatory but, I'll give you a "high level overview" of it.
It returns a table.

Whoo! Now in lazy.lua replace whatever I gave you (replace("lazy").setup(...)) with...

require("lazy").setup({
  { import = "plugins" }
})

Now we're all done! Now let's go get a cup of mocha.
In our setup/init.lua...

-- Some code here...
vim.cmd.colorscheme "catppuccin"

Now it should show the beautiful catppuccin theme! Let's actually get a cup of mocha now!

(Quick plug: here)

kthxbye :wq

A basic configuration of Neovim

Async hronous — Fri, 24 Feb 2023 09:48:33 +0000

Introduction

Hello, I felt as my Neovim configuration was bloated. So, today I'll be teaching you on how to configure your Neovim config, from scratch!

The layout of the configuration.

(If you don't like something, feel free to change up some stuff!)
First, if you haven't already go get Neovim from your favorite package manager(s) or build Neovim from scratch (!)

So, first we're going to set some basic Neovim options, keymaps and then we can go add some plugins!

Initalize your Neovim config.

Go ahead and make a nvim folder in:

*Nix systems: ~/.config/nvim (or your: $XDG_CONFIG_HOME/nvim, if you set that up.)
Windows: ~/AppData/Local/nvim

If you've done that, go create an init.lua in your nvim configuration directory.

Neovim 5.0+ provides users to write their Neovim configurations in Lua which is:

Fast.
Easy.
And fun!

So, nuf' talkin' and let's go write our Neovim configuration.

We can write all our configuration in one big file. That'll work, but it'll be less easier to maintain. So, we can go break our Neovim configuration in multiple files.
We can have a file structure like:

~/.config/nvim/
├── init.lua
└── lua/
    ├── core/
    │   ├── init.lua
    │   └── options.lua
    └── keymaps/
        └── movement.lua
        └── ...

Alright. In out core/init.lua we're going to require the core.options and keymaps modules.
using:

local M = {}

M.setup = function()
  require("core.options")
  require("keymaps.movement")
end

return M

This code, it provided a .setup() function. Because it looks cool.

So, now...

Setting options

Let's set some options in our core/options.lua!
Here's how it could look like:

local o = vim.opt

o.undofile = true -- Persistent undo's across all sessions
o.backup = false -- Don't write backups. (For better performance and, unneeded non-sense
o.writebackup = false -- Don't write backups.
o.shiftwidth = 2 -- Insert two shifts per indent.
o.autoindent = true -- Copy indent from the current line when starting a new line
o.breakindent = true -- Indent wrapped lines too.
o.copyindent = true -- Copy the structure of the existing lines' indents.
o.expandtab = true -- Convert tabs to spaces.
o.smartindent = true -- Non-strict cindent.
o.number = true -- Enable line numbers

I'm not going into much detail on what these options do, but the comments should be self-explanatory

Keymaps.

Neovim provides an interface for it's user to create new key mappings. I'll give you an example:

local map = vim.api.nvim_set_keymap

-- Move up/down on VISUAL line instead of a ACTUAL line
map("n", "j", "v:count == 0 ? 'gj' : 'j'", { expr = true, silent = true })
map("n", "k", "v:count == 0 ? 'gk' : 'k'", { expr = true, silent = true })

That's it!

That's it x2! In the next post, I'll show you how to install lazy.nvim. So be tuned! (P.S this is the final result: here)

Building Neovim from source

Async hronous — Sat, 18 Feb 2023 01:40:02 +0000

Building neovim: A Comprehensive Guide

neovim is a highly customizable and a lightweight text editor (it can be configured to something much more!)
While it maybe installed to your system by using your favorite package manager, it is best used if you build it from source!
So enough talking and let's start building 🧱!

Prerequisites

Before you start building Neovim, you need some build dependencies installed on your system (psst you might need to update your package list by

sudo apt-get update

on Ubuntu/Debian!):

Ubuntu/Debian

sudo apt-get install ninja-build gettext libtool libtool-bin autoconf automake cmake g++ pkg-config unzip curl doxygen

CentOS/RHEL/Fedora

sudo yum -y install ninja-build libtool autoconf automake cmake gcc gcc-c++ make pkgconfig unzip patch gettext curl

openSUSE

sudo zypper install ninja libtool autoconf automake cmake gcc-c++ gettext-tools curl

Arch Linux

sudo pacman -S base-devel cmake unzip ninja tree-sitter curl

Alpine Linux

apk add build-base cmake automake autoconf libtool pkgconf coreutils curl unzip gettext-tiny-dev

Void Linux

xbps-install base-devel cmake curl git

FreeBSD

sudo pkg install cmake gmake libtool sha automake pkgconf unzip wget gettext curl

OpenBSD

doas pkg_add gmake cmake libtool unzip autoconf-2.69p2 automake-1.15p0 curl
export AUTOCONF_VERSION=2.69
export AUTOMAKE_VERSION=1.15

OpenBSD

doas pkg_add gmake cmake libtool unzip autoconf-2.69p2 automake-1.15p0 curl
export AUTOCONF_VERSION=2.69
export AUTOMAKE_VERSION=1.15

MacOS/Homebrew

brew install ninja libtool automake cmake pkg-config gettext curl

Building neovim

Once you have installed the dependencies, you can start building neovim. The following steps will guide you through the process:

Clone the neovim repository

   git clone https://github.com/neovim/neovim.git

Navigate to the cloned repository

   cd neovim

Build neovim

   make CMAKE_BUILD_TYPE=RelWithDebInfo

This might take some time, so you while you wait, you can go get a cup of Mocha ☕

Install Neovim system wide Great! You've build neovim. But now, you need to install it to your system

   sudo make install

Now if that's done finishing you should be able to start neovim by typing neovim in your terminal of choice.

If Neovim is successfully installed, this command should start the editor.

That's it! You've successfully built neovim from source!

   sudo make install

Run neovim

   nvim

If Neovim is successfully installed, this command should start the editor.

Congratulations, you have successfully built Neovim from source!