mutt alias

abook bietet eine Funktion um aus den vorhandenen Kontaktdaten Aliase für mutt zu generieren. Das ist auch mit einem kleinen Skript möglich:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#!/bin/bash
# File: cbook2alias.sh
 
# Speicherort des Addressbuches
CBOOK_DIR=~/.cbook
 
MAIL_LIST=(`grep '^Email:' "$CBOOK_DIR" | egrep -o '[^ ]+$'`)
INFO_LIST=""
NAME=""
 
for ADDRESS in ${MAIL_LIST[*]}; do
  INFO_LIST=(`awk 'BEGIN { RS = "###"; FS = "Email: " } ($2 ~ "'$ADDRESS'") { print $1 }' "$CBOOK_DIR"`)
  NAME=${INFO_LIST[0]:0:1}
  echo "alias ${NAME,}${INFO_LIST[1],,} <$ADDRESS>"
done

Anwendungsbeispiel:

# File: ~/.cbook
Ron Wesley
Fuchsbau
1337 Irgendwo im Nirgendwo
Email: ron@weasley.hog
Birthday: 12.12.9000

$ ./cbook2alias.sh
alias rweasley <ron@weasley.hog>
Wie man sieht, wird der Vorname auf den Anfangsbuchstaben verkürzt und dieser vor den Nachnamen gehängt. Eine Modifikation von Zeile 13 kann diesen Effekt aufheben:

13

NAME=${INFO_LIST[0]}

$ ./cbook2alias.sh
alias ronweasley <ron@weasley.hog>

Geburtstagsübersicht

Manche Geburtstage sollte man einfach nicht vergessen. Damit das passiert, kann man sich aus dem Addressbuch die kommenden Geburtstage anzeigen lassen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

#!/bin/bash 
# File: cbook_birthdays.sh
 
# Variables
CBOOK_DIR=~/.cbook
 
# This var  holds a list of all the birthdays in the contacts file
BD_LIST=(`grep '^Birthday:' "$CBOOK_DIR" | egrep -o '[^ ]+$'`)
# This var will hold a list of information for the person corresponding to a birthday in BD_LIST
INFO_LIST=""
# The persons name
NAME=""
# The flag that is relevant for output
ONE_MONTH_FLAG=false
# Current date and delimiter
CUR_DAY=`date +"%d"`
CUR_MONTH=`date +"%m"`
CUR_YEAR=`date +"%Y"`
# Birthday segment indices, delimiter and format
BD_DAY=2
BD_MONTH=1
BD_YEAR=0
DELIM="."
FMT="ymd"
# helper variables
TEMP=""
NUM=0
 
# Functions
function print_usage {
    echo "Usage: `basename $0` [Options]"
    echo "Description:"
    echo "This script helps you remember birthdays. You can pass it"
    echo "some options concerning the date format. Then you"
    echo "will get to see a list of birthdays to come for this year."
    echo "Options:"
    echo "-m"
    echo -e "\t print only the birthdays for this month (the ones that are to come"
    echo "-f <FORMAT>"
    echo -e "\t the date format, choose one of [dmy,mdy,ymd]"
    echo -e "\t d for day, m for month, y for year"
    echo "-d <DELIMITER>"
    echo -e "\t the date delimiter"
    echo "-h, --help"
    echo -e "\t display this message"
}
 
# Argument parsing
while true; do
    case "$1" in
        -h | --help)
               print_usage
                exit 0
                ;;
        -m)
                ONE_MONTH_FLAG=true
                shift
                ;;
        -f)
                # The date format of the birthday
                FMT="$2"
                shift 2
                ;;
        -d)
                # The date delimiter
                DELIM="$2"
                shift 2
                ;;
         *) shift; break
                ;;
    esac
done
 
#===============
# The main work
#===============
 
 
# find out the date segment indices
if [ "$FMT" != "ymd" ]; then
    TEMP=(`echo $FMT | fold -w1`)
    NUM=0
    while [ $NUM -lt ${#TEMP[*]} ]; do
        case "${TEMP[$NUM]}" in
            d)
                BD_DAY="$NUM";;
            m)
                BD_MONTH="$NUM";;
            y)
                BD_YEAR="$NUM";;
            *)
                echo "OMG! Error!"
                exit 2
        esac
        NUM=$(($NUM+1))
    done
fi
 
for BDAY in ${BD_LIST[*]}; do
        INFO_LIST=(`awk 'BEGIN { RS = "###"; FS = "Birthday: " } ($2 ~ "'$BDAY'") { print $1 }' "$CBOOK_DIR"`)
        NAME="${INFO_LIST[0]} ${INFO_LIST[1]}"
        # Decide wether the birthday has already taken place
        TEMP=(`echo $BDAY | tr "$DELIM" "\n"`)
 
        # Print the month-only birthdays first
        if [ $CUR_MONTH -eq ${TEMP[$BD_MONTH]} -a $ONE_MONTH_FLAG ]; then
                if [ $CUR_DAY -le ${TEMP[$BD_DAY]} ]; then
                        echo -e "$BDAY\t$NAME($(($CUR_YEAR - ${TEMP[$BD_YEAR]})))"
                fi
        elif [ $CUR_MONTH -le ${TEMP[$BD_MONTH]} ]; then
                # if were in here, it is this month or some month in the future
                if [ $CUR_DAY -le ${TEMP[$BD_DAY]} ]; then
                        # if we're here, it has not yet passed
                        echo -e "$BDAY\t$NAME($(($CUR_YEAR - ${TEMP[$BD_YEAR]})))"
                fi
        fi
done

Anwendungsbeispiel
Bei Verwendung des Addressbuchs von oben:
$ date +%Y
2011
$ ./cbook_birthdays.sh -f dmy
12.12.9000 Ron Weasley(-6989)

Vorteile

Bei Verwendung kleiner Skripte stellt sich fast keine Problematik bezüglich verschiedenen Formaten. Eine Konversion in andere ist eigentlich immer möglich. Natürlich bedeutet das ein wenig Arbeit, aber das bedeutet nicht dass es unmöglich ist

Dieser Artikel ist nicht in Stein gemeisselt. Die Skripte unterstehen noch einer gewissen Entwicklung. Eine aktuelle Version der Skripte gibt es auf github.

—

Bevor richtig losgelegt werden kann, müssen einige Codecs installiert werden. Verwendet wird in unserem Beispiel Xvid und LAME mp3. Aus Gründen der Kompabilität ist es ratsam, die 32bit-Version von VirtualDub zu verwenden. Nutzer von Windows Vista/7 finden hier weitere Tipps zur Installation von LAME.

So, nun sind die Codecs installiert. Damit sie eingesetzt werden können, muss erstmal Videomaterial an den Start gebracht werden. Also: kkapture starten, eine Demo auswählen und unkomprimiertes Material abspeichern lassen. Falls hier schon Probleme auftreten sollten, die Tipps auf wurstcaptures helfen vielleicht weiter.

Gehen wir davon aus, dass das Aufzeichnen mit kkapture geklappt hat und nun die gerade eben erstellte Folge von .avi-Dateien in VirtualDub geöffnet ist(Open video file… und Append segment…).
wurstcaptures empfiehlt 2-Pass Encodings für eine optimale Qualität mit Xvid, also machen wir uns VirtualDubs Job-System zunutze. Vorher legen wir aber fest, ob das Format verändert werden soll (Video > Filters… > Add > resize, auf Verhältnistreue achten!), oder nur gewisse Teile des Videos im Endergebnis beinhaltet sein sollen (Video > Filters… > Filter in der Liste auswählen > Cropping…).
Anschließend wird der Audio-Codec eingestellt: Audio > Full processing mode und Audio > Compression… > Codec auswählen

Okay, damit haben wir alles eingestellt, was wir brauchen um die beiden Jobs für jeweils den ersten und den zweiten Encoding-Pass einzurichten:

Job 1

• Video > Compression > Xvid auswählen > Configure > Encoding Type: TwoPass – 1st pass
• File > Queue batch operation > Save as AVI file…

Job 2

• Video > Compression > Xvid auswählen > Configure > Encoding Type: TwoPass – 2nd pass
• File > Queue batch operation > Save as AVI file…

Nun kann man per File > Jobs… sich die Jobliste anzeigen lassen, die Abarbeitung starten und sich einen Kaffee holen gehen
Die Größe der Datei lässt sich beeinflussen, indem man Auflösung, Bitrate und Framerate des Videos verändert. Um A/V-Desynchronisation zu vermeiden, kann man die gewünschte Framerate gleich in kkapture festlegen. Es gibt bestimmt auch Wege, dies in VirtualDub zu tun, diese führten beim Autor aber zum Misserfolg

Weiterführendes:
Wer sich mit dem .avi-Containerformat nicht zufriedengeben möchte, ist vielleicht mit VirtualDubMod glücklicher. Dieses unterstützt mehrere Containerformate, darunter auch .mkv
Freunde der Kombination h.264/AAC finden auf wurstcaptures weiterführendes. Wie man merkt, war wurstcaptures eine meiner Hauptquellen
Die Jobs von VirtualDub nehmen einem viel Arbeit ab, sie kann man auch scripten. Ein Tool das dabei hilft, wäre DubMan.

Das fertige Ergebnis sollte folgendermaßen aussehen (In Anlehnung an den rechts dargestellten Baum – die Nummerierung erfolgt von links nach rechts):

[Wurzel] + [Blatt 1, Ebene 1] + [Blatt 1, Ebene 2] + [Blatt 1, Ebene 3]
         |                    |                    ` [Blatt 2, Ebene 3]
         |                    ` [Blatt 2, Ebene 1] + [Blatt 3, Ebene 3]
         |                                         ` [Blatt 4, Ebene 3]
         `[Blatt 2, Ebene 1] + [Blatt 3, Ebene 2] + [Blatt 5, Ebene 3]
                             |                    ` [Blatt 2, Ebene 3]
                              ` [Blatt 2, Ebene 1] + [Blatt 3, Ebene 3]
                                                    ` [Blatt 4, Ebene 3]

Wir zeichnen also bei jeder Verzweigung ein Plus, dann den Namen des Blattes und immer so weiter, bis ein Blatt erreicht ist, dass sich nicht mehr verzweigt. Dann wird eine neue Zeile begonnen und so lange unter jedes Plus ein “|” geschrieben, bis man wieder auf dem Level angelangt ist, zu dem das Blatt gehört. Soweit so gut, ist ja nicht so komplex.

Die Probleme fingen bei mir an, als ich diese Idee in Code umsetzen musste: Ich hatte eine Liste mit Objektinstanzen, aus denen ein Baum generiert werden sollte.

Jedes Objekt hatte drei für die Ausgabe relevante Attribute:

Objekt* child1; //Der Pointer auf das erste Blatt dieser Objektinstanz
Objekt* child2; //Der Pointer auf das zweite Blatt dieser Objektinstanz
string name; // Der Name dieser Objektinstanz
//Die Pointer beziehen sich jeweils auf andere, in der Liste vorhandene Instanzen.

Also hatte ich folgende fixe Idee: Ich baue in das Objekt eine Funktion ein, die mir den String zusammenbastelt und sich, um die Verschachtelung darzustellen, wieder selbst aufruft. Damit muss ich nicht festhalten, welche Information von welchem Blatt nun ausgegeben werden soll. Fassen wir diese Idee in Pseudo-Pseudocode zusammen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# Die Funktion erhält eine Liste, in der jeder Index eine Zeile symbolisiert
# Zeile 1 also Index 0 usw...
def generate_tree (list_of_strings):
 # An die aktuelle Zeile den Namen unseres Blattes dranhängen
 list_of_strings.back().append( name )
 
# Wenn unser Objekt ein Kind hat, dann müssen wir ein 
# Plus dranhängen und die Rekursion anstoßen.
# Die Unterscheidung ob "+" oder "-" ist nicht notwendig, 
# sieht aber am Ende schicker aus:
 if has_child1:
  if has_child2:
   list_of_strings.back().append( "+" )
  else:
   list_of_strings.back().append("-")
 
  # Hiermit starten wir die Rekursion
  # Das Folgende soll einen Memberaufruf symbolisieren :)
  child1.generate_tree( list_of_strings )
 
 if has_child2: # Ein Objekt kann ja bis zu zwei Kinder haben
  buffer = "" #Einen Buffer anlegen
  # Die Position des letzten Plusses rausfinden
  p = list_of_strings.back().find_last_of( "+" ) 
  # Die Position des letzten Strichs rausfinden
  k = list_of_strings.back().find_last_of( "|" ) 
 
  if p < k: #Den höheren Wert der beiden müssen wir nehmen
   p = k
 
# Von 0 bis p in Einerschritten durchgehen
  for i=0 | i <= p | i++
   if i < p:
    if list_of_strings.back()[i] == "+" or list_of_strings.back()[i] == "|":
     buffer.append( "|")
    else:
     buffer.append( " " )
   else if i == p:
    buffer.append( "`" )
 
  list_of_strings.append( buffer )
 
  # Wieder eine Rekursion starten
  # Das ist auch ein Memberaufruf
  child2.generate_tree( list_of_strings )
# ENDE der Funktion

So…diese Zeilen verlangen ein wenig nach Erklärung:
Zeile 1: Wir hängen den Namen des Blattes an das letzte Element in der Liste dran. Es ist egal ob die aktuelle Instanz jetzt Wurzel ist oder nicht. Wichtig ist nur, dass die übergebene Liste nicht leer ist. Dafür muss beim Aufruf der Funktion beim Wurzelelement gesorgt sein.

Zeile 11-15: Hier wird nur unterschieden, ob die aktuelle Instanz ein oder zwei Blätter hat und dementsprechend das Verbindungszeichen gewählt

Zeile 19/20: Hier wird die Funktion generate_tree bei dem ersten Kind aufgerufen, mit Übergabe der auch von dieser Funktion verwendeten Liste. Dadurch ist gewährleistet, dass alle ersten Kinder des jeweils vorhergehenden Blatts in einer Zeile stehen.

Zeile 21: Nun ist die Funktion für das erste Kind durchgelaufen, wenn es ein zweites Kind gibt, wird es nun etwas schwieriger, einen String zusammenzubauen.

Zeile 22-26: Es wird ein Puffer angelegt (er wird am Ende die neue Zeile enthalten, die wir zusammengebaut haben), der Index des letzten Plusses und der Index des letzten senkrechten Striches herausgefunden. Zur Erinnerung: Striche sollten die Verzweigung über mehrere Zeilen hinweg kenntlich machen. Plusse sollten zeigen, dass dieses Blatt mehr als ein Kind hat.

Zeile 28-Ende: Die Zuweisung in Zeile 29 macht nur Sinn, wenn man sich die for-Schleife danach anschaut. Wir gehen jeden einzelnen Index der letzten Zeile in der Liste bis p durch. p ist der Index des letzten Plusses/letzten Striches, je nachdem welcher Index höher ist. Solange i < p gilt, wird unter jeden Strich/jedes Plus ein weiterer Strich gehängt (indem man dieses Zeichen an den Puffer hängt). Haben wir p erreicht, so wird ein “`” an den Puffer gehängt, weil jetzt endlich der Name des zweiten Kindes kommen kann.
Dazu hängen wir den Buffer an die Liste dran (er symbolisiert ja eine neue Zeile) und rufen generate_tree bei dem zweiten Kind auf, mit unserer Liste als Parameter.

—–

Eine Implementierung dieses Algorithmus in C++ könnte folgendermaßen aussehen: *klick*

Die Funktion funktioniert allerdings nur unter zwei Bedingungen:

• Verwendung eines Monospace-Fonts bei der Ausgabe
• Die übergebene Liste ist beim Aufruf der Funktion beim Wurzelelement NICHT leer. Sie muss mindestens einen leeren String enthalten.

Da ich in der nächsten Zeit nicht allzu viel zu tun habe, habe ich beschlossen, den Blog zweisprachig werden zu lassen. Wichtige und große Artikel und Seiten sollen relativ schnell übersetzt werden, kleinere kommen dann irgendwann.

Das Ziel ist, dass der Blog nicht nur deutschsprachigen Menschen weiterhilft, sondern auch den ganzen Rest da draußen erreichen kann. Wir sind ja nicht nur zum Amusement hier