How do I group repeating compositor content with xml stylesheet?

I used muenchian grouping,
which is very well explained here
http://www.jenitennison.com/xslt/grouping/muenchian.xml

Dear Gertone!

Thanks for reply.

Anyway, your solution does work on the sample data I gave, but it does not work in general if you change the values of the elements.

Your solution focus on grouping the values rather than taking the structure into account.

What I am looking for is a solution that will work with the XML Schema structure despite of the actual data content.

I hope you can come up with the brilliant solution on this one too...?

Thanks in advance,
in anticipation,
best regards

Well, I didn't look at the schemata actually,
just at your input data,
yeah, well that doesn't work actually.
I think I now understand what you need,
you could have been a bit more explicit about that,

anyway, I have to think about this, not so straightforward I am afraid
CAn you use XSLT2?

Now that I understand what you want,
I would solve this
- in XSLT2
- or in a two pass XSLT1

Since it is only three elements that need grouping, you could test all conditions,
so an approach could be to iterate over all the elements that can start a new group
That is: one, two that doesn't have a direct preceding sibling one and three that doesn't have a direct preceding sibling one or two
If you need an implementation in XSLT1 having more grouping elements, eg. <four> and <five> I recommend you two make this a two step... I can imagine some more elegant approaches

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
    <xsl:key name="rt" match="rootcanal/*" use="text()"/>
    <xsl:strip-space elements="*"/>
    <xsl:output indent="yes"/>
    <xsl:template match="rootcanal">
        <xsl:copy>
            <xsl:for-each select="one | two[not(preceding-sibling::*[1]/self::one)] | three[not(preceding-sibling::*[1]/self::one)][not(preceding-sibling::*[1]/self::two)]">
                <xsl:element name="group">
                    <xsl:copy-of select="."/>
                    <xsl:if test="self::one">
                        <xsl:if test="following-sibling::*[1]/self::two">
                            <xsl:copy-of select="following-sibling::*[1]"/>
                            <xsl:if test="following-sibling::*[2]/self::three">
                                <xsl:copy-of select="following-sibling::*[2]"/>
                            </xsl:if>
                        </xsl:if>
                        <xsl:if test="following-sibling::*[1]/self::three">
                            <xsl:copy-of select="following-sibling::*[1]"/>
                        </xsl:if>
                    </xsl:if>
                    <xsl:if test="self::two">
                        <xsl:if test="following-sibling::*[1]/self::three">
                            <xsl:copy-of select="following-sibling::*[1]"/>
                        </xsl:if>
                    </xsl:if>
                </xsl:element>
            </xsl:for-each>
        </xsl:copy>
    </xsl:template>
</xsl:stylesheet>

                                              

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:

Dear Gertone!

Thanks for reply.

Yes, I should have made it more clear, that my focus was on the Schema construct rather than the data...

Yes, I need a solution for XSLT 1

And yes, I am looking for a generic solution.

How would you do this in two step in XSLT 1?

Actually constructs like this is quite common in XHTML, but a mess when you want to (re)structure it for database tables or the like...

Thanks a lot.

Regards,

In a more general way
I would walk through the child elements recursively,
passing a parameter containing the "history" and a parameter for current group
based on the current element name and the history you could either keep the group or make a new group
and you copy the element but add an attribute with the group
This way you have selected for each node in which group it belongs

The second pass would be a simple muenchian based on the group attribute

You have now seperated the actual grouping (which changes the structure of the document and could give you some issues with nesting)
from the indicator step that decides which group a node belongs too

In XSLT2, you could easily do that in one step because you can list the new-group-triggers in a for-each-group statement

If you are dealing with nesting XHTML, you need to take into account that a h2 nests deeper than a h1... which is yet another issue.
Doing that in XSLT1 would give you a pipeline of processes to be comfortable. It is a piece of cake in XSLT2
If you are realy nesting HTML, I recommend that you evaluate using XSLT2

I forgot to add one line in my last comment...

so it is not shamefull to make it multipass. I am even convinced that multi-pass is often a best practice when doing complex grouping