ghazel-parslet 1.4.0.1

data/example/comments.rb

@@ -0,0 +1,35 @@
+# A small example on how to parse common types of comments. The example
+# started out with parser code from Stephen Waits. 
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require 'parslet'
+require 'parslet/convenience'
+
+class ALanguage < Parslet::Parser
+  root(:lines)
+  
+  rule(:lines) { line.repeat }
+  rule(:line) { spaces >> expression.repeat >> newline }
+  rule(:newline) { str("\n") >> str("\r").maybe }
+  
+  rule(:expression) { (str('a').as(:a) >> spaces).as(:exp) }
+  
+  rule(:spaces) { space.repeat }
+  rule(:space) { multiline_comment | line_comment | str(' ') }
+  
+  rule(:line_comment) { (str('//') >> (newline.absent? >> any).repeat).as(:line) }
+  rule(:multiline_comment) { (str('/*') >> (str('*/').absent? >> any).repeat >> str('*/')).as(:multi) }
+end
+
+code = %q(
+  a
+  // line comment
+  a a a // line comment
+  a /* inline comment */ a 
+  /* multiline
+  comment */
+)
+
+pp ALanguage.new.parse_with_debug(code)

data/example/deepest_errors.rb

@@ -0,0 +1,131 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+# This example demonstrates how to do deepest error reporting, as invented 
+# by John Mettraux (issue #64).
+
+require 'parslet'
+require 'parslet/convenience'
+
+def prettify(str)
+  puts " "*3 + " "*4 + "." + " "*4 + "10" + " "*3 + "." + " "*4 + "20"
+  str.lines.each_with_index do |line, index|
+    printf "%02d %s\n", 
+      index+1, 
+      line.chomp
+  end
+end
+
+class Parser < Parslet::Parser
+  # commons
+
+  rule(:space) { match('[ \t]').repeat(1) }
+  rule(:space?) { space.maybe }
+
+  rule(:newline) { match('[\r\n]') }
+
+  rule(:comment) { str('#') >> match('[^\r\n]').repeat }
+
+  rule(:line_separator) {
+    (space? >> ((comment.maybe >> newline) | str(';')) >> space?).repeat(1)
+  }
+
+  rule(:blank) { line_separator | space }
+  rule(:blank?) { blank.maybe }
+
+  rule(:identifier) { match('[a-zA-Z0-9_]').repeat(1) }
+
+  # res_statement
+
+  rule(:reference) {
+    (str('@').repeat(1,2) >> identifier).as(:reference)
+  }
+
+  rule(:res_action_or_link) {
+    str('.').as(:dot) >> (identifier >> str('?').maybe ).as(:name) >> str('()')
+  }
+
+  rule(:res_actions) {
+    (
+      reference
+    ).as(:resources) >>
+    (
+      res_action_or_link.as(:res_action)
+    ).repeat(0).as(:res_actions)
+  }
+
+  rule(:res_statement) {
+    res_actions >>
+    (str(':') >> identifier.as(:name)).maybe.as(:res_field)
+  }
+
+  # expression
+
+  rule(:expression) {
+    res_statement
+  }
+
+  # body
+
+  rule(:body) {
+    (line_separator >> (block | expression)).repeat(1).as(:body) >>
+    line_separator
+  }
+
+  # blocks
+
+  rule(:begin_block) {
+    (str('concurrent').as(:type) >> space).maybe.as(:pre) >>
+    str('begin').as(:begin) >>
+    body >>
+    str('end')
+  }
+
+  rule(:define_block) {
+    str('define').as(:define) >> space >>
+    identifier.as(:name) >> str('()') >>
+    body >>
+    str('end')
+  }
+
+  rule(:block) {
+    define_block | begin_block
+  }
+
+  # root
+
+  rule(:radix) {
+    line_separator.maybe >> block >> line_separator.maybe
+  }
+
+  root(:radix)
+end
+
+ds = [
+  %{
+    define f()
+      @res.name
+    end
+  },
+  %{
+    define f()
+      begin
+        @res.name
+      end
+    end
+  }
+]
+
+ds.each do |d|
+
+  puts '-' * 80
+  prettify(d)
+
+  parser = Parser.new
+
+  begin
+    parser.parse_with_debug(d, 
+      :reporter => Parslet::ErrorReporter::Deepest.new)
+  end
+end
+
+puts '-' * 80

data/example/documentation.rb

@@ -0,0 +1,18 @@
+# A small example that shows a really small parser and what happens on parser
+# errors. 
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require 'parslet'
+
+class MyParser < Parslet::Parser
+  rule(:a) { str('a').repeat }
+  
+  def parse(str)
+    a.parse(str)
+  end
+end
+
+pp MyParser.new.parse('aaaa')
+pp MyParser.new.parse('bbbb')

data/example/email_parser.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+# Example contributed by Hal Brodigan (postmodern). Thanks!
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'parslet'
+require 'parslet/convenience'
+
+class EmailParser < Parslet::Parser
+  rule(:space) { match('\s').repeat(1) }
+  rule(:space?) { space.maybe }
+  rule(:dash?) { match['_-'].maybe }
+
+  rule(:at) {
+    str('@') |
+    (dash? >> (str('at') | str('AT')) >> dash?)
+  }
+  rule(:dot) {
+    str('.') |
+    (dash? >> (str('dot') | str('DOT')) >> dash?)
+  }
+
+  rule(:word) { match('[a-z0-9]').repeat(1).as(:word) >> space? }
+  rule(:separator) { dot.as(:dot) >> space? | space }
+  rule(:words) { word >> (separator >> word).repeat }
+
+  rule(:email) {
+    (words.as(:username) >> space? >> at >> space? >> words).as(:email)
+  }
+
+  root(:email)
+end
+
+class EmailSanitizer < Parslet::Transform
+  rule(:dot => simple(:dot), :word => simple(:word)) { ".#{word}" }
+  rule(:word => simple(:word)) { word }
+
+  rule(:username => sequence(:username)) { username.join + "@" }
+  rule(:username => simple(:username)) { username.to_s + "@" }
+
+  rule(:email => sequence(:email)) { email.join }
+end
+
+parser = EmailParser.new
+sanitizer = EmailSanitizer.new
+
+unless ARGV[0]
+  STDERR.puts "usage: #{$0} \"EMAIL_ADDR\""
+  STDOUT.puts "since you haven't specified any EMAIL_ADDR, for testing purposes we're using a.b.c.d@gmail.com"
+end
+
+p sanitizer.apply(parser.parse_with_debug(ARGV[0] || 'a.b.c.d@gmail.com'))

data/example/empty.rb

@@ -0,0 +1,13 @@
+# Basically just demonstrates that you can leave rules empty and get a nice
+# NotImplementedError. A way to quickly spec out your parser rules?
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parslet'
+
+class Parser < Parslet::Parser
+  rule(:empty) { }
+end
+
+
+Parser.new.empty.parslet

data/example/erb.rb

@@ -0,0 +1,47 @@
+# Example that demonstrates how a simple erb-like parser could be constructed. 
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parslet'
+
+class ErbParser < Parslet::Parser
+  rule(:ruby) { (str('%>').absent? >> any).repeat.as(:ruby) }
+  
+  rule(:expression) { (str('=') >> ruby).as(:expression) }
+  rule(:comment) { (str('#') >> ruby).as(:comment) }
+  rule(:code) { ruby.as(:code) }
+  rule(:erb) { expression | comment | code }
+  
+  rule(:erb_with_tags) { str('<%') >> erb >> str('%>') }
+  rule(:text) { (str('<%').absent? >> any).repeat(1) }
+  
+  rule(:text_with_ruby) { (text.as(:text) | erb_with_tags).repeat.as(:text) }
+  root(:text_with_ruby)
+end
+
+parser = ErbParser.new
+p parser.parse "The value of x is <%= x %>."
+p parser.parse "<% 1 + 2 %>"
+p parser.parse "<%# commented %>"
+ 
+
+evaluator = Parslet::Transform.new do
+  
+  erb_binding = binding
+  
+  rule(:code => { :ruby => simple(:ruby) }) { eval(ruby, erb_binding); '' }  
+  rule(:expression => { :ruby => simple(:ruby) }) { eval(ruby, erb_binding) }
+  rule(:comment => { :ruby => simple(:ruby) }) { '' }
+  
+  rule(:text => simple(:text)) { text }
+  rule(:text => sequence(:texts)) { texts.join }
+  
+end
+
+puts evaluator.apply(parser.parse(<<-ERB
+The <% a = 2 %>not printed result of "a = 2".
+The <%# a = 1 %>not printed non-evaluated comment "a = 1", see the value of a below.
+The <%= 'nicely' %> printed result.
+The <% b = 3 %>value of a is <%= a %>, and b is <%= b %>.
+ERB
+))

data/example/ignore.rb

@@ -0,0 +1,33 @@
+# A small example on how to make parslet ignore parts of the parse tree. 
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'parslet'
+
+class IgnoreParslet < Parslet::Atoms::Base
+  def initialize(parslet)
+    @parslet = parslet
+  end
+  def to_s_inner(prec)
+    @parslet.to_s(prec)
+  end
+  def try(source, context)
+    success, value = result = @parslet.try(source, context)
+    
+    return succ(nil) if success
+    return result
+  end
+  
+end
+module IgnoreDSL
+  def ignore
+    IgnoreParslet.new(self)
+  end
+end
+
+class Parslet::Atoms::Base
+  include IgnoreDSL
+end
+
+include Parslet
+p (str('a') >> str('b').ignore >> str('c')).
+  parse('abc')

data/example/ip_address.rb

@@ -0,0 +1,125 @@
+# This example is heavily inspired by citrus' ip.citrus. Have a look at both
+# of these to get some choice!
+
+# The grammars in this file conform to the ABNF given in Appendix A of RFC 3986
+# Uniform Resource Identifier (URI): Generic Syntax.
+#
+# See http://tools.ietf.org/html/rfc3986#appendix-A for more information.
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require 'parslet'
+
+module IPv4
+  include Parslet
+  
+  # A host identified by an IPv4 literal address is represented in
+  # dotted-decimal notation (a sequence of four decimal numbers in the range 0
+  # to 255, separated by "."), as described in [RFC1123] by reference to
+  # [RFC0952].  Note that other forms of dotted notation may be interpreted on
+  # some platforms, as described in Section 7.4, but only the dotted-decimal
+  # form of four octets is allowed by this grammar.
+  rule(:ipv4) {
+    (dec_octet >> str('.') >> dec_octet >> str('.') >>
+      dec_octet >> str('.') >> dec_octet).as(:ipv4)
+  }
+  
+  rule(:dec_octet) {
+    str('25') >> match("[0-5]") |
+    str('2') >> match("[0-4]") >> digit |
+    str('1') >> digit >> digit |
+    match('[1-9]') >> digit |
+    digit
+  }
+  
+  rule(:digit) {
+    match('[0-9]')
+  }
+end
+
+# Must be used in concert with IPv4
+module IPv6 
+  include Parslet
+  
+  rule(:colon) { str(':') }
+  rule(:dcolon) { colon >> colon }
+  
+  # h16 :
+  def h16r(times)
+    (h16 >> colon).repeat(times, times)
+  end
+  
+  # : h16
+  def h16l(times)
+    (colon >> h16).repeat(0,times)
+  end
+  
+  # A 128-bit IPv6 address is divided into eight 16-bit pieces. Each piece is
+  # represented numerically in case-insensitive hexadecimal, using one to four
+  # hexadecimal digits (leading zeroes are permitted). The eight encoded
+  # pieces are given most-significant first, separated by colon characters.
+  # Optionally, the least-significant two pieces may instead be represented in
+  # IPv4 address textual format. A sequence of one or more consecutive
+  # zero-valued 16-bit pieces within the address may be elided, omitting all
+  # their digits and leaving exactly two consecutive colons in their place to
+  # mark the elision.
+  rule(:ipv6) {
+    (
+      (
+        h16r(6) |
+        dcolon >> h16r(5) | 
+        h16.maybe >> dcolon >> h16r(4) |
+        (h16 >> h16l(1)).maybe >> dcolon >> h16r(3) |
+        (h16 >> h16l(2)).maybe >> dcolon >> h16r(2) |
+        (h16 >> h16l(3)).maybe >> dcolon >> h16r(1) |
+        (h16 >> h16l(4)).maybe >> dcolon
+      ) >> ls32 |
+      (h16 >> h16l(5)).maybe >> dcolon >> h16 |
+      (h16 >> h16l(6)).maybe >> dcolon
+    ).as(:ipv6)
+  }
+  
+  rule(:h16) {
+    hexdigit.repeat(1,4)
+  }
+  
+  rule(:ls32) {
+    (h16 >> colon >> h16) |
+    ipv4
+  }
+
+  rule(:hexdigit) {
+    digit | match("[a-fA-F]")
+  }
+end
+
+class Parser
+  include IPv4
+  include IPv6
+  
+  def parse(str)
+    (ipv4 | ipv6).parse(str)
+  end
+end
+
+%W(
+  0.0.0.0
+  255.255.255.255
+  255.255.255
+  1:2:3:4:5:6:7:8
+  12AD:34FC:A453:1922::
+  12AD::34FC
+  12AD::
+  ::
+  1:2
+).each do |address|
+  parser = Parser.new
+  printf "%30s -> ", address
+  begin
+    result = parser.parse(address)
+    puts result.inspect
+  rescue Parslet::ParseFailed => m
+    puts "Failed: #{m}"
+  end
+end