2021 | Mainz

Einführung in X-Technologien

Modellieren, Strukturieren, Repräsentieren

Sektion 4: XSLT

Slides: Link

Max Grüntgens | Dominik Kasper | @digicademy | digicademy | CC-BY 4.0

Table of Contents

1. XSLT allgemein
   1. Erklärung
   2. Use Cases
2. Grundprinzipien
   1. Das XSLT Stylesheet
      1. Stylesheet-Element
      2. Template-Element
   2. Pull-Verarbeitung
      1. Einfache Pull-Verarbeitung mit value-of
      2. Komplexe Pull-Verarbeitung mit Schleifen
   3. Push-Verarbeitung
      1. Rekursion
      2. Hidden Text Template und Identity Transform-Prinzip
3. Spezifischere Funktionalitäten

01

XSLT allgemein

XSLT allgemein

Erklärung

XSLT - eXtensible Stylesheet Language Transformation

XSLT liegt inzwischen in der dritten Version (3.0) vor.

XSLT allgemein

Paradigma

XSLT ist eine deklarative Programmiersprache.

Weitere deklarative Sprachen sind bspw. SQL, SPARQL und Cypher. Die bekannteren deklarativen Sprachen dienen der Daten-Abfrage und -Akquise.

XSLT allgemein

Versionen

• 1999: Version 1.0 wird vorgestellt (Erweiterungen zu 1.1 2006) und enthält grundlegende Funktionalität.
• 2007: Version 2.0 bietet mehr Gestaltungsmöglichkeiten und beseitigt einige Schwächen der ersten Version
• 2017: Version 3.0 bietet mehr Möglichkeiten bei der Konfiguration des XSL-Prozesses sowie bei der Textmanipulation und fügt Möglichkeiten zum Streamen von XML-Dokumente hinzu. Dies ist notwendig, wenn die Quelldatei zu groß für eine Bearbeitung aus dem Hauptspeicher wird. Auch in Anwendungen, wo bereits Daten ausgeliefert werden sollen, bevor das ganze Dokument geladen ist, spielt streaming eine wichtige Rolle.

Hinweis: In den Libraries vieler Programmiersprachen wurde XSLT nur bis einschließlich Version 2.0 implementiert. Eine umfassende Implementierung von XSLT 3.0 existiert nur als Saxon-C für Java, C/C++, PHP und neuerdings auch für Python 3 (hierzu mehr hier und hier).

XSLT allgemein

Use Cases

Transformation von XML-Dokument(en) …

• … in HTML-Dokumente (für eine Website)
• … in andere XML-Dokumente (z. B. von einem projektspezifischen XML in einen speziellen Dialekt wie TEI)

Extraktion von …

• … bestimmten Textinhalten (Knoten) zur Einbettung in einen neuen Dokumenten-Kontext
• … XML-Fragmenten zur Einbettung in einen neuen Dokumenten-Kontext
• … Information aus XML-Dokumenten in Reintext-Dokumente (e.g. Tabellen im CSV-Format)

Hinweis: Extraktionen sind im Grunde Spezialfälle von Transformationen.

02

Grundprinzipien

Grundprinzipien

Das XSLT Stylesheet

Das XSL-Wurzelelement I

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="3.0"></xsl:stylesheet>

Alternativ kann auch das Synonym <xsl:transform> verwendet werden. Die Gründe sind historischer Art.

Wichtig: Ein XSL-Dokument ist stets ein wohlgeformtes XML-Dokument!
Wichtig: Die Angabe des @xmlns:xsl-Namespaces ist obligatorisch!

Das XSLT Stylesheet

Das XSL-Template-Element

xsl:template-Elemente sind Kind-Elemente des xsl:stylesheet-Elements

<xsl:template match="/root" >
    /* Verarbeitet spezifische Knoten via XPath-navigation, e.g. */
    <xsl:value-of select="head/title" />.
    /* Der aktuelle Kontext-Knoten ist "/root". */
</xsl:template>

• Es muss immer mindestens ein xsl:template-Element vorhanden sein, das per XPath-Ausdruck den Einstiegsknoten des XSL-Prozesses im Quelldokument matcht.
• Innerhalb eines xsl:template-Elementes können durch spezifische Kind-Elemente Knoten- und XML-Fragmente kopiert oder weitere Template-Aufrufe gesteuert werden.
• Die verarbeitenden Kind-Elemente innerhalb des xsl:template addressieren ihre Zielbereiche innerhalb der Quelldatei ebenfalls über XPath-Ausdrücke; hierbei wird aber der vom Eltern-Element adressierte Knoten als Kontextknoten angesehen.

Grundprinzipien

Pull-Verarbeitung

Einfache Pullverarbeitung mit xsl:value-of

<xsl:template match="/TEI">
    <document>
        <meta>
            <title>
            <xsl:value-of 1 select="teiHeader/fileDesc/titleStmt/title"2/>
            </title>
        </meta>
        <persons>
            <p>Add the xsl for persons hear.</p>
        </persons>
    </document>
</xsl:template>

• Mit Pull-Verarbeitung bezeichnet man das “Hereinziehen” von 1 Text-Bereichen (xsl:value-of) sowie Knoten- und XML-Fragmenten (xsl:copy-of) aus dem Quelldokument über das XSL-Template in das Ziel-Dokument.
• Innerhalb des 2 @select wird dabei per XPath das Ziel in der Quelldatei angesteuert. An dieser Stelle können auch weitere XPath-Funktionen angebracht werden.

Übung: Bitte öffnen Sie die Dateien Uebungen/Sturm_persList.xml und Uebungen/base_xslt.xsl, kopieren Sie obigen Code an die korrekte Stelle in der Datei und ergänzen Sie den Header-Bereich in document/meta durch weitere Information aus dem TEI-Header der Quelldatei.

Grundprinzipien

Pull-Verarbeitung

Komplexe Pullverarbeitung mit xsl:for-each (Schleifen)

<xsl:template match="/TEI">
    <document>
        <meta>
            <p>Add the xsl for meta information aggregation here.</p>
        </meta>
        <persons>
            <xsl:for-each 1 select="text/body//listPerson/person"2>
                <name><xsl:value-of select="persName"/>3</name>
            </xsl:for-each>
        </persons>
    </document>
</xsl:template>

• Mit 1 xsl:for-each kann per XPath in 2 @select eine Liste an Knoten gesammelt werden, deren einzelne Elemente von den 3 Kind-Elementen des xsl:for-each iteriert und weiterverarbeitet werden.
• Innerhalb des @select können auch weitere XPath-Funktionen angebracht werden.
• xsl:for-each können verschachtelt werden.

Übung: Bitte öffnen Sie die Dateien Uebungen/Sturm_persList.xml und Ressourcen/XSLT/Sturm_persList.xsl und ergänzen Sie den xsl:for-each-Bereich in document/persons durch weitere Information aus der Quelldatei.

Grundprinzipien

Push-Verarbeitung mit Rekursion

<xsl:template match="/TEI">
    <document> <meta> <p>Add the xsl for meta information aggregation here.</p> </meta>
        <persons>
            <xsl:for-each 1 select="text/body//listPerson/person"2>
                <xsl:apply-templates 4 select="."3/>
            </xsl:for-each>
        </persons>
    </document>
</xsl:template>
5<xsl:template 6 match="person" 7> 
    8<record type="person"><xsl:apply-templates 9/></record>
</xsl:template>
5<xsl:template match="persName"> 
    <name><xsl:apply-templates/></name>
</xsl:template>
5<xsl:template match="linkGrp" /> 

• Jeder in 1 xsl:for-each per XPath in 2 @select angesteuerte Knoten, wird nun über das 3 @select="." des Kind-Elementes 4 xsl:apply-templates in die “Template-Rekursion” übergeben.
• Das heißt, dass der XSL-Prozess nun die Liste der 5 folgenden Templates (xsl:template) durchgeht und prüft ob der Xpath-Ausdruck in 6 @match auf den Kontextknoten, im Beispiel 7 person genannt, passt.
• Wenn ein @match erzielt wird, wird der 8 Inhalt des Templates ausgeführt und der aktualisierte Kontext gegebenenfalls wieder per 9 xsl:apply-templates in die Rekursion zurückgespielt.

Übung: Bitte erläutern Sie, 1) warum die Tags person nicht in der Ausgabedatei auftauchen. 2) warum ptr-Tags nicht in der Ausgabedatei auftauchen.
Bitte schreiben Sie weitere Templates, um weitere Informationen in der Ausgabedatei auszugeben.

Grundprinzipien

Hidden Text Template und Identity Transform-Prinzip

XSLT 1.0 & 2.0 verfügen nicht über Konfigurationsmöglichkeiten, die es gestatten, festzulegen, wie mit Knoten umgegangen werden soll, für die kein “matchendes” Template existiert. In diesen Fällen greifen die sogenannten “hidden templates”. Diese führen dazu, dass es bei fehlendem Template-Match immer zu einem Minimal-Output an Text(-knoten) kommt. Alle sonstigen Knoten gehen bei diesem “Notfall-Match” verloren.

Hidden Text Template und Identity Transform-Prinzip

Will man in XSLT 1.0 & 2.0 sämtliche Knoten, für die kein Template definiert wurde, erhalten, muss ein sogenanntes “Identity Transform-Template” eingebunden werden, dessen Regel derart allgemein ist, dass alle Knoten gematcht werden, für die kein spezialisierteres Template existiert.

<xsl:template match="@*|*|processing-instruction()|comment()">
    <xsl:copy>
        <xsl:apply-templates select="*|@*|text()|processing-instruction()|comment()"/>
    </xsl:copy>
</xsl:template>

Oder kürzer (aber weniger explizit):

<xsl:template match="@*|node()">
    <xsl:copy>
        <xsl:apply-templates select="@*|node()"/>
    </xsl:copy>
</xsl:template>

In XSLT 3.0 kann der Umgang mit Knoten, für die es keine matchenden Templates gibt mit xsl:mode und @on-no-match, konfiguriert werden. Siehe zu den verfügbaren Werten hier.

<xsl:stylesheet
    /* Snip */
    version="3.0">
    <xsl:output indent="yes" method="xml"/>
    <xsl:mode on-no-match="shallow-copy"/>
</xsl:stylesheet>

Spezifischere Funktionalitäten

• XPath-Functions
• Variables & Parameters
• Input & Output
• Conditional Flow
• Custom Functions
• Element & Attribute Constructors
• Rawtext Input

XPath-Functions (Auswahl)

In XSLT können die bekannten XPath-Funktionen genutzt werden.

• Zählen & bestimmen: count(), substring(), string-length()
• Prüfen: contains(), matches(), ...
• Negieren: not()
• Austauschen: translate(), replace(), ...
• Konvertieren: string(), number(), ...
• siehe zum Einstieg die IDE-Kurzreferenzen
• Weiterführend: https://www.data2type.de/xml-xslt-xslfo/xslt/xslt-und-xpath-referenz/alphabetische-liste/

Variables & Parameters (1)

In XSLT können innerhalb eines Templates Variablen gesetzt und abgerufen werden. String-Interpolation erfolgt über 1 {$var_name}.

<xsl:template match="commentary">
    <xsl:variable name="ID" select="ancestor::resource/@id"/>
    <div type="commentary" ancestor="{$ID}"1>
        <xsl:apply-templates select="." />
    </div>
</xsl:template>

Variables & Parameters (2)

In XSLT können 1 Variablen und 2 Parameter gesetzt und innerhalb eines Templates abgerufen werden. Parameter können zudem im xsl:apply-templates an nachfolgende Templates übergeben werden. String-Interpolation erfolgt über {$var_name}.

<xsl:template match="commentary">
<xsl:variable 1 name="ID" select="ancestor::resource/@id"/>
    <div type="commentary">
        <xsl:apply-templates select=".">
            <xsl:with-param 3 name="ID" select="$ID"/>
        </xsl:apply-templates>
    </div>
</xsl:template>

<xsl:template match="sup">
<xsl:param 2 name="ID" />
    <hi rend="superscript">
        <ref xml:id="{$ID}" target="#apparatus_{$ID}"><xsl:apply-templates /></ref>
    </hi>
</xsl:template>

Hinweis: Wenn eine xsl:variable per 3 xsl:with-param in der Rekursion weitergereicht wird, muss sie in nachfolgenden Templates mit xsl:param 2 “gefangen” werden, um nutzbar zu sein. Soll sie in der Rekursion weiter verfügbar sein, muss die Variable zudem erneut im xsl:apply-templates-Aufruf per xsl:with-param weitergegeben werden.

Input & Output (2)

Einbinden externer Dateien

Mit der 1 document()-Funktion können über eine URI (Pfad im Dateisystem, URL zu einer Web-Ressource) in den laufenden XSL-Prozess einbezogen werden.

Die per document() eingebundene Datei kann durch weitere Templates und Funktionen weiterverarbeitet werden.

<xsl:template match="person">
    <person>
    <name><xsl:value-of select="persName" /></name>
    <pre>
    <code>
    <xsl:copy-of 1 select="document(concat('https://lobid.org/gnd/',@gnd,'.rdf'))/node()" />
    </code>
    </pre>
    </person>
</xsl:template>

Wichtig: Beim Einbinden und Verarbeiten externer Ressourcen muss darauf geachtet werden, gegebenenfalls neu auftretende Namespaces adäquat zu verarbeiten.

Conditional Flow

In XSLT können einfache und komplexe Conditionals gesetzt werden:

• 1 Einfach: xsl:if; nur if.
• 2 Komplex: xsl:choose; äquivalent zu 3if/4elif/5else

<xsl:template match="person">
    <p class="person">
    1<xsl:if test="@title">
            <span class="title"><xsl:value-of select="@title" /></span>
        </xsl:if>
        <xsl:text> </xsl:text>
        <xsl:apply-templates select="." />
        2<xsl:choose>
            3<xsl:when test="@gender = 'male'">
                <xsl:text> (♂)</xsl:text>
            </xsl:when>
            4<xsl:when test="@gender = 'female'">
                <xsl:text> (♀)</xsl:text>
            </xsl:when>
            5<xsl:otherwise>
                <xsl:text> (?)</xsl:text>
            </xsl:otherwise>
        </xsl:choose>
    </p>
</xsl:template>

Custom Functions

In XSLT können innerhalb eines Templates Funktionen erstellt und aufgerufen werden.

• 1as="xs:string" gibt den Rückgabewert einer Funktion oder den Datentyp einer Parameterdeklaration.
• 2 xsl:sequence ist äquivalent zum Keyword return in anderen Programmiersprachen und gibt das Ergebnis der Funktion zurück.
• Die Funktion muss notwendigerweise mit einem eigenen 3 Namespace deklariert werden.
• Die Funktion wird wie eine “normale” XPath-Funktion aufgerufen.

<xsl:stylesheet
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    …
    3 xmlns:functx="http://www.functx.com" …/>
    …
<xsl:function 3 name="functx:substring-after-match" 1 as="xs:string?">
    <xsl:param name="arg" 1 as="xs:string?"/>
    <xsl:param name="regex" as="xs:string"/>
    2 <xsl:sequence select="replace($arg,concat('^.*?',$regex),'')"/>
</xsl:function>

Siehe auch Artikel auf Data2Type.

Element & Attribute Constructors

Man erstellt …

• 1 Elemente mit <xsl:element name="element_name">
• 2 Attribute mit <xsl:attribute name="attribute_name">
• 4 Elementinhalte und 3 Attributwerte werden als Kind-Elemente der Konstruktor-Elemente notiert.

<xsl:template match="person">
1 <xsl:element name="name">
        2<xsl:attribute name="norm_data">
            3<xsl:value-of select="@gnd"/>
        </xsl:attribute>
        4<xsl:value-of select="persName"/>
    </xsl:element>
</xsl:template>

Rawtext Input

# Headline

I’am a paragraph.

## Second Order Headline

I am a paragraph as well.

• Reintext muss mittels 1 unparsed-text() geladen werden (am besten in eine 2 Variable).
• Danach muss der Reintext-Input meistens in ein Array 3 gesplittet und 4 regelbasiert verarbeitet werden.

Rawtext Input

<xsl:template match="/">
2 <xsl:variable name="rawtext_input" select="unparsed-text('rawtext.md')" 1/>
        <root>
            <xsl:for-each select="tokenize($rawtext_input, '&#xa;')" 3>
                <xsl:variable name="line" select="normalize-space(.)"/>
            4 <xsl:choose>
                    <xsl:when test="starts-with($line, '#')">
                        <xsl:element name="h{string-length(substring-before($line, ' '))}">
                            <xsl:value-of select="normalize-space(substring-after($line, ' '))"/>
                        </xsl:element>
                    </xsl:when>
                    <xsl:when test="$line != ''">
                        <xsl:element name="p">
                            <xsl:value-of select="$line"/>
                        </xsl:element>
                    </xsl:when>
                    <xsl:otherwise/>
                </xsl:choose>
            </xsl:for-each>
        </root>
    </xsl:template>

Output:

<root>
        <h1>Headline</h1>
        <p>I’am a paragraph.</p>
        <h2>Second Order Headline</h2>
        <p>I am a paragraph as well.</p>
    </root>

Literature & Software

Literatur

• Beals, M. H. (2016): Transforming Data for Reuse and Re-publication with XML and XSL, in: The Programming Historian 5 (2016), https://programminghistorian.org/en/lessons/transforming-xml-with-xsl.
• Data2Type:
  • XSLT 1.0 https://www.data2type.de/xml-xslt-xslfo/xslt/xslt-einfuehrung/
  • XSLT 2.0 https://www.data2type.de/xml-xslt-xslfo/xslt/xslt2/
  • XSLT 3.0 https://www.data2type.de/xml-xslt-xslfo/xslt/xslt3/
• Tidwell, Doug (²2009): XSLT, 2nd Edition. Sebastopol. Vorsicht: Dieses Buch behandelt nur die XSLT Versionen 1.0 und 2.0.
• w3schools: https://www.w3schools.com/xml/xsl_intro.asp (Zugriff 14.01.2020).

Download

• Link to presentation
• License: CC-BY 4.0, Author