A Procfile runner for tmux. Each procfile will have its own tmux session
and each process will have its own window. This way you can use tmux to
attach view logs and also restart individual processes.
This will output the git sha of the merge commit that a given commit is
part of. This can be used to get back to the pull request a commit was
part of. Or it can be used to help revert a hole changeset rather than
only one commit.
There are two wrapper scripts for running codeclimate locally in docker.
This script is adapted from their website. There is also a script that
will output the results in vimgrep format, so they can be easily loaded
into the quickfix list.
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.
I have been using this quite a lot and have not missed the search
highlights. When this was on would alway search then use `:noh` to
remove all the highlighting.
When working on the start of a project its nice to know what you are
changing. Or when you are working on a refactor having points to get
back to is nice. When we are done we can go and clean up the history so
it makes sense, for review, or just give our points more descriptive
messages and you don't need to brake your flow when coding.
In markdown I have long lines wrapping as we are often editing docs that
don't stick to 80 columns. This makes it hard to navigate with j and k
imposable to use becase is skips over the wrapped lines.
This now using gj and gk to navigate wrapped lines so j and k will act
naturaly and move down one "line" even on the wrapping.
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.
Sets code folding of diffs and hunks so we can review hunks on there
own. This is good for larger pull requests, you can focus on the hunk
and not get overwhelmed by the rest of the code.
Adds a go to definition mapping for prr lines. This will allow you to go
straight to the line of code when reviewing a pull request. Seeing the
code in full context is really helpful when reviewing. You are then
there in your editor with all the linters and the LSP.
There is some weirdness with `:GBrowse` where it will open the file and
line but only if the line / block is visually selected. This was too
many keystrokes so I added a binding to do it.
You can now run Jest on different parts of our app and populate the
quickfix list with the errors. You can run the tests on
- The current tests under the cursor
- All the tests in the current file
- All the tests on the project
This was an issue when editing files that don't have an lsp server. The
document highlight is only enabled for lsp's. This splits out the
highlighting and the diagnostic float into two separate auto commands.
The document highlight is now only enabled when the lsp is registered.
The diagnostic float is now enabled for all files. This is because the
the vim diagnostics are used for lots of other things like spell checking
and codelimate.
We have the kind of the completion item in the menu as an icon and the
name at the end. Now the end one has been replaced with the source name
so we can see what the completion item is and where it is from.
Due to starting to learn clojure, I've had java classes popping up in
the completion menu. Because they are so long it needs to be wider so I
can see then.
OMG this is AMAZING, it writes files and creates all the directories for
that file working the same as `mkdir -p`. I have honestly had a todo to
create a plugin that dose this on the before save hook for a long time.
Thank you reddit, and remember always read the manual `:help :w`!!
Install all of the tools and config for clojure development. This adds
the first configz module that is not yet properly integrated and
automaticaly run with the `dotfiles` shell command.
Now when loading vim the them from the shell is getting used rather than
only every using tomorrow night. When I use tomorrow it will be
inherited in vim.
Now when the editor is idle it will use the lsp to highlight other
references to the token under the cursor.
It will also show all the diagnostics in a popup like the lsp hover that
I manually use via <C-k>. This is helpful with long diagnostic messages
that run off the edge of the terminal when.
Custom plugin to check the .nvmrc file. When entering a directory, it
checks to see if you have the desired node version installed for the
current project. If it is, it will use it automatically, if not, then it
will ask you if you want to install it. After, it will install all the
JS developer tools for that version of NodeJS.
This is a different implementation than the default oh-my-zsh version.
The main difference is that it will not reset the node version when
leaving a directory. It will only preform an action if there is a
`.nvmrc` file in the current directory. It will not even use the
`nvm_find_nvmrc` command because any interaction with nvm make the
stranded `cd` command extremely sluggish.
The biggest change here is that I am no longer cycling though completion
items as the first thing. Tab will now mainly control the snippet jumps
in completion not items. Completion items can be used exclusively with
<C-n> and <C-p> and <CR> to complete the selected item. If the
completion menu is open and <CR> is pressed, this will select and
complete the first item.
I will soon be able to remove the <C-h> and <C-l> mappings when my
muscle memory adapts as this will now be controlled with tab.
This is to keep things consistent with how I have ivy.nvim working in
vim. All fuzzy finding is now done at the bottom of the terminal with
the preview on top. This prevents the eyes to jumping up and down and
keep the focus to the bottom of the terminal.
