Ось XPath, получить все следующие узлы, пока

Использование:

(//h2[. = 'Foo bar'])[1]/following-sibling::p
   [1 = count(preceding-sibling::h2[1] | (//h2[. = 'Foo bar'])[1])]

В случае, если гарантируется, что каждый h2 имеет отличное значение, это можно упростить до:

//h2[. = 'Foo bar']/following-sibling::p
   [1 = count(preceding-sibling::h2[1] | ../h2[. = 'Foo bar'])]

Это означает: выбрать все элементы p, следующие за элементами h2 (первыми или единственными в документе), строковое значение которых равно 'Foo bar', а также первый предшествующий элемент h2 для всех этих элементов p является точно h2(first or only one in the document) whose string value is'Foo bar'`.

Здесь мы используем метод определения идентичности двух узлов:

count($n1 | $n2) = 1

равно true(), когда узлы $n1 и $n2 являются одним и тем же узлом.

Это выражение можно обобщить:

$x/following-sibling::p
       [1 = count(preceding-sibling::node()[name() = name($x)][1] | $x)]

выбирает всех "непосредственно следующих братьев и сестер" любого узла, указанного $x.

В XPath 2.0 (я знаю, что это вам не поможет...) самое простое решение, вероятно,

h2[. = 'Foo bar']/following-sibling::* кроме h2[. = 'Bar baz']/(.|следующий-брат::* )

Но, как и другие представленные решения, это, вероятно (при отсутствии оптимизатора, распознающего шаблон), будет линейным по количеству элементов за пределами второго h2, тогда как вам действительно нужно решение, производительность которого зависит только от количества элементов. выбрано. Я всегда чувствовал, что было бы неплохо иметь оператор until:

h2[. = 'Foo bar']/(following-sibling::* until . = 'Bar baz')

В его отсутствие решение XSLT или XQuery, использующее рекурсию, вероятно, будет работать лучше, когда число выбираемых узлов невелико по сравнению с числом следующих братьев и сестер.

Этот оператор XPATH 1.0 выбирает все <p>, которые являются одноуровневыми элементами, которые следуют за <h2>, строковое значение которого равно "Foo bar", за которыми также следует одноуровневый элемент <h2>, чей первый предшествующий одноуровневый элемент <h2> имеет строковое значение "Foo bar".

//p[preceding-sibling::h2[.='Foo bar']]
 [following-sibling::h2[
  preceding-sibling::h2[1][.='Foo bar']]]

Просто потому, что это не входит в число ответов, классический XPath 1.0 устанавливает исключение:

A - B = $A[count(.|$B)!=count($B)]

Для этого случая:

(//h2[.='Foo bar']
    /following-sibling::p)
       [count(.|../h2[.='Foo bar']
                     /following-sibling::h2[1]
                        /following-sibling::p)
        != count(../h2[.='Foo bar']
                     /following-sibling::h2[1]
                        /following-sibling::p)]

Примечание: это было бы отрицанием метода Кайса.

XPath 2.0 имеет оператор << (с $node1 << $node2 истинным, если $node1 предшествует $node2), так что вы можете использовать //h2[. = 'Foo bar']/following-sibling::p[. << //h2[. = 'Bar baz']]. Однако я не знаю, что такое nokogiri и поддерживает ли он XPath 2.0.

require 'nokogiri'

doc = Nokogiri::XML <<ENDXML
<root>
  <h2>Foo</h2>
  <p>lorem</p>
  <p>ipsum</p>
  <p>etc</p>

  <h2>Bar</h2>
  <p>dum dum dum</p>
  <p>poopfiddles</p>
</root>
ENDXML

a = doc.xpath( '//h2[text()="Foo"]/following::p[not(preceding::h2[text()="Bar"])]' )
puts a.map{ |n| n.to_s }
#=> <p>lorem</p>
#=> <p>ipsum</p>
#=> <p>etc</p>

Я подозревал, что может быть эффективнее просто пройтись по DOM, используя next_sibling, пока не дойдете до конца:

node = doc.at_xpath('//h2[text()="Foo bar"]').next_sibling
stop = doc.at_xpath('//h2[text()="Bar baz"]')
a = []
while node && node!=stop
  a << node unless node.type == 3 # skip text nodes
  node = node.next_sibling
end

puts a.map{ |n| n.to_s }
#=> <p>lorem</p>
#=> <p>ipsum</p>
#=> <p>etc</p>

Однако это НЕ быстрее. В нескольких простых тестах я обнаружил, что только xpath (первое решение) примерно в 2 раза быстрее, чем этот циклический тест, даже когда после стоп-узла очень много абзацев. Когда есть много узлов для захвата (и мало после остановки), он работает еще лучше, в диапазоне 6x-10x.

как насчет совпадения на втором? Если вам нужен только верхний раздел, сопоставьте второй и возьмите все, что выше него.
doc.xpath("//h2[text()='Bar baz']/preceding-sibling::p").map { |m| m.text } => ["lorem", "ipsum", "etc"]

или, если вы не знаете второй, перейдите на другой уровень с помощью: doc.xpath("//h2[text()='Foo bar']/following-sibling::h2/preceding-sibling::p").map { |it| it.text } => ["lorem", "ipsum", "etc"]