Выбор предыдущих двоюродных братьев и сестер (включая братьев и сестер)

Я не могу придумать простое выражение, мне интересно, реализует ли следующий код, использующий path и xsl:evaluate, это требование:

<?xml version = "1.0" encoding = "utf-8"?>
<xsl:stylesheet xmlns:xsl = "http://www.w3.org/1999/XSL/Transform"
  version = "3.0"
  xmlns:xs = "http://www.w3.org/2001/XMLSchema"
  exclude-result-prefixes = "#all"
  xmlns:mf = "http://example.com/mf"
  expand-text = "yes">
  
  <xsl:function name = "mf:cousins" as = "node()*">
    <xsl:param name = "node" as = "node()"/>
    <xsl:variable name = "path" select = "path($node)"/>
    <xsl:variable name = "path-without-predicates" select = "replace($path, '\[[0-9]+\]', '')"/>
    <xsl:variable name = "cousins" as = "node()*">
      <xsl:evaluate context-item = "$node" xpath = "$path-without-predicates"/>
    </xsl:variable>
    <xsl:sequence select = "$cousins except $node"/>
  </xsl:function>
  
  <xsl:function name = "mf:preceding-cousins" as = "node()*">
    <xsl:param name = "node" as = "node()"/>
    <xsl:sequence select = "mf:cousins($node)[. &lt;&lt; $node]"/>
  </xsl:function>
  
  <xsl:template match = "level2[@id = 6] | level2[@id = 5]">
    <xsl:comment>preceding cousin: {mf:preceding-cousins(.)[last()]=>serialize(map{ 'method' : 'xml' })}</xsl:comment>
    <xsl:next-match/>
  </xsl:template>

  <xsl:output method = "xml" indent = "no"/>

  <xsl:mode on-no-match = "shallow-copy"/>

</xsl:stylesheet>

Это немного похоже на «взлом» использования функции path, затем замены строки и xsl:evaluate, но я не вижу простого прямого XPath.

Если я правильно понимаю ваши требования, XPath 1.0 — это все, что вам нужно.

Учитывая ваш входной XML, это XSLT 2.0 (для тестовой программы ключ XPath равен 1.0),

<?xml version = "1.0" encoding = "utf-8"?>
<xsl:stylesheet xmlns:xsl = "http://www.w3.org/1999/XSL/Transform"
  version = "2.0">
  <xsl:output indent = "yes"/>
  <xsl:template match = "/">
    <results>
      <xsl:for-each select = "//level2">
        <case id = "{@id}">
          <xsl:variable name = "depth" select = "count(ancestor::*)"/>
          <xsl:sequence select = "preceding::level2[count(ancestor::*) = $depth][1]"/>
        </case>
      </xsl:for-each>
    </results>
  </xsl:template>
</xsl:stylesheet>

выдает эти результаты испытаний,

<?xml version = "1.0" encoding = "UTF-8"?>
<results>
   <case num = "1"/>
   <case num = "2">
      <level2 id = "1"/>
   </case>
   <case num = "3">
      <level2 id = "2"/>
   </case>
   <case num = "4">
      <level2 id = "3"/>
   </case>
   <case num = "5">
      <level2 id = "4"/>
   </case>
   <case num = "9"/>
   <case num = "6">
      <level2 id = "5">
         <level2 id = "9"/>
      </level2>
   </case>
   <case num = "7">
      <level2 id = "6"/>
   </case>
   <case num = "8">
      <level2 id = "7"/>
   </case>
</results>

который охватывает два проблемных случая и дает приемлемые результаты для всех стартовых элементов level2.

Я думаю, я бы, наверное, сделал

let $this := .
let $precedingCousins := (../../*/*)[. << $this]
return $precedingCousins[last()]

или его эквивалент в XSLT.

Решение XPath 1.0 будет

(preceding-sibling::* | ../preceding-sibling::*/*)[last()]

Чтобы сделать N-ых двоюродных братьев, где N — параметр, предоставляемый динамически, я бы написал рекурсивную функцию, которая обязательно делает ее XPath 2.0+.

В нотации XQuery

declare function my:cousins($node as node(), 
                            $degree as xs:integer) as node()* {
   if ($degree eq 0) 
   then $node/../*
   else my:cousins($node/.., $degree - 1)/*
} 
  

Честно говоря, ответ Майкла Кея в основном там, за исключением того, что он проверяет уровень напрямую, мне бы хотелось, чтобы это был вариант, который игнорировал уровень и просто возвращал всех кузенов.

<xsl:function name = "kooks:cousins" as = "node()*">
    <xsl:param name = "node" as = "node()"/>
    <xsl:sequence select = "$node/../*"/>         
    <xsl:if test = "$node/..">
        <xsl:sequence select = "kooks:cousins($node/..)/*"/>
    </xsl:if>
</xsl:function> 

обратите внимание, что, как и в другом ответе, предиката соответствия нет, он просто соответствует всем двоюродным братьям элементов, а также не обрабатывает предыдущий/следующий, но это можно сделать с помощью '<<'

Если вы знаете полный путь, то

(/foo/bar/wibble)[. << $this]  

это просто и понятно

где $this является членом "/foo/bar/wibble"

это МОЖЕТ работать в xslt 1.0, я его не использовал, и порядок меня беспокоит из-за использования набора узлов (для следования вам может потребоваться изменить порядок операндов объединения), и согласно ответу М. Кея заказ – это заказ документа.

<xsl:template mode = "preceding-cousin" match = "/"/>

<xsl:template mode = "preceding-cousin" match = "*">
    <xsl:variable name = "precedingUnclesRTF">
        <xsl:apply-templates mode = "preceding-cousin" select = ".."/>
    </xsl:variable>
    <xsl:variable name = "precedingUncles" select = "msxsl:node-set($precedingUnclesRTF)/*"/>
    <xsl:copy-of select = "$precedingUncles/* | preceding-sibling::*"/>
</xsl:template>

и ответ на глубину также работает в XSLT 1.0, он проще, чем приведенный выше, и не будет страдать от экспоненциального копирования узлов, как описано выше, но обрабатывает все предыдущие узлы в документе, он работает во всех версиях XSLT и не является рекурсивным. (так что не уничтожим стек), хотя я думаю, что ответ рекурсивной функции можно переписать как свертку или итерацию xsl.

<xsl:template mode = "preceding-cousin2" match = "*">
    <xsl:variable name = "depth" select = "count(ancestor::*)"/>
    <xsl:copy-of select = "preceding::*[count(ancestor::*) = $depth]"/>
</xsl:template>