parslet 1.0.0 → 1.0.1

data/HISTORY.txt

@@ -1,3 +1,17 @@
+= 1.1.0 / ???
+  
+  + Uses throw/catch internally for an order of magnitude increase in execution
+    speed.
+    
+= 1.0.1 / 17Jan2011
+
+  A happy new year!
+  
+  ! FIX: Parslet::Transform was wrongly fixed earlier - it now wont mangle 
+    hashes anymore. (Blake Sweeney)
+    
+  + parslet/rig/rspec.rb contains useful rspec matchers. (R. Konstantin Haase)
+
 = 1.0.0 / 29Dez2010
 
   - #each_match was removed. There was some duplication of code that even 

data/README

@@ -47,8 +47,6 @@ This library should work with both ruby 1.8 and ruby 1.9.
 
 STATUS 
 
-0.12.0 
-
-On the road to 1.0; improving documentation, trying to ease access to the API.
+one dot oh.
 
 (c) 2010 Kaspar Schiess

data/Rakefile

@@ -18,7 +18,7 @@ spec = Gem::Specification.new do |s|
 
   # Change these as appropriate
   s.name              = "parslet"
-  s.version           = "1.0.0"
+  s.version           = "1.0.1"
   s.summary           = "Parser construction library with great error reporting in Ruby."
   s.author            = "Kaspar Schiess"
   s.email             = "kaspar.schiess@absurd.li"
@@ -29,7 +29,7 @@ spec = Gem::Specification.new do |s|
   s.rdoc_options      = %w(--main README)
 
   # Add any extra files to include in the gem
-  s.files             = %w(Gemfile HISTORY.txt LICENSE Rakefile README) + Dir.glob("{spec,lib/**/*}")
+  s.files             = %w(Gemfile HISTORY.txt LICENSE Rakefile README) + Dir.glob("{lib,example}/**/*")
   s.require_paths     = ["lib"]
 
   # If you want to depend on other gems, add them here, along with any

data/example/documentation.rb

@@ -0,0 +1,18 @@
+# A small example that shows a really small parser and what happens on parser
+# errors. 
+
+$:.unshift '../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!
+
+require 'parslet'
+
+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) { space? >> dot.as(:dot) >> space? | space }
+  rule(:words) { word >> (separator >> word).repeat }
+
+  rule(:email) {
+    (words >> space? >> at.as(:at) >> space? >> words).as(:email)
+  }
+
+  root(:email)
+end
+
+class EmailSanitizer < Parslet::Transform
+  rule(:dot => simple(:dot), :word => simple(:word)) { ".#{word}" }
+  rule(:at => simple(:at)) { '@' }
+  rule(:word => simple(:word)) { word }
+  rule(:email => sequence(:email)) { email.join }
+end
+
+parser = EmailParser.new
+sanitizer = EmailSanitizer.new
+
+unless ARGV[0]
+  STDERR.puts "usage: #{$0} \"EMAIL_ADDR\""
+  exit -1
+end
+
+begin
+  puts sanitizer.apply(parser.parse(ARGV[0]))
+rescue Parslet::ParseFailed => error
+  puts error
+  puts parser.root.error_tree
+end

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 '../lib'
+
+require 'parslet'
+
+class Parser < Parslet::Parser
+  rule(:empty) { }
+end
+
+
+Parser.new.empty.parslet

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 '../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

data/example/minilisp.rb

@@ -0,0 +1,101 @@
+# Reproduces [1] using parslet. 
+# [1] http://thingsaaronmade.com/blog/a-quick-intro-to-writing-a-parser-using-treetop.html
+
+$:.unshift '../lib'
+
+require 'pp'
+require 'parslet'
+
+module MiniLisp
+  class Parser < Parslet::Parser
+    root :expression
+    rule(:expression) {
+      space? >> str('(') >> space? >> body >> str(')')
+    }
+    
+    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('"').absnt? >> 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
+
+# Parse stage
+begin
+  result = parser.parse %Q{
+    (define test (lambda ()
+      (begin
+        (display "something")
+        (display 1)
+        (display 3.08))))
+    (test)
+  }
+rescue Parslet::ParseFailed => failure
+  puts failure
+  puts parser.root.error_tree if parser.root.cause
+  exit
+end
+
+# Transform the result
+pp transform.do(result)
+
+# Thereby reducing it to the earlier problem: 
+# http://github.com/kschiess/toylisp
+

data/example/parens.rb

@@ -0,0 +1,42 @@
+# A small example that demonstrates the power of tree pattern matching. Also
+# uses '.as(:name)' to construct a tree that can reliably be matched
+# afterwards. 
+
+$:.unshift '../lib'
+
+require 'pp'
+require 'parslet'
+
+module LISP # as in 'lots of insipid and stupid parenthesis'
+  class Parser < Parslet::Parser
+    rule(:balanced) {
+      str('(').as(:l) >> balanced.maybe.as(:m) >> str(')').as(:r)
+    }
+  
+    root(:balanced)
+  end
+
+  class Transform < Parslet::Transform
+    rule(:l => '(', :m => simple(:x), :r => ')') { 
+      # innermost :m will contain nil
+      x.nil? ? 1 : x+1
+    }
+  end
+end
+
+parser = LISP::Parser.new
+transform = LISP::Transform.new
+%w!
+  ()
+  (())
+  ((((()))))
+  ((())
+!.each do |pexp|
+  begin
+    result = parser.parse(pexp)
+    puts "#{"%20s"%pexp}: #{result.inspect} (#{transform.apply(result)} parens)"
+  rescue Parslet::ParseFailed => m
+    puts "#{"%20s"%pexp}: #{m}"
+  end
+  puts
+end

data/example/readme.rb

@@ -0,0 +1,36 @@
+# The example from the readme. With this, I am making sure that the readme 
+# 'works'. Is this too messy?
+
+$:.unshift '../lib'
+
+require 'pp'
+require 'parslet'
+include Parslet
+
+require 'parslet'
+include Parslet
+
+# Constructs a parser using a Parser Expression Grammar like DSL: 
+parser =  str('"') >> 
+          (
+            str('\\') >> any |
+            str('"').absnt? >> any
+          ).repeat.as(:string) >> 
+          str('"')
+  
+# Parse the string and capture parts of the interpretation (:string above)        
+tree = parser.parse(%Q{
+  "This is a \\"String\\" in which you can escape stuff"
+}.strip)
+
+tree # => {:string=>"This is a \\\"String\\\" in which you can escape stuff"}
+
+# Here's how you can grab results from that tree:
+
+# 1)
+transform = Parslet::Transform.new do
+  rule(:string => simple(:x)) { 
+    puts "String contents: #{x}" }
+end
+transform.apply(tree)
+

data/example/seasons.rb

@@ -0,0 +1,45 @@
+$:.unshift '../lib/'
+require 'parslet'
+require 'pp'
+
+tree = {:bud => {:stem => []}}
+
+class Spring < Parslet::Transform
+  rule(:stem => sequence(:branches)) {
+    {:stem => (branches + [{:branch => :leaf}])}
+  }
+end
+class Summer < Parslet::Transform
+  rule(:stem => subtree(:branches)) {
+    new_branches = branches.map { |b| {:branch => [:leaf, :flower]} }
+    {:stem => new_branches}
+  }
+end
+class Fall < Parslet::Transform
+  rule(:branch => sequence(:x)) {
+    x.each { |e| puts "Fruit!" if e==:flower }
+    x.each { |e| puts "Falling Leaves!" if e==:leaf }
+    {:branch => []}
+  }
+end
+class Winter < Parslet::Transform
+  rule(:stem => subtree(:x)) {
+    {:stem => []}
+  }
+end
+
+def do_seasons(tree)
+  [Spring, Summer, Fall, Winter].each do |season|
+    p "And when #{season} comes"
+    tree = season.new.apply(tree)
+    pp tree
+    puts
+  end
+  tree
+end
+
+# What marvel of life!
+tree = do_seasons(tree)
+tree = do_seasons(tree)
+
+

data/example/simple.lit

@@ -0,0 +1,3 @@
+123
+12345
+" Some String with \"escapes\""

data/example/simple_xml.rb

@@ -0,0 +1,57 @@
+# A simple xml parser. It is simple in the respect as that it doesn't address
+# any of the complexities of XML. This is ruby 1.9.
+
+$:.unshift '../lib'
+
+require 'pp'
+require 'parslet'
+
+module XML
+  include Parslet
+
+  root :document
+  
+  rule(:document) {
+    tag(close: false).as(:o) >> document.as(:i) >> tag(close: true).as(:c) |
+    text
+  }
+  
+  # Perhaps we could have some syntax sugar to make this more easy?
+  #
+  def tag(opts={})
+    close = opts[:close] || false
+    
+    parslet = str('<')
+    parslet = parslet >> str('/') if close
+    parslet = parslet >> (str('>').absnt? >> match("[a-zA-Z]")).repeat(1).as(:name)
+    parslet = parslet >> str('>')
+    
+    parslet
+  end
+  
+  rule(:text) {
+    match('[^<>]').repeat(0)
+  }
+end
+
+def check(xml)
+  include XML
+  r=parse(xml)
+
+  # We'll validate the tree by reducing valid pairs of tags into simply the
+  # string "verified". If the transformation ends on a string, then the
+  # document was 'valid'. 
+  #
+  t = Parslet::Transform.new do
+    rule(
+      o: {name: simple(:tag)}, 
+      c: {name: simple(:tag)}, 
+      i: simple(:t)
+    ) { 'verified' } 
+  end
+
+  t.apply(r)
+end
+
+pp check("<a><b>some text in the tags</b></a>")
+pp check("<b><b>some text in the tags</b></a>")

data/example/string_parser.rb

@@ -0,0 +1,75 @@
+# A more complex parser that illustrates how a compiler might be constructed.
+# The parser recognizes strings and integer literals and constructs almost a
+# useful AST from the file contents. 
+
+require 'pp'
+
+$:.unshift '../lib/'
+require 'parslet'
+
+include Parslet
+
+class LiteralsParser < Parslet::Parser
+  rule :space do
+    (match '[ ]').repeat(1)
+  end
+  
+  rule :literals do
+    (literal >> eol).repeat
+  end
+  
+  rule :literal do
+    (integer | string).as(:literal) >> space.maybe
+  end
+  
+  rule :string do
+    str('"') >> 
+    (
+      (str('\\') >> any) |
+      (str('"').absnt? >> any)
+    ).repeat.as(:string) >> 
+    str('"')
+  end
+  
+  rule :integer do
+    match('[0-9]').repeat(1).as(:integer)
+  end
+  
+  rule :eol do
+    line_end.repeat(1)
+  end
+  
+  rule :line_end do
+    crlf >> space.maybe
+  end
+  
+  rule :crlf do
+    match('[\r\n]').repeat(1)
+  end
+
+  root :literals
+end
+
+parsetree = LiteralsParser.new.parse(
+  File.read('simple.lit'))
+  
+class Lit < Struct.new(:text)
+  def to_s
+    text.inspect
+  end
+end
+class StringLit < Lit
+end
+class IntLit < Lit
+  def to_s
+    text
+  end
+end
+
+transform = Parslet::Transform.new do
+  rule(:literal => {:integer => simple(:x)}) { IntLit.new(x) }
+  rule(:literal => {:string => simple(:s)}) { StringLit.new(s) }
+end
+  
+ast = transform.apply(parsetree)
+pp ast

data/example/test.lit

@@ -0,0 +1,4 @@
+"THis is a string"
+"This is another string"
+"This string is escaped \"embedded quoted stuff \" "
+12 // an integer literal and a comment

data/lib/parslet.rb

@@ -66,7 +66,7 @@ module Parslet
   #     puts parslet.error_tree
   #   end
   #
-  class ParseFailed < Exception
+  class ParseFailed < StandardError
   end
   
   module ClassMethods

data/lib/parslet/atoms/alternative.rb

@@ -30,10 +30,9 @@ class Parslet::Atoms::Alternative < Parslet::Atoms::Base
   
   def try(io) # :nodoc:
     alternatives.each { |a|
-      begin
+      catch(:error) {
         return a.apply(io)
-      rescue Parslet::ParseFailed => ex
-      end
+      }
     }
     # If we reach this point, all alternatives have failed. 
     error(io, "Expected one of #{alternatives.inspect}.")

data/lib/parslet/atoms/base.rb

@@ -13,7 +13,18 @@ class Parslet::Atoms::Base
       io = StringIO.new(io)
     end
     
-    result = apply(io)
+    result = nil
+    error_message_or_success = catch(:error) {
+      result = apply(io)
+      :success
+    }
+    
+    # If we didn't succeed the parse, raise an exception for the user. 
+    # Stack trace will be off, but the error tree should explain the reason
+    # it failed.
+    if error_message_or_success != :success
+      raise Parslet::ParseFailed, error_message_or_success
+    end
     
     # If we haven't consumed the input, then the pattern doesn't match. Try
     # to provide a good error message (even asking down below)
@@ -22,30 +33,49 @@ class Parslet::Atoms::Base
       # error to fail with. Otherwise just report that we cannot consume the
       # input.
       if cause 
-        raise Parslet::ParseFailed, "Unconsumed input, maybe because of this: #{cause}"
+        # Don't garnish the real cause; but the exception is different anyway.
+        raise Parslet::ParseFailed, 
+          "Unconsumed input, maybe because of this: #{cause}"
       else
-        error(io, "Don't know what to do with #{io.string[io.pos,100]}") 
+        parse_failed(
+          format_cause(io, "Don't know what to do with #{io.string[io.pos,100]}"))
       end
     end
     
     return flatten(result)
   end
 
+  #---
+  # Calls the #try method of this parslet. In case of a parse error, apply
+  # leaves the io in the state it was before the attempt. 
+  #+++
   def apply(io) # :nodoc:
     # p [:start, self, io.string[io.pos, 10]]
     
     old_pos = io.pos
     
     # p [:try, self, io.string[io.pos, 20]]
-    begin
+    message = catch(:error) {
       r = try(io)
       # p [:return_from, self, r, flatten(r)]
+      
+      # This has just succeeded, so last_cause must be empty
       @last_cause = nil
       return r
-    rescue Parslet::ParseFailed => ex
-      # p [:failing, self, io.string[io.pos, 20]]
-      io.pos = old_pos; raise ex
-    end
+    }
+    
+    # We only reach this point if the parse has failed. message is not nil.
+    # p [:failing, self, io.string[io.pos, 20]]
+    
+    io.pos = old_pos
+    throw :error, message
+  end
+
+  # Override this in your Atoms::Base subclasses to implement parsing
+  # behaviour. 
+  #
+  def try(io)
+    raise NotImplementedError, "Atoms::Base doesn't have behaviour, please implement #try(io)."
   end
 
   # Construct a new atom that repeats the current atom min times at least and
@@ -126,6 +156,9 @@ class Parslet::Atoms::Base
     Parslet::Atoms::Named.new(self, name)
   end
 
+  # Takes a mixed value coming out of a parslet and converts it to a return
+  # value for the user by dropping things and merging hashes. 
+  #
   def flatten(value) # :nodoc:
     # Passes through everything that isn't an array of things
     return value unless value.instance_of? Array
@@ -225,31 +258,35 @@ class Parslet::Atoms::Base
   # with #cause. 
   #
   def error_tree
-    Parslet::ErrorTree.new(self) if cause?
+    Parslet::ErrorTree.new(self)
   end
   def cause? # :nodoc:
     not @last_cause.nil?
   end
 private
+  # TODO comments!!!
   # Report/raise a parse error with the given message, printing the current
   # position as well. Appends 'at line X char Y.' to the message you give. 
   # If +pos+ is given, it is used as the real position the error happened, 
   # correcting the io's current position.
   #
   def error(io, str, pos=nil)
+    @last_cause = format_cause(io, str, pos)
+    throw :error, @last_cause
+  end
+  def parse_failed(str)
+    @last_cause = str
+    raise Parslet::ParseFailed,
+      @last_cause
+  end
+  def format_cause(io, str, pos=nil)
     pre = io.string[0..(pos||io.pos)]
     lines = Array(pre.lines)
     
-    if lines.empty?
-      formatted_cause = str
-    else
-      pos   = lines.last.length
-      formatted_cause = "#{str} at line #{lines.count} char #{pos}."
-    end
-
-    @last_cause = formatted_cause
-    
-    raise Parslet::ParseFailed, formatted_cause, nil
+    return str if lines.empty?
+      
+    pos   = lines.last.length
+    return "#{str} at line #{lines.count} char #{pos}."
   end
   def warn_about_duplicate_keys(h1, h2)
     d = h1.keys & h2.keys

data/lib/parslet/atoms/lookahead.rb

@@ -16,27 +16,30 @@ class Parslet::Atoms::Lookahead < Parslet::Atoms::Base
   
   def try(io) # :nodoc:
     pos = io.pos
-    begin
+
+    failed = true
+    catch(:error) {
       bound_parslet.apply(io)
-    rescue Parslet::ParseFailed 
-      return fail(io)
-    ensure 
-      io.pos = pos
-    end
-    return success(io)
+      failed = false
+    }
+    return failed ? fail(io) : success(io)
+
+  ensure 
+    io.pos = pos
   end
   
+  # TODO Both of these will produce results that could be reduced easily. 
+  # Maybe do some shortcut reducing here?
   def fail(io) # :nodoc:
     if positive
       error(io, "lookahead: #{bound_parslet.inspect} didn't match, but should have")
     else
-      # TODO: Squash this down to nothing? Return value handling here...
       return nil
     end
   end
   def success(io) # :nodoc:
     if positive
-      return nil  # see above, TODO
+      return nil
     else
       error(
         io, 

data/lib/parslet/atoms/re.rb

@@ -8,16 +8,16 @@
 #   match('\s')     # like regexps: matches space characters
 #
 class Parslet::Atoms::Re < Parslet::Atoms::Base
-  attr_reader :match
+  attr_reader :match, :re
   def initialize(match) # :nodoc:
     @match = match
+    @re    = Regexp.new(match, Regexp::MULTILINE)
   end
 
   def try(io) # :nodoc:
-    r = Regexp.new(match, Regexp::MULTILINE)
     s = io.read(1)
     error(io, "Premature end of input") unless s
-    error(io, "Failed to match #{match.inspect[1..-2]}") unless s.match(r)
+    error(io, "Failed to match #{match.inspect[1..-2]}") unless s.match(re)
     return s
   end
 

data/lib/parslet/atoms/repetition.rb

@@ -17,22 +17,21 @@ class Parslet::Atoms::Repetition < Parslet::Atoms::Base
   def try(io) # :nodoc:
     occ = 0
     result = [@tag]   # initialize the result array with the tag (for flattening)
-    loop do
-      begin
-        result << parslet.apply(io)
-        occ += 1
-
-        # If we're not greedy (max is defined), check if that has been 
-        # reached. 
-        return result if max && occ>=max
-      rescue Parslet::ParseFailed => ex
-        # Greedy matcher has produced a failure. Check if occ (which will
-        # contain the number of sucesses) is in {min, max}.
-        # p [:repetition, occ, min, max]
-        error(io, "Expected at least #{min} of #{parslet.inspect}") if occ < min
-        return result
-      end
-    end
+    catch(:error) {
+      result << parslet.apply(io)
+      occ += 1
+      
+      # If we're not greedy (max is defined), check if that has been 
+      # reached. 
+      return result if max && occ>=max
+      redo
+    }
+    
+    # Greedy matcher has produced a failure. Check if occ (which will
+    # contain the number of sucesses) is in {min, max}.
+    # p [:repetition, occ, min, max]
+    error(io, "Expected at least #{min} of #{parslet.inspect}") if occ < min
+    return result
   end
   
   precedence REPETITION

data/lib/parslet/atoms/sequence.rb

@@ -16,12 +16,14 @@ class Parslet::Atoms::Sequence < Parslet::Atoms::Base
   end
   
   def try(io) # :nodoc:
-    [:sequence]+parslets.map { |p| 
-      # Save each parslet as potentially offending (raising an error). 
-      @offending_parslet = p
-      p.apply(io) 
+    catch(:error) {
+      return [:sequence]+parslets.map { |p| 
+        # Save each parslet as potentially offending (raising an error). 
+        @offending_parslet = p
+        p.apply(io) 
+      }
     }
-  rescue Parslet::ParseFailed
+
     error(io, "Failed to match sequence (#{self.inspect})")
   end
       

data/lib/parslet/pattern.rb

@@ -99,7 +99,8 @@ class Parslet::Pattern
   end
   
   def element_match_hash(tree, exp, bindings)
-    # p [:emh, tree, exp, bindings]
+    # Early failure when not all of the hash keys are matched.
+    return false unless exp.keys == tree.keys
     
     # We iterate over expected pattern, since we demand that the keys that
     # are there should be in tree as well.

data/lib/parslet/rig/rspec.rb

@@ -0,0 +1,24 @@
+RSpec::Matchers.define(:parse) do |input|
+  chain(:as) { |as| @as = as }
+
+  match do |parser|
+    begin
+      @result = parser.parse(input)
+      @as == @result or @as.nil?
+    rescue Parslet::ParseFailed
+      false
+    end
+  end
+
+  failure_message_for_should do |is|
+    "expected " << (@result ?
+      "output of parsing #{input.inspect} with #{is.inspect} to equal #{@as.inspect}, but was #{@result.inspect}" :
+      "expected #{is.inspect} to be able to parse #{input.inspect}")
+  end
+
+  failure_message_for_should_not do |is|
+    "expected " << (@as ?
+      "output of parsing #{input.inspect} with #{is.inspect} not to equal #{@as.inspect}" :
+      "expected #{is.inspect} to be able to parse #{input.inspect}")
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Kaspar Schiess
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-29 00:00:00 +01:00
+date: 2011-01-17 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -90,8 +90,21 @@ files:
 - lib/parslet/pattern/binding.rb
 - lib/parslet/pattern/context.rb
 - lib/parslet/pattern.rb
+- lib/parslet/rig/rspec.rb
 - lib/parslet/transform.rb
 - lib/parslet.rb
+- example/documentation.rb
+- example/email_parser.rb
+- example/empty.rb
+- example/ip_address.rb
+- example/minilisp.rb
+- example/parens.rb
+- example/readme.rb
+- example/seasons.rb
+- example/simple.lit
+- example/simple_xml.rb
+- example/string_parser.rb
+- example/test.lit
 has_rdoc: true
 homepage: http://kschiess.github.com/parslet
 licenses: []