在 Ruby 中使用 Parslet 的缩进敏感解析器？

我正在尝试使用以下方法解析简单的缩进敏感语法ParsletRuby 中的库。

以下是我尝试解析的语法示例：

level0child0
level0child1
  level1child0
  level1child1
    level2child0
  level1child2

结果树看起来像这样：

[
  {
    :identifier => "level0child0",
    :children => []
  },
  {
    :identifier => "level0child1",
    :children => [
      {
        :identifier => "level1child0",
        :children => []
      },
      {
        :identifier => "level1child1",
        :children => [
          {
            :identifier => "level2child0",
            :children => []
          }
        ]
      },
      {
        :identifier => "level1child2",
        :children => []
      },
    ]
  }
]

我现在拥有的解析器可以解析嵌套级别 0 和 1 节点，但无法解析过去的节点：

require 'parslet'

class IndentationSensitiveParser < Parslet::Parser

  rule(:indent) { str('  ') }
  rule(:newline) { str("\n") }
  rule(:identifier) { match['A-Za-z0-9'].repeat.as(:identifier) }

  rule(:node) { identifier >> newline >> (indent >> identifier >> newline.maybe).repeat.as(:children) }

  rule(:document) { node.repeat }

  root :document

end

require 'ap'
require 'pp'

begin
  input = DATA.read

  puts '', '----- input ----------------------------------------------------------------------', ''
  ap input

  tree = IndentationSensitiveParser.new.parse(input)

  puts '', '----- tree -----------------------------------------------------------------------', ''
  ap tree

rescue IndentationSensitiveParser::ParseFailed => failure
  puts '', '----- error ----------------------------------------------------------------------', ''
  puts failure.cause.ascii_tree
end

__END__
user
  name
  age
recipe
  name
foo
bar

很明显，我需要一个动态计数器，它需要 3 个缩进节点来匹配嵌套级别 3 上的标识符。

如何以这种方式使用 Parslet 实现缩进敏感语法解析器？是否可以？

有几种方法。

1. 通过将每一行识别为缩进和标识符的集合来解析文档，然后应用转换以根据缩进数重建层次结构。

2. 使用捕获来存储当前缩进，并期望下一个节点包含该缩进以及更多内容以作为子项进行匹配（我没有深入研究这种方法，因为我想到了下一种方法）

3. 规则只是方法。所以你可以将'node'定义为一个方法，这意味着你可以传递参数！ （如下）

这可以让您定义node(depth)按照node(depth+1)。然而，这种方法的问题在于node方法不匹配字符串，它会生成一个解析器。所以递归调用永远不会完成。

这就是为什么dynamic存在。它返回一个解析器，直到它尝试匹配它时才解析，允许您现在可以毫无问题地递归。

请看下面的代码：

require 'parslet'

class IndentationSensitiveParser < Parslet::Parser

  def indent(depth)
    str('  '*depth)
  end

  rule(:newline) { str("\n") }

  rule(:identifier) { match['A-Za-z0-9'].repeat(1).as(:identifier) }

  def node(depth) 
    indent(depth) >> 
    identifier >> 
    newline.maybe >> 
    (dynamic{|s,c| node(depth+1).repeat(0)}).as(:children)
  end 

  rule(:document) { node(0).repeat }

  root :document
end

这是我最喜欢的解决方案。