Automagical editing and creation of snippets.

• Features
• Rationale
• Installation
• Usage
• Configuration
• Cookbook & FAQ
  • Example for the VSCode-style snippet format
  • Version Controlling Snippets: JSON-formatting
  • Snippets on Visual Selection
  • friendly-snippets
  • Auto-triggered Snippets
• Credits

• Add new snippets, edit snippets, or delete snippets on the fly.
• Syntax highlighting while you edit the snippet. Includes highlighting of tokens like $0 or ${2:foobar}.
• Automagical conversion from buffer text to JSON string (quotes are escaped, etc.)
• Intuitive UI for editing the snippet, dynamically adapting the number of prefixes.
• Auto-reloading of the new/edited snippet (if using LuaSnip).
• JSON-formatting and sorting of the snippet file after updating, using yq or jq. (Optional, but useful when version-controlling your snippet collection.)
• Snippet/file selection via telescope or vim.ui.select.
• Automatic bootstrapping of the snippet folder, if it is empty or missing a package.json.
• Supports only VSCode-style snippets.

• Regrettably, there are innumerable formats in which snippets can be saved. The closest thing to a standard is the VSCode snippet format. For portability, easier sharing, and to future-proof your snippet collection, it can make sense to save your snippets in that format.
• Most notably, the VSCode format is used by plugins like friendly-snippets and supported by LuaSnip.
• However, the snippets are stored as JSON files, which are a pain to modify manually. This plugin aims to alleviate that pain by automagically writing the JSON for you.

The plugin requires that your snippet are saved in the VSCode-style snippet format. If your snippet folder is empty, this plugin bootstraps a simple snippet folder for you.

For the specific requirements of the VSCode-style snippets, please see the FAQ section on the VSCode format.

-- lazy.nvim
{
	"chrisgrieser/nvim-scissors",
	dependencies = "nvim-telescope/telescope.nvim", -- optional
	opts = {
		snippetDir = "path/to/your/snippetFolder",
	} 
},

-- packer
use {
	"chrisgrieser/nvim-scissors",
	dependencies = "nvim-telescope/telescope.nvim", -- optional
	config = function()
		require("scissors").setup ({
			snippetDir = "path/to/your/snippetFolder",
		})
	end,
}

When telescope.nvim is installed, it is automatically used as picker. Otherwise, nvim-scissors falls back to vim.ui.select. (You can use dressing.nvim to re-direct vim.ui.select to fzf-lua, if you prefer it over telescope.)

If you are not using VSCode-style snippets already, here is how you load them with LuaSnip:

require("luasnip.loaders.from_vscode").lazy_load { paths = { "path/to/your/snippetFolder" } }

The plugin provides two commands, :ScissorsAddNewSnippet and :ScissorsEditSnippet. You can pass range to :ScissorsAddSnippet command to prefill snippet body (for example :'<,'>ScissorsAddSnippet or :3ScissorsAddSnippet).

The plugin also provides two lua functions addNewSnippet and editSnippet, which you can use to directly create keymaps:

vim.keymap.set("n", "<leader>se", function() require("scissors").editSnippet() end)

-- When used in visual mode prefills the selection as body.
vim.keymap.set({ "n", "x" }, "<leader>sa", function() require("scissors").addNewSnippet() end)

The popup intelligently adapts to changes in the prefix area: Each line represents one prefix, and creating or removing lines thus changes the number of prefixes. ("Prefix" is how trigger words are referred to in the VSCode format.)

The .setup() call is optional.

-- default settings
require("scissors").setup {
	snippetDir = vim.fn.stdpath("config") .. "/snippets",
	editSnippetPopup = {
		height = 0.4, -- relative to the window, number between 0 and 1
		width = 0.6,
		border = "rounded",
		keymaps = {
			cancel = "q",
			saveChanges = "<CR>", -- alternatively, can also use `:w`
			goBackToSearch = "<BS>",
			deleteSnippet = "<C-BS>",
			duplicateSnippet = "<C-d>",
			openInFile = "<C-o>",
			insertNextToken = "<C-t>", -- insert & normal mode
			jumpBetweenBodyAndPrefix = "<C-Tab>", -- insert & normal mode
		},
	},
	telescope = {
		-- By default, the query only searches snippet prefixes. Set this to
		-- `true` to also search the body of the snippets.
		alsoSearchSnippetBody = false,
	},
	-- `none` writes as a minified json file using `vim.encode.json`.
	-- `yq`/`jq` ensure formatted & sorted json files, which is relevant when
	-- you version control your snippets.
	jsonFormatter = "none", -- "yq"|"jq"|"none"
}

This plugin requires that you have a valid VSCode snippet folder. In addition to saving the snippets in the required JSON format, there must also be a package.json at the root of the snippet folder, specifying which files are should be used for which languages.

Example file structure inside the snippetDir:

.
├── package.json
├── python.json
├── project-specific
│   └── nvim-lua.json
├── javascript.json
└── allFiletypes.json

Example package.json:

{
	"contributes": {
		"snippets": [
			{
				"language": "python",
				"path": "./python.json"
			},
			{
				"language": "lua",
				"path": "./project-specific/nvim-lua.json"
			},
			{
				"language": ["javascript", "typescript"],
				"path": "./javascript.json"
			},
			{
				"language": "all",
				"path": "./allFiletypes.json"
			}
		]
	},
	"name": "my-snippets"
}

Example snippet file (here: nvim-lua.json):

{
  "autocmd (Filetype)": {
    "body": [
      "vim.api.nvim_create_autocmd(\"FileType\", {",
      "\tpattern = \"${1:ft}\",",
      "\tcallback = function()",
      "\t\t$0",
      "\tend,",
      "})"
    ],
    "prefix": "autocmd (Filetype)"
  },
  "file exists": {
    "body": "local fileExists = vim.loop.fs_stat(\"${1:filepath}\") ~= nil",
    "prefix": "file exists"
  },
}

For details, read the official VSCode snippet documentation:

• Snippet file specification
• package.json specification
• LuaSnip-specific additions to the format

This plugin writes JSON files via vim.encode.json. That method saves the file in minified form, and does not have a deterministic order of dictionary keys.

Both, minification, and unstable key order, are of course problem if you version-control your snippet collection. To solve this problem, nvim-scissors can optionally unminify and sort the JSON files via yq or jq after updating a snippet. (Both are also available via mason.nvim.)

It is recommended to run yq/jq once on all files in your snippet collection, since the first time you edit a file, you would still get a large diff from the initial sorting. You can do so with yq using this command:

cd "/your/snippet/dir"
fd ".*\.json" | xargs -I {} yq --inplace --output-format=json "sort_keys(..)" {}

How to do the same with jq is left as an exercise to the reader.

With Luasnip, this is an opt-in feature, enabled via:

require("luasnip").setup {
	store_selection_keys = "<Tab>",
}

In your VSCode-style snippet, use the token $TM_SELECTED_TEXT at the location where you want the selection to be inserted. (It's roughly the equivalent of LS_SELECT_RAW in the Luasnip syntax.)

Then, in visual mode, press the key from store_selection_keys. The selection disappears, and you are put in insert mode. The next snippet you now trigger is going to have $TM_SELECTED_TEXT replaced with your selection.

Even though the snippets from the friendly-snippets repository are written in the VSCode-style format, editing them directly is not supported. The reason being that any changes made would be overwritten as soon as the friendly-snippets repository is updated (which happens fairly regularly), and there is little nvim-scissors can do about that.

What you can do, however, is to copy individual snippets files from the friendly-snippets repository into your own snippet folder, and edit them then.

While the VSCode snippet format does not support auto-triggered snippets, LuaSnip allows you to specify auto-triggering in the VSCode-style JSON files by adding the luasnip key.

nvim-scissors does not touch any keys other than prefix and body in the JSON files, so any additions via the luasnip key are preserved.

About Me
In my day job, I am a sociologist studying the social mechanisms underlying the digital economy. For my PhD project, I investigate the governance of the app economy and how software ecosystems manage the tension between innovation and compatibility. If you are interested in this subject, feel free to get in touch.

Blog
I also occasionally blog about vim: Nano Tips for Vim

Profiles

• reddit
• Discord
• Academic Website
• Twitter
• Mastodon
• ResearchGate
• LinkedIn