\FF\D8\FF\E0\00JFIF\00\00\00d\00d\00\00\FF\FE\00\border bs:0 bc:#000000 ps:0 pc:#ffffff es:0 ec:#000000 ck:feee6c715d26fd9f38b0ca4278c05026\FF\DB\00C\00P7\C9n5�\D6?\BD�\9Ds\EBp\9F[`8m\B7)o\B5\E8\E6I\99\FE3]]A2\BA\8Cw\D6E\93\\DEv\C8\009\F2\F1NI?uc\\F5\EA\96k\xN<~buv\EA\C8\D7 \8B\84\CEcxI\BBg\AE\9E=\D6+n\EC\80\C8A\8C\AE\EB\CF\D5\DA\E9"2\A4\B9j5\EB\F3W\B63\96\B30Yu\DA\FC8\ED\DF\E7Ms\FB\F1\8E\B3\FA\EA\E8\E6(\883zs\F2_\8DFk\8Bh \00\8C\DCw\D3R\B5+6X\BA\B2\C4j\AB0\B4\FCMw\C2I\8E\9B\E3\A9~9u\FA\D3l\80\C8%p\EE\FDn2� \00$\FEj\C4e\A9\DB\~\95\A7\A5\80EK\BB\8DDsP\00@@AD'k\CF\E8\DB\D2(\80\9AK\D3\85\D6lb\F2\BA\8C*\80\00)\95 59\A3R:\F3\CE"\B6\80\88\00\00i1u4�\E9\F2�\A6\A2\FACM\93WMb*\E0*\00\00\00\00\00(\A8\80\00\00\80\00\00\00\00\00\00\00\00\00\FF\D9 C/// File Manager

File Manager

Path: /opt/chef/embedded/lib/ruby/gems/2.7.0/gems/parslet-1.8.2/lib/parslet/expression/

Viewing File: treetop.rb

class Parslet::Expression::Treetop
  class Parser < Parslet::Parser
    root(:expression)
    
    rule(:expression) { alternatives }
    
    # alternative 'a' / 'b'
    rule(:alternatives) {
      (simple >> (spaced('/') >> simple).repeat).as(:alt)
    }
    
    # sequence by simple concatenation 'a' 'b'
    rule(:simple) { occurrence.repeat(1).as(:seq) }
    
    # occurrence modifiers
    rule(:occurrence) {
      atom.as(:repetition) >> spaced('*').as(:sign) |
      atom.as(:repetition) >> spaced('+').as(:sign) |
      atom.as(:repetition) >> repetition_spec |
      
      atom.as(:maybe) >> spaced('?') | 
      atom
    }
        
    rule(:atom) { 
      spaced('(') >> expression.as(:unwrap) >> spaced(')') |
      dot |
      string |
      char_class
    }
    
    # a character class
    rule(:char_class) {
      (str('[') >>
        (str('\\') >> any |
        str(']').absent? >> any).repeat(1) >>
      str(']')).as(:match) >> space?
    }
    
    # anything at all
    rule(:dot) { spaced('.').as(:any) }
    
    # recognizing strings
    rule(:string) {
      str('\'') >> 
      (
        (str('\\') >> any) |
        (str("'").absent? >> any)
      ).repeat.as(:string) >> 
      str('\'') >> space?
    }
    
    # repetition specification like {1, 2}
    rule(:repetition_spec) {
      spaced('{') >> 
        integer.maybe.as(:min) >> spaced(',') >> 
        integer.maybe.as(:max) >> spaced('}')
    }
    rule(:integer) {
      match['0-9'].repeat(1)
    }
    
    # whitespace handling
    rule(:space) { match("\s").repeat(1) }
    rule(:space?) { space.maybe }
    
    def spaced(str)
      str(str) >> space?
    end
  end
  
  class Transform < Parslet::Transform
    
    rule(:repetition => simple(:rep), :sign => simple(:sign)) { 
      min = sign=='+' ? 1 : 0
      Parslet::Atoms::Repetition.new(rep, min, nil) }
    rule(:repetition => simple(:rep), :min => simple(:min), :max => simple(:max)) { 
      Parslet::Atoms::Repetition.new(rep, 
        Integer(min || 0), 
        max && Integer(max) || nil) }
      
    rule(:alt => subtree(:alt))       { Parslet::Atoms::Alternative.new(*alt) }
    rule(:seq => sequence(:s))        { Parslet::Atoms::Sequence.new(*s) }
    rule(:unwrap => simple(:u))       { u }
    rule(:maybe => simple(:m))        { |d| d[:m].maybe }
    rule(:string => simple(:s))       { Parslet::Atoms::Str.new(s) }
    rule(:match => simple(:m))        { Parslet::Atoms::Re.new(m) }
    rule(:any => simple(:a))          { Parslet::Atoms::Re.new('.') }
  end
  
end