逐行搜索XML

Question

我有一个XML文档，格式如下:

<document>
  <page>
    <column>
      <text>
        <par>
          <line></line>
        </par>
      </text>
    </column>
  </page>
</document>

我想在XML中搜索字符串，但可能在多个行标记、多个块文档和/或多个页面标记中:

<document>
  <page>
    <column>
      <text>
        <par>
          <line>Hello</line>
        </par>
      </text>
    </column>
    <column>
      <text>
        <par>
          <line>World</line>
        </par>
      </text>
    </column>
  </page>
  <page>
    <column>
      <text>
        <par>
          <line>What's</line>
          <line>Up?</line>
        </par>
      </text>
    </column>
  </page>
</document>

我需要搜索"Hello World What's Up?"，并且知道它位于第1列的第1行，第2列的第1行和第3块(第3页第1块)的第1-2行。

我在行上有元数据，告诉我它是什么行号，以及它属于哪个列号，例如:

<line linenum="1" columnnum="2">World</line>

在不同的列中搜索这个词，并能够知道它们属于哪些行和列的细节，最好的方法是什么?

我可以获得第一个单词的所有实例，对每个单词进行迭代，看看下面的单词是否与搜索单词相对应(一个单词一个单词)，如果该行中没有更多的单词，则转到下一行。如果没有人排队了，就去下一个街区。想法吗?

下面是示例XML代码的真实片段，以及脚本返回的内容:

<block>
  <text>
    <par>
      <line colnum="1" linenum="1">
        (12) United States Patent
      </line>
    </par>
    <par>
      <line colnum="1" linenum="2">
        Kar-Roy et al.
      </line>
    </par>
  </text>
</block>
<block>
  <text>
    <par>
      <line colnum="2" linenum="3">
        US007078310B1
      </line>
    </par>
  </text>
</block>
<block>
  <text>
    <par>
      <line colnum="3" linenum="4">
        (io) Patent No.: US 7,078,310 B1
      </line>
    </par>
    <par>
      <line colnum="3" linenum="5">
        (45) Date of Patent: Jul. 18,2006
      </line>
    </par>
  </text>
</block>
<block>
  <text>
    <par>
      <line>
        (54) METHOD FOR FABRICATING A HIGH
      </line>
      <line>
        DENSITY COMPOSITE MIM CAPACITOR
      </line>
    </par>
  </text>
</block>

当我搜索"METHOD for FABRICATING A HIGH"时，map{|f| f.text}返回:

["Kar-Roy et al.", "US007078310B1", "(io) Patent No.: US 7,078,310 B1", "(45) Date of Patent: Jul. 18,2006", "(54) METHOD FOR FABRICATING A HIGH"]

由于某些原因，它看起来像是在取五个单词的长度，并在实际结果之前得到四行

Answer 1

我的想法是:首先，将结构解析为XML解析器(如Nokogiri)，然后使用XPath搜索提取所有line元素。然后，将每个元素分解为该节点中包含的单词，这样我们就可以匹配只匹配节点部分的短语。然后，对单词进行连续排序，使用each_cons(4)(其中4是您正在搜索的单词数)查看所有四个单词的连续集合，如果它们在连接时匹配您的搜索字符串，则返回。下面是我的代码:

xml = Nokogiri::XML.parse(doc)
search = "HIGH DENSITY"
# 1. break down all the lines into words tagged with their nodes
# 2. find matching subsequence
# 3. build up from nodes
nodes = xml.xpath('//line')
words = nodes.map do |n|
  words_in_node = n.text.split(' ').map(&:upcase) # split into words and normalize
  words_in_node.map { |word| { word: word, node: n } }
end
words = words.flatten # at this point we have a single, ordered list like [ {word: "foo", node: ...}, {word: "bar", node: ...} ]
keywords = search.split(' ').map(&:upcase)
result = words.each_cons(keywords.size).find do |sample|
  # Extract just the :word key from each hash, then compare to our search string
  sample_words = sample.map { |w| w[:word] }
  sample_words == keywords
end
if result
  puts "Found in these nodes:"
  puts result.map { |w| w[:node] }.uniq.inspect
  # you can find where each node was located via Nokogiri
else
  puts "No match"
end

生产:

Found in these nodes:
[#<Nokogiri::XML::Element:0x4ea323e name="line" children=[#<Nokogiri::XML::Text:0x4ea294c "n        (54) METHOD FOR FABRICATING A HIGHn      ">]>,
 #<Nokogiri::XML::Element:0x4ea3018 name="line" children=[#<Nokogiri::XML::Text:0x4ea2654 "n        DENSITY COMPOSITE MIM CAPACITORn      ">]>]

Answer 2

如果我明白你想要什么，我会这样做:

require 'nokogiri'
doc = Nokogiri::XML(<<EOT)
<document>
  <page>
    <column>
      <text>
        <par>
          <line linenum="1" columnnum="1">Hello</line>
        </par>
      </text>
    </column>
    <column>
      <text>
        <par>
          <line linenum="1" columnnum="2">World</line>
        </par>
      </text>
    </column>
  </page>
  <page>
    <column>
      <text>
        <par>
          <line linenum="1" columnnum="3">What's</line>
          <line linenum="2" columnnum="3">Up?</line>
        </par>
      </text>
    </column>
  </page>
</document>
EOT
line_text = doc.search('column').map { |column| 
  column.search('line').map{ |line|
    {
      line: line['linenum'],
      column: line['columnnum'],
      text: line.text
    }
  }
}

此时line_text包含:

line_text 
# => [[{:line=>"1", :column=>"1", :text=>"Hello"}],
#     [{:line=>"1", :column=>"2", :text=>"World"}],
#     [{:line=>"1", :column=>"3", :text=>"What's"},
#      {:line=>"2", :column=>"3", :text=>"Up?"}]]

这是按<column>分组。元数据不是必需的，但是如果它存在于XML中就很方便了。如果没有，则删除捕获这些参数的行，并只返回文本:

line_text = doc.search('column').map { |column| 
  column.search('line').map{ |line|
    line.text
  }
}
line_text 
# => [["Hello"], ["World"], ["What's", "Up?"]]

line_text现在是数组的数组。外部数组中的每个元素表示一列，子数组中的元素是行，因此您可以使用更小的返回数组以及一些额外的代码来跟踪这些内容:

line_text.each.with_index(1) do |column, column_num|
  column.each.with_index(1) do |text, line_num|
    puts "column: #{column_num} line: #{line_num} text: #{text}"
  end
end
# >> column: 1 line: 1 text: Hello
# >> column: 2 line: 1 text: World
# >> column: 3 line: 1 text: What's
# >> column: 3 line: 2 text: Up?