peglite 0.0.1 → 0.0.2

data/.gemspec

@@ -2,7 +2,7 @@
 
 GemSpec = Gem::Specification.new do |gem|
   gem.name = 'peglite'
-  gem.version = '0.0.1'
+  gem.version = '0.0.2'
   gem.license = 'MIT'
   gem.required_ruby_version = '>= 1.9.1'
 

data/CHANGELOG.yaml

@@ -1,3 +1,9 @@
+- version: 0.0.2
+  date:    Wed Jan  2 18:05:30 PST 2013
+  changes:
+  - Add examples
+  - Add \A to regexes automatically
+  - Test an extended grammar
 - version: 0.0.1
   date:    Wed Jan  2 14:51:35 PST 2013
   changes: Ported from Pegex.pm CPAN module.

data/ToDo

@@ -0,0 +1,2 @@
++ Add \A automatically
++ Add accessor for @input

data/examples/parslet1.rb

@@ -0,0 +1,23 @@
+require 'peglite'
+
+class Mini < PegLite
+  rule integer: (/(\d+)/)
+end
+
+p Mini.new.parse "132432"   # => "132432"
+
+__END__
+This is the PegLite version of the "simplest Parselet" example from here:
+
+    http://kschiess.github.com/parslet/get-started.html
+
+Here is the original:
+
+    require 'parslet'
+
+    class Mini < Parslet::Parser
+      rule(:integer) { match('[0-9]').repeat(1) }
+      root(:integer)
+    end
+
+    Mini.new.parse("132432")  # => "132432"@0

data/examples/parslet2.rb

@@ -0,0 +1,51 @@
+require 'peglite'
+
+class Mini < PegLite
+  rule expression: "sum | integer"
+  rule integer: /(\d+)/
+  rule operator: /([+])/
+  rule sum: "integer _ operator _ expression"
+end
+
+def parse str
+  mini = Mini.new
+  mini.parse str
+rescue PegLite::PegexParseError => failure
+  Mini.new(debug: true).parse str
+end
+
+p parse "1 + 2 + 3"     # => ["1", "+", ["2", "+", "3"]]
+p parse "a + 2"         # => Print debug trace and error analysis
+
+__END__
+This is the PegLite version of the "Parselet expression parser" example from
+here:
+
+    http://kschiess.github.com/parslet/get-started.html
+
+Here is the original:
+
+  class Mini < Parslet::Parser
+    rule(:integer)    { match('[0-9]').repeat(1) >> space? }
+
+    rule(:space)      { match('\s').repeat(1) }
+    rule(:space?)     { space.maybe }
+
+    rule(:operator)   { match('[+]') >> space? }
+
+    rule(:sum)        { integer >> operator >> expression }
+    rule(:expression) { sum | integer }
+
+    root :expression
+  end
+
+  def parse(str)
+    mini = Mini.new
+
+    mini.parse(str)
+  rescue Parslet::ParseFailed => failure
+    puts failure.cause.ascii_tree
+  end
+
+  parse "1 + 2 + 3"  # => "1 + 2 + 3"@0
+  parse "a + 2"      # fails, see below

data/lib/peglite.rb

@@ -7,17 +7,18 @@ require 'yaml'; def YYY *args; args.each \
 
 #------------------------------------------------------------------------------
 class PegLite
-  $PegLiteRules = {}         # XXX global variable smell
+  VERSION = '0.0.2'
+
+  $PegLiteRules = {}         # TODO get rid of global variable smell
   def self.rule args
     name, rule = args.first
     name = name.to_s
     $PegLiteTopRule ||= name
     if rule.kind_of? Regexp
-      fail "Regexp for '#{name}' must begin with '\\A'" \
-        unless rule.to_s.match /\A\(\?-mix:\\A/
+      regex = Regexp.new(rule.to_s.sub(/:/, ':\\A'))
       $PegLiteRules[name] = {
         'type' => 'rgx',
-        'rule' => rule,
+        'rule' => regex,
         'min' => 1,
         'max' => 1,
       }
@@ -28,20 +29,25 @@ class PegLite
     end
   end
 
-  rule _: (/\A\s*/)
-  rule __: (/\A\s+/)
-  rule EQUAL: (/\A=/)
-  rule COMMA: (/\A,/)
-  rule NL: (/\A\n/)
+  # TODO define all the Pegex Atoms here
+  rule _: (/\s*/)
+  rule __: (/\s+/)
+  rule EQUAL: (/=/)
+  rule COMMA: (/,/)
+  rule PLUS: (/\+/)
+  rule NL: (/\n/)
+  rule EOL: (/\r?\n/)
   $PegLiteTopRule = nil
 
   attr_accessor :got
   attr_accessor :wrap
   attr_accessor :debug
+  attr_accessor :input
   def initialize attrs={}
     @got = nil
     @wrap = false
     @debug = false
+    @input = nil
 
     attrs.each { |k,v| self.send "#{k}=", v }
 
@@ -51,7 +57,7 @@ class PegLite
     yield self if block_given?
   end
 
-  def parse input, top=($PegLiteTopRule || 'top')
+  def parse input=@input, top=($PegLiteTopRule || 'top')
     fail "PegLite parse() method requires an input string" \
       unless input.kind_of? String
     @input = input

data/test/address.rb

@@ -1,12 +1,18 @@
+# This PegLite test shows an address grammar parsing an street address.
+# We parse it 3 different ways, to get different desired results.
+
+
 require 'test/unit'
 require 'peglite'
 
-$address1 = <<'...'
+# A sample street address
+$address = <<'...'
 John Doe
 123 Main St
 Los Angeles, CA 90009
 ...
 
+# Expected result tree for default/plain parsing
 $parse_plain = <<'...'
 ---
 - John Doe
@@ -16,6 +22,7 @@ $parse_plain = <<'...'
   - '90009'
 ...
 
+# Expected result tree using the 'wrap' option
 $parse_wrap = <<'...'
 ---
 address:
@@ -32,25 +39,67 @@ address:
         - '90009'
 ...
 
+# Expected result tree from our Custom parser extension
+$parse_custom = <<'...'
+---
+name: John Doe
+street: 123 Main St
+city: Los Angeles
+state: CA
+zipcode: '90008'
+...
+
+# Run 3 tests
 class Test::Unit::TestCase
+  # Parse address to an array of arrays
   def test_plain
     parser = AddressParser.new
-    result = parser.parse $address1
+    result = parser.parse $address
     assert_equal YAML.dump(result), $parse_plain, "Plain parse works"
   end
+  # Turn on 'wrap' to add rule name to each result
   def test_wrap
     parser = AddressParser.new wrap: true
-    result = parser.parse $address1
+    result = parser.parse $address
     assert_equal YAML.dump(result), $parse_wrap, "Wrapping parse works"
   end
+  # Return a custom AST
+  def test_custom
+    parser = AddressParserCustom.new
+    result = parser.parse $address
+    assert_equal YAML.dump(result), $parse_custom, "Custom parse works"
+  end
 end
 
+# This class defines a complete address parser using PegLite
 class AddressParser < PegLite
   rule address: "name street place"
-  rule name: (/\A(.*?)\n/)
-  rule street: (/\A(.*?)\n/)
+  rule name: (/(.*?)\n/)
+  rule street: (/(.*?)\n/)
   rule place: "city COMMA _ state __ zip NL"
-  rule city: (/\A(\w+(?: \w+)?)/)
-  rule state: (/\A(WA|OR|CA)/)  # Left Coast Rulez
-  rule zip: (/\A(\d{5})/)
+  rule city: (/(\w+(?: \w+)?)/)
+  rule state: (/(WA|OR|CA)/)  # Left Coast Rulez
+  rule zip: (/(\d{5})/)
+end
+
+# Extend AddressParser
+class AddressParserCustom < AddressParser
+  def address
+    name, street, place = match.first
+    city, state, zip = place
+    # Make the final AST from the parts collected.
+    @got = {
+      'name' => name,
+      'street' => street,
+      'city' => city,
+      'state' => state,
+      # Show as 'zipcode' instead of 'zip'
+      'zipcode' => zip,
+    }
+  end
+
+  # Subtract 1 from the zipcode for fun
+  def zip
+    (match.first.to_i - 1).to_s
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: peglite
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-02 00:00:00.000000000 Z
+date: 2013-01-03 00:00:00.000000000 Z
 dependencies: []
 description: ! 'PegLite is a very simple framework for creating your own PEG parsers.
 
@@ -25,6 +25,9 @@ files:
 - LICENSE
 - README.rdoc
 - Rakefile
+- ToDo
+- examples/parslet1.rb
+- examples/parslet2.rb
 - lib/peglite.rb
 - lib/peglite/compiler.rb
 - test/address.rb