alexanderjeurissen / dotfiles Goto Github PK

Create a script that provisions a new dev machine using ansible, see https://github.com/jeremy-hanna/my-provisioning_cookbook for inspiration.

Ref https://www.mankier.com/1/rg#Configuration_Files

There are several lua plugins that facilitate lightweight definition of statusline in lua.

• https://github.com/glepnir/galaxyline.nvim
• https://github.com/hoob3rt/lualine.nvim
• https://github.com/tjdevries/express_line.nvim

There is also the option to write it ourselves in a lua module.

Currently we use vim-test

we only use the Testfile and TestNearest commands.

The same functionality can likely be achieved using designated vim make programs for specific file types (.rb / .feature).
Or by ensuring Dispatch knows how to dispatch the given files

ref:

• https://jbernard.io/2011/09/30/vim-makeprg.html
• https://vi.stackexchange.com/questions/10239/how-to-customize-symbol-in-makeprg-command
• https://vim.fandom.com/wiki/Errorformat_and_makeprg
• tpope/vim-dispatch#10

Seems that from initial investigation, the only way to get a changelog (commits) when updating all submodules is using the foreach option in the git submodule command in conjuction with the lg option I have defined in .gitconfig

git submodule foreach 'git fetch origin && git lg origin/master..master && git submodule update'
This requires fetching prior to updating to show the change log for each update. And as a result is much slower then simply calling git submodule update --recursive in the root directory.

https://reddit.com/r/neovim/comments/l6okhx/nvimcompe_is_an_excellent_autocompletion_plugin/

Used to preserve cursor position and registers when removing trailing whitespace.
Function itself is straightforward, usage is tightly coupled and prone to break several mappings and autocommands.

investigate if there is a lua plugin that already exists to remove trailing whitespace if not consider writing this functionality in lua, test it out for a couple of days and evaluate if it makes sense to create as separate plugin for this.

RE: https://gitlab.com/gitlab-org/gitlab/-/issues/220906

Rename branch to "main" to be considerate of people for the negative connotation that "master" has for a lot of people.

relevant line: /Users/alexanderjeurissen/.zshrc:167

Instead of having to create git commit aliases to auto fill a certain commit message, consider just using git commit (which allows for seeing a git diff before committing) and having snippets/vim abbreviations that expand to the desired common commit messages

I have installed the gotham theme but the colours in the tmux bar are all wrong. How did you get them to look so good? I am using gnome-terminal.

Edit: added scrot.

https://reddit.com/r/neovim/comments/l6a8z8/is_it_just_me_or_some_options_dont_work_in_lua_yet/

Collection of navigation keybindings, can all be converted to lua using the Util.nnoremap etc functions.
Whilst going over all keybindings evaluate where possible to co-locate the keybindings with their respective functions / modules.

The idea is that abduco can provide persisting sessions, neovim can act as terminal multiplexer with the :terminal buffers, and nvimux can help with muscle memory of tmux keybinds.

The intended result is a more lean and more easy to script terminal multiplexer.

ref:

https://www.reddit.com/r/neovim/comments/936obn/make_neovim_open_with_terminal_ontop_by_default/

https://github.com/mhinz/neovim-remote

https://github.com/Vigemus/nvimux

https://github.com/martanne/abduco

https://twitter.com/nelstrom/status/935489435206127621

Context

Current dot files setup still requires manual installing of several dependencies.
Most of these are captured in bundle files that are consumed by brew or yarn-bundle.

What I want is to create a new docker file as described in https://bergie.iki.fi/blog/docker-developer-shell/ to have the option to containerize the complete setup.

Collection of misc keybindings, can all be converted to lua using the Util.nnoremap etc functions.
Whilst going over all keybindings evaluate where possible to co-locate the keybindings with their respective functions / modules.

It's currently a bit annoying to go to the milestone workboard in Phabricator, it requires either:

1. Go to the project workboard -> scroll to the far right -> click the heading of the milestone column
2. Go to the project -> click the overview menu item -> scan the milestone list -> click the active one

preferably a shell alias like milestonew or openw should exist. It should:

1. Query Phabricator and obtain the active milestones of the provided project (which should be a arg)
2. show all milestones in FZF (fuzzy selector)
3. When pressing enter on one of the items, arc browse said milestone

Used to support executing macros in visual mode.

Only referenced in a single xnoremap keybinding: vim/keybindings.vim:32

With Neovim providing a very comprehensive LUA api it's worth exploring rewriting the following vim configuration segments to LUA:

• autoloads files containing namespaced vim functions
• vim options in init.vim

references:

• https://github.com/neovim/neovim/blob/master/runtime/doc/api.txt
• https://www.reddit.com/r/neovim/comments/fka58t/coming_back_to_nvim_with_a_very_almost_alllua
• https://gitlab.com/CraftedCart/dotfiles/-/blob/master/.config/nvim/lua/c/log.lua
• https://github.com/neovim/neovim/blob/master/runtime/doc/lua.txt

ref: https://asdf-vm.com/#/

Currently using dein but not really content with it.

drawbacks:

1. Progress indicator of installing plugins is less clear then vimplug.
2. the necessity to recache the runtimepath.
3. too many options for lazy loading, whilst plenty of plugins already have that in place.
4. Uninstalling plugins sometimes requires multiple recach attempts / vimrc sourcing, and leaves empty folders in the file system.
5. documentation is less clear then vimplug / pathogen.

Basically since I'm cutting down on plugin usage, removing anything I don't use often enough or where the added value compared to default vim is non present, the use for a complex plugin manager is not there..

potential alternatives

1. vim-plug
2. pathogen

Create a shell method or executable that queries Phabricator and obtains all unclaimed tasks in the sprint backlog, selecting a task should:

• Claim the task
• Move it to the in progress column
• Copy the task id to the system clipboard

Collection of editing related keybindings, can all be converted to lua using the Util.nnoremap etc functions.
Whilst going over all keybindings evaluate where possible to co-locate the keybindings with their respective functions / modules.

These functions are only referencing each other, it's referenced by a single normal mode mapping o which allows for visually selecting urls and opening them in chrome.

I'v been a long time user of zsh, but there are several things I'm dissatisfied with with zsh:

1. Config bloat: basic things such as autocomplete, history, syntax highlighting require a lot of configuration and setup upfront.
2. Configuration spread: cofiguration is spread amongst .zshenv, .zshhrc, .zprofile. Reasoning is to support scenario's where there is a dumb terminal and to reduce the amount of configuration that is loaded in such terminals. Given that most of my terminals are --login terminals that don't require this it ends up overcomplicating the configuration.
3. Prompt slowness: prompt speed has been hit and miss for me.

There are some ways to speed up zsh, most notably I've been looking into:
https://carlosbecker.com/posts/speeding-up-zsh/

But I also want to explore if Fish addresses some of those pain points.

https://reddit.com/r/neovim/comments/l61gzb/builtin_lsp_client_exeprience/

https://reddit.com/r/neovim/comments/l6y9fp/why_should_i_use_the_in_built_lsp_over_cocvim/

• https://posts.michaelks.org/instant-pyenv-rbenv-startup-times-with-tmux/
• https://posts.michaelks.org/faster-fish-startup-times/

https://reddit.com/r/neovim/comments/l6bbrd/can_anyone_give_a_simple_step_by_step_guide_to/

milestone: https://github.com/starship/starship/milestone/3

That way we will be able to replicate https://github.com/oh-my-fish/theme-agnoster
with more customization options to boot.

• evaluate necessity of existing autocommands
• convert autocommands to lua using a similar approach as: https://github.com/norcalli/nvim_utils/blob/master/lua/nvim_utils.lua#L554-L567

Propper support is not implemented yet: https://github.com/nanotee/nvim-lua-guide#defining-autocommands

relevant line: /Users/alexanderjeurissen/.zshrc:172

investigate if we still need this hack, which was needed due to the yarn global dir being incorrectly set.

I'm currently using the https://www.jetbrains.com/lp/mono/ font

In order to be able to use the ligatures in a fast minimal terminal I had to move from Alacritty to Kitty:

alacritty/alacritty#50

However, Kitty comes with it's own challenges:

• More "User friendly" features that I will never use such as shortcuts and scrollback
• binary is bigger
• Alacritty is faster from my testing, most notably in rendering and scrolling in bigger files.

There have also been instances where ligatures caused friction in my workflow:

• Occasionally ligatures were undesirably rendered in comments or documentation.
• Pairing partners that occasionally got confused by the ligatures
• When editing ligatures such as !== in vim, sometimes the wrong character is removed if you edit in the wrong character position of the ligature.

I'm aware that there are workarounds for some of these issues, but the question is if it is worth it to invest in those.

As such I'm going to review the following posts and think if I can live without code ligatures and move back to Alacritty:

• https://practicaltypography.com/ligatures-in-programming-fonts-hell-no.html
• https://news.ycombinator.com/item?id=19805053
• http://www.chicagowebexperts.com/blog/im-not-a-fan-of-programming-font-ligatures
• https://graphicdesign.stackexchange.com/questions/33666/when-should-someone-use-ligatures
• http://blog.fonts.com/2016/06/30/to-ligature-or-not-to-ligature/
• https://news.ycombinator.com/item?id=14830797

This function is only referenced in the n and N normal mode mappings to make navigating between incsearch results and substitute invocations easier to spot visually.

convert to lua and update mappings accordingly.

see https://github.com/jwilm/alacritty

Context

We can likely utilize https://github.com/tjdevries/astronauta.nvim to convert all ftplugins defined in https://github.com/alexanderjeurissen/dotfiles/tree/main/config/nvim/after/ftplugin to lua while awaiting resolution of neovim/neovim#12670 (comment) upstream .

recently discovered https://github.com/arcticicestudio/snowsaw
looks promising, I should evaluate it's added value compared to Thoughtbot's RCM and see if switching is worthwhile.

I don't understand, how you add icons to tmux. I added characters from mac but look like not good. I need transparent icons. Maybe you can help me?

Currently the nexttask shell method is not really useful. It lists all tasks that are assigned to me and uses head -1 to get the first one.

I should either remove said method, or opt for repurposing it so that the method will arc browse to the first unclaimed task on the sprint workboard

This function is rather straightforward, and can easily be converted to lua.

• Ensure we also update or move any mappings / ex commands that reference this function.

https://github.com/wbthomason/packer.nvim