Noah Bubenhofer: Einführung in die Korpuslinguistik (HTML zu XML)

Weitere Korpora	Daten analysieren
Text zu XML	Daten aufbereiten: Text

Von HTML zu XML

Im vorherigen Kapitel wurde gezeigt, wie strukturierte Textdateien zu XML-Dateien konvertiert werden können. Hier geht es nun darum, HTML-Dokumente in eine bestimmte XML-Struktur zu bringen. HTML ist die wichtigste Auszeichnungssprache im Web. Praktisch alle Webseiten sind in HTML codiert.

Wie bereits verdeutlich, ist HTML genau so eine Auszeichnungssprache wie XML. Es ist deshalb möglich, HTML-Dokumente nach bestimmten Regeln in eine XML-Struktur zu überführen.

Achtung: Dieses Kapitel gehört zu den anspruchsvollsten Kapiteln des ganzen Einführung in die Korpuslinguistik! Trotzdem habe ich mich bemüht, Schritt für Schritt alles genau zu erklären und ich empfehle deswegen auch allen Zaudernden, sich dieses Kapitel zu Gemüte zu führen. Auch wer anschließend nicht unbedingt in der Lage ist, selber XSLT-Stylesheets zu schreiben und anzuwenden, weiß danach wenigstens, was möglich ist und was die Grundgedanken sind.

HTML und XHTML

Allerdings genügt HTML nicht den strengen Syntaxregeln von XML. So müssen beispielsweise öffnende Tags nicht zwingend geschlossen werden:

<p>Hier ist ein Absatz.
<p>Und hier folgt ein zweiter Absatz.

Nach XML-Standard wäre dies nicht wohlgeformt. Um eine XML-kompatible Auszeichnungssprache fürs Web zu haben, wurde XHTML entwickelt. XHTML ist eine Art Übersetzung von HTML, um den Regeln von wohlgeformtem XML zu genügen. Das HTML-Beispiel oben müsste in XHTML lauten:

<p>Hier ist ein Absatz.</p>
<p>Und hier folgt ein zweiter Absatz.</p>

Manchmal sind Webseiten in XHTML codiert, so dass sie im Prinzip direkt weiterverarbeitet werden können. Darauf sollte man sich jedoch nicht verlassen. Deshalb gibt es Programme, die HTML-Dokumente in XHTML übersetzen und dabei auch eine Reihe von gängigen syntaktischen Fehlern, die in HTML-Dokumenten in der freien Wildbahn vorkommen, korrigieren.

Ich empfehle die Verwendung von TagSoup. Es handelt sich dabei um eine Java-Anwendung, die über die Kommandozeile aufgerufen werden muss. Alternativ kann ein XML-Editor wie Oxygen (kommerziell) verwendet werden.

Konvertierung mit TagSoup

Für TagSoup muss Java auf dem Rechner installiert sein. Hier gibt es ausführliche Informationen zur Installation von Java auf verschiedenen Betriebssystemen. Zudem wird TagSoup über die Kommandozeile (Eingeabeaufforderung, Terminal) bedient. Grundlegende Informationen dazu finden sich für den Mac und Unix-Systeme hier, für Windows z.B. hier.

Alle HTML-Dateien, die konvertiert werden sollen, müssen sich in einem Verzeichnis befinden. In unserem Beispiel liegen diese alle im Verzeichnis html/.
Nun muss die TagSoup-Datei mit der Endung .jar aufgerufen werden. Dies geschieht über Programme -> Dienstprogramme -> Terminal (Mac) bzw. Start -> Alle Programme -> Zubehör -> Eingabeaufforderung (Windows). Der Aufruf lautet nun:
```
java -jar <Pfad zum TagSoup-Verzeichnis>/tagsoup-1.2.1.jar --files 
--encoding=utf8 <Pfad zum html-Verzeichnis>/*
```
Um die Pfade nicht eintippen zu müssen, kann man meist die tagsoup-Datei und das html-Verzeichnis auf das Kommandozeilen-Fenster schieben, dann wird der Pfad automatisch an der Stelle des Cursors eingetragen.
Wenn alles gut geht, konvertiert TagSoup nun alle html-Dateien im html-Verzeichnis. Zu jeder Datei gibt es dann zusätzlich eine mit der Endung .xhtml.

Konvertierung mit Oxygen

In Oxygen Editor können HTML-Dateien über das Menü Datei -> Import -> HTML-Datei... importiert werden. Dabei werden sie automatisch in XHTML konvertiert. Anschließend kann die Datei abgespeichert werden. Zudem kann gleich auch in Oxygen das XSLT-Stylesheet erstellt und angewendet werden (siehe Ausführungen dazu unten).

XSLT-Transformation von XHTML zu XML

Nun kommt der eigentliche Schritt der Transformation. Eine wohlgeformte XML-Datei (und XHTML ist XML) kann mittels Transformationsregeln in eine andere XML-Struktur (und andere Formate) konvertiert werden. Die Idee ist diese: Mittels eines Stylesheets werden Regeln der Art definiert:

Für jedes XHTML-Dokument erstelle eine grundlegende XML-Struktur, z.B.:
```
<?xml version="1.0" encoding="UTF-8"?>
<text>
	
</text>
```
Dann hole den Titel des Dokuments, der ist in der XHTML-Datei beispielsweise so ausgezeichnet:
```
<h1 class="entry-title">“Überwachen und Sprache”</h1>
```
Suche also in der XHTML-Datei nach <h1> mit einem class-Attribut namens entry-title. Den Inhalt davon setze in die bestehende XML-Struktur:
```
<?xml version="1.0" encoding="UTF-8"?>
<text>
	<title>
		“Überwachen und Sprache”
	</title>
	
</text>
```
Das wird fortgeführt, bis alle gewünschten Informationen da sind. Der Rest wird ignoriert.

Zuerst muss also die XHTML-Datei analysiert werden, um herauszufinden, wo die gewünschten Informationen stecken. Schauen wir uns ein konkretes Beispiel an:

Wir betrachten uns einen Blog-Artikel aus dem Sprechtakel: "Überwachen und Sprache".
Die von TagSoup prozessierte XHTML-Datei sieht so aus:

Nun müssen wir im Quellcode die Tags finden, die die gewünschten Informationen enthalten. Die relevanten Zeilen sind bereits eingefärbt.
Wir merken uns nun die XHTML-Tags, über die wir die gewünschten Inhalte zu fassen kriegen:
- Zeile 2, Wurzelknoten des Dokuments: Das Element <html> ist der sog. Wurzelknoten, also das in der Hierarchie der Elemente zuoberst stehende Element. Immer wenn wir dieses Element antreffen, beginnt eine Seite mit einem Blog-Artikel.
- Zeile 9, Titel des Blogs: Der Titel steht innerhalb eines <a>-Tags. Natürlich gibt es sehr viele <a>-Tags, deshalb müssen wir das weiter spezifizieren. Dazu können Attribute des <a>-Tags dienen (shape, href, title oder rel). Wir können aber auch schauen, welches das Elternelement von diesem <a> ist: <span> umschließt das <a>-Element. <span>-Tags gibt es ebenfalls sehr viele, zudem trägt dieses überhaupt keine Attribute. Also schauen wir, was davon wiederum Elternelement ist, nämlich <div> mit einem Attribut id. id-Attribute sind sehr gut, da diese eine ID des Elements vergeben, die nur einmal vorkommt. Das Element <div> mit der id = site-title kommt also sicher nur einmal im ganzen Dokument vor. Der Pfad zu unserem gewünschten Inhalt des <a>-Elements lautet also:
```
<div id="site-title"> → <span> → <a>
```
- Zeile 9, URL des Blogs: In der gleichen Zeile steht auch noch die URL des Blogs im <a>-Element, allerdings dort im Attribut href. Der Pfad lautet also:
```
<div id="site-title"> → <span> → <a> → Attribut: href
```
- Zeile 12, Untertitel des Blogs: Der Untertitel wird praktischerweise direkt von einem <div>-Element mit der eindeutigen id = "site-description" umfasst. Der Pfad zum gewünschten Inhalt lautet also:
```
<div id="site-description">
```
- Zeile 36, Titel des Beitrags: Auch beim Titel haben wir leichtes Spiel. Zwar besitzt das <h1>-Element kein id-Attribut, aber ein class-Attribut mit dem eindeutigen Wert entry-title. Dieser Wert könnte zwar nochmals vorkommen, was aber hier nicht der Fall ist. Der Pfad lautet demnach:
```
<h1 class="entry-title">
```
- Zeile 39, Datum: Etwas versteckt im hinteren Teil der Zeile finden wir das Datum des Beitrags in einem <span>-Element mit einem class-Attribut mit eindeutigem Wert:
```
<span class="entry-date">
```
- Zeilen 41 bis 45, Beitragstext: Der eigentliche Beitragstext wird ebenfalls von einem eindeutigen <div>-Element umfasst:
```
<div class="entry-content">
```
Mit diesen Pfadangaben, übersetzt in eine sog. XPath-Sprache, können wir nun ein XSLT-Stylesheet erstellen. Dazu gleich mehr.

Wir schauen uns nun Stück für Stück das XSLT-Stylesheet an, mit dem die oben genannten Informationen aus der XHTML-Datei extrahiert werden können.

Zunächst benötigen wir ein paar Kopfzeilen, die spezifizieren, dass selbst das Stylesheet ein XML-Dokument ist (Zeile 1), aber eine XSLT-Stylesheet ist (Zeile 2) und die Ausgabe der damit zu bearbeitenden XHTML-Datei XML sein soll (Zeile 3):

Wir definieren nun für verschiedene Elemente, die wir in der XHTML-Datei antreffen, Transformationsregeln. Eine solche Regel ist ein sog. "Template" für ein bestimmtes Element (oder eine Gruppe von Elementen). Eine solche Regel wird mit folgender Syntax beschrieben:

Wir beginnen mit dem Wurzelknoten <html> (in der XHTML-Datei in Zeile 2). Immer wenn dieses angetroffen wird, erzeugen wir in unserer XML-Datei ein <text>-Element:

Das Attribut match oben hat den Wert xhtml:html: Es soll also auf das Element <html> zutreffen. Wir müssen zusätzlich noch den sog. Namensraum spezifzieren – es handelt sich alles um xhtml-Elemente. Deswegen steht davor noch xhtml:.

Die Anweisung <xsl:apply-templates/> bedeutet, dass die XHTML-Datei weiter prozessiert werden soll, da unterhalb des html-Knotens ja noch weitere Elemente kommen.

Da wir gerade dabei sind, können wir gleich noch ein paar Metadaten zum Blog holen. Wir modifizieren deshalb das Stylesheet und haben nun Folgendes:

Wir setzen also innerhalb von text noch die Elemente blogtitle, blogtagline und blogurl. Die Inhalte dafür kriegen wir über die XPath-Pfade, die wir oben aufgrund der Analyse der XHTML-Datei bereits gefunden haben:

Zeile 9, Titel des Blogs:
```
<div id="site-title"> → <span> → <a>
```
Als XPath-Ausdruck lautet dieser Pfad:
```
//div[@id='site-title']/span/a
```
Wir suchen also irgendein div (die beiden Schrägstriche davor bedeuten, dass das div irgendwo in der Hierarchie stehen kann), aber mit der Bedingung (in eckigen Klammern), dass das Attribut id den Wert site-title hat. Als Kindelement davon muss ein span-Element kommen, und als Kind davon wiederum ein a-Element. Dessen Inhalt wollen wir haben.
Zeile 9, URL des Blogs:
```
<div id="site-title"> → <span> → <a> → Attribut: href
```
Als XPath-Ausdruck:
```
//div[@id='site-title']/span/a/@href
```
In Ergänzung zum Titel des Blogs wollen wir hier nicht einfach den Textinhalt des a-Elements, sondern von dessen Attribut href (/@href).
Zeile 12, Untertitel des Blogs:
```
<div id="site-description">
```
Als XPath-Ausdruck:
```
//div[@id='site-description']
```
Hier wollen wir also irgendein div-Element, dessen Attribut id den Wert site-description haben soll.

Genau diese XPath-Ausdrücke verwenden wir nun in drei XSLT-Ausdrücken der Art:

Um wiederum den XHTML-Namensraum explizit zu benennen, setzen wir in den XPath-Ausdrücken vor jedem Elementnamen noch xhtml: hin, so dass alles komplett folgendermaßen aussieht:

Nun definieren wir weitere Templates. Als Nächstes definieren wir ein Template, das den eigentlichen Textinhalt des Blogs finden und in ein content-XML-Element setzen soll:

Der XPath-Ausdruck sucht also nach einem beliebigen div-Element mit einer Attribut class, die den Wert entry-content beinhaltet. Mit <xsl:apply-templates/> geben wir an, dass hier noch kein Elementinhalt eingesetzt werden soll, sondern die XHTML-Datei einfach weiter prozessiert werden soll (da ja noch weitere Elemente innerhalb des div kommen).

In diesem Zusammenhang definieren wir gleich noch ein Template für p-Elemente, die auch in unserem XML-Dokument als p-Elemente gekennzeichnet sein sollen:

Beachte: Wir nehmen nur p-Elemente, die ein Elternelement div mit den bereits gekannten Einschränkungen (class = 'entry-content'). Mit <xsl:value-of select="."/> sagen wir, dass, wenn ein solches p-Element gefunden wird, genau dessen Inhalt (Punkt als XPath-Ausdruck) verwendet werden soll. Zusätzlich benutzen wir noch die XPath-Funktion normalize-space(), mit der allfälliger überflüssiger Leerraum entfernt wird.

Jetzt holen wir noch den Titel des Blogeintrags:

Eine kleine Besonderheit gibt es mit dem Datum. Im Prinzip können wir das einfach holen:

Unschön dabei ist, dass wir es dann im Format "1. Januar 2014" haben. Deshalb wollen wir das etwas umformatieren und schreiben dazu ein eigenes Template. Um dies zu verstehen, benötigt man etwas Programmier-Kenntnisse – ich zeige es mal in der kommentierten Version unten und erkläre es nur andeutungsweise:

Dieses Template nimmt ein beliebiges Datum im Format "1. Januar 2014" auf (Zeile 72), zerlegt es in die Komponenten Tag, Monat und Jahr (Zeilen 77-87), ändert den Monat in eine Zahl um (Zeilen 93-106) und gibt das Datum neu formatiert zurück: 2014-01-01.

Wir können nun im Template, das die Datumsangabe findet, dieses Template "FormatDate" aufrufen:

Damit haben wir alle benötigten Regeln beisammen. Hier finden sich die Dateien zum Download:

Das komplette Stylesheet extractWordpress.xsl.
Drei XHTML-Testdateien:

Mit dem XSL-Stylesheet können die XHTML-Dateien nun mit einem XSL-Parser transferiert werden. Dafür gibt es mehrere Möglichkeiten:

XML-Editor Oxygen: XHTML-Datei öffnen, dann Dokument -> Transformation -> Transformationszenarien konfigurieren: XSLT-Stylesheet laden und dann Transformation anwenden.
jEdit: Plugin "XSLT" installieren (über Plugins-Manager -> Install); dann Menü Plugins -> XSLT -> XSLT-Prozessor: Hier Quelldokument (XHTML) und Stylesheet angeben und unten auf den Knopf "Transform XML" klicken.
Unter Mac OS X und Unix ist meist der Prozessor xsltproc bereits vorinstalliert. Bedienung über das Terminal:
```
xsltproc <XSLT-Datei> <XHTML-Datei>
```
Saxon XSLT-Prozessor, basiert auf Java und muss auch über das Terminal verwendet werden.
Light GUI XSLT Processor auf Java-Basis
Zu Testzwecken ein Online-XSLT-Prozessor verwenden, z.B.:

Die XHTML-Datei Testdatei1.xhtml wird mittels des XSLT-Stylesheet oben in folgende XML-Datei überführt:

Text zu XML	Daten aufbereiten: Text
Weitere Korpora	Daten analysieren

Das Copyright dieses Kurses liegt bei Noah Bubenhofer. Bei Zitaten oder Verweisen darauf, freut der Autor sich über eine Mitteilung. Ebenso bei Fehlern und anderen Hinweisen!
Diese elektronische Ressource soll wie folgt zitiert werden: Bubenhofer, Noah (2006-2024): Einführung in die Korpuslinguistik: Praktische Grundlagen und Werkzeuge. Elektronische Ressource: http://www.bubenhofer.com/korpuslinguistik/.