XSLT 1.0 - Grouper par liste de noeuds identiques

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : XSLT 1.0 - Grouper par liste de noeuds identiques

fred_53

Bonjour,

J'ai un fichier XML ayant la structure suivante :

<order>
<version>
<version_name>ABO</version_name>
<sequence>
<sequence_name>ABOPAL</sequence_name>
<hopper number="0" id="11">CV</hopper>
<hopper number="1" id="12">INT</hopper>
<hopper number="2" id="13">ENC</hopper>
</sequence>
<sequence>
<sequence_name>ABOCAR</sequence_name>
<hopper number="0" id="11">CV</hopper>
<hopper number="1" id="12">INT</hopper>
<hopper number="2" id="13">ENC</hopper>
</sequence>
</version>
<version>
<version_name>GEN</version_name>
<sequence>
<sequence_name>GENPAL</sequence_name>
<hopper number="0" id="11">CV</hopper>
<hopper number="1" id="12">INT</hopper>
<hopper number="2" id="13">ENC</hopper>
</sequence>
<sequence>
<sequence_name>ABOCAR</sequence_name>
<hopper number="0" id="11">CV</hopper>
<hopper number="1" id="12">INT</hopper>
<hopper number="2" id=""></hopper>
</sequence>
</version>
</order>

Dans mon order, j'ai donc 2 versions, et dans chaque version, j'ai 2 séquences, contenant des hoppers numérotés associés ou non à des id.

Dans l'exemple ci-dessus, les 3 premières séquences sont identiques (mêmes id en face de chaque numéro de hopper).

Je souhaite grouper tout cela par séquence identique (même combinaison de hoppers), pour obtenir le résultat suivant :

<order>
<sequence>
<version>ABO</version>
<version>GEN</version>
<sequence_name>ABOPAL</sequence_name>
<sequence_name>ABOCAR</sequence_name>
<sequence_name>GENPAL</sequence_name>
<hopper number="0" id="11">CV</hopper>
<hopper number="1" id="12">INT</hopper>
<hopper number="2" id="13">ENC</hopper>
</sequence>
<sequence>
<version>GEN</version>
<sequence_name>GENCAR</sequence_name>
<hopper number="0" id="11">CV</hopper>
<hopper number="1" id="12">INT</hopper>
<hopper number="2" id=""></hopper>
</sequence>
</order>

J'ai trouvé des infos sur la page http://www.jenitennison.com/xslt/g [...] nchian.xml pour grouper à l'aide d'une clé correspondant à un champ du XML,
mais dans mon cas, la clé devrait être une liste de noeuds (les hoppers).

Quelqu'un a-t'il une idée sur la façon de procéder pour y arriver ?

Publicité

gilou

Modérateur
Modosaurus Rex

Si je pige bien, c'est la liste des hopper d'une sequence qui est ta clé.

Code :

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet  
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  exclude-result-prefixes="#all"
  version="3.0">
  
  <xsl:output indent="true"/>
  
  <xsl:template match="/">
    <xsl:apply-templates/>
  </xsl:template>
  
  <xsl:template match="order">
    <order>
      <xsl:for-each-group select="version/sequence" group-by="string-join(tail(*)!string(), '-')">
        <xsl:variable name ="versions" as="xs:string*">
          <xsl:for-each select="current-group()">
            <xsl:sequence select="preceding-sibling::version_name/data()"/>
          </xsl:for-each>
        </xsl:variable>
        <xsl:variable name ="sequence_names" as="xs:string*">
          <xsl:for-each select="current-group()">
            <xsl:sequence select="sequence_name/data()"/>
          </xsl:for-each>
        </xsl:variable>
        <sequence>
          <xsl:for-each select="distinct-values($versions)">
            <version><xsl:value-of select="current()"/></version>
          </xsl:for-each>
          <xsl:for-each select="distinct-values($sequence_names)">
            <sequence_name><xsl:value-of select="current()"/></sequence_name>
          </xsl:for-each>
          <xsl:copy-of select="head(current-group())/hopper"/>
        </sequence>
      </xsl:for-each-group>
    </order>
  </xsl:template>
  
</xsl:stylesheet>

Sur tes données, ça donne en sortie

Code :

<?xml version="1.0" encoding="UTF-8"?>
<order>
   <sequence>
      <version>ABO</version>
      <version>GEN</version>
      <sequence_name>ABOPAL</sequence_name>
      <sequence_name>ABOCAR</sequence_name>
      <sequence_name>GENPAL</sequence_name>
      <hopper number="0" id="11">CV</hopper>
      <hopper number="1" id="12">INT</hopper>
      <hopper number="2" id="13">ENC</hopper>
   </sequence>
   <sequence>
      <version>GEN</version>
      <sequence_name>ABOCAR</sequence_name>
      <hopper number="0" id="11">CV</hopper>
      <hopper number="1" id="12">INT</hopper>
      <hopper number="2" id=""/>
   </sequence>
</order>

J'ai mis version="3.0" mais ça marche aussi en xsl 2.0
J'ai regroupé les éléments sequence sur une clé composite obtenue en concaténant les contenus des hoppers et en séparant avec des - ce qui fait une bonne clé de tri des sequences :
string-join(tail(*)!string(), '-') ça construit la clé ainsi : tail(*) pour virer le premier fils de sequence, qui n'est pas un hopper, ça me fait la liste des hoppers, tail(*)!string() ça me fait la liste de leurs contenus, et le reste est explicite.

Et si tu veux trier en sortie les versions et/ou sequence_name, tu remplace le/les <xsl:for-each select="distinct-values(...)"> par <xsl:for-each select="sort(distinct-values(...))">

Bon, si on veut faire ça en xslt 1.0 c'est plus coton (programmer en xslt 1.0 de nos jours, c'est comme utiliser windows 95 comme OS, bref c'est obsolète et complètement dépassé). Tu as pas d'autre possibilité? parce que ça, avec la version Home Edition (gratuite) de Saxon, ça marche.

Sinon, il faudra que tu fasses du multi-passe avec des modes distincts, et transformation de ton arbre.
Bref, tu transformes tes données initiales avec la clé composite explicitement ajoutée à la main (technique à la Schwartzian transform du Perl)

Code :

<?xml version="1.0" encoding="UTF-8"?>
<order>
    <sequence>
      <key>CV-INT-ENC</key>
      <version_name>ABO</version_name>
      <sequence_name>ABOPAL</sequence_name>
      <hopper number="0" id="11">CV</hopper>
      <hopper number="1" id="12">INT</hopper>
      <hopper number="2" id="13">ENC</hopper>
    </sequence>
    <sequence>
      <key>CV-INT-ENC</key>
      <version_name>ABO</version_name>
      <sequence_name>ABOCAR</sequence_name>
      <hopper number="0" id="11">CV</hopper>
      <hopper number="1" id="12">INT</hopper>
      <hopper number="2" id="13">ENC</hopper>
    </sequence>
    <sequence>
      <key>CV-INT-ENC</key>
      <version_name>GEN</version_name>
      <sequence_name>GENPAL</sequence_name>
      <hopper number="0" id="11">CV</hopper>
      <hopper number="1" id="12">INT</hopper>
      <hopper number="2" id="13">ENC</hopper>
    </sequence>
    <sequence>
      <key>CV-INT-</key>
      <version_name>GEN</version_name>
      <sequence_name>ABOCAR</sequence_name>
      <hopper number="0" id="11">CV</hopper>
      <hopper number="1" id="12">INT</hopper>
      <hopper number="2" id=""/>
    </sequence>
</order>

et une seconde passe pour générer tes données regroupées par clé (mais ça va être encore du boulot pour ne pas avoir des entrées version ou sequence_name dupliquées, il faudra peut être trois passes. Bon, de toute façon, je touche plus au xslt 1.0, faut être maso pour en faire quand on voit tout ce qui a été apporté par les versions 2.0 et 3.0 et qu'il y a un outil gratuit qui le fait pour un usage perso).

A+,

Message édité par gilou le 30-05-2019 à 12:59:40

---------------
There's more than what can be linked! -- Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- No jab ? No job ! -- (╯°□°)╯︵ ┻━┻

fred_53

Merci pour les exemples et explications.
C'est pour un usage pro avec un logiciel qui utilise PrintXML 8.1, donc je suis bloqué en version 1.0, et je ne peux par corriger le XML (même à la main, car c'est pour un usage régulier d'impression en PDF).
Quand tu parles de multi-passes, c'est possible avec un seul fichier XSL, ou il faut générer des fichiers XML intermédiaires ? (Dans ce cas, ça me paraît difficile avec PrintXML)

Message cité 1 fois

gilou

Modérateur
Modosaurus Rex

fred_53 a écrit :

Tu parles de PrinceXML je suppose. PrinceXML il imprime du XML, donc ce qui a généré le XML, il s'en fiche à priori.
Mais manifestement, tu as un outil obsolète en amont (surtout que PrinceXML, il est en 12.5 actuellement. Je ne sais pas quel est ton outil Pro, mais ça fait pas sérieux, ça).
Rien ne vaut un exemple pour expliciter la technique:

Code :

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet  
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  version="1.0">
  
  <xsl:output indent="true"/>
  
  <xsl:template match="/">
    <xsl:variable name="pass1">
      <xsl:apply-templates select="." mode="toto"/>
    </xsl:variable>
    <xsl:apply-templates select="$pass1" mode="titi"/>
  </xsl:template>  
  
  <xsl:template match="*" mode="toto">
    <xsl:element name="{concat('TOTO-', local-name())}">
      <xsl:apply-templates select="@*|node()" mode="toto"/>
    </xsl:element>
  </xsl:template>
  
  <xsl:template match="@*" mode="toto">
    <xsl:copy/>
  </xsl:template>
  
  <xsl:template match="*" mode="titi">
    <xsl:copy>
      <xsl:apply-templates select="@*|node()" mode="titi"/>
    </xsl:copy>
  </xsl:template>
  
  <xsl:template match="@*" mode="titi">
    <xsl:attribute name="{concat(local-name(), '-TITI')}">
      <xsl:copy/>
    </xsl:attribute>
  </xsl:template>
  
</xsl:stylesheet>

Le premier mode, toto, va rajouter TOTO- a tous les noms d'éléments.
Le second mode, titi, va rajouter -TITI à tous les noms d'attributs.
On applique le premier mode aux données initiales, et on stocke le résultat dans une variable, ici, pass1.
On applique le second mode au résultat de la transformation précédente, ie pass1.
Et au final on a le résultat des deux transformations successives.

Après, au prix d'un peu de mémoire et de temps d'exécution, on peut factoriser pour rendre le traitement des passes homogène :

Code :

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet  
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  version="1.0">
  
  <xsl:output indent="true"/>
  
  <xsl:template match="/">
    <xsl:variable name="pass1">
      <xsl:apply-templates select="." mode="toto"/>
    </xsl:variable>
    <xsl:variable name="pass2">
      <xsl:apply-templates select="$pass1" mode="titi"/>
    </xsl:variable>
    <xsl:apply-templates select="$pass2" mode="identity"/>
  </xsl:template>  
  
  <xsl:template match="*" mode="toto">
    <xsl:element name="{concat('TOTO-', local-name())}">
      <xsl:apply-templates select="@*|node()" mode="toto"/>
    </xsl:element>
  </xsl:template>
  
  <xsl:template match="@*" mode="toto">
    <xsl:copy/>
  </xsl:template>
  
  <xsl:template match="*" mode="titi">
    <xsl:copy>
      <xsl:apply-templates select="@*|node()" mode="titi"/>
    </xsl:copy>
  </xsl:template>
  
  <xsl:template match="@*" mode="titi">
    <xsl:attribute name="{concat(local-name(), '-TITI')}">
      <xsl:copy/>
    </xsl:attribute>
  </xsl:template>
  
  <xsl:template match="/|@*|*" mode="identity">
    <xsl:copy>
      <xsl:apply-templates select="@*|node()" mode="identity"/>
    </xsl:copy>
  </xsl:template>
  
</xsl:stylesheet>

A+,

Message édité par gilou le 03-06-2019 à 12:31:18

---------------
There's more than what can be linked! -- Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- No jab ? No job ! -- (╯°□°)╯︵ ┻━┻

gilou

Modérateur
Modosaurus Rex

Et au final tu obtiens un truc de ce genre:

Code :

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet  
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  version="1.0">
  
  <xsl:output indent="true"/>
  <xsl:strip-space elements="*"/>
  
  <xsl:template match="/">
    <xsl:variable name="pass1">
      <xsl:apply-templates select="." mode="pass1"/>
    </xsl:variable>
    <xsl:variable name="pass2">
      <xsl:apply-templates select="$pass1" mode="pass2"/>
    </xsl:variable>
    <xsl:variable name="pass3">
      <xsl:apply-templates select="$pass2" mode="pass3"/>
    </xsl:variable>
    <xsl:variable name="pass4">
      <xsl:apply-templates select="$pass3" mode="pass4"/>
    </xsl:variable>
    <xsl:apply-templates select="$pass4" mode="pass5"/>
  </xsl:template>  
  
  <!-- copie par défaut -->
  <xsl:template match="/|@*|*" mode="pass1">
    <xsl:copy>
      <xsl:apply-templates select="@*|node()" mode="pass1"/>
    </xsl:copy>
  </xsl:template>
  
  <xsl:template match="/|@*|*" mode="pass2">
    <xsl:copy>
      <xsl:apply-templates select="@*|node()" mode="pass2"/>
    </xsl:copy>
  </xsl:template>
  
  <xsl:template match="/|@*|*" mode="pass3">
    <xsl:copy>
      <xsl:apply-templates select="@*|node()" mode="pass3"/>
    </xsl:copy>
  </xsl:template>
  
  <xsl:template match="/|@*|*" mode="pass4">
    <xsl:copy>
      <xsl:apply-templates select="@*|node()" mode="pass4"/>
    </xsl:copy>
  </xsl:template>
  
  <xsl:template match="/|@*|*" mode="pass5">
    <xsl:copy>
      <xsl:apply-templates select="@*|node()" mode="pass5"/>
    </xsl:copy>
  </xsl:template>
  
  <!-- =================================================== -->
  
  <xsl:template match="version" mode="pass1">
    <xsl:apply-templates select="*|@*" mode="pass1"/>
  </xsl:template>
  
  <xsl:template match="version_name" mode="pass1"/>
  
  <xsl:template match="sequence" mode="pass1">
    <xsl:copy>
      <xsl:apply-templates select="@*" mode="pass1"/>
      <xsl:variable name="key">
        <xsl:for-each select="hopper">
          <xsl:value-of select="current()"/>
          <xsl:value-of select="'~'"/>
        </xsl:for-each>
      </xsl:variable>
      <xsl:element name="sort-key">
        <xsl:value-of select="$key"/>
      </xsl:element>  
      <xsl:copy-of select="preceding-sibling::version_name[1]"/>
      <xsl:apply-templates select="node()" mode="pass1"/>
    </xsl:copy>
  </xsl:template>
  
  <!-- =================================================== -->
  
  <xsl:template match="order" mode="pass2">
    <xsl:copy>
      <xsl:apply-templates select="sequence" mode="pass2">
        <xsl:sort select="sort-key"/>
      </xsl:apply-templates>
    </xsl:copy>
  </xsl:template>
  
  <xsl:template match="version_name" mode="pass2">
    <xsl:element name="version">
      <xsl:apply-templates select="@*|node()" mode="pass2"/>
    </xsl:element>
  </xsl:template>
  
  <!-- =================================================== -->

  <xsl:template match="sequence[string(sort-key) != string(preceding-sibling::sequence[1]/sort-key)]" mode="pass3">
    <xsl:copy>
      <xsl:apply-templates select="@*|node()" mode="pass3"/>
      <xsl:apply-templates select="following-sibling::sequence[string(sort-key) = string(current()/sort-key)]" mode="pass3.1"/>
    </xsl:copy>
  </xsl:template>
  
  <xsl:template match="sequence[string(sort-key) = string(preceding-sibling::sequence[1]/sort-key)]" mode="pass3"/>
  
  <xsl:template match="sequence" mode="pass3.1">
    <xsl:apply-templates select="version" mode="pass3"/>
    <xsl:apply-templates select="sequence_name" mode="pass3"/>
  </xsl:template>
  
  <xsl:template match="sort-key" mode="pass3"/>

  <!-- =================================================== -->
  
  <xsl:template match="sequence" mode="pass4">
    <xsl:copy>
      <xsl:apply-templates select="version" mode="pass4">
        <xsl:sort select="string(.)"/>
      </xsl:apply-templates>
      <xsl:apply-templates select="sequence_name" mode="pass4">
        <xsl:sort select="string(.)"/>
      </xsl:apply-templates>
      <xsl:apply-templates select="hopper" mode="pass4"/>
    </xsl:copy>
  </xsl:template>
  
  <!-- =================================================== -->
  
  <xsl:template match="version[string()=string(preceding-sibling::version[1])]" mode="pass5"/>
    
  <xsl:template match="sequence_name[string()=string(preceding-sibling::sequence_name[1])]" mode="pass5"/>
  
</xsl:stylesheet>

qui fait le taff (testé en live sur tes données avec Oxygen).

L'étape 1 calcule la clé identifiant les suite de hopper identiques et l'ajoute comme élément sort-key à chaque séquence
L'étape 2 trie les sequences par sort-key
L'étape 3 traite les sequences de même sort-keys (donc successifs) en différenciant le traitement du premier de la suite de celui des suivants
L'étape 4 ordonne les version et sequence_name d'une même sequence pour pouvoir virer les doublons à l'étape 5.

Mais c'est bien lourd comparé à du xsl moderne qui fait ça en une seule template et le mode par défaut:

Code :

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet  
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  exclude-result-prefixes="#all"
  version="3.0">
  
  <xsl:output indent="true"/>
  
  <xsl:template match="/">
    <order>
      <xsl:for-each-group select="order/version/sequence" group-by="string-join(tail(*)!string(), '~')">
        <xsl:variable name ="versions" as="xs:string*">
          <xsl:for-each select="current-group()">
            <xsl:sequence select="preceding-sibling::version_name/data()"/>
          </xsl:for-each>
        </xsl:variable>
        <xsl:variable name ="sequence_names" as="xs:string*">
          <xsl:for-each select="current-group()">
            <xsl:sequence select="sequence_name/data()"/>
          </xsl:for-each>
        </xsl:variable>
        <sequence>
          <xsl:for-each select="distinct-values($versions)">
            <version><xsl:value-of select="current()"/></version>
          </xsl:for-each>
          <xsl:for-each select="distinct-values($sequence_names)">
            <sequence_name><xsl:value-of select="current()"/></sequence_name>
          </xsl:for-each>
          <xsl:copy-of select="head(current-group())/hopper"/>
        </sequence>
      </xsl:for-each-group>
    </order>
  </xsl:template>
  
</xsl:stylesheet>

Note finale, si je choisis ~ comme séparateur des constituants des clés de tri, c'est parce que sa valeur ascii est inférieure à celle des chiffres et lettres, et que ça convient donc mieux pour ne pas perturber un tri lexicographique.

A+,

Message édité par gilou le 01-06-2019 à 17:50:40

---------------
There's more than what can be linked! -- Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- No jab ? No job ! -- (╯°□°)╯︵ ┻━┻

fred_53

Oui il s'agit bien de PrinceXML.

J'ai testé ton code dans Oxygen XML Editor 10.3 et dans Notepad++ 7.6.3/XML Tools 2.4.11.0, et j'ai obtenu respectivement les erreurs suivantes :

E: [Saxon6.5.5] indent must be yes or no or an integer

Unable to apply transformation on current source. Make sure that XSL is valid.

Si je remplace true par yes dans <xsl:output indent="yes"/>, j'ai alors les erreurs suivantes :

E [Saxon6.5.5] Cannot process a result tree fragment as a node-set under XSLT 1.0

The transformation has generated empty document.

Est-ce du à ma version d'Oxygen et de Notepad++ ?

gilou

Modérateur
Modosaurus Rex

La version de Saxon utilisée dans Oxygen (qui est en version 21 de nos jours, tandis que Saxon est en 9.9...).
Il faut transformer les paramètres passés a chaque passe (des arbres résultant de la transfo d'une passe) en node-set. En xsl 2.0 avec la notion de sequence, ce problème n'existe plus.

Avec ce code, ça marche (on peut encore poser saxon6.5.5 comme processeur xsl dans Oxygen 20):

Code :

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:exsl="http://exslt.org/common"
version="1.0">
<xsl:output indent="yes"/>
<xsl:strip-space elements="*"/>
<xsl:template match="/">
<xsl:variable name="pass1">
<xsl:apply-templates select="." mode="pass1"/>
</xsl:variable>
<xsl:variable name="pass2">
<xsl:apply-templates select="exsl:node-set($pass1)" mode="pass2"/>
</xsl:variable>
<xsl:variable name="pass3">
<xsl:apply-templates select="exsl:node-set($pass2)" mode="pass3"/>
</xsl:variable>
<xsl:variable name="pass4">
<xsl:apply-templates select="exsl:node-set($pass3)" mode="pass4"/>
</xsl:variable>
<xsl:apply-templates select="exsl:node-set($pass4)" mode="pass5"/>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass1">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass1"/>
</xsl:copy>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass2">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass2"/>
</xsl:copy>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass3">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass3"/>
</xsl:copy>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass4">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass4"/>
</xsl:copy>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass5">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass5"/>
</xsl:copy>
</xsl:template>
<xsl:template match="version" mode="pass1">
<xsl:apply-templates select="*|@*" mode="pass1"/>
</xsl:template>
<xsl:template match="version_name" mode="pass1"/>
<xsl:template match="sequence" mode="pass1">
<xsl:copy>
<xsl:apply-templates select="@*" mode="pass1"/>
<xsl:variable name="key">
<xsl:for-each select="hopper">
<xsl:value-of select="current()"/>
<xsl:value-of select="'~'"/>
</xsl:for-each>
</xsl:variable>
<xsl:element name="sort-key">
<xsl:value-of select="$key"/>
</xsl:element>
<xsl:copy-of select="preceding-sibling::version_name[1]"/>
<xsl:apply-templates select="node()" mode="pass1"/>
</xsl:copy>
</xsl:template>
<xsl:template match="order" mode="pass2">
<xsl:copy>
<xsl:apply-templates select="sequence" mode="pass2">
<xsl:sort select="sort-key"/>
</xsl:apply-templates>
</xsl:copy>
</xsl:template>
<xsl:template match="version_name" mode="pass2">
<xsl:element name="version">
<xsl:apply-templates select="@*|node()" mode="pass2"/>
</xsl:element>
</xsl:template>
<xsl:template match="sequence[string(sort-key) != string(preceding-sibling::sequence[1]/sort-key)]" mode="pass3">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass3"/>
<xsl:apply-templates select="following-sibling::sequence[string(sort-key) = string(current()/sort-key)]" mode="pass3.1"/>
</xsl:copy>
</xsl:template>
<xsl:template match="sequence[string(sort-key) = string(preceding-sibling::sequence[1]/sort-key)]" mode="pass3"/>
<xsl:template match="sequence" mode="pass3.1">
<xsl:apply-templates select="version" mode="pass3"/>
<xsl:apply-templates select="sequence_name" mode="pass3"/>
</xsl:template>
<xsl:template match="sort-key" mode="pass3"/>
<xsl:template match="sequence" mode="pass4">
<xsl:copy>
<xsl:apply-templates select="version" mode="pass4">
<xsl:sort select="string(.)"/>
</xsl:apply-templates>
<xsl:apply-templates select="sequence_name" mode="pass4">
<xsl:sort select="string(.)"/>
</xsl:apply-templates>
<xsl:apply-templates select="hopper" mode="pass4"/>
</xsl:copy>
</xsl:template>
<xsl:template match="version[string()=string(preceding-sibling::version[1])]" mode="pass5"/>
<xsl:template match="sequence_name[string()=string(preceding-sibling::sequence_name[1])]" mode="pass5"/>
</xsl:stylesheet>

A+,

Message édité par gilou le 04-06-2019 à 15:09:46

---------------
There's more than what can be linked! -- Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- No jab ? No job ! -- (╯°□°)╯︵ ┻━┻

fred_53

Merci beaucoup, cela fonctionne dans Oxygen.

Il faut maintenant que je regarde comme j'intègre cela dans mon fichier XSL, car il doit se présenter sous la forme suivante :

Code :

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template name="myTemplate">
<xsl:for-each select="/order/sequence">
...
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>

gilou

Modérateur
Modosaurus Rex

Code :

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:exsl="http://exslt.org/common"
version="1.0">
<xsl:output indent="yes"/>
<xsl:strip-space elements="*"/>
<!-- Pour tester, car un template nommé doit être appellé
<xsl:template match="/">
<xsl:call-template name="myTemplate"/>
</xsl:template>
-->
<xsl:template name="myTemplate">
<xsl:variable name="pass1">
<xsl:apply-templates select="/" mode="pass1"/>
</xsl:variable>
<xsl:variable name="pass2">
<xsl:apply-templates select="exsl:node-set($pass1)" mode="pass2"/>
</xsl:variable>
<xsl:variable name="pass3">
<xsl:apply-templates select="exsl:node-set($pass2)" mode="pass3"/>
</xsl:variable>
<xsl:variable name="pass4">
<xsl:apply-templates select="exsl:node-set($pass3)" mode="pass4"/>
</xsl:variable>
<xsl:apply-templates select="exsl:node-set($pass4)" mode="pass5"/>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass1">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass1"/>
</xsl:copy>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass2">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass2"/>
</xsl:copy>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass3">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass3"/>
</xsl:copy>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass4">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass4"/>
</xsl:copy>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass5">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass5"/>
</xsl:copy>
</xsl:template>
<xsl:template match="version" mode="pass1">
<xsl:apply-templates select="*|@*" mode="pass1"/>
</xsl:template>
<xsl:template match="version_name" mode="pass1"/>
<xsl:template match="sequence" mode="pass1">
<xsl:copy>
<xsl:apply-templates select="@*" mode="pass1"/>
<xsl:variable name="key">
<xsl:for-each select="hopper">
<xsl:value-of select="current()"/>
<xsl:value-of select="'~'"/>
</xsl:for-each>
</xsl:variable>
<xsl:element name="sort-key">
<xsl:value-of select="$key"/>
</xsl:element>
<xsl:copy-of select="preceding-sibling::version_name[1]"/>
<xsl:apply-templates select="node()" mode="pass1"/>
</xsl:copy>
</xsl:template>
<xsl:template match="order" mode="pass2">
<xsl:copy>
<xsl:apply-templates select="sequence" mode="pass2">
<xsl:sort select="sort-key"/>
</xsl:apply-templates>
</xsl:copy>
</xsl:template>
<xsl:template match="version_name" mode="pass2">
<xsl:element name="version">
<xsl:apply-templates select="@*|node()" mode="pass2"/>
</xsl:element>
</xsl:template>
<xsl:template match="sequence[string(sort-key) != string(preceding-sibling::sequence[1]/sort-key)]" mode="pass3">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass3"/>
<xsl:apply-templates select="following-sibling::sequence[string(sort-key) = string(current()/sort-key)]" mode="pass3.1"/>
</xsl:copy>
</xsl:template>
<xsl:template match="sequence[string(sort-key) = string(preceding-sibling::sequence[1]/sort-key)]" mode="pass3"/>
<xsl:template match="sequence" mode="pass3.1">
<xsl:apply-templates select="version" mode="pass3"/>
<xsl:apply-templates select="sequence_name" mode="pass3"/>
</xsl:template>
<xsl:template match="sort-key" mode="pass3"/>
<xsl:template match="sequence" mode="pass4">
<xsl:copy>
<xsl:apply-templates select="version" mode="pass4">
<xsl:sort select="string(.)"/>
</xsl:apply-templates>
<xsl:apply-templates select="sequence_name" mode="pass4">
<xsl:sort select="string(.)"/>
</xsl:apply-templates>
<xsl:apply-templates select="hopper" mode="pass4"/>
</xsl:copy>
</xsl:template>
<xsl:template match="version[string()=string(preceding-sibling::version[1])]" mode="pass5"/>
<xsl:template match="sequence_name[string()=string(preceding-sibling::sequence_name[1])]" mode="pass5"/>
</xsl:stylesheet>

Je suppose qu'il y a quelque chose qui fait le call <xsl:call-template name="myTemplate"/> ailleurs dans ton outil.

A+,

Message édité par gilou le 07-06-2019 à 18:18:11

---------------
There's more than what can be linked! -- Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- No jab ? No job ! -- (╯°□°)╯︵ ┻━┻

gilou

Modérateur
Modosaurus Rex

Une version équivalente mais qui évite d'avoir une passe 3 avec une sous passe et est un peu plus facile à suivre dans sa construction.

Code :

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:exsl="http://exslt.org/common"
exclude-result-prefixes="xs exsl"
version="1.0">
<xsl:output indent="yes"/>
<xsl:strip-space elements="*"/>
<!--<xsl:template match="/">
<xsl:call-template name="myTemplate"/>
</xsl:template>-->
<xsl:template name="myTemplate">
<xsl:variable name="pass1">
<xsl:apply-templates select="/" mode="pass1"/>
</xsl:variable>
<xsl:variable name="pass2">
<xsl:apply-templates select="exsl:node-set($pass1)" mode="pass2"/>
</xsl:variable>
<xsl:variable name="pass3">
<xsl:apply-templates select="exsl:node-set($pass2)" mode="pass3"/>
</xsl:variable>
<xsl:variable name="pass4">
<xsl:apply-templates select="exsl:node-set($pass3)" mode="pass4"/>
</xsl:variable>
<xsl:variable name="pass5">
<xsl:apply-templates select="exsl:node-set($pass4)" mode="pass5"/>
</xsl:variable>
<xsl:apply-templates select="exsl:node-set($pass5)" mode="pass6"/>
</xsl:template>
<xsl:template match="/|@*|*" mode="identity">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="identity"/>
</xsl:copy>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass1">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass1"/>
</xsl:copy>
</xsl:template>
<xsl:template match="order" mode="pass1">
<xsl:copy>
<xsl:apply-templates mode="pass1"/>
</xsl:copy>
</xsl:template>
<xsl:template match="version" mode="pass1">
<xsl:apply-templates select="sequence" mode="pass1">
<xsl:with-param name="version-name" select="string(version_name)"/>
</xsl:apply-templates>
</xsl:template>
<xsl:template match="sequence" mode="pass1">
<xsl:param name="version-name"/>
<xsl:copy>
<sort-key>
<xsl:for-each select="hopper">
<xsl:if test="position()!=1 and string(.)!=''">
<xsl:value-of select="'-'"/>
</xsl:if>
<xsl:value-of select="string(.)"/>
</xsl:for-each>
</sort-key>
<version><xsl:value-of select="$version-name"/></version>
<xsl:apply-templates mode="identity"/>
</xsl:copy>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass2">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass2"/>
</xsl:copy>
</xsl:template>
<xsl:template match="order" mode="pass2">
<xsl:copy>
<sort-keys>
<xsl:for-each select="sequence/sort-key">
<xsl:sort select="."/>
<sort-key><xsl:value-of select="."/></sort-key>
</xsl:for-each>
</sort-keys>
<xsl:apply-templates mode="identity"/>
</xsl:copy>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass3">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass3"/>
</xsl:copy>
</xsl:template>
<xsl:template match="order" mode="pass3">
<xsl:copy>
<xsl:apply-templates select="sort-keys" mode="pass3"/>
<xsl:apply-templates select="sequence" mode="identity"/>
</xsl:copy>
</xsl:template>
<xsl:template match="sort-keys" mode="pass3">
<xsl:copy>
<xsl:apply-templates mode="pass3"/>
</xsl:copy>
</xsl:template>
<xsl:template match="sort-key" mode="pass3">
<xsl:choose>
<xsl:when test="string(.)=string(preceding-sibling::sort-key[1])"/>
<xsl:otherwise>
<xsl:apply-templates select="." mode="identity"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass4">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass4"/>
</xsl:copy>
</xsl:template>
<xsl:template match="order" mode="pass4">
<xsl:copy>
<xsl:for-each select="sort-keys/sort-key">
<xsl:variable name="key-value" select="string(.)"/>
<sequences>
<xsl:for-each select="/order/sequence[string(sort-key)=$key-value]">
<xsl:apply-templates select="." mode="identity"/>
</xsl:for-each>
</sequences>
</xsl:for-each>
</xsl:copy>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass5">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass5"/>
</xsl:copy>
</xsl:template>
<xsl:template match="sequences" mode="pass5">
<sequence>
<xsl:apply-templates select="sequence/sequence_name" mode="pass5">
<xsl:sort select="string(.)"/>
</xsl:apply-templates>
<xsl:apply-templates select="sequence/version" mode="pass5">
<xsl:sort select="string(.)"/>
</xsl:apply-templates>
<xsl:apply-templates select="sequence[1]/hopper" mode="pass5"/>
</sequence>
</xsl:template>
<xsl:template match="/|@*|*" mode="pass6">
<xsl:copy>
<xsl:apply-templates select="@*|node()" mode="pass6"/>
</xsl:copy>
</xsl:template>
<xsl:template match="version[string()=string(preceding-sibling::version[1])]" mode="pass6"/>
<xsl:template match="sequence_name[string()=string(preceding-sibling::sequence_name[1])]" mode="pass6"/>
</xsl:stylesheet>

A+,

---------------
There's more than what can be linked! -- Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- No jab ? No job ! -- (╯°□°)╯︵ ┻━┻

Publicité

fred_53

Oui, le template est appelé par un autre fichier XSL.

Encore merci pour le code, j'en ferai bon usage.

FORUM HardWare.fr

Programmation

XML/XSL

XSLT 1.0 - Grouper par liste de noeuds identiques

Sujets relatifs
actualiser donnée database via liste deroulante ajax	[résolu] liste A dans B, modifier A modifie B ?
Aide vba word choix dans une liste	Supprimer un doublon dans une liste python
liste des feuilles d'un fichier excel	Perl - Tableau associatif et liste
copier tuple dans liste	Création d'une liste en SQL
Liste de record et lecture des valeurs	pile et liste chainée
Plus de sujets relatifs à : XSLT 1.0 - Grouper par liste de noeuds identiques

Page générée en 0.193 secondes