feat: init no-neck-pain.nvim

Author: shortcuts

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @shortcuts

.github/workflows/main.yml

@@ -0,0 +1,20 @@
+name: main
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    types: [opened, synchronize]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    name: Lint
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: JohnnyMorganz/stylua-action@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          version: latest
+          args: --check .

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Clément Vannicatte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,36 @@
+# no-neck-pain.nvim
+
+## Introduction
+
+Dead simple plugin to center the current buffer to the middle of the screen.
+
+## Why an other focus-zen-center-buffer plugin?
+
+While there's many other (amazing!) plugins that does similar stuff, they all require some configuration or alter your NeoVim workflow.
+
+In my case, I only wanted a plugin that: **center the current buffer**.
+
+## Installation
+
+### packer.nvim
+
+```lua
+use {'shortcuts/no-neck-pain.nvim'}
+```
+
+### vim-plug
+
+```lua
+Plug 'shortcuts/no-neck-pain.nvim'
+```
+
+## Getting started
+
+### Lua
+
+```lua
+-- values below are the default
+require("no-neck-pain").setup({
+    width = 100, -- the size of the main buffer
+})
+```

lua/no-neck-pain/config.lua

@@ -0,0 +1,11 @@
+local config = {}
+
+config.options = {
+    width = 100,
+}
+
+function config.setup(opts)
+    config.options = vim.tbl_deep_extend("keep", opts or {}, config.options)
+end
+
+return config

lua/no-neck-pain/init.lua

@@ -0,0 +1,11 @@
+local M = {}
+
+function M.start()
+    require("no-neck-pain.main").toggle()
+end
+
+function M.setup(opts)
+    require("no-neck-pain.config").setup(opts)
+end
+
+return M

lua/no-neck-pain/main.lua

@@ -0,0 +1,205 @@
+local cfg = require("no-neck-pain.config").options
+local SIDES = { "left", "right" }
+
+local M = {
+    -- State of NoNeckPain
+    state = {
+        enabled = false,
+        win = {
+            -- side buffer/windows options
+            opts = {
+                bo = {
+                    buftype = "nofile",
+                    bufhidden = "hide",
+                    modifiable = false,
+                    buflisted = false,
+                    swapfile = false,
+                },
+                wo = {
+                    cursorline = false,
+                    cursorcolumn = false,
+                    number = false,
+                    relativenumber = false,
+                    foldenable = false,
+                    list = false,
+                },
+            },
+            curr = nil,
+            left = nil,
+            right = nil,
+        },
+    },
+}
+
+vim.api.nvim_create_augroup("NoNeckPain", {
+    clear = true,
+})
+
+-- toggle plugin and restart states
+function M.toggle()
+    if M.state.enabled then
+        M.disable()
+    else
+        M.enable()
+    end
+end
+
+local function getPadding()
+    local width = vim.api.nvim_list_uis()[1].width
+
+    if cfg.width >= width then
+        return 1
+    end
+
+    local curr_width = cfg.width * 3
+    if curr_width > width then
+        local available_space = width - cfg.width
+        return (available_space % 2 > 0 and ((available_space - 1) / 2) or available_space / 2)
+    end
+
+    return cfg.width
+end
+
+-- Creates a buffer for the given padding, at the given direction
+local function createBuf(cmd, padding, moveTo)
+    vim.cmd(cmd)
+
+    local id = vim.api.nvim_get_current_win()
+
+    vim.api.nvim_win_set_width(0, padding)
+
+    for scope, _ in pairs(M.state.win.opts) do
+        for name, value in pairs(M.state.win.opts[scope]) do
+            vim[scope][name] = value
+        end
+    end
+
+    vim.cmd(moveTo)
+    return id
+end
+
+-- creates a NNP focused buffer when called with `init`. Resizes sides on `resize`
+local function createWin(action)
+    local padding = getPadding()
+
+    if action == "init" then
+        local splitbelow, splitright = vim.o.splitbelow, vim.o.splitright
+        vim.o.splitbelow, vim.o.splitright = true, true
+
+        M.state.win = {
+            opts = M.state.win.opts,
+            curr = vim.api.nvim_get_current_win(),
+            left = createBuf("leftabove vnew", padding, "wincmd l"),
+            right = createBuf("vnew", padding, "wincmd h"),
+        }
+
+        vim.o.splitbelow, vim.o.splitright = splitbelow, splitright
+
+        return
+    end
+
+    -- resize
+    for _, side in ipairs(SIDES) do
+        if vim.api.nvim_win_is_valid(M.state.win[side]) then
+            vim.api.nvim_win_set_width(M.state.win[side], padding)
+        end
+    end
+end
+
+function M.enable()
+    createWin("init")
+
+    vim.api.nvim_create_autocmd({ "VimResized" }, {
+        callback = function()
+            createWin()
+        end,
+        group = "NoNeckPain",
+        desc = "Resizes side windows after resize",
+    })
+
+    vim.api.nvim_create_autocmd({ "WinClosed" }, {
+        callback = function()
+            vim.schedule(function()
+                -- if main window is closed, disable
+                if M.state.enabled and vim.api.nvim_get_current_win() ~= M.state.win.curr then
+                    M.disable()
+                end
+            end)
+        end,
+        group = "NoNeckPain",
+        desc = "Disables NoNeckPain when main window is closed",
+    })
+
+    vim.api.nvim_create_autocmd({ "WinEnter", "WinClosed" }, {
+        callback = function()
+            vim.schedule(function()
+                -- trigger on float window (e.g. telescope)
+                if vim.api.nvim_win_get_config(0).relative ~= "" then
+                    createWin()
+
+                    return
+                end
+
+                -- skip if the newly focused window is a side buffer
+                if
+                    vim.api.nvim_get_current_win() == M.state.win.left
+                    or vim.api.nvim_get_current_win() == M.state.win.right
+                then
+                    return
+                end
+
+                local padding = 0
+
+                -- when opening a new buffer as current, keep its padding and resize everything (e.g. side tree)
+                if vim.api.nvim_get_current_win() ~= M.state.win.curr then
+                    padding = vim.api.nvim_win_get_width(0)
+                end
+
+                local width = vim.api.nvim_list_uis()[1].width
+                local totalSideSizes = (width - padding) - cfg.width
+
+                for _, side in ipairs(SIDES) do
+                    if M.state.win[side] ~= nil then
+                        if vim.api.nvim_win_is_valid(M.state.win[side]) then
+                            vim.api.nvim_win_set_width(
+                                M.state.win[side],
+                                math.floor(totalSideSizes / 2)
+                            )
+                        end
+                    end
+                end
+            end)
+        end,
+        group = "NoNeckPain",
+        desc = "Resize to apply on Enter/Closed callbacks",
+    })
+
+    M.state.enabled = true
+end
+
+function M.disable()
+    -- when disabling, if current isn't NNP curr, focus it
+    if vim.api.nvim_win_is_valid(M.state.win.curr) then
+        if M.state.win.curr ~= vim.api.nvim_get_current_win() then
+            vim.fn.win_gotoid(M.state.win.curr)
+        end
+    end
+
+    vim.cmd("only")
+
+    vim.api.nvim_create_augroup("NoNeckPain", {
+        clear = true,
+    })
+
+    M.state = {
+        enabled = false,
+        win = {
+            opts = M.state.win.opts,
+            curr = nil,
+            left = nil,
+            right = nil,
+        },
+    }
+end
+
+return M

plugin/no-neck-pain.lua

@@ -0,0 +1,8 @@
+if vim.g.noNeckPain then
+    return
+end
+vim.g.noNeckPain = true
+
+vim.api.nvim_create_user_command("NoNeckPain", function()
+    require("no-neck-pain").start()
+end, {})

stylua.toml

@@ -0,0 +1,3 @@
+indent_type = "Spaces"
+indent_width = 4
+column_width = 100