Neovim-Configuration/init.lua

-- Map leader "Global Key" to space, so you can use it optionally like spacemacs etc.
vim.g.mapleader = " "
vim.g.maplocalleader = " "

-- Beautifully cursed, let's rebind C-x to the leader key and other respective emacs keybindings
vim.cmd("map <C-x> <Space>")
vim.cmd("map <C-g> <Esc>")
vim.cmd("imap <C-g> <Esc>")
vim.cmd("map <C-c> <Nop>")

-- Lazy plugin manager
require("config.lazy")

-- Enable line numbers
vim.cmd("set number")
-- Turn off highlighting after search completion
vim.cmd("set nohlsearch")

-- Colourscheme
vim.o.background = "light" -- or "dark" for dark mode
vim.cmd("colorscheme gruvbox")

-- Telescope setup (Like emacs ivy-mode)
require('telescope').setup{
  defaults = {
    -- ...
  },
  pickers = {
    find_files = {
      theme = "ivy",
    }
  },
  extensions = {
    -- ...
  }
}

-- Custom statusline (modeline)
require('mini.statusline').setup()

-- Custom filetypes configuration
vim.api.nvim_create_autocmd({ 'BufEnter', 'BufNewFile' }, {
	pattern = '*ansible*.yml',
	command = 'set filetype=yaml.ansible',
})
vim.api.nvim_create_autocmd({ 'BufEnter', 'BufNewFile' }, {
	pattern = '*playbook*.yml',
	command = 'set filetype=yaml.ansible',
})
vim.api.nvim_create_autocmd({ 'BufEnter', 'BufNewFile' }, {
	pattern = '*server*.yml',
	command = 'set filetype=yaml.ansible',
})
vim.api.nvim_create_autocmd({ 'BufEnter', 'BufNewFile' }, {
	pattern = '*service*.yml',
	command = 'set filetype=yaml.ansible',
})
vim.api.nvim_create_autocmd({ 'BufEnter', 'BufNewFile' }, {
	pattern = '*compose*.yml',
	command = 'set filetype=yaml.docker-compose',
})


-- LSP Configuration
require('lsp-zero')
local lspconfig = require('lspconfig')
lspconfig.lua_ls.setup({})
lspconfig.bashls.setup({})
lspconfig.clangd.setup({})
lspconfig.tsserver.setup({})
lspconfig.jedi_language_server.setup({})
lspconfig.nixd.setup({})
lspconfig.nginx_language_server.setup({})
lspconfig.docker_compose_language_service.setup({})
lspconfig.ansiblels.setup({})
-- lspconfig.yamlls.setup({
--   settings = {
--     yaml = {
--       schemas = {
--         ["https://json.schemastore.org/github-workflow.json"] = "/.github/workflows/*",
-- 	["https://raw.githubusercontent.com/ansible/ansible-lint/main/src/ansiblelint/schemas/ansible.json#/$defs/playbook"] = "**/*playbook*.yaml",
-- 	["https://raw.githubusercontent.com/ansible/ansible-lint/main/src/ansiblelint/schemas/inventory.json"] = "**/*hosts*.yaml",
--       },
--     },
--   }
-- })
lspconfig.emmet_language_server.setup({
  filetypes = { "css", "eruby", "html", "javascript", "javascriptreact", "less", "sass", "scss", "pug", "typescriptreact" },
  -- Read more about this options in the [vscode docs](https://code.visualstudio.com/docs/editor/emmet#_emmet-configuration).
  -- **Note:** only the options listed in the table are supported.
  init_options = {
    ---@type table<string, string>
    includeLanguages = {},
    --- @type string[]
    excludeLanguages = {},
    --- @type string[]
    extensionsPath = {},
    --- @type table<string, any> [Emmet Docs](https://docs.emmet.io/customization/preferences/)
    preferences = {},
    --- @type boolean Defaults to `true`
    showAbbreviationSuggestions = true,
    --- @type "always" | "never" Defaults to `"always"`
    showExpandedAbbreviation = "always",
    --- @type boolean Defaults to `false`
    showSuggestionsAsSnippets = false,
    --- @type table<string, any> [Emmet Docs](https://docs.emmet.io/customization/syntax-profiles/)
    syntaxProfiles = {},
    --- @type table<string, string> [Emmet Docs](https://docs.emmet.io/customization/snippets/#variables)
    variables = {},
  },
})
--Enable (broadcasting) snippet capability for completion
local capabilities = vim.lsp.protocol.make_client_capabilities()
capabilities.textDocument.completion.completionItem.snippetSupport = true
lspconfig.cssls.setup {
  capabilities = capabilities,
}
lspconfig.jsonls.setup {
  capabilities = capabilities,
}

-- DAP Configuration
local dap = require("dap")
local dapwidgets = require("dap.ui.widgets")
local dapwidgetscope = dapwidgets.sidebar(dapwidgets.scopes)
local daprunning = false

-- Functions to initialise Dap, open UI widgets and set helper keybindings
local function dapInit()
	dap.repl.open()
	dapwidgetscope.open()
	daprunning = true
	-- Can't get these working!
	-- vim.keymap.del({"n", "v", "o"}, "<C-s>")
	-- vim.keymap.set({"n", "v", "o"}, "<C-n>", "<C-c>ln")
	-- vim.keymap.set({"n", "v", "o"}, "<C-i>", "<C-c>ln")
	-- vim.keymap.set({"n", "v", "o"}, "<C-r>", "<C-c>ln")
	-- vim.keymap.set({"n", "v", "o"}, "<C-s>", "<C-c>ln")
	vim.cmd("unmap <C-s>")
	vim.cmd("map <C-n> <C-c>ln")
	vim.cmd("map <C-i> <C-c>li")
	vim.cmd("map <C-r> <C-c>lr")
	vim.cmd("map <C-s> <C-c>ls")
	print("Initialised debugger successfully")
end
local function dapCleanup()
	dap.repl.close()
	dapwidgetscope.close()
	daprunning = false
	vim.cmd("unmap <C-n>")
	vim.cmd("unmap <C-i>")
	vim.cmd("unmap <C-r>")
	vim.cmd("unmap <C-s>")
	vim.keymap.set({"n", "v", "o"}, '<C-s>', '<cmd>Telescope live_grep<cr>')
	-- vim.keymap.del({"n", "v", "o"}, "<C-n>")
	-- vim.keymap.del({"n", "v", "o"}, "<C-i>")
	-- vim.keymap.del({"n", "v", "o"}, "<C-r>")
	-- vim.keymap.del({"n", "v", "o"}, "<C-s>")
	-- vim.keymap.set({"n", "v", "o"}, '<C-s>', '<cmd>Telescope live_grep<cr>')
	print("Cleaned up debugger successfully")
end

-- DAP Server configurations
-- C DAP Configuration
dap.adapters.gdb = {
  type = "executable",
  command = "gdb",
  args = { "-i", "dap" }
}
dap.configurations.c = {
  {
    name = "Launch",
    type = "gdb",
    request = "launch",
    program = function()
      return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file')
    end,
    cwd = "${workspaceFolder}",
    stopAtBeginningOfMainSubprogram = false,
  },
}
-- Remake of emacs which-key mode, I'll add all custom keybinds here
-- TODO: The DAP related functions should be moved into their own respective file/modularised better!
require("which-key").add ({
  { "<C-s>", "<cmd>Telescope live_grep<cr>" , desc = "Swiper", mode = "n" },

  -- This does not allow you to make a new file only search existing, but good enough for now.
  { "<leader><C-f>", "<cmd>Telescope find_files<cr>" , desc = "Find File", mode = "n" },

  -- To properly remake the Emacs ivy buffer command, we should figure out how to combine Telescope buffers and Telescope oldfiles
  -- This is good enough for now
  { "<leader>b", "<cmd>Telescope oldfiles<cr>" , desc = "Recently opened files", mode = "n" },
  { "<leader><C-b>", "<cmd>Telescope buffers<cr>" , desc = "Buffers", mode = "n" },

  { "<leader>k", "<cmd>bp|bd#<cr>" , desc = "Close current buffer", mode = "n" },
  { "<leader>0", "<cmd>close<cr>", desc = "Close focused window" },
  { "<leader>2", "<cmd>split<cr>", desc = "Split window horizontally" },
  { "<leader>3", "<cmd>vs<cr>", desc = "Split window vertically" },
  { "<leader>o", "<cmd>wincmd w<cr>", desc = "Switch to next window" },
  {
    -- Nested mappings are allowed and can be added in any order
    -- Most attributes can be inherited or overridden on any level
    -- There's no limit to the depth of nesting
    mode = { "n", "v" }, -- NORMAL and VISUAL mode
    { "<leader><C-c>", "<cmd>qa<cr>", desc = "Quit" },
    { "<leader><C-s>", "<cmd>w<cr>", desc = "Write" },
  },

  -- LSP/DAP Options
  {
    mode = { "n", "v" }, -- NORMAL and VISUAL mode
    { "<C-c>lb", function() dap.toggle_breakpoint() end, desc = "Debugger: Toggle breakpoint" },
    { "<C-c>ld", function()
	if daprunning == false then
		if pcall(function() dap.continue() end) then
			dapInit()
		else
			print("Debugger failed to start!")
			daprunning = false
		end
    	else
		print("Debugger already running!")
    	end
    end, desc = "Debugger: Run" },
    { "<C-c>lD", function()
	if daprunning == false then
		if pcall(function() dap.run_last() end) then
			dapInit()
			print("Started debugger from previous configuration successfully")
		else
			print("Debugger failed to start!")
			daprunning = false
		end
    	else
		print("Debugger already running!")
    	end
    end, desc = "Debugger: Run last configuration again" },
    { "<C-c>ls", function()
	if daprunning == true then
		if pcall(function() dap.terminate() end) then
			dapCleanup()
			print("Stopped debugger successfully")
		else
			daprunning = true
		end
    	else
		print("Debugger is not running!")
    	end
    end, desc = "Debugger: Stop" },
    { "<C-c>lr", function()
	if daprunning == true then
		if not pcall(function() dap.continue() end) then
			dapCleanup()
	    	end
	else
		print("Debugger is not running! Please run debugger first")
	end
    end, desc = "Debugger: Resume execution" },
    { "<C-c>ln", function()
	if daprunning == true then
		if not pcall(function() dap.step_over() end) then
			dapCleanup()
	    	end
	else
		print("Debugger is not running! Please run debugger first")
	end
    end, desc = "Debugger: Step over" },
    { "<C-c>li", function()
	if daprunning == true then
		if not pcall(function() dap.step_into() end) then
			dapCleanup()
	    		print("Debugger failed to continue!")
	    	end
	else
		print("Debugger is not running! Please run debugger first")
	end
    end, desc = "Debugger: Step into" },
  }
})