Question

简历（我将以下长篇故事简化为简单的问题）

tree = {:properties => [{:a => 'b'}, {:c => 'd'}]}
big_tree = {:properties => [{:a => 'b'}, {:c => 'd'}], :moves => [{:a => 'b'}, {:c => 'd'}]}

trans = Parslet::Transform.new do
    rule(:properties => subtree(:nested)) do
        out = {}
        nested.each {|pair| out = out.merge pair}
        {:properties => out}
    end
end

pp tree
pp trans.apply(tree)
pp big_tree
pp trans.apply(big_tree)

# OUTPUT

{:properties=>[{:a=>"b"}, {:c=>"d"}]}
{:properties=>{:a=>"b", :c=>"d"}} # Worked with small tree
{:properties=>[{:a=>"b"}, {:c=>"d"}], :moves=>[{:a=>"b"}, {:c=>"d"}]}
{:properties=>[{:a=>"b"}, {:c=>"d"}], :moves=>[{:a=>"b"}, {:c=>"d"}]} # Didn't work with bigger tree

=========================完整的故事（标题后不那么相关）

我正在使用Parslet创建一个SGF文件解析器。

现在我正处于制作变形金刚的阶段。

从Parser我已经得到了这样的结构：

[{:properties=>
   [{:name=>"GM"@2, :values=>[{:value=>"1"@5}]},
    {:name=>"FF"@7, :values=>[{:value=>"4"@10}]},
    {:name=>"SZ"@12, :values=>[{:value=>"19"@15}]},
    {:name=>"AP"@18, :values=>[{:value=>"SmartGo Kifu:2.2"@21}]},
    {:name=>"GN"@40, :values=>[{:value=>"2013-05-11g"@43}]},
    {:name=>"PW"@57, :values=>[{:value=>"Dahan"@60}]},
    {:name=>"PB"@68, :values=>[{:value=>"SmartGo"@71}]},
    {:name=>"DT"@81, :values=>[{:value=>"2013-05-11"@84}]},
    {:name=>"KM"@97, :values=>[{:value=>"6.5"@100}]},
    {:name=>"RE"@106, :values=>[{:value=>"W+R"@109}]},
    {:name=>"RU"@115, :values=>[{:value=>"AGA (Area)"@118}]},
    {:name=>"ID"@129, :values=>[{:value=>"ch0"@132}]}],
  :moves=>
   [{:player=>"B"@137, :place=>"oq"@139},
    {:player=>"W"@143, :place=>"dd"@145},
    {:player=>"B"@149, :place=>"oo"@151},
    ...etc...

我用于转换的规则集：

    # Rewrite player: COLOR, place: X to COLOR: X
    rule( player: simple(:p), place: simple(:pl)) do
        if p == 'W'
            { white: pl }
        elsif p == 'B'
            { black: pl }
        end
    end
    # Un-nest single-value hash
    rule( value: simple(:v)) { v }
    # Rewrite name: KEY, values: SINGLE_VALUE to KEY: SINGLE_VALUE
    rule( name: simple(:n), values: [ simple(:v) ]) { {n.to_sym => v} }
    # A Problem!!!
    rule( properties: subtree(:props) ) do
        out = {}
        props.each {|pair| pair.each {|k, v| out[k] = v}}
        { properties: out }
    end

根据这些规则，我得到以下结构：

[{:properties=>
   [{:GM=>"1"@5},
    {:FF=>"4"@10},
    {:SZ=>"19"@15},
    {:AP=>"SmartGo Kifu:2.2"@21},
    {:GN=>"2013-05-11g"@43},
    {:PW=>"Dahan"@60},
    {:PB=>"SmartGo"@71},
    {:DT=>"2013-05-11"@84},
    {:KM=>"6.5"@100},
    {:RE=>"W+R"@109},
    {:RU=>"AGA (Area)"@118},
    {:ID=>"ch0"@132}],
  :moves=>
   [{:black=>"oq"@139},
    {:white=>"dd"@145},
    {:black=>"oo"@151},
    ...etc...

一切都很完美。我唯一的问题是：属性哈希数组。

最后我想要

[{:properties=>
   {:GM=>"1"@5,
    :FF=>"4"@10,
    :SZ=>"19"@15,
    :AP=>"SmartGo Kifu:2.2"@21,
    :GN=>"2013-05-11g"@43,
    :PW=>"Dahan"@60,
    :PB=>"SmartGo"@71,
    :DT=>"2013-05-11"@84,
    :KM=>"6.5"@100,
    :RE=>"W+R"@109,
    :RU=>"AGA (Area)"@118,
    :ID=>"ch0"@132},
  :moves=>
   [{:black=>"oq"@139},
    {:white=>"dd"@145},
    {:black=>"oo"@151},
    ...etc...

你知道吗？合并内部的所有阵列哈希：属性，因为在之前的转换之后，它们现在具有唯一键。也稍微压平了结构。

喂！我可以手动完成。我的意思是运行一个单独的方法，如

merged_stuff = {}
tree.first[:properties].each {|pair| pair.each {|k, v| merged_stuff[k] = v}}
tree.first[:properties] = merged_stuff

但是为什么我不能用简洁的转换规则做到这一点，在一个地方拥有所有转换逻辑？

重点是rule( properties: subtree(:props) )根本没有被解雇。即使我只是从块中返回nil，它也不会改变任何东西。所以，似乎这个subtree没有抓住这些东西，或者我没有。

Answer 1

问题是:properties和:moves是同一哈希中的键，而subtree显然不希望匹配哈希的一部分。如果您删除:moves，则会执行该规则。有点解释in the documentation：

关于模式的一个词

鉴于PORO哈希
{ 
  :dog => 'terrier', 
  :cat => 'suit' }
可以假设以下规则与:dog匹配，并将其替换为'foo'：
rule(:dog => 'terrier') { 'foo' }
坦白说这是不可能的。 'foo'除:cat => 'suit'之外如何生活哈希里面？这不可以。这就是哈希完全匹配的原因，猫全部，或根本没有。

虽然我必须承认这不是一个非常明确的例子。

因此问题规则应如下所示：

rule( properties: subtree(:props), moves: subtree(:m) ) do
    out = {}
    props.each {|pair| pair.each {|k, v| out[k] = v}}
    { properties: out , moves: m}
end

Answer 2

转换规则匹配整个节点并替换它，因此您需要匹配整个哈希，而不仅仅是一个键。

rule( properties: subtree(:props),  moves: subtree(:moves) )

如果您将{:name=>"GM", :values=>[{:value=>"1"}]}类型的内容转换为对象（使用OpenStruct说），那么您不需要使用subtree，您可以使用sequence。

Parslet子树不会发射

2 个答案:

关于模式的一个词