This will be using `dotnet format` under the hood and take any settings from
the editorconfig. The advantage of this is it will only do the file, with
`dotnet format` you need todo the hole solution.
Nvim lsp has changed the way the config works. This is now on all the versions
on nvim I am using. The main one is in tumbleweed this is relatively up to
date.
The sign_define has also moved into the diagnostic config.
This add most of the snippets I used to have. It implements a custom
env_namespace for adding in the namespace of the file based on where it in the
file tree.
When you are in a monorepo you don't always have a tsconfig in the root. You do
however have a yarn.lock. This will now start ts_ls when it finds a yarn.lock
in the root of the repo.
This is some investigation in to nushell will work. I will be looking to use
this cross platform, as zsh will not work on windows.
Adds some of the core modules so I don't loose my mind having to relearn mussel
memory. The goal of this is to replicate my use of oh-my-zsh, I think this will
take some time, I have sunk years into the zsh config. The aliases will be the
same, the GOPATH project structure will be replicated and the dir hooks will be
implemeted so my PATH gets setup just as I like it.
This uses different icons to try and make things look a bit more cool. The look
of vim is not something I have really been focused on however, I think it may
be time to spice things up.
This is a bit tricky due to the filetype of deno being typescript. The
typescript server automatically starts on this filetype.
For now this looks in the root of the project to see if there is a deno.json or
package.json. Based on this, it will pick what one to use.
For formatting f# there really is only one tool, fantomas. The CLI for fantomas
has no input and will only do files. Ionide has built in support for fantomas,
we need some extra config to make this work because right now we are only using
Neoformat for formatting.
This updates the formatting function to format with the lsp only for f# files.
Anything else it will fall back to usign Neoformat. I am hoping that there will
not be many cases of this and we can continue to use Neoformat.
Removes the complete override to the linters and add extra flags to the
existing args. This will now automatically get any updates made to the plugin
linters.
This also add the `unstable_ts_config` to the eslint command so we can use
typescript configs with eslint 9. I don't really know how this will affect BC
with version 8, I will have to cross that bridge when we come to it. ATM this
is good for daily use of version 9.
So this is the first commit where we are starting to migrate from tmux.
Right now I'm not sure how this will go, every other attempt has not
lasted very long.
This does support all the features I am using in tmux though. TBH most
of the stuff in the tmux.conf wezterm does by default. For example, the
pain numbers start at 1 not 0.
This implements a fork of tmux navigation, the plugin I have been using
in vim since like.... day one.
This was a plugin I had started writing and using for running jest tests
in a nvim buffer. This has now been split out into its own dedicated
plugin.
See: https://github.com/adeattwood/spec.nvim
I have been wanting to play with this plugin for a long time now. I have
a minimal config that will give me most of what I need. Moving
parameters and arguments is a big one. Also selecting parameters, this
will also include the type definition so its much more powerful than
selecting words.
Jumping to functions has also been included, right now I am not sure how
much that will be used. My muscle memory is very used to <C-d> and <C-u>
for paging.
When you are in a buffer sometimes you want to do a search and replace
but preserve the case. For example if we have the following code.
```rust
let some_struct = SomeStruct::new();
```
if we want to rename this to `another_struct` we can call dev case and
it will search and replace preserving the case. We can run the following
command.
```
:S some_struct another_struct
```
This will replace the above code so we will be left with
```rust
let another_struct = AnotherStruct::new();
```
This plugin handles calling the cli tool and displaying an in place
preview of the change so you can see exactly what you will be changing.
It uses the `S` custom command so it feels similar to the built in `s`
Substitute command.
This is moves everything I can think of. A lot of the things I use have
this built in. The vim and tmux themes has been added so the place I
spend all my time looks nice.
This add a pattern for all lua files that will go to the corresponding
spec files. I don't think this will work on all the different projects
but, its a good start. There may need to be some tweaking to make it
work in vim plugins.
There have been some changes in the cspell config upstream to fix issues
in the cspell cli. These are mainly around the parsing of the output.
The only things my changes are adding in the file type and applying my
config file. They are only in the command not the parser.
Now we are using the upstream config and adding the extra params I need
rather than having to maintain a completely override.
Previously we were defining what ones we want to install. Now we are say
we want to install the grammar when we go to a file. If we don't have
that grammar installed then we will install it then
When writing tests with busted they use some other globals that you need
to tell you lsp about. I already have this for when I'm working on the
nvim config and configz.
The ollama plugin was using some APIs that are not yet available in nvim
stable. Now we are using the older APIs we can use this on other
versions of nvim.
The `vim.api.nvim_buf_set_text` does not take some parameters as `-1` to
add text to the end of the line. Now we are getting the text on the last
line adding the new text to it, then replacing the last line.
This is the plugin I have been using for a while now. I think its much
nicer to use than a tree style. Treating the filesystem as a buffer is
something I used in emacs and have come quite used to.
This is mainly for stylelint, I don't always have this installed and it
throws an error when you open a sass file and it tries to lint the
buffer. Now it will not know about any linters unless they are in the
PATH.
Eslint has become slow for some projects for reasons unknown. In an
attempt to speed up my linting process, I'm experimenting with eslint_d,
which keeps a process running. For the time being, I'd like to keep
linting and formatting separate from the Language Server Protocol (LSP)
to avoid the need to install every LSP. This way, I can have `shfmt`
without the bash LSP, for example.
For JavaScript, I may consider moving this into an LSP since I use it
for work, which would justify combining responsibilities. However, for
now, I'll be giving eslint_d a try.
Indent Line is no longer in use; it's quite an old plugin, and there are
likely better ways to implement this functionality. For now, I won't be
using any indent markers, and we'll see how that goes. If I encounter
issues, I will explore alternative plugins.
Orgmode was an attempt to bring over the knowledge base from Emacs. Vim
doesn't have the same workflow as Emacs, and everything is less tightly
integrated into a single application. I have now transitioned to using
Markdown and Obsidian, focusing on the more widely-used Markdown
integration.
Conjure is too heavy for my needs. All I require is a simple plugin to
execute Clojure in a REPL. This plugin conflicts with many other plugins
and filetypes, where the LSP (Language Server Protocol) should handle
most of the heavy lifting. I've created my own plugin for my very basic
use case.
See: https://github.com/AdeAttwood/nrepl.nvim
The Ollama plugin provides a simple way to interact with an Ollama
language model from within Neovim. It uses as many of the built in
features as possible like buffers, tabs and markdown. This will make
this as small as possible so you don't have to install plugins with
loads of features you don't use.
Move the linters to run on BufReadPost instead of BufEnter. This was
running the linters whenever a buffer opened, when jumping around
quickly with <CTRL-i> and <CTRL-o> this would cause the linters to run a
lot when there were not needed. Now were are only running them once when
the buffer is read from disk.
Adds a custom function that will add cspell to all of the filetypes.
This will then only run `try_lint` once to improve the performance. Now
neoformat has gone fully async. When calling `try_lint` one after the
other, the first processes were getting canceled.
The jest out put is quite hard to process. This points that were add
into the quickfix list where often incorrect. This is a bit pointless
and I would find myself running it again in the terminal to see all of
the output.
This will have todo until I can find time to create proper test runner,
I really don't like the look of any of the plugins available.
Solargraph is best used installed in your Gemfile, this will allow you
to use manage the versions by each project. This will ensure that we are
using the version in your Gemfile, not the one installed globally.
