Парслет с самоцветом

 rule(:wordcolon) { match('[a-zA-Z]') >> str(':') } 

Хитрый пробел

Очень заманчиво использовать #repeat(0) чтобы сделать ваш анализатор гибким, но нужно быть осторожным. При работе с пробелами обычно рекомендуется иметь такие правила:

 rule(:space) { match('\s').repeat(1) } rule(:space?) { space.maybe } 

Если вы просто используете одно всеобъемлющее правило пробелов, вы рискуете запутаться в двусмысленности. Играя с пробелами, мне удалось создать парсер, который зависает.

 # tricky_whitespace.rb # Be careful with #repeat(0) require 'parslet' class BadWhitespaceParser < Parslet::Parser rule(:space) { match('\s').repeat(0) } rule(:identifier) { match('[a-zA-Z0-9]').repeat(1) } rule(:line) { identifier | space } rule(:lines) { (line >> space).repeat(0) } root(:lines) end doc = <<-eof east west eof parser = BadWhitespaceParser.new # This will hang. Use ctrl-c to interrupt. puts parser.parse(doc).inspect 

Отчет об ошибках

Parslet предоставляет отличные отчеты об ошибках, если вы используете его. Если вы просто позволите Parslet потерпеть неудачу, он скажет вам, с какой последовательностью он не соответствует. Однако, если вы Parslet::ParseFailed , вы можете получить дерево сбоев.

 # parse_failed.rb require 'parslet' class FailParser < Parslet::Parser rule(:alpha) { match('[a-zA-Z]').repeat(1) } rule(:number) { digit.repeat(1) >> (str('.') >> digit.repeat(1)).maybe } rule(:digit) { match('[0-9]').repeat(1) } rule(:space) { str(' ') } rule(:line) { alpha >> space >> number >> space >> alpha } root(:line) end input = "ab 1.2 d1" parser = FailParser.new # not so great error reporting puts "--STANDARD ERROR REPORTING--" begin parser.parse(input) rescue Exception => error puts error end puts ("\n") # better error reporting puts "--ASCII TREE ERROR REPORTING--" begin parser.parse(input) rescue Parslet::ParseFailed => error puts error.cause.ascii_tree end 

Это распечатывает:

 --STANDARD ERROR REPORTING-- Failed to match sequence (ALPHA SPACE NUMBER SPACE ALPHA) at line 1 char 8. --ASCII TREE ERROR REPORTING-- Failed to match sequence (ALPHA SPACE NUMBER SPACE ALPHA) at line 1 char 8. `- Extra input after last repetition at line 1 char 9. `- Failed to match [a-zA-Z] at line 1 char 9. 

Parslet предоставляет удобный метод, так что вам не нужно каждый раз записывать обработку исключений.

 require 'parslet/convenience' parser.parse_with_debug(input) 

Генерация дерева

По умолчанию Parslet просто проверяет ввод. Он не генерирует синтаксическое дерево. Метод #as создает узел в дереве.

 rule(:assignment) { left.as(:left) >> str('=') >> right.as(:right) } 

Вот более полный пример.

 # assignment_parser.rb require 'parslet' class AssignmentParser < Parslet::Parser rule(:identifier) { match('[a-zA-Z0-9_]').repeat(1) } rule(:value) { match('[0-9]').repeat(1) } rule(:assignment) { identifier.as(:left) >> str('=') >> value.as(:right) >> str("\n").maybe } rule(:assignments) { assignment.as(:assignment).repeat } root(:assignments) end doc = <<-eof a=23 b=56 eof parser = AssignmentParser.new puts parser.parse(doc).inspect 

Если вы запустите assignment_parser.rb, вместо того, чтобы вернуть ввод, вы получите массив хэшей присваивания.

[{: assignment => {: left => ”a” @ 0,: right => ”23 ″ @ 2}}, {: assignment => {: left =>” b ”@ 5,: right =>” 56 «@ 7}}]

преобразование

Parslet предоставляет Parslet :: Transform для понимания синтаксических графов, созданных Parslet::Parser . Вы можете использовать его для создания интерпретатора или генератора байт-кода.

Как и Parslet :: Parser, Parslet :: Transform состоит из правил и блоков.

 rule(nodes => capture_method) { action_block } 

Метод захвата определяет, что правило будет соответствовать и является одним из:

• просто — любой объект, кроме хэшей или массивов
• последовательность — хэши или массивы
• поддерево — все

Результат блока действия заменит шаблон узла, указанный в правиле. Если указан только конечный узел, будет заменен только конечный узел.

 # transform_replace.rb require 'parslet' ast = {:document => {:words => "hello world"}} # replaces the words node class LeafTransform < Parslet::Transform rule(:words => simple(:x)) { x.upcase } end # replaces document and words nodes class TreeTransform < Parslet::Transform rule(:document => {:words => simple(:x)}) { x.upcase } end leaf_transform = LeafTransform.new puts leaf_transform.apply(ast).inspect tree_transform = TreeTransform.new puts tree_transform.apply(ast).inspect 

Здесь LeafTransform просто заменяет {: words => «hello world»}, а TreeTransform заменяет все дерево.

 {:document=>"HELLO WORLD"} "HELLO WORLD" 

Давайте преобразуем дерево, созданное синтаксическим анализатором присваивания (Примечание: убран символ Parslet «@»).

 # assignment_transform.rb require 'parslet' tree = [{:assignment=>{:left=>"a", :right=>"23"}}, {:assignment=>{:left=>"b", :right=>"56"}}] class Assignment def initialize(left, right) @left = left @right = right end def generate_code # spit out bytecode/machinecode associated with assignment operation end end class AssignmentTransform < Parslet::Transform rule(:left => simple(:left), :right => simple(:right)) do Assignment.new(left, Integer(right)) end end transform = AssignmentTransform.new puts transform.apply(tree).inspect 

Метод #apply возвращает преобразованное дерево с объектами Assignment вместо хешей.

 [{:assignment=>#<Assignment:0x000000019df520 @left="a",@right=23>}, {:assignment=>#<Assignment:0x000000019c9018 @left="b", @right=56>}] 

Чтобы узнать больше о Parlset :: Transform, ознакомьтесь с документацией .

Вывод

Если вы новичок в создании языков программирования, Parslet — отличный способ начать. Он обеспечивает большую грамматическую гибкость, чем типичный генератор LALR (1), и может использовать ваш код Ruby. Тем не менее, Parslet — не единственная игра PEG в городе для Ruby. Вот некоторые другие:

• верхушка дерева
• цитрусовые
• rsec

Вот несколько дополнительных ресурсов, если вы хотите больше узнать о создании языков с помощью Parslet:

• Разбор TOML с Parslet
• Использование Parslet для написания собственного языка
• Написание DSL с помощью Parslet — Wicked Good Ruby 2013