[XSLT] transformation XML d'un fichier ant

**fornorst** · 27/10/2005, 17h02

Bonjour à tous,

mon chef m'a demandé de développer un petit fichier xsl pour rendre lisible par l'humain un fichier utilisé lors de l'appel à ant (compilation, tests unitaires et fonctionnels, résolution des dépendances, .... en gros ce fichier fait pas mal de choses

). Ce fichier ressemble à celà :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
<?xml version="1.0"?>
<dependencies module="moduleATraiter" version="4-6-3" moduleType="proprietaire" hasConflict="no">
   <ModuleList>
      <module name="dependance1" version="1-2-0" moduleType="proprietaire" level="4" isUsed="yes" id="mod1">
         <deliverables>
            <deliverable name="dependance1.jar" id="dep1_0"/>
         </deliverables>
      </module>
      <module name="dependance2" version="4-6-3" moduleType="proprietaire" level="3" isUsed="yes" id="mod0">
         <deliverables>
         </deliverables>
      </module>
      <module name="dependance3" version="1-13-0" moduleType="proprietaire" level="2" isUsed="yes" id="mod2">
         <deliverables>
            <deliverable name="dependance3.jar" id="dep2_0"/>
         </deliverables>
      </module>
      <module name="dependance4" version="5-1-1" moduleType="libExterne" level="1" isUsed="yes" id="mod3">
         <deliverables>
            <deliverable name="dependance4_0_5-1-1.jar" id="dep3_0"/>
            <deliverable name="dependance'_0_mock_5-1-1.jar" id="dep3_1"/>
         </deliverables>
      </module>
   </ModuleList>
</dependencies>

pour produire un fichier de ce type :

This is the head dependencies for this module : moduleATraiter
in version 4-6-3
----------------------------------------------------------------------------------------------------
dependencies on module : dependance4, version 5-1-1, at level 1
----------------------------------------------------------------------------------------------------
dependencies on module : dependance3, version 1-13-0, at level 2
----------------------------------------------------------------------------------------------------
dependencies on module : dependance2, version 4-6-3, at level 3
----------------------------------------------------------------------------------------------------
dependencies on module : dependance1, version 1-2-0, at level 4
----------------------------------------------------------------------------------------------------
[/code]

Grosso modo, il s'agit de récupérer les niveaux de dépendance d'un composant (défini par l'attribut level de l'élément module) et de présenter toutes les dépendances en fonction de leur niveau. Chaque niveau sera représenté par une couleur particulière (pas aléatoire : on a plus de 250 composants et on aimerait bien que les utilisateurs aient l'habitude que le bleu symbolise le premier niveau de dépendances, le rouge le second, ... (couleur à titre complètement indicatif).
Premier point de difficulté : on ne connait pas le nombre de niveau de dépendances d'un composant à l'avance. Ce nombre n'est connu que pendant le traitement xslt (en gros on n'a pas d'infos clair dans l'arbre qui nous donnerait levelMax).

J'ai essayé quelques solutions assez crades histoire de fournir une première version fonctionnelle (qui appelle un template qui match module pour les level 0 puis 1 puis 2 puis 3 puis 4 puis 5 -> si il y a plus de 5 niveaux de dépendances, ce qui est quelquefois le cas, les autres niveaux ne sont pas affichés ). Petite info, ce fichier xsl n'est pas interprété par un quelconque navigateur mais par Xalan en version 2-5-1 afin de produire un fichier html pour chaque composant et de les mettre à disposition sur un serveur.

Quelqu'un aurait-il la gentillesse de me donner un coup de main sur mon problème ? Je débute avec le xsl (bien que j'ai lu plusieurs fois le doc w3c et fureté pas mal de sites web) et j'ai beaucoup de mal avec les langages fonctionnels (pas de vrais variables ni de fonctions qui retournent un résultat !!).

Merci d'avance.

**fornorst** · 27/10/2005, 17h37

Actuellement, j'ai un code comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="html" indent="yes" encoding="UTF-8"/>
<xsl:template match="/">
<html>
  <head>
     This is the head
  </head>
  <body>
	    <xsl:apply-templates select="dependencies"/>
  </body>
</html>
</xsl:template>
 
<xsl:template match="dependencies">
   dependencies for this  module : <xsl:value-of select="@module"/> <br/>
                    in version <xsl:value-of select="@version"/> <br/>
      <xsl:apply-templates select="ModuleList"/>
</xsl:template>
 
<xsl:template match="ModuleList">
 
   <xsl:apply-templates select="module">
      <xsl:sort data-type="number" order="ascending" select="@level"/>
   </xsl:apply-templates> 
 
</xsl:template>
 
 
<xsl:template match="module">
 
   mon level : <xsl:value-of select="@level"/>
   next level : <xsl:value-of select="following-sibling::module[@level][@level]"/>
 
</xsl:template>

Pour le moment, l'algo auquel je pense est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
   . lecture et affichage des infos du tag dependencies
   . appel au template qui match ModuleList
   . Tri ascendant de ses fils (les éléments module)
   . appel au template qui match les modules
   . vérification que le level du module actuel :
      -> si identique au précédent alors je l'écris bêtement (encore que la gestion des couleurs me pose toujours problème, ne connaissant pas le nombre de level à l'avance donc pas le nombre de couleurs donc j'ai besoin)
      -> si différent alors faire un premier traitement (ex : saut de ligne, écriture d'un ligne de caractères '-' ou '.', ....) puis faire le traitement générique, à savoir l'écriture bête et méchante de mon élément module

Le problème est au niveau de la comparaison du level courant avec le level de l'élément précédent : je ne peux pas récupérer le level du précédent. j'obtiens ça comme fichier résultat :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
This is the head dependencies for this module : moduleATraiter
in version 4-6-3
mon level : 1 next level :
mon level : 2 next level :
mon level : 3 next level :
mon level : 4 next level :

**GrandFather** · 27/10/2005, 18h16

Bonjour,

je déduis de la description de ton algorithme que tu peux avoir, pour un <dependancies> donné, plusieurs <module> avec le même level. Il faut donc regrouper les module avec le même level.

Le regroupement avec XSLT 1.0 s'effectue généralement, avec la méthode Muench (elle est très fréquemment évoquée dans ce forum).
Ca devrait donner quelque chose dans le genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="html" indent="yes" encoding="UTF-8"/>
 
	<xsl:key name="modules" match="module" use="@level"/>
 
	<xsl:template match="/">
		<html>
			<head>
				<title>This is the head</title>
			</head>
			<body>
				<xsl:apply-templates select="dependencies"/>
			</body>
		</html>
	</xsl:template>
 
	<xsl:template match="dependencies">
		<p>dependencies for this  module : <xsl:value-of select="@module"/> <br/> 
                    in version <xsl:value-of select="@version"/></p> <br/> 
		 <xsl:apply-templates select="ModuleList"/> 
	</xsl:template>
 
	<xsl:template match="ModuleList">
		<xsl:for-each select="module[generate-id(.) = generate-id(key('modules', @level)[1])]">
			<xsl:sort data-type="number" select="@level"/>
			<xsl:apply-templates select="key('modules', @level)"/>
		</xsl:for-each>
	</xsl:template>
 
	<xsl:template match="module">
	    dependencies on module : <xsl:value-of select="@name"/>, version <xsl:value-of select="@version"/>, at level <xsl:value-of select="@level"/><br/> 
 
	</xsl:template>
 
</xsl:stylesheet>

La partie un peu difficile du code est le select du for-each, qui permet de faire une itération sur tous les niveaux des modules, sans doublons.

**fornorst** · 28/10/2005, 08h50

Tout à fait : il est possible (et même presque tout le temps le cas) que le fichier comporte plusieurs modules de même level. Celà s'explique, au level 1, par le fait qu'un composant possède plusieurs dépendances directes. Ainsi, si le composant dont on traite le fichier de déppendances dispose de 5 dépendances directes, le fichier comportera, dans <ModuleList>, 5 modules de level 1.
Par souci de simplifications, j'ai omis de mettre la fin du fichier. En effet, en, plus de l'élément <ModuleList>, ce fichier comporte beaucoup d'autres informations comme les dépendances pour la compilation, pour les tests, les dépendances sur les Mock Object (objets servant à simuler des objets ou des univers complexes lors de tests unitaires), ...

Merci donc pour ta solution qui me fait faire un pas en avant dans ma recherche de solution. Il me reste maintenant à analyser ton code pour être capable d'ajouter des lignes de séparation lors du changement de level et en profiter pour englober chaque level dans un tag html <span> pour modifier la couleur, la taille du texte, .... Si tu as des idées de comment faire celà, je suis bien évidemment preneur. Encore merci pour ton aide.

**GrandFather** · 28/10/2005, 11h09

J'aurais pu effectivement le préciser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
   <xsl:template match="ModuleList"> 
      <xsl:for-each select="module[generate-id(.) = generate-id(key('modules', @level)[1])]"> 
         <xsl:sort data-type="number" select="@level"/>
         <!-- Place ici ligne de séparation, tout ce qui doit être affiché à chaque changement de level -->
        <span...>  
           <xsl:apply-templates select="key('modules', @level)"/> 
        </span>
      </xsl:for-each> 
   </xsl:template>

**fornorst** · 28/10/2005, 11h35

merci pour la réponse. J'avais compris comment ça marchait et j'avais pu avancé.
par contre, je suis à nouveau bloqué (le xsl et moi, c'est pas encore ça. Langage sympa et bien pratique mais pas évident de rentrer dedans). J'aimerai que chaque level ait une couleur spécifique. Pour ne pas coder en dur les couleurs de n premiers niveaux (solution pas trop difficile à réaliser mais relativement crade), j'aimerai faire un truc du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
   . créer une variable levelColor
      . récupérer le level
      . si inférieur à 10 alors levelColor = concat(0,level)
      . si supérieur à 10 alors levelColor = level
   . pour chaque module que j'affiche utiliser une balse <span style="color: #00$levelColor00"

Mon code ressemble donc à ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
...
<xsl:template match="module">
   <xsl:variable name="levelColor">
       <xsl:choose>
	  <xsl:when test="level &lt; 10">
	     <xsl:value-of select="concat(0,level)"/>
	  </xsl:when>
	  <xsl:when test="level >= 10">
	     <xsl:value-of select="level"/>
	  </xsl:when>
      </xsl:choose>
   </xsl:variable>      
   <span style="color: #00<xsl:value-of select="$levelColor"/>00; background-color: #FFFFFF">
         dependencies on module : <xsl:value-of select="@name"/>, version <xsl:value-of select="@version"/><br/>
         <xsl:apply-templates select="deliverables"/>
      </span>
   </xsl:template>
...

Ce qui bien évidemment ne marche pas. J'ai essayé pas mal de choses (remplacement des caractères spéciaux type '<' par '<', appel uniquement à $levelColor, ...) mais rien ne marche. J'arrive bien à initialiser la variable levelColor (je l'affiche bien pour mes tests) mais impossible de l'utiliser comme je le souhaiterai.

Aurais-tu une solution ?

**GrandFather** · 28/10/2005, 16h41

Il y a deux problèmes dans ton code :

1) level est un attribut de <module>, et l'axe XPath attribute doit être spécifié (il l'est ici sous sa forme abrégée @) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
   <xsl:variable name="levelColor"> 
       <xsl:choose> 
     <xsl:when test="@level &lt; 10"> 
        <xsl:value-of select="concat(0,@level)"/> 
     </xsl:when> 
     <xsl:when test="@level &gt;= 10"> 
        <xsl:value-of select="@level"/> 
     </xsl:when> 
      </xsl:choose> 
   </xsl:variable>

2) L'insertion d'expressions XPath dans des attributs d'éléments non XSLT se fait en les entourant d'accolades :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

<span style="color: #00{$levelColor}00; background-color: #FFFFFF">

**fornorst** · 28/10/2005, 17h52

Merci de toutes tes réponses, j'ai réussi à réaliser le fichier xsl voulu. Pour info et au cas où ça intéresse des gens, voici la version (pas encore) optimisé en terme de nombre de ligne (beaucoup de choses pourraient être factorisés et le seront dès lundi

)
Pour information, j'ai modifié le nom de mon entreprtise par "org", ce qui donne des adresses Web un peu "bizarre" (org.net

), mais j'y suis contraint pour raison de confidentialité. Néanmoins, il m'apparait intéressant de mettre mon code à disposition pour les gens, comme moi, qui débutent en xsl et aiment bien avoir des exemples de code plus complexes et plus applicatifs que ceux proposés dans les tutoriaux (que je ne critique pas , très loin de là.)
Si vous avez des remarques ou des suggestions à faire sur ce code, ne vous gênez surtout pas. Toute remarque est bonne à prendre quand on découvre un langage !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
   <xsl:output method="html" indent="yes" encoding="UTF-8"/>
 
   <xsl:key name="modules" match="module" use="@level"/>
 
   <xsl:template match="/">
 
            <xsl:apply-templates select="dependencies"/>
 
   </xsl:template>
 
   <xsl:template match="dependencies">
      <html>
         <head>
            <title>Summary for module <xsl:value-of select="@module"/>_<xsl:value-of select="@version"/></title>
         </head>
         <body>
            <a name="top"></a><h1><xsl:value-of select="@module"/>_<xsl:value-of select="@version"/></h1>
             <xsl:apply-templates select="ModuleList" mode="tableOfContent"/>
	     <xsl:apply-templates select="ModuleList" mode="orgContent"/>
             <p align="right"><a href="#top">Top</a></p>
	     <hr/>
	     <xsl:apply-templates select="ModuleList" mode="extContent"/>
	     <p align="right"><a href="#top">Top</a></p>
	 </body>
      </html>
   </xsl:template>
 
   <xsl:template match="ModuleList" mode="tableOfContent">
      <font size="+1">Table of content</font><br/>
      <xsl:for-each select="module[generate-id(.) = generate-id(key('modules', @level)[1])]">
         <xsl:sort data-type="number" select="@level"/>
	        <a href="#Level{@level}">Level <xsl:value-of select="@level"/></a><br/>
      </xsl:for-each>
             <a href="#LevelExt">External Dependencies</a><br/>
      <br/><hr/>
   </xsl:template>
 
   <xsl:template match="ModuleList" mode="extContent">
      <span style="color: #000000; background-color: #FFFFFF">
         <a name="LevelExt"> </a><b><font size="+2" color="#9966FF">External Dependencies</font></b>
      </span><br/>
      <table border="1" bordercolor="#9966FF">
      <colgroup>
         <col width="250"/>
         <col width="80"/>
         <col width="300"/>
	 <col width="120"/>
	 <col width="120"/>
      </colgroup>
      <tr bgcolor="#9966FF">
	 <th><span style="color : #FFFFFF; font-weight : bolder;">Module</span></th>
	 <th><font color="#FFFFFF">Version</font></th>
	 <th><font color="#FFFFFF">Dependencies</font></th>
	 <th><font color="#FFFFFF">Documentation</font></th>
	 <th><font color="#FFFFFF">Twiki</font></th>
      </tr>	 
      <xsl:for-each select="module[generate-id(.) = generate-id(key('modules', @level)[1])]">
         <xsl:sort data-type="number" select="@level"/>	 
         <xsl:apply-templates select="key('modules', @level)" mode="extContent"/>
      </xsl:for-each>
      </table>
   </xsl:template>
 
   <xsl:template match="ModuleList" mode="orgContent">
      <xsl:for-each select="module[generate-id(.) = generate-id(key('modules', @level)[1])]">
         <xsl:sort data-type="number" select="@level"/>
	 <span style="color: #000000; background-color: #FFFFFF">
	    <a name="Level{@level}"> </a><b><font size="+2" color="#9966FF">Level <xsl:value-of select="@level"/></font></b>
	 </span><br/>
	 <table border="1" bordercolor="#9966FF">
	 <colgroup>
            <col width="250"/>
            <col width="80"/>
            <col width="300"/>
	    <col width="120"/>
	    <col width="120"/>
         </colgroup>
	 <tr bgcolor="#9966FF">
	    <th><span style="color : #FFFFFF; font-weight : bolder;">Module</span></th>
	    <th><font color="#FFFFFF">Version</font></th>
	    <th><font color="#FFFFFF">Dependencies</font></th>
	    <th><font color="#FFFFFF">Documentation</font></th>
	    <th><font color="#FFFFFF">Twiki</font></th>
	 </tr>	 
         <xsl:apply-templates select="key('modules', @level)" mode="orgContent"/>
	 </table>
	 <br/><br/>
      </xsl:for-each>
   </xsl:template>
 
   <xsl:template match="module" mode="orgContent"> 
      <xsl:variable name="Docs">http://docs.org.net/MTAdminDocumentation/DOCS/Components</xsl:variable> 
      <xsl:variable name="Twiki">https://phoenix.org.net/data/corp/rdteam/twiki/bin/view/RDteam/ComponentsList</xsl:variable> 
      <xsl:variable name="index">index.html</xsl:variable>
      <xsl:variable name="versionSeparator">-</xsl:variable>
      <xsl:if test="not(starts-with(@name,'ext'))">
         <tr color="#000000" bgcolor="#CCCCFF">
            <td><xsl:value-of select="@name"/></td> 
	    <td><xsl:value-of select="@version"/></td>
            <td><xsl:apply-templates select="deliverables"/></td>
	    <xsl:choose>
	       <xsl:when test="string-length(@version) != 0">
	          <xsl:variable name="ModuleDoc">
	             <xsl:value-of select="$Docs"/>/<xsl:value-of select="@name"/>/<xsl:value-of select="substring-before(@version,$versionSeparator)"/>/<xsl:value-of select="substring-before(substring-after(@version,$versionSeparator),$versionSeparator)"/>/<xsl:value-of select="$index"/>
	          </xsl:variable>
	          <xsl:variable name="ModuleTwiki">
		        <xsl:value-of select="$Twiki"/>#<xsl:value-of select="@name"/>
		     </xsl:variable>
	          <td align="center">
	             <a href="{$ModuleDoc}">
	                Documentation
	             </a>
	          </td>
	          <td align="center">
	             <a href="{$ModuleTwiki}">
		        Twiki
		     </a>
	          </td>
	       </xsl:when>
	       <xsl:otherwise>
	          <td colspan="2"><font color="red">Incorrect version of the component.</font></td>
	       </xsl:otherwise>
	    </xsl:choose>
         </tr>
      </xsl:if>  
   </xsl:template>
 
   <xsl:template match="module" mode="extContent"> 
      <xsl:variable name="Docs">http://docs.org.net/MTAdminDocumentation/DOCS/Components</xsl:variable> 
      <xsl:variable name="Twiki">https://phoenix.org.net/data/corp/rdteam/twiki/bin/view/RDteam/ComponentsList</xsl:variable> 
      <xsl:variable name="index">index.html</xsl:variable>
      <xsl:variable name="versionSeparator">-</xsl:variable>
      <xsl:if test="starts-with(@name,'ext')">
         <tr color="#000000" bgcolor="#CCCCFF">
            <td><xsl:value-of select="@name"/></td> 
	    <td><xsl:value-of select="@version"/></td>
            <td><xsl:apply-templates select="deliverables"/></td>
	    <xsl:choose>
	       <xsl:when test="string-length(@version) != 0">
	          <xsl:variable name="ModuleDoc">
	             <xsl:value-of select="$Docs"/>/<xsl:value-of select="@name"/>/<xsl:value-of select="substring-before(@version,$versionSeparator)"/>/<xsl:value-of select="substring-before(substring-after(@version,$versionSeparator),$versionSeparator)"/>/<xsl:value-of select="$index"/>
	          </xsl:variable>
	          <xsl:variable name="ModuleTwiki">
		        <xsl:value-of select="$Twiki"/>#<xsl:value-of select="@name"/>
		     </xsl:variable>
	          <td align="center">
		     <xsl:choose>
		        <xsl:when test="string-length(substring-after(substring-after(@version,$versionSeparator),$versionSeparator)) != 0">
		           <a href="{$ModuleDoc}">
	                      Documentation
	                   </a>  
		        </xsl:when>
	                <xsl:otherwise>
	                   <font color="red">A valid version need 3 digits</font>
	                </xsl:otherwise>
	             </xsl:choose>
		  </td>
	          <td align="center">
	             <a href="{$ModuleTwiki}">
		        Twiki
		     </a>
	          </td>
	       </xsl:when>
	       <xsl:otherwise>
	          <td colspan="2"><font color="red">Incorrect version of the component.</font></td>
	       </xsl:otherwise>
	    </xsl:choose>
         </tr>
      </xsl:if>  
   </xsl:template>
 
 
   <xsl:template match="deliverables">
      <xsl:for-each select="deliverable">
	 - <xsl:value-of select="@name"/><br/>
      </xsl:for-each>
   </xsl:template>
</xsl:stylesheet>

[XSLT] transformation XML d'un fichier ant

XSL/XSLT/XPATH XML

Vue hybride

Discussions similaires

Partager

Partager