hwde

How to show files and contents of a directory in nvim-telescope if it is in .gitignore

2024-07-05T00:00:00+02:00

The usecase is pretty simple here: I'm heavily using gitlab-ci job templates in various gitlab projects by using the include statement.

While this greatly reduces code duplication, it opens up for another problem: Many IDEs (neovim - well, telescope - among them) by default ignore files/directories present in .gitignore. This makes perfectly sense in most cases and is not somethin I'd like to generally switch off (even though it is easil possible).

But my idea here is different though: I'd like to provide the content of the gitlab-templastes project as a symlink in other projects to make the files searchable for telescope. At the same time I do not want to accidentially commit them to any project.

So, I do

ln -s /path/to/gitlab-templates
echo gitlab-templates >> .gitignore

So far so good, doing a git status does not show the symlink, but the files also do not show up in telescope (where I would like to make them searchable etc.)

The solution is pretty simple: In my case, telescope uses fzf and fd under the hood to search for files. Both support themselves the usage of the file ~/.ignore. This file can be used to provide a list of files and directories that should be ignored by the search. This does not yet help as we are trying to un-ignore files here, so now comes the trick:

The .ignore files precedes over .gitignore
The .ignore file can also contain negated rules.

Any rule that starts with an exclamation mark will explicitely unignore the pattern (same as in .gitignore files).

Thus, adding the following line to ~/.ignore will make the files under the symlinked directory gitlab-templates searchable in telescope, because they will not be ignored by fd:

cat ~/.ignore
!gitlab-templates
.git/

On the other hand, git will still ignore the files, so no need to worry about accidentially committing them.

Problem solved.

Create regular Valheim backups automatically

2021-04-23T11:06:00+02:00

why?

Valheim is a fantastic game that currently eats up most of my gaming time. The game so far offers no backup possibility, but it has been reported that through a bug lots of people have lost their world and their character. Taking a look at the directory with the valheim files, there are already .old files for both world and character, which in many cases is enough to restore. But there might be the case where one wants to restore an older snapshot of his/her progress through valheim.

This tool implements a watcher, that runs in the backgound, becomes active every 5 minutes, then watches the valheim world and character files and creates a backup right after the game itself has written the files (which also happens periodically).

Usage

Open svenXY/valheim_utils for details

Either build and use the docker container (see below) or do the following:

git clone https://github.com/svenXY/valheim-utils
cd valheim-utils

# optional: create and/r activate a virtual environment
pip install requirements.txt

python valheim_backup --help

python valheim_backup \
    --source $HOME/.config/unity3d/IronGate/Valheim
    --destination $HOME//valheim_backup \
    --verbose

# do not close the terminal

You are done. Now start Valheim and enjoy playing.

ctrl-c stops the backup utility at any time.

Docker container

This utility uses inotify which is not available for Windows and macOS, but at least on macOS, where docker desktop runs docker through a transparent linux VM, inotify can be used.

I've tested and it runs, but with no valheim installation available on my macOS, I was not able to end-to-end test if it really works. Maybe someone can give me some clarification.

Depending on how docker runs on Windows, it might also work on Windows. Again - comments if this is actually possible are greatly appreciated.

Important is to first pass the real (docker-external) source and destination to the docker container as volumes, then set the docker-internal paths as source and destination parameters as shown in the example below.

docker run run -it --rm \
    -v $(pwd)/testdir:/usr/src/app/valheim \
    -v $(pwd)/backup:/backup \
    --name valheim_bck valheim_backup:latest \
    --source /usr/src/app/valheim \
    --destination /backup \
    --verbose

Restore

warning: always make a copy of your valheim directory before trying this!

The backups contain either the world or the character files. To restore whichever you need, just extract them from the tgz file of your choice and copy them into the worlds or characters directory.

Again, for safety precautions, create a backup of the files there before overwriting them!

You do this at your own risk!

use autojump effectively with tmux

2020-12-09T08:48:43+01:00

Autojump is a nice little tool that learns from your cd history and then allows you to directly jump to a directory with just a few - even fuzzy - characters of the path by just issuing something along the lines of

# destination path is abc/def/ghi

j ab/hi

The tj command (read tmux-jump) is a very small helper function that makes use of autojump, but instead of directly cd'ing, it opens a new tmux window and there jumps to the selected directory. It also sets a proper name for the tmux window.

The Code

tj() {
    DIR=$(autojump $1)
    NAME=$(basename $DIR)
    tmux new-window -c $DIR -n $NAME
}

How to use it

Put the code into a file, e.g. tmux-jump.zsh and source it. If you like it, add the command to source it to one of your shell initialization scripts.

Then instead of j, run tj. If no path is found within the autojump database, nothing will happen. Otherwise, a new tmux window with a shell will be opened in the found directory.

two fzf-helpers for kubernetes

2020-11-10T00:00:00+01:00

What it is

FZF to create zsh functions to interactively select kubernetes pods for further usage.

FZF is a nice tool for all kinds of fuzzy finding on your computer. It really shines when combined with other tools to make them interactive.

What it does for you

The two functions we create here can do the following for us:

show all pods of a kubernetes cluster (optionally only those of a namespace)
optinally takes an fzf query string to prepopulate fzf
allow for fuzzy-finding the one we want with fzf interactively
select one and then either start a bash shell in the container or show the logs for the container

The Code

function klogs() { #--argument-names pod_name namespace
  local OPTIND flag
  while getopts 'p:n:' flag; do
    case $flag in
      p) local pod_name="$OPTARG";;
      n) local namespace="$OPTARG";;
    esac
  done

  shift $(( OPTIND - 1 ))
  local remaining_args="$@"

  if [ -z "$namespace" ]; then
    local namespace_pod=$(kubectl get pods -A | fzf --header-lines=1 -q "$pod_name"| awk '{print $1" "$2}')
    local namespace=${namespace_pod%% *}
    local pod=${namespace_pod##* }
  else
    local pod=$(kubectl get pods -n $namespace | fzf --header-lines=1 -q "$pod_name"| awk '{print $1}')
  fi
  if [ -z "$pod" ]; then
    return
  fi

  echo Retrieving logs from $pod
  kubectl logs -n $namespace $remaining_args $pod
}

function kbash() { #--argument-names pod_name namespace
  while getopts ':p:n:' arg; do
    case $arg in
      p) local pod_name="$OPTARG";;
      n) local namespace="$OPTARG";;
    esac
  done

  shift $(($OPTIND - 1))
  local remaining_args="$@"

  if [ -z "$namespace" ]; then
    local namespace_pod=$(kubectl get pods -A | fzf --header-lines=1 -q "$pod_name"| awk '{print $1" "$2}')
    local namespace=${namespace_pod%% *}
    local pod=${namespace_pod##* }
  else
    local pod=$(kubectl get pods -n $namespace | fzf --header-lines=1 -q "$pod_name"| awk '{print $1}')
  fi
  if [ -z "$pod" ]; then
    return
  fi

  echo Executing bash on $pod
  kubectl exec -n $namespace -it $pod -- bash
}

How to use it

Put the code into a file, e.g. fzf_k8s.zsh and source it. If you like it, add the command to source it to one of your shell initialization scripts.

Then run

kbash [-n <namespace] [-p <pod querystring>]

# or

klogs [-n <namespace] [-p <pod querystring>] [-- <other kubectl logs options>]

to find the to find the pod you wish to interact with, type some more search characters - it can be a fuzzy-find - and/or use the arrow keys to select a pod.

Then press <Enter> either start a bash shell or show the logs. Use <ESC> to exit without doing anything.

Enjoy!

bwtarif - eine Mogelpackung

2020-11-09T10:07:00+01:00

Ich bin Inhaber eines Abo Plus VRN/KVV Tickets der Deutschen Bahn (DB), um zwischen Heidelberg und Karlsruhe pendeln zu können.

Dafür bezahle ich momentan monatlich 135€ (VRN Rhein-Neckar-Ticket + KVV mit 50% Rabatt).

Heute habe ich von der DB einen Brief erhalten, in dem mir angekündigt wird, dass ich in Zukunft entweder den vollen KVV Preis bezahlen muss oder das tolle neue bwABO beziehen könne, mit dem es billiger werden würde.

Dem ist leider nicht so:

Für beide Abos zusammen (RNV + KVV) ohne die 50% Rabatt komme ich auf 178,80€.

Der BW-Tarifrechner kommt für mich auf 178,20€.

Die Ersparnis hier ist also nicht einmal 1 Euro, im Vergleich zum bisherigen Tarif ist es eine Verteuerung um ca. 45€, das sind rund 33%.

Dafür kann ich das Ticket in der Freizeit nicht mehr nutzen, weder nach Mannheim, noch ins Neckartal, noch in die Pfalz, es ist nur noch in Heidelberg, Karlsruhe und auf der Strecke dazwischen gültig. Wie man in Zeiten, in denen man wegen des Klimas mehr Menschen auch am Wochenende vom Auto weglocken will, gleichzeitig das Angebot verschlechtern kann, nur um eine angebliche Vereinfachung zu erreichen ist mir nicht verständlich. Für mich ist es eine Verschlechterung des Angebots bei gleichzeitiger Verteuerung um ein Drittel!

Man fragt sich, wie es überhaupt zu der Entscheidung kam, das Kombi-Ticket abzuschaffen?

Wie viele andere Pendler gibt es auch für mich nicht erst seit Corona die Möglichkeit des Homeoffice. Ich pendle in der Regel dreimal wöchentlich, komme also auf etwa 12 Fahrten im Monat. Ohne jegliches Abo oder Monatskarte müsste ich mit etwa 20€ pro Pendeltag rechnen und käme auf 240€ - zwar 35% mehr, aber ohne jegliche Verpflichtung.

Seit Februar bin ich Corona-bedingt darüberhinaus komplett im HomeOffice, brauche also gar kein teures Ticket. Bisher habe ich von einer Kündigung auch deswegen abgesehen, weil ich mich damit auch ein wenig an den trotzdem anfallenden Kosten des ÖPNV solidarisch beteiligen wollte. Mir ist das Klima wichtig und ich versuche, meinen Beitrag zu leisten, aber hier fühlt es sich an, als solle man dafür ausgerechnet im grün regierten Baden-Württemberg noch extra abkassiert werden.

Ich möchte jetzt hier nicht anfangen gegenzurechnen, was mich die Nutzung des Autos (das ohnehin vorhanden ist) kosten würde, da hat keines der "Angebote" eine Chance, aber was hier gemacht wird ist klimapolitisch und verkehrspolitisch Unsinn und wird vermutlich Viele wie mich, denen es ähnlich geht dazu veranlassen wieder häufiger, wenn nicht immer, mit dem Auto zu fahren und von solchen tollen "Angeboten" lieber Abstand zu nehmen.

Ich werde nun auf jeden Fall zunächst kündigen, da ich nicht damit rechne, vor März oder April wieder nach Karlsruhe fahren zu müssen. Für die wenigen Fahrten innerhalb von Heidleberg werde ich mir dann einfach eine Fahrkarte besorgen.

Das spart mir bis dahin ein paar Hundert Euro und verlieren tue ich nichts, da es bei der Bahn ja auch nicht so etwas wie einen Treuerabatt gibt...

Schade eigentlich

gopass secret selection with fzf

2020-10-02T16:07:00+02:00

What it is

FZF to create a zsh functiona to interactively search for passwords or other information in the gopass databases

FZF is a nice tool for all kinds of fuzzy finding on your computer. It really shines when combined with other tools to make them interactive.

What it does for you

The function we create here can do the following for us:

show all secrets from all password stores that gopass knows of
optinally takes an fzf query string to prepopulate fzf
allow for fuzzy-finding the one we want with fzf interactively
help with the selection by showing any additional info of a secret in fzf's preview
select one and copy it to the clipboard

The Code

p(){
  QUERY=$1
  if [ -z "$QUERY" ]; then
    QUERY=''
  fi
  gopass show -C \
    $(gopass ls --flat \
      | fzf -q "$QUERY" --preview "gopass show {}" \
    )
}

How to use it

Put the code into a file, e.g. fzf_gopass.zsh and source it. If you like it, add the command to source it to one of your shell initialization scripts.

Then type

p

# optionally followed by some (fuzzy) search text to start with

p goo

Type some more search characters - it can be a fuzzy-find - and/or use the arrow keys to select a branch.

Then press <Enter> to copy the password to the clipboard. Use <ESC> to exit without copying anything.

You can also use this command to quickly get any additional information stored in your secrets database.

Enjoy!

git branch checkout made easy with fzf

2020-10-01T16:07:00+02:00

What it is

FZF to create a zsh functiona to interactively select a git branch to check out.

FZF is a nice tool for all kinds of fuzzy finding on your computer. It really shines when combined with other tools to make them interactive.

What it does for you

The function we create here can do the following for us:

show all branches of the current repository as a list
optinally takes an fzf query string to prepopulate fzf
allow for fuzzy-finding the one we want with fzf interactively
help with the selection by showing the commit history of that branch in fzf's preview
select one and automatically check it out

The Code

function gcx() {
  my_branch=$(git branch -a --no-color | sort |uniq | tr -d " " | fzf --select-1 --ansi --preview 'git log --graph --color=always --format="%C(auto)%h%d %s %C(black)%C(bold)%cr" {} 2>/dev/null')
  if echo $my_branch | grep -q "remotes/origin"; then
    my_branch=${my_branch##remotes/origin/}
  fi
  if echo "$my_branch" | grep -q -P --regexp='\*'; then
    my_branch=${my_branch##\*}
  fi

  git checkout $my_branch
}

How to use it

Put the code into a file, e.g. fzf_git.zsh and source it. If you like it, add the command to source it to one of your shell initialization scripts.

Then run

gcx

# or provide some (fuzzy) search text to start with

gcx feat

and it will look similarly to this:

to find the branch you want to checkout, type some more search characters - it can be a fuzzy-find - and/or use the arrow keys to select a branch.

Then press <Enter> to check the selected branch out. Use <ESC> to exit without checking out.

You can also use this command to quickly get some overview about the commit history in different branches.

Enjoy!