parslet 0.10.1 → 0.11.0

data/HISTORY.txt

@@ -1,4 +1,9 @@
-= 0.10.1 / ???
+= 0.11.0 / 25Nov2010
+
+  ! Bugfixes to tree handling. Let's hope that was the last such significant
+    change to the core.
+
+= 0.10.1 / 22Nov2010
 
   + Allow match['a-z'], shortcut for match('[a-z]')
 

data/Rakefile

@@ -18,7 +18,7 @@ spec = Gem::Specification.new do |s|
 
   # Change these as appropriate
   s.name              = "parslet"
-  s.version           = "0.10.1"
+  s.version           = "0.11.0"
   s.summary           = "Parser construction library with great error reporting in Ruby."
   s.author            = "Kaspar Schiess"
   s.email             = "kaspar.schiess@absurd.li"

data/lib/parslet/atoms/base.rb

@@ -35,7 +35,7 @@ class Parslet::Atoms::Base
     # p [:try, self, io.string[io.pos, 20]]
     begin
       r = try(io)
-      # p [:return_from, self, flatten(r)]
+      # p [:return_from, self, r, flatten(r)]
       @last_cause = nil
       return r
     rescue Parslet::ParseFailed => ex
@@ -89,30 +89,34 @@ class Parslet::Atoms::Base
     fail "BUG: Unknown tag #{tag.inspect}."
   end
   def flatten_sequence(list)
-    list.inject('') { |r, e|        # and then merge flat elements
-      case [r, e].map { |o| o.class }
-        when [Hash, Hash]             # two keyed subtrees: make one
-          warn_about_duplicate_keys(r, e)
-          r.merge(e)
-        # a keyed tree and an array (push down)
-        when [Hash, Array]
-          [r] + e
-        when [Array, Hash]   
-          r + [e]
-        when [String, String]
-          r << e
+    list.compact.inject('') { |r, e|        # and then merge flat elements
+      merge_fold(r, e)
+    }
+  end
+  def merge_fold(l, r)
+    # equal pairs: merge. 
+    if l.class == r.class
+      if l.is_a?(Hash)
+        warn_about_duplicate_keys(l, r)
+        return l.merge(r)
       else
-        if r.instance_of? Hash
-          r   # Ignore e, since its not a hash we can merge
-        else
-          # Now e is either nil, in which case we drop it, or something else. 
-          # If it is something else, it is probably more important than r, 
-          # since we've checked for important values of r above. 
-          e||r
-        end
+        return l + r
       end
-    }
+    end
+    
+    # unequal pairs: hoist to same level. 
+    
+    # special case: If one of them is a string, the other is more important 
+    return l if r.class == String
+    return r if l.class == String
+    
+    # otherwise just create an array for one of them to live in 
+    return l + [r] if r.class == Hash
+    return [l] + r if l.class == Hash
+    
+    fail "Unhandled case when foldr'ing sequence."
   end
+
   def flatten_repetition(list)
     if list.any? { |e| e.instance_of?(Hash) }
       # If keyed subtrees are in the array, we'll want to discard all 

data/lib/parslet/expression.rb

@@ -2,6 +2,9 @@
 # Allows specifying rules as strings using the exact same grammar that treetop
 # does, minus the actions. This is on one hand a good example of a fully fledged
 # parser and on the other hand might even turn out really useful. 
+#
+# This can be viewed as an extension to parslet and might even be hosted in
+# its own gem one fine day. 
 # 
 # NOT FINISHED & EXPERIMENTAL
 #
@@ -22,7 +25,7 @@ class Parslet::Expression
   def transform(tree)
     transform = Treetop::Transform.new
     
-    pp tree
+    # pp tree
     transform.apply(tree)
   end
   

data/lib/parslet/expression/treetop.rb

@@ -2,18 +2,15 @@ class Parslet::Expression::Treetop
   class Parser < Parslet::Parser
     root(:expression)
     
-    rule(:expression) {
-      alternatives
-    }
+    rule(:expression) { alternatives }
     
+    # alternative 'a' / 'b'
     rule(:alternatives) {
-      simple >> (spaced('/') >> alternatives) |
-      simple
+      (simple >> (spaced('/') >> simple).repeat).as(:alt)
     }
     
-    rule(:simple) {
-      perhaps.repeat
-    }
+    # sequence by simple concatenation 'a' 'b'
+    rule(:simple) { perhaps.repeat(1).as(:seq) }
 
     rule(:perhaps) {
       atom.as(:maybe) >> spaced('?') | 
@@ -43,8 +40,9 @@ class Parslet::Expression::Treetop
   end
   
   class Transform < Parser::Transform
+    rule(:alt => subtree(:alt)) { Parslet::Atoms::Alternative.new(*alt) }
+    rule(:seq => sequence(:s))  { Parslet::Atoms::Sequence.new(*s) }
     rule(:unwrap => simple(:u)) { u }
-    rule(sequence(:s))          { |d| Parslet::Atoms::Sequence.new(*d[:s]) }
     rule(:maybe => simple(:m))  { |d| d[:m].maybe }
     rule(:string => simple(:s)) { |d| str(d[:s]) }
   end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 10
-  - 1
-  version: 0.10.1
+  - 11
+  - 0
+  version: 0.11.0
 platform: ruby
 authors: 
 - Kaspar Schiess
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-23 00:00:00 +01:00
+date: 2010-11-25 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency