3

我正在研究parslet以编写大量数据导入代码。总的来说，图书馆看起来不错，但我正在为一件事而苦苦挣扎。我们的很多输入文件都是固定宽度的，并且不同格式的宽度不同，即使实际字段没有。例如，我们可能会得到一个文件有 9 个字符的货币，而另一个文件有 11 个字符（或其他）。有谁知道如何在 parslet atom 上定义固定宽度约束？

理想情况下，我希望能够定义一个能够理解货币的原子（带有可选的美元符号、千位分隔符等......）然后我将能够在运行中基于旧原子创建一个新原子这是完全等价的，只是它解析了 N 个字符。

parslet 中是否存在这样的组合器？如果没有，自己写一个可能/困难吗？

4

3 回答 3

1

解析器类中的方法基本上是解析器原子的生成器。这些方法最简单的形式是“规则”，每次调用时只返回相同的原子的方法。创建自己的生成器同样容易，而不是那么简单的野兽。请查看http://kschiess.github.com/parslet/tricks.html以获取此技巧的说明（匹配字符串不区分大小写）。

在我看来，您的货币解析器是一个只有几个参数的解析器，您可能可以创建一个方法 (def ... end) 来返回根据您的喜好量身定制的货币解析器。也许甚至使用初始化和构造函数参数？（即：MoneyParser.new(4,5)）

如需更多帮助，请将您的问题发送至邮件列表。如果你用代码来说明，这些问题通常更容易回答。

于 2011-04-08T11:38:49.687 回答
1

也许我的部分解决方案将有助于澄清我在问题中的意思。

假设您有一个不重要的解析器：

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

当然，这是一个相当黑客的解决方案。除其他外，行号和错误消息在固定宽度约束内不好。我很想看到这个想法以更好的方式实施。

于 2011-04-13T15:08:24.767 回答
1

这样的事情怎么办...

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
于 2014-02-12T05:34:46.657 回答