xsl-list
[Top] [All Lists]

Re: [xsl] Joining list fragments (was: Handling position in non-atomic sequences)

2020-05-03 05:07:24


On 3 May 2020, at 09:54, gerrit(_dot_)imsieke(_at_)le-tex(_dot_)de 
<xsl-list-service(_at_)lists(_dot_)mulberrytech(_dot_)com> wrote:

This looks like a nested group-starting-with / group-adjacent to me at first 
glance.

My reaction too. Of course the various options on xsl:for-each-group are 
"stereotypes" - they handle 90% of grouping requirements but there are cases 
they can't cope with, and in that case you have to go to lower-level solutions. 
The "window" clause in XQuery is more powerful - perhaps it takes you from the 
90% level to 99%. There's also a small minority of cases where XQuery's "for $x 
at $p in..." can be very valuable. But generally, anything that involves 
manipulating a sequence using integer positions smells of desperation, and 
makes one look hard to see if there isn't some better way.

Michael Kay
Saxonica



Sent from MailDroid <https://goo.gl/ODgwBb>

-----Original Message-----
From: "Michael Müller-Hillebrand mmh(_at_)docufy(_dot_)de" 
<xsl-list-service(_at_)lists(_dot_)mulberrytech(_dot_)com>
To: xsl-list(_at_)lists(_dot_)mulberrytech(_dot_)com
Sent: Sun, 03 May 2020 10:33
Subject: Re: [xsl] Joining list fragments (was: Handling position in 
non-atomic sequences)

Am 02.05.2020 um 13:43 schrieb Michael Kay:

You're talking about a solution, but I don't think you've told us what the 
problem is. What are you trying to achieve?

Fair enough,

sometimes one is so deep wrapping one’s thoughts around a detail problem, 
that the broader picture gets lost.

We want to join list fragments and some content in between them. An HTML-ish 
version of the input looks like this:

      <div>
              <h2 id="E2">Item with content to be joined follows div to 
collect</h2>
              <div>
                      <ol data-meta="listlevel=start">
                              <li>
                                      <p>1st item</p>
                              </li>
                      </ol>
                      <div class="box" data-meta="collect">
                              <p>Hint</p>
                      </div>
                      <ol data-meta="listlevel=continue">
                              <li data-meta="listitem=continue">
                                      <p>Para ff</p>
                              </li>
                              <li>
                                      <p>2nd item</p>
                              </li>
                      </ol>
                      <p>Other arbitrary content</p>
              </div>
      </div>

Every broken list sequence starts with data-meta="listlevel=start" and a list 
or a list item that is supposed to be joined with the start list is marked 
using data-meta="listlevel=continue" and data-meta="listitem=continue". There 
can be any number of collect items between lists and multiple continue lists, 
but it is guaranteed that whatever needs to be collected will end with a 
list. In DTD content model notation: startList, (collectItem*, continueList)+

The lists are not limited to a single level. Gladly, if there is a 
"listitem=continue" in a continue list, it is guaranteed to be at the same 
level the previous list ends.

The task is to add to the last item of the previous list:
* all content marked "collect" between the lists; other content would break 
the process
* content of the next list’s first list item if marked "listitem=continue"
The remaining content of each continue list would be added as additional 
items to the start list.

The desired result for the input data above would look like this:

      <div>
              <h2 id="E2">Item with content to be joined follows div to 
collect</h2>
              <div>
                      <ol data-meta="listlevel=start">
                              <li>
                                      <p>1st item</p>
                                      <div class="box" data-meta="collect">
                                              <p>Hint</p>
                                      </div>
                                      <p>Para ff</p>
                              </li>
                              <li>
                                      <p>2nd item</p>
                              </li>
                      </ol>
                      <p>Other arbitrary content</p>
              </div>
      </div>

All the "collect" content and continue lists are at the same hierarchical 
level as the start list. So my initial strategy was to begin with the start 
list and collect all "valid" siblings (collect, listlevel="continue") by 
walking the following-sibling axis one by one. The result would be a sequence 
of elements that have to be processed into the start list at various 
locations. 

My original question was how to find the position of the next <ol> in that 
sequence to easily use subsequence(). And I got some helpful pointers for 
that (I even looked at xsltfunctions.com <http://xsltfunctions.com/>, but due 
to my xsl:copy-of decision node identity seemed not to be an option), thanks 
a lot!

But currently I am doubting my general strategy and I have the feeling I am 
missing one very obvious thing. The task is basic tree transformation, and my 
current ideas all look very complicated. For the simplified data I cannot yet 
share XSLT code. 

Basically I use a mode to process the continue lists and their items. Within 
each template I add special handling for "continue" content (ignoring the 
elements, just processing their content). For the very last item in each list 
I add rules to process the collect elements. Getting to the content of a <li 
data-meta="listitem=continue"> and making sure it is processed only once is 
where I am stuck at.

Currently I think of putting more effort in the collect phase, e.g. to 
already split continue lists in two parts: the continue item, which is then 
easily processed with the collect items, and the rest of the list, which will 
always be new items or sub-lists.

Pointers if anyone has had success for a problem like this, would be very 
welcome. (And I wonder if I have to deal with position in element sequences 
at all.)

- Michael Müller-Hillebrand

XSL-List info and archive <http://www.mulberrytech.com/xsl/xsl-list>
EasyUnsubscribe <http://lists.mulberrytech.com/unsub/xsl-list/225679> (by 
email <applewebdata://016F98FA-4FB2-4DF1-8029-E3708F1A4438>)
XSL-List info and archive <http://www.mulberrytech.com/xsl/xsl-list>
EasyUnsubscribe <http://lists.mulberrytech.com/unsub/xsl-list/293509> (by 
email <>)
--~----------------------------------------------------------------
XSL-List info and archive: http://www.mulberrytech.com/xsl/xsl-list
EasyUnsubscribe: http://lists.mulberrytech.com/unsub/xsl-list/1167547
or by email: xsl-list-unsub(_at_)lists(_dot_)mulberrytech(_dot_)com
--~--
<Prev in Thread] Current Thread [Next in Thread>