Как определить ограничение фиксированной ширины в parslet

А как насчет такого...

class MyParser < Parslet::Parser
    def initialize(widths)
        @widths = widths
        super
    end

    rule(:currency)  {...}
    rule(:fixed_c)   {currency.fixed(@widths[:currency])}


    rule(:fixed_str) {str("bob").fixed(4)}
end 

puts MyParser.new.fixed_str.parse("bob").inspect

Это не удастся с:

"Expected 'bob' to be 4 long at line 1 char 1"

Вот как это сделать:

require 'parslet'

class Parslet::Atoms::FixedLength < Parslet::Atoms::Base  
  attr_reader :len, :parslet
  def initialize(parslet, len, tag=:length)
    super()

    raise ArgumentError, 
      "Asking for zero length of a parslet. (#{parslet.inspect} length #{len})" \
      if len == 0

    @parslet = parslet
    @len = len
    @tag = tag
    @error_msgs = {
      :lenrep  => "Expected #{parslet.inspect} to be #{len} long", 
      :unconsumed => "Extra input after last repetition"
    }
  end

  def try(source, context, consume_all)
    start_pos = source.pos

    success, value = parslet.apply(source, context, false)

    return succ(value) if success && value.str.length == @len

    context.err_at(
      self, 
      source, 
      @error_msgs[:lenrep], 
      start_pos, 
      [value]) 
  end

  precedence REPETITION
  def to_s_inner(prec)
    parslet.to_s(prec) + "{len:#{@len}}"
  end
end

module Parslet::Atoms::DSL
  def fixed(len)
    Parslet::Atoms::FixedLength.new(self, len)
  end
end

Методы в классах синтаксических анализаторов в основном являются генераторами атомов парсеров. Простейшая форма, в которую эти методы входят, - это «правила», методы, которые просто возвращают одни и те же атомы каждый раз, когда они вызываются. Так же легко создавать свои собственные генераторы, которые не являются такими простыми зверями. Пожалуйста, посмотрите http://kschiess.github.com/parslet/tricks.html для иллюстрация этого трюка (сопоставление строк без учета регистра).

Мне кажется, что ваш синтаксический анализатор валют — это синтаксический анализатор с несколькими параметрами, и что вы, вероятно, могли бы создать метод (def ... end), который возвращает парсеры валюты, адаптированные к вашим предпочтениям. Может быть, даже использовать аргументы инициализации и конструктора? (т.е.: MoneyParser.new(4,5))

Для получения дополнительной помощи, пожалуйста, обращайтесь со своими вопросами в список рассылки. На такие вопросы часто легче ответить, если вы проиллюстрируете это кодом.

Возможно, мое частичное решение поможет прояснить, что я имел в виду в вопросе.

Допустим, у вас есть несколько нетривиальный парсер:

class MyParser < Parslet::Parser
    rule(:dollars) {
        match('[0-9]').repeat(1).as(:dollars)
    }
    rule(:comma_separated_dollars) {
        match('[0-9]').repeat(1, 3).as(:dollars) >> ( match(',') >> match('[0-9]').repeat(3, 3).as(:dollars) ).repeat(1)
    }
    rule(:cents) {
        match('[0-9]').repeat(2, 2).as(:cents)
    }
    rule(:currency) {
        (str('$') >> (comma_separated_dollars | dollars) >> str('.') >> cents).as(:currency)
        # order is important in (comma_separated_dollars | dollars)
    }
end

Теперь, если мы хотим проанализировать строку валюты фиксированной ширины; это не самое простое дело. Конечно, вы могли бы точно определить, как выразить повторяющиеся выражения с точки зрения конечной ширины, но это становится действительно излишне сложным, особенно в случае с разделителями-запятыми. Кроме того, в моем случае валюта — это всего лишь один пример. Я хочу иметь простой способ придумать определения фиксированной ширины для адресов, почтовых индексов и т.д....

Это похоже на то, с чем должен справиться PEG. Мне удалось написать прототип, используя Lookahead как шаблон:

class FixedWidth < Parslet::Atoms::Base
    attr_reader :bound_parslet
    attr_reader :width

    def initialize(width, bound_parslet) # :nodoc:
        super()

        @width = width
        @bound_parslet = bound_parslet
        @error_msgs = {
            :premature => "Premature end of input (expected #{width} characters)",
            :failed => "Failed fixed width",
        }
    end

    def try(source, context) # :nodoc:
        pos = source.pos
        teststring = source.read(width).to_s
        if (not teststring) || teststring.size != width
            return error(source, @error_msgs[:premature]) #if not teststring && teststring.size == width
        end
        fakesource = Parslet::Source.new(teststring)
        value = bound_parslet.apply(fakesource, context)
        return value if not value.error?

        source.pos = pos
        return error(source, @error_msgs[:failed])
    end

    def to_s_inner(prec) # :nodoc:
        "FIXED-WIDTH(#{width}, #{bound_parslet.to_s(prec)})"
    end

    def error_tree # :nodoc:
        Parslet::ErrorTree.new(self, bound_parslet.error_tree)
    end
end

# now we can easily define a fixed-width currency rule:
class SHPParser
    rule(:currency15) {
        FixedWidth.new(15, currency >> str(' ').repeat)
    }
end

Конечно, это довольно взломанное решение. Помимо прочего, номера строк и сообщения об ошибках не подходят для ограничения фиксированной ширины. Хотелось бы, чтобы эта идея была реализована более качественно.