[XSLT] templates recursifs

Version imprimable

Bonjour/bonsoir:

Je suis en train de créer un stylesheet XSL qui me transforme du DocBook/XML en XHTML, plus précisément en des listes embriquées. Mon code actuel est le suivant, mais je voudrais savoir si je peux le reduire avec des appels recursifs aux templates, et si oui, comment?
Genre si je peux passer des paramètres, ca me permettra déjà de le reduire, mais est-ce qu'il y a une autre méthode?

Code:

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
 
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" 
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
    xmlns:db="http://docbook.org/ns/docbook"
    xmlns="http://www.w3.org/1999/xhtml">
    <xsl:output method="xml" encoding="utf-8" indent="yes"    
        doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd" 
        doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN"/>        
 
    <xsl:template match="//db:book">
        <html>
            <head>
                <title>Kujaku[book] - <xsl:value-of select="db:title"/>
                </title>
            </head>
            <body>
                <xsl:if test="db:chapter">              
                <ul class="chapter">                    
                    <xsl:apply-templates select="db:chapter"/>
                </ul>                
                </xsl:if>
            </body>
        </html>
    </xsl:template>
 
    <xsl:template match="//db:article">
        <html>
            <head>
                <title>Kujaku[article] - <xsl:value-of select="db:title"/>
                </title>
            </head>
            <body>
                <xsl:if test="./db:sect1|./db:section">              
                    <ol class="section">                    
                        <xsl:apply-templates select="db:sect1|section"/>
                    </ol>                
                </xsl:if>
            </body>
        </html>
    </xsl:template>
 
    <xsl:template match="db:chapter">
        <li  class="chapter">
            <xsl:value-of select="db:title"/>
            <xsl:if test="./db:sect1|./db:section">              
                <ol class="section">                    
                    <xsl:apply-templates select="db:sect1|db:section"/>
                </ol>                
            </xsl:if>
        </li>
    </xsl:template>
 
    <xsl:template match="db:sect1|db:section">
        <li class="section">
            <xsl:value-of select="db:title"/>
            <xsl:if test="./db:sect2|./db:section">              
                <ol class="subsection">                    
                    <xsl:apply-templates select="db:sect2|db:section"/>
                </ol>                
            </xsl:if>
        </li>
    </xsl:template>    
 
 
    <xsl:template match="db:sect2|//*/*/db:section">
        <li class="subsection">
            <xsl:value-of select="db:title"/>
            <xsl:if test="./db:sect3|./db:section">              
                <ol class="subsubsection">                    
                    <xsl:apply-templates select="db:sect3|db:section"/>
                </ol>                
            </xsl:if>
        </li>
    </xsl:template> 
 
    <xsl:template match="db:sect3|//*/*/*/db:section">
        <li class="subsubsection">
            <xsl:value-of select="db:title"/>
            <xsl:if test="./db:sect4|./db:section">              
                <ol class="subsubsubsection">                    
                    <xsl:apply-templates select="db:sect4|db:section"/>
                </ol>                
            </xsl:if>         
        </li>
    </xsl:template>
 
    <xsl:template match="db:sect4|//*/*/*/*/db:section">
        <li class="subsubsubsection">
            <xsl:value-of select="db:title"/>   
            <xsl:if test="./db:sect5|./db:section">              
                <ol class="subsubsubsubsection">                    
                    <xsl:apply-templates select="db:sect5|db:section"/>
                </ol>                
            </xsl:if>         
        </li>
    </xsl:template>
 
    <xsl:template match="db:sect5|//*/*/*/*/*/db:section">
        <li class="subsubsubsubsection">
            <xsl:value-of select="db:title"/>            
        </li>
    </xsl:template>
</xsl:stylesheet>

Si vous voulez savoir pourquoi je fais un truc aussi fou, c'est pour créer un CMS basé sur DocBook, et ceci constitue l'index du site. Le contenu sera chargé via AJAX si tout va bien.

Mon problème, c'est que je peux avoir soit des éléments "sect1" à "sect5" imbriquées ou des éléments "section" imbriqués. Sans compter que je peux avoir soit une racine "book", soit "set", soit "article". ("book" peut contenir des "chapter" ou "part/chapter", puis "section"/"sect1", "article" contient directement des "section" ou "sect1")

Bonjour,

personnellement je gèrerais cela comme ça :

Code:

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
	<xsl:template match="db:sect1|db:sect2|db:sect3|db:sect4|db:sect5|db:section">
		<xsl:variable name="depth" select="count(ancestor-or-self::db:sect1|ancestor-or-self::deb:sect2|ancestor-or-self::deb:sect3|ancestor-or-self::deb:sect4|ancestor-or-self::deb:sect5|ancestor-or-self::deb:section)"/>
		<li>
			<xsl:attribute name="class">
				<xsl:call-template name="get-class">
					<xsl:with-param name="depth" select="$depth"/>
				</xsl:call-template>
			</xsl:attribute>
			<xsl:value-of select="db:title"/>
			<xsl:if test="db:sect1|db:sect2|db:sect3|db:sect4|db:sect5|db:section">
				<ol>
					<xsl:attribute name="class">
						<xsl:call-template name="get-class">
							<xsl:with-param name="depth" select="$depth + 1"/>
						</xsl:call-template>
					</xsl:attribute>
					<xsl:apply-templates select="db:sect1|db:sect2|db:sect3|db:sect4|db:sect5|db:section"/>
				</ol>				
			</xsl:if>
		</li>
	</xsl:template>
	<xsl:template name="get-class">
		<xsl:param name="depth"/>
		<xsl:choose>
			<xsl:when test="$depth = 1">section</xsl:when>
			<xsl:when test="$depth = 2">subsection</xsl:when>
			<xsl:when test="$depth = 3">subsubsection</xsl:when>
			<xsl:when test="$depth = 4">subsubsubsection</xsl:when>
			<xsl:when test="$depth = 5">subsubsubsubsection</xsl:when>												
		</xsl:choose>
	</xsl:template>

07/12/2006, 00h01
Kurisu

ah, la fonction "count()", j'y avais pas pensé. Merci bien.

Mais ma question sur les templates recursifs subiste néanmoins: est-ce que ca fonctionne? Si oui, comment est-ce que fonctionne, par exemple dans mon cas d'application?
07/12/2006, 07h44
GrandFather

Citation:

Envoyé par Kurisu

Mais ma question sur les templates recursifs subiste néanmoins: est-ce que ca fonctionne? Si oui, comment est-ce que fonctionne, par exemple dans mon cas d'application?

Qu'est-ce que je t'ai proposé, sinon un template récursif ? Et, sauf erreur grossière de ma part, oui ça fonctionne.

De par sa conception XSLT est un langage récursif, je ne saisis donc pas très bien ta question...
08/12/2006, 13h23
Kurisu

en fait, j'avais répondu avant d'avoir vraiment analysé le code, qui fonctionne d'ailleurs vraiment très bien. Donc ma question n'a pas vraiment lieu.