ghazel-parslet 1.4.0.1

data/example/json.rb

@@ -0,0 +1,128 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+#
+# MIT License - (c) 2011 John Mettraux
+#
+
+require 'rubygems'
+require 'parslet' # gem install parslet
+
+
+module MyJson
+
+  class Parser < Parslet::Parser
+
+    rule(:spaces) { match('\s').repeat(1) }
+    rule(:spaces?) { spaces.maybe }
+
+    rule(:comma) { spaces? >> str(',') >> spaces? }
+    rule(:digit) { match('[0-9]') }
+
+    rule(:number) {
+      (
+        str('-').maybe >> (
+          str('0') | (match('[1-9]') >> digit.repeat)
+        ) >> (
+          str('.') >> digit.repeat(1)
+        ).maybe >> (
+          match('[eE]') >> (str('+') | str('-')).maybe >> digit.repeat(1)
+        ).maybe
+      ).as(:number)
+    }
+
+    rule(:string) {
+      str('"') >> (
+        str('\\') >> any | str('"').absent? >> any
+      ).repeat.as(:string) >> str('"')
+    }
+
+    rule(:array) {
+      str('[') >> spaces? >>
+      (value >> (comma >> value).repeat).maybe.as(:array) >>
+      spaces? >> str(']')
+    }
+
+    rule(:object) {
+      str('{') >> spaces? >>
+      (entry >> (comma >> entry).repeat).maybe.as(:object) >>
+      spaces? >> str('}')
+    }
+
+    rule(:value) {
+      string | number |
+      object | array |
+      str('true').as(:true) | str('false').as(:false) |
+      str('null').as(:null)
+    }
+
+    rule(:entry) {
+      (
+         string.as(:key) >> spaces? >>
+         str(':') >> spaces? >>
+         value.as(:val)
+      ).as(:entry)
+    }
+
+    rule(:attribute) { (entry | value).as(:attribute) }
+
+    rule(:top) { spaces? >> value >> spaces? }
+
+    root(:top)
+  end
+
+  class Transformer < Parslet::Transform
+
+    class Entry < Struct.new(:key, :val); end
+
+    rule(:array => subtree(:ar)) {
+      ar.is_a?(Array) ? ar : [ ar ]
+    }
+    rule(:object => subtree(:ob)) {
+      (ob.is_a?(Array) ? ob : [ ob ]).inject({}) { |h, e| h[e.key] = e.val; h }
+    }
+
+    rule(:entry => { :key => simple(:ke), :val => simple(:va) }) {
+      Entry.new(ke, va)
+    }
+
+    rule(:string => simple(:st)) {
+      st.to_s
+    }
+    rule(:number => simple(:nb)) {
+      nb.match(/[eE\.]/) ? Float(nb) : Integer(nb)
+    }
+
+    rule(:null => simple(:nu)) { nil }
+    rule(:true => simple(:tr)) { true }
+    rule(:false => simple(:fa)) { false }
+  end
+
+  def self.parse(s)
+
+    parser = Parser.new
+    transformer = Transformer.new
+
+    tree = parser.parse(s)
+    puts; p tree; puts
+    out = transformer.apply(tree)
+
+    out
+  end
+end
+
+
+s = %{
+  [ 1, 2, 3, null,
+    "asdfasdf asdfds", { "a": -1.2 }, { "b": true, "c": false },
+    0.1e24, true, false, [ 1 ] ]
+}
+
+out = MyJson.parse(s)
+
+p out; puts
+
+out == [
+  1, 2, 3, nil,
+  "asdfasdf asdfds", { "a" => -1.2 }, { "b" => true, "c" => false },
+  0.1e24, true, false, [ 1 ]
+] || raise("MyJson is a failure")

data/example/local.rb

@@ -0,0 +1,34 @@
+
+# An exploration of two ideas: 
+#   a) Constructing a whole parser inline, without the artificial class around
+#      it. 
+# and:
+#   b) Constructing non-greedy or non-blind parsers by transforming the 
+#      grammar.
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parslet'
+include Parslet
+
+a =  str('a').repeat >> str('aa')
+
+# E1% E2
+# 
+# S = E2 | E1 S 
+
+def this(name, &block); return Parslet::Atoms::Entity.new(name, &block) end
+def epsilon; any.absent? end 
+
+# Traditional repetition will try as long as the pattern can be matched and 
+# then give up. This is greedy and blind. 
+a = str('a').as(:e) >> this('a') { a }.as(:rec) | epsilon
+
+# Here's a pattern match that is greedy and non-blind. The first pattern
+# 'a'* will be tried as many times as possible, while still matching the 
+# end pattern 'aa'.
+b = str('aa').as(:e2) >> epsilon | str('a').as(:e1) >> this('b') { b }.as(:rec)
+
+p a.parse('aaaa')
+p b
+p b.parse('aaaa')

data/example/mathn.rb

@@ -0,0 +1,44 @@
+# Demonstrates that we have a compatibility fix to mathn's weird idea of 
+# integer mathematics. 
+# This was contributed by Jonathan Hinkle (https://github.com/hynkle). Thanks!
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parslet'
+require 'parslet/convenience'
+include Parslet
+
+def attempt_parse
+  possible_whitespace = match['\s'].repeat
+
+  cephalopod =
+    str('octopus') |
+    str('squid')
+
+  parenthesized_cephalopod =
+    str('(') >>
+    possible_whitespace >>
+    cephalopod >>
+    possible_whitespace >>
+    str(')')
+
+  parser =
+    possible_whitespace >>
+    parenthesized_cephalopod >>
+    possible_whitespace
+
+  # This parse fails, but that is not the point. When mathn is in the current
+  # ruby environment, it modifies integer division in a way that makes 
+  # parslet loop indefinitely.
+  parser.parse %{(\nsqeed)\n}
+rescue Parslet::ParseFailed
+end
+
+attempt_parse 
+puts 'it terminates before we require mathn'
+
+puts "requiring mathn now"
+require 'mathn'
+puts "and trying again (will hang without the fix)"
+attempt_parse # but it doesn't terminate after requiring mathn
+puts "okay!"

data/example/minilisp.rb

@@ -0,0 +1,94 @@
+# Reproduces [1] using parslet. 
+# [1] http://thingsaaronmade.com/blog/a-quick-intro-to-writing-a-parser-using-treetop.html
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require 'parslet'
+require 'parslet/convenience'
+
+module MiniLisp
+  class Parser < Parslet::Parser
+    root :expression
+    rule(:expression) {
+      space? >> str('(') >> space? >> body >> str(')') >> space?
+    }
+    
+    rule(:body) {
+      (expression | identifier | float | integer | string).repeat.as(:exp)
+    }
+    
+    rule(:space) {
+      match('\s').repeat(1)
+    }
+    rule(:space?) {
+      space.maybe
+    }
+    
+    rule(:identifier) { 
+      (match('[a-zA-Z=*]') >> match('[a-zA-Z=*_]').repeat).as(:identifier) >> space?
+    }
+    
+    rule(:float) { 
+      (
+        integer >> (
+          str('.') >> match('[0-9]').repeat(1) |
+          str('e') >> match('[0-9]').repeat(1)
+        ).as(:e)
+      ).as(:float) >> space?
+    }
+    
+    rule(:integer) {
+      ((str('+') | str('-')).maybe >> match("[0-9]").repeat(1)).as(:integer) >> space?
+    }
+    
+    rule(:string) {
+      str('"') >> (
+        str('\\') >> any |
+        str('"').absent? >> any 
+      ).repeat.as(:string) >> str('"') >> space?
+    }
+  end
+  
+  class Transform
+    include Parslet
+    
+    attr_reader :t
+    def initialize
+      @t = Parslet::Transform.new
+      
+      # To understand these, take a look at what comes out of the parser. 
+      t.rule(:identifier => simple(:ident)) { ident.to_sym }
+        
+      t.rule(:string => simple(:str))       { str }
+        
+      t.rule(:integer => simple(:int))      { Integer(int) }
+        
+      t.rule(:float=>{:integer=> simple(:a), :e=> simple(:b)}) { Float(a + b) }
+        
+      t.rule(:exp => subtree(:exp))         { exp }
+    end
+    
+    def do(tree)
+      t.apply(tree)
+    end
+  end
+end
+
+parser = MiniLisp::Parser.new
+transform = MiniLisp::Transform.new
+
+result = parser.parse_with_debug %Q{
+  (define test (lambda ()
+    (begin
+      (display "something")
+      (display 1)
+      (display 3.08))))
+}
+
+# Transform the result
+pp transform.do(result) if result
+
+# Thereby reducing it to the earlier problem: 
+# http://github.com/kschiess/toylisp
+

data/example/modularity.rb

@@ -0,0 +1,47 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require "parslet"
+
+# Demonstrates modular parsers, split out over many classes. Please look at
+# ip_address.rb as well.
+
+module ALanguage
+  include Parslet
+    
+  # Parslet rules are really a special kind of method. Mix them into your
+  # classes!
+  rule(:a_language) { str('aaa') }
+end
+
+# Parslet parsers are parslet atoms as well. Create an instance and chain them
+# to your other rules. 
+#
+class BLanguage < Parslet::Parser
+  root :blang
+  
+  rule(:blang) { str('bbb') }
+end
+
+# Parslet atoms are really Ruby values, pass them around. 
+c_language = Parslet.str('ccc')
+  
+class Language < Parslet::Parser
+  def initialize(c_language)
+    @c_language = c_language
+    super()
+  end
+  
+  root :root
+
+  include ALanguage
+  
+  rule(:root) { str('a(') >> a_language >> str(')') >> space |
+                str('b(') >> BLanguage.new >> str(')') >> space | 
+                str('c(') >> @c_language >> str(')') >> space }
+  rule(:space) { str(' ').maybe }
+end
+
+Language.new(c_language).parse('a(aaa)')
+Language.new(c_language).parse('b(bbb)')
+Language.new(c_language).parse('c(ccc)')

data/example/nested_errors.rb

@@ -0,0 +1,132 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parslet'
+require 'parslet/convenience'
+
+# This example demonstrates tree error reporting in a real life example. 
+# The parser code has been contributed by John Mettraux.
+
+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)
+  end
+end
+
+puts '-' * 80