Von Notizen, Texten, Skripten und braindumps

Eine bunte Mischung aus handgeschriebenen und digitalen Notizen ziehen seit je her ihre Spuren durch mein Leben.

Ideen, Links, Recherche-Ergebnisse, Notizen, kleine Code-Schnipsel, alles muss irgendwie nicht nur notiert werden, es sollte auch alles möglichst schnell wieder auffindbar sein, ohne allzugroße Verzögerungen.

Orgs übernehmen die Führung

Reine Textformate haben den Riesenvorteil, dass sie immer lesbar bleiben werden. Ganz unabhägnig davon ob es das eine oder andere Programm übermorgen noch geben wird oder die nächste Version wieder beschließt nicht mehr Rückwärtskompatibel zu sein usw.

Orgmode ist quasi Markdown auf Steroiden ohne dabei von der Einfachhheit reiner Textformate zu verlieren. Doch orgmode lässt sich nur mit Emacs nutzen. Für diejenigen, die lieber mit vim arbeiten kommt hier Spacemacs zur Rettung.

Org-Dateien (markdown ebenfalls) sind einfach genug um sie mit jedem beliebigen Texteditor bearbeiten zu können und das Markup ist einfach genug um es zu verstehen, auch wenn es vielleicht nicht mehr so aufgehübscht dargestellt wird.

Um nun also möglichst alles in reine Textformate umzuwandeln begann ich damit meine bestehenden digitalen Notizen zu org-Dateien umwandeln.

Notizen aus google keep, meiner bisherigen Hauptnotizapp, kann man mit googles takeout einfach exportieren, doch diese liegen dann als einzelne .html Dateien vor. Um sie nun zu .org Dateien umzuwandeln hilft mir folgendes kleines Skript:

#!/bin/zsh

# Script mit 2 Argumenten aufrufen: arg-1 Input Endung, arg-2 Output Endung
# pandoc konvertiert die Dateien

IN=$1
OUT=$2

# Konvertiere Dateien mit pandoc
# '+RTS Ksize -RTS' damit pandoc keinen Stack space overflow provoziert

find . -name \*.$IN -type f -exec pandoc +RTS -K100000000 -RTS -o {}.$OUT {} \;

# Dateiendungen der neuen Dateien bereinigen, sonst wird es zu: <datei.alt.neu>

for file in *.$IN.$OUT;
do
    mv "$file" "${file%.$IN.$OUT}.$OUT";
done

# Eingangsdateien löschen

rm -f *.$IN

# Leerzeichen in Dateinamen mit "-" ersetzen

for f in *\ *;
do
    mv "$f" "${f// /-}";
done

# org Dateien bereinigen

if [ $OUT = "org" ]
then
    for file in *.org;
    do
        cat "$file" | grep -v "#+BEGIN_" | grep -v "#+END_" |  grep -v ":PROPERTIES:" |  grep -v ":CUSTOM_ID:" |  grep -v ":END:" | grep -v "</div>" | grep -v "<div" > "$file".tmp ;

        cat -s "$file".tmp > "$file"
    done
else
    cat "$file" | cat -s "$file" > "$file".tmp ; mv -f "$file".tmp "$file"
fi

# temporäre Dateien entfernen

rm -f *.tmp

Der schwierigste Teil war es die konvertierten .org Dateien zu “bereinigen”. Diese waren voll mit

"#+BEGIN_HTML"
"#+END_HTML"
":PROPERTIES:" 

und

":CUSTOM_ID:" 

Tags, sowie einer großen Anzahl an

<div> 

Containern.

Das Aufrufen von

cat -s 

sorgt außerdem noch dafür, dass mehrere leere Zeilen zu einer zusammengefasst werden.

Mit dem Skript, habe ich nun schöne saubere org Dateien. Das Skript wird mit zwei Argumenten aufgerufen:

$ <skriptname> Eingangsformat Endformat

Und was ist mit Terminal?

Neue Notizen kann ich nun über Deft mit spacemacs erstellen.

Doch auch direkt aus dem Terminal geht das. Wie gesagt, ich möchte möglichst wenig “Reibung” haben beim Erstellen oder Abrufen meiner Notizen.

Auch das geht. Mit dieser kleinen Ergänzung in der .bashrc oder .zshrc:

# Notizen aus dem Terminal heraus schreiben.
# note datei.endung
# Inhalt
# mit ctrl-d beenden
note() {
	  pushd ~/Dropbox/notizen/; # ins Verzeichnis wechseln
	  touch $*;
	  echo >> $*;
	  date >> $*;
	  cat >> $*;
	  popd # zurück zum aktuellen Arbeistverzeichnis
}

# die oben erstellten Notizen im Terminal anzeigen:
# show datei.endung
show(){
	  cat ~/Dropbox/notizen/$*;
      }

Das heisst ich kann jetzt aus dem Terminal heraus mit:

$ note datei.org 

meinen Text einfach einfügen

<ctrl> d

quasi “on the fly” neue Notizen erstellen, die im richtigen Dropbox-Verzeichnis gespeichert werden um so auch für Deft und alle Geräte erreichbar zu sein.

Ergänzungen funktionieren ebenfalls, einfach den Namen der entsprechenden Notiz tippen. Weiteren Inhalt hinzufügen fertig.

Will ich die Notiz anzeigen reicht ein einfaches:

$ show datei.org

Soweit so gut. Ich hab jetzt also ein Format für meine Notizen, kann von überall zugreifen, diese in einem meiner Lieblingseditoren durchsuchen, organisieren, bearbeiten und allen voran ich kann auch direkt aus der Kommandozeile neue Notizen erstellen, ergänzen und bestehende lesen.

Aber das hat mir noch nicht gereicht.

Kürzlich habe ich mich wieder an eine alte Seite erinnert: die searchlores von Fravia.

Was mich daran so fasziniert (außer der Fülle an Wissen und der Großzügigkeit diese wirklich frei zu teilen) ist , dass es keine vorgegebene Struktur gibt.

Auch diese Seite hier folgt einer Struktur (wenn auch sehr minimalistisch):

Wir haben eine Kopfzeile mit dem Link zur Hauptseite und einem zur Umschreibung dieser Seite.
Darunter kommt der Inhalt, die einzelnen Beiträge chronologisch sortiert und unten findet sich die Fußzeile mit ein paar Infos und dem rechtlichen Gedöns. So wie nahezu jede Seite heutzutage.

Searchlores hingegen wirkt unstrukturiert, es gibt Themenübersichtsseiten auf manche kommt man von der Startseite auf andere stößt man hingegen erst wenn man sich etwas eingelesen hat. Die Texte sprießen nur so von Links und ich als Leser kann entscheiden welchem Gedankengang ich weiter folgen will, welchen ich links liegen lasse und welchen ich mir später anschauen will.

Dieses Chaos mag anfänglich ungewohnt sein, doch sie zwingt mich als Leser dazu mich wirklich mit dem Inhalt auseinanderzusetzen. Das Lesen hier wird zu einer Entdeckungsreise.

Das ist natürlich nichts für Menschen deren Aufmerksamkeitsspanne nur bis zum nächsten Eichhörnchen reicht. Aber die sind in der Regel ja auch nicht an Inhalten interessiert.

Naja, ich schweife ab.

Meine Vorstellung ist es irgendwann aus diesen ganzen Notizen eine Art kuratierten “Braindump” zu erstellen. Auf möglichst einfacher Architektur. Reiner Text mit all seinen Markup-Dialekten ist dafür wohl immer noch der zukunftssicherste Weg.

Und was ist einfacher als html? Nicht zum Schreiben, aber zum Darstellen.

http://bettermotherfuckingwebsite.com/ war mir hier eine mehr als willkommene Quelle.

braindump

Hier kommt Pandoc mal wieder zum Einsatz. Spezifischer die Template-Funktion in pandoc. Man kann nämlich für jedes zu konvertierende Format auch eine eigene Vorlage erstellen.

Falls noch nicht vorhanden:

$ mkdir ~/.pandoc/templates
$ pandoc -D html > ~/.pandoc/templates/default.html5
$ cd ~/.pandoc/templates
$ cp default.html5 braindump.html5

Jetzt können wir braindump.html5 so bearbeiten, wie wir es gerne hätten.
Als Vorlage oder Inspiration oder einfach nur kopiert dient wie schon erwähnt: http://bettermotherfuckingwebsite.com/ mich interessieren hier vor allem die paar Zeilen css.

ist die Vorlage einmal wunschgemäß angepasst wird mit:

$ pandoc -s --template="braindump.html5" -o <zieldatei>.html <quelldatei>.org 

daraus eine schöne, kleine, fast reine html Seite.

Und nun zum Skript:

Als erstes will ich die .org Dateien zu .html umwandeln.

find . -name "*.org" -type f -exec pandoc -s --template="braindump.html5" -o {}.html {} {} \;

‘find’ findet alle .org Dateien im Arbeitsverzeichnis über -exec werden diese gefundenen Dateien an pandoc weitergegeben.
Die lustigen geschweiften Klammern sind der -exec Funktion von ‘find’ geschuldet. {} ist der Platzhalter für die von find gefundenen Dateien.

Jetzt schon mal ein wenig Kosmetik. Pandoc hat zwar die Dateien konvertiert, doch sie haben jetzt die Endung .org.html. Unschön. Der nächste Teil räumt damit auf:

for file in *.org.html;
do
    mv "$file" "${file%.org.html}.html";
done

Wir haben jetzt also unsere fertigen .html Dateien. Doch die Links in diesen verweisen immer noch auf .org Dateien.

Hier können wir nun grep und sed zu Hilfe rufen:

for file in *.html;
do
    grep -rl --exclude-dir='.git' '.org">' "$file"  | xargs sed -i 's/.org">/.html">/g' "$file";
done

Ich denke .org”> ist zur Linkerkennung spezifisch genug, so dass ich mir keine sorgen machen muss, dass aus organisieren auf einmal htmlanisieren wird oder ähnlicher Unfug.

Wir erstellen noch ein Unterverzeichnis Namens ‘html’, falls noch keines vorhanden ist und schieben die generierten Dateien da rein und fertsch is.

if [ ! -d /html ]
then
    mkdir -p html/
fi

mv *.html html/

Und zu guter Letzt habe ich noch Deft für spacemacs folgendermaßen angepasst: Bei den Einstellungen zum Deftverzeichnis noch

(setq deft-recursive t) 

zusätzlich eingetragen.

So werden auch Unterverzeichnisse im Standard-Notizverzeichnis von Deft mit erkannt und durchsucht. D.h. ich kann die kuratierten Einträge für den braindump hier als org-Dateien aufbauen und strukturieren und später dann mit einem einfachen Skript zur Veröffentlichung konvertieren.

Ich glaub ich darf mich mittlerweile Script-Kiddie schimpfen.