fabulator-grammar 0.0.3 → 0.0.4

data/Rakefile

@@ -7,7 +7,7 @@ begin
     gem.email = "jgsmith@tamu.edu"
     gem.homepage = "http://github.com/jgsmith/ruby-fabulator-grammar"
     gem.authors = ["James Smith"]
-    gem.add_dependency(%q<fabulator>, [">= 0.0.7"]) 
+    gem.add_dependency(%q<fabulator>, [">= 0.0.8"]) 
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
     # not sure how to add dependency of a library that's not a gem
     gem.requirements << 'bitset, 1.0 or greater'

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/features/library.feature

@@ -0,0 +1,133 @@
+@library
+Feature: Grammars embedded in libraries
+
+  Scenario: Parsing a grammar xml definition
+    Given a context
+     And the prefix m as "http://example.com/ns/grammar"
+     And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+    Given the library
+      """
+        <l:library
+                   xmlns:l="http://dh.tamu.edu/ns/fabulator/library/1.0#"
+                   xmlns:g="http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+                   xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#"
+                   l:ns="http://example.com/ns/grammar"
+        >
+          <g:grammar>
+            <g:context g:mode="normal">
+              <g:token g:name="LETTER" g:matches="[:alpha:]" />
+            </g:context>
+            <g:token g:name="NUMBER" g:matches="[:digit:]" />
+            <g:token g:name="LETTER" g:matches="[:upper:]" g:mode="upper"/>
+            <g:token g:name="LETTER" g:matches="[:lower:]" g:mode="lower"/>
+            <g:rule g:name="something">
+              <g:when g:matches="^^ [mode normal] LETTER NUMBER [mode upper] LETTER" />
+            </g:rule>
+            <g:rule g:name="something2">
+              <g:when g:matches="^^ [mode normal] LETTER NUMBER [mode upper] LETTER">
+                <g:result g:path="foo" f:select="NUMBER" />
+              </g:when>
+            </g:rule>
+          </g:grammar>
+        </l:library>
+      """
+    Then the expression (m:something?('a0A')) should equal [f:true()]
+     And the expression (m:something?('a0a')) should equal [f:false()] 
+     And the expression (m:something('a0A')/NUMBER) should equal ['0']
+     And the expression (m:something2('a0A')/foo) should equal ['0']
+
+  @library
+  Scenario: Using a grammar for filters and constraints
+    Given a context
+     And the prefix m as "http://example.com/ns/grammar"
+     And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+    Given the library
+      """
+        <l:library
+                   xmlns:l="http://dh.tamu.edu/ns/fabulator/library/1.0#"
+                   xmlns:g="http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+                   xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#"
+                   l:ns="http://example.com/ns/grammar"
+        >
+          <g:grammar>
+            <g:context g:mode="normal">
+              <g:token g:name="LETTER" g:matches="[:alpha:]" />
+            </g:context>
+            <g:token g:name="NUMBER" g:matches="[:digit:]" />
+            <g:token g:name="LETTER" g:matches="[:upper:]" g:mode="upper"/>
+            <g:token g:name="LETTER" g:matches="[:lower:]" g:mode="lower"/>
+            <g:rule g:name="something">
+              <g:when g:matches="[mode normal] LETTER NUMBER [mode upper] LETTER" />
+            </g:rule>
+            <g:rule g:name="something2">
+              <g:when g:matches="[mode normal] LETTER NUMBER [mode upper] LETTER">
+                <g:result g:path="foo" f:select="NUMBER" />
+              </g:when>
+            </g:rule>
+          </g:grammar>
+          <l:mapping l:name="double">
+            <f:value-of f:select=". * 2" />
+          </l:mapping>
+          <l:function l:name="fctn">
+            <f:value-of f:select="$1 - $2" />
+          </l:function>
+          <l:action l:name="actn" l:has-actions="true">
+            <f:value-of f:select="f:eval($actions) * 3" />
+          </l:action>
+        </l:library>
+      """
+     And the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#"
+                       xmlns:m="http://example.com/ns/grammar"
+        >
+          <f:view f:name="start">
+            <f:goes-to f:view="step1">
+              <f:params>
+                <f:param f:name="foo">
+                  <f:filter f:name="m:something" />
+                  <f:value>a0A</f:value>
+                </f:param>
+              </f:params>
+              <f:value f:path="barbell" f:select="m:double(3)" />
+              <f:value f:path="barboil">
+                <m:actn><f:value-of f:select="7" /></m:actn>
+              </f:value>
+            </f:goes-to>
+          </f:view>
+          <f:view f:name="step1">
+            <f:goes-to f:view="stop">
+              <f:params>
+                <f:param f:name="bar">
+                  <f:filter f:name="trim" />
+                  <f:constraint f:name="m:something" />
+                </f:param>
+              </f:params>
+            </f:goes-to>
+          </f:view>
+          <f:view f:name="stop" />
+        </f:application>
+      """
+    Then it should be in the 'start' state  
+    When I run it with the following params:
+      | key   | value         |
+      | foo   | bar  a0a  que   |
+    Then it should be in the 'start' state
+     And the expression (/foo) should be nil
+    When I run it with the following params:
+      | key   | value |   
+      | foo   | bara0Aque   |
+    Then it should be in the 'step1' state
+     And the expression (/foo) should equal ['a0A']
+     And the expression (/barbell) should equal [6]
+     And the expression (/barboil) should equal [21]
+    When I run it with the following params:
+      | key   | value |   
+      | bar   | a0a   |
+    Then it should be in the 'step1' state
+    When I run it with the following params:
+      | key   | value |   
+      | bar   | a0B   |
+    Then it should be in the 'stop' state
+     And the expression (/bar) should equal ['a0B']
+     And the expression (m:fctn(3,2)) should equal [1]

data/features/step_definitions/xml_steps.rb

@@ -2,7 +2,8 @@ Given /the grammar/ do |doc_xml|
   @context ||= Fabulator::Expr::Context.new
 
   if @grammar.nil?
-    @grammar = Fabulator::Grammar::Actions::Grammar.new.compile_xml(doc_xml, @context)
+    @grammar = Fabulator::Grammar::Actions::Grammar.new
+    @grammar.compile_xml(doc_xml, @context)
   else
     @grammar.compile_xml(doc_xml, @context)
   end
@@ -10,3 +11,40 @@ Given /the grammar/ do |doc_xml|
 #  puts YAML::dump(@grammar)
 end
 
+Given /the library/ do |doc_xml|
+  @context ||= Fabulator::Expr::Context.new
+
+  if @library.nil?
+    @library = Fabulator::Lib::Lib.new
+    @library.compile_xml(doc_xml, @context)
+  else
+    @library.compile_xml(doc_xml, @context)
+  end
+
+  @library.register_library
+end
+
+Given /the statemachine/ do |doc_xml|
+  @context ||= Fabulator::Expr::Context.new
+
+  if @sm.nil?
+    @sm = Fabulator::Core::StateMachine.new
+    @sm.compile_xml(doc_xml)
+  else
+    @sm.compile_xml(doc_xml)
+  end
+  @sm.init_context(@context)
+end
+
+When /I run it with the following params:/ do |param_table|
+  params = { }
+  param_table.hashes.each do |hash|
+    params[hash['key']] = hash['value']
+  end
+  @sm.run(params)
+end
+
+Then /it should be in the '(.*)' state/ do |s|
+  @sm.state.should == s
+end
+

data/features/support/env.rb

@@ -4,5 +4,6 @@ $: << File.expand_path(File.dirname(__FILE__))+'/../../lib'
 $: << File.expand_path(File.dirname(__FILE__))+'/../../../fabulator/lib'
 
 require 'fabulator'
+require 'fabulator/lib'
 require 'fabulator/grammar'
 require 'spec/expectations'

data/lib/fabulator/grammar/actions/grammar.rb

@@ -5,14 +5,18 @@ module Fabulator
 
     namespace GRAMMAR_NS
 
+    element :grammar
+
     contains :rule
     contains :token
     contains :context
 
+    contained_in Fabulator::FAB_LIB_NS, :library
+
     has_actions
 
     def compile_xml(xml, context = nil)
-       super
+      super
 
       @modes = { :default => { } }
 
@@ -33,8 +37,6 @@ module Fabulator
 
       @tokens = nil
       @rules = nil
-
-      self
     end
 
     def add_rule(r, m = :default)
@@ -53,7 +55,7 @@ module Fabulator
       cursor.anchored = true
       ret = do_parse(nom, cursor)
       cursor.do_skip
-      cursor.eof ? ret : nil
+      cursor.eof? ? ret : nil
     end
 
     def match(ctx, nom, s)
@@ -61,13 +63,67 @@ module Fabulator
       !do_parse(nom, cursor).nil?
     end
 
+    def run_function(context, nom, args)
+      # treat these as mappings
+      strings = args.collect{ |a| a.to_s }
+      matching = false
+      if nom =~ /\?$/
+        matching = true
+      end
+      nom.gsub!(/\?$/, '')
+      ret = matching ? strings.collect{ |s| self.match(context, nom, s) } :
+                       strings.collect{ |s| self.parse(context, nom, s) }
+      #ret -= [ nil ]
+      if matching
+        ret = ret.collect{ |r| context.root.anon_node(!!r, [FAB_NS, 'boolean']) }
+      else
+        while ret.select{ |r| r.name.nil? && r.value.nil? }.size > 0
+          ret = ret.collect{ |r|
+            if r.name.nil? && r.value.nil?
+              r.children
+            else
+              r
+            end
+          }.flatten - [ nil ]
+        end
+        if !ret.empty?
+          new_ret = ret.first.roots['data'].anon_node(nil)
+          ret.each do |r|
+            new_ret.add_child(r)
+          end
+        end
+        ret = [ new_ret ]
+      end
+      ret
+    end
+
+    def run_filter(ctx, nom)
+      # runs as a parser and replaces the string with the resulting
+      # content that matched
+      source = ctx.root.to_s
+      cursor = Fabulator::Grammar::Cursor.new(self, ctx, source)
+      ret = do_parse(nom, cursor)
+      ctx.root.value = ret.nil? ? '' : source[cursor.start .. cursor.pos-1]
+    end
+
+    def run_constraint(ctx, nom)
+      # runs as a match and requires full anchored matching
+      !self.parse(ctx, nom, ctx.root.to_s).nil?
+    end
+
       protected
 
     def do_parse(nom, cursor)
       obj = get_rule(:default, nom)
       return nil if obj.nil?
 
-      obj.parse(cursor)
+      begin
+        obj.parse(cursor)
+      rescue Fabulator::Grammar::RejectParse
+        return nil
+      else
+        return cursor.context.root
+      end
     end
 
       end

data/lib/fabulator/grammar/actions/result.rb

@@ -0,0 +1,23 @@
+module Fabulator
+  module Grammar
+  module Actions
+  class Result < Fabulator::Action
+    attr_accessor :select, :name
+
+    namespace Fabulator::GRAMMAR_NS
+    attribute :path, :static => true
+    has_select
+    has_actions
+
+    def run(context, autovivify = false)
+      @context.with(context) do |ctx|
+        values = self.has_actions? ? self.run_actions(ctx) : @select.run(ctx,false)
+        if !values.nil?
+          ctx.with_root(ctx.root.roots['result']).set_value(self.path, values)
+        end
+      end
+    end
+  end
+  end
+  end
+end

data/lib/fabulator/grammar/actions/rule.rb

@@ -21,29 +21,29 @@ module Fabulator
           # try each when...
           best_attempt = nil
           @choices.each do |choice|
-            cursor.attempt do |c|
-              ret = choice.parse(c)
-              if !ret.nil?
-                score = choice.score(cursor.context, ret)
-                if best_attempt.nil? || best_attempt[:score] < score
-                  best_attempt = {
-                    :score => score,
-                    :choice => choice,
-                    :ret => ret
-                  }
-                end
+            ret = cursor.attempt { |c| choice.parse(c) }
+            if !ret.nil?
+              score = choice.score(cursor.context, ret)
+              if best_attempt.nil? || best_attempt[:score] < score
+                best_attempt = {
+                  :score => score,
+                  :choice => choice,
+                  :ret => ret
+                }
               end
             end
           end
-          return nil if best_attempt.nil?
+          raise Fabulator::Grammar::RejectParse if best_attempt.nil?
           choice = best_attempt[:choice]
           ret = best_attempt[:ret]
           if choice.has_actions?
-            ctx = cursor.context.with_root(cursor.context.root.anon_node(nil))
-            ctx.merge_data(ret)
-            choice.run(ctx)
+            cursor.context.root.roots['result'] = cursor.context.root.roots['result'].anon_node(nil)
+            new_ret = cursor.context.root.roots['result']
+            choice.run(cursor.context.with_root(ret))
+            cursor.set_result(new_ret)
+          else
+            cursor.set_result(ret)
           end
-          return ret
         end
       end
     end

data/lib/fabulator/grammar/actions/when.rb

@@ -25,9 +25,7 @@ module Fabulator
 
         def score(context, data)
           return 0 if @score.nil?
-          ctx = context.with_root(context.root.anon_node(nil))
-          ctx.merge_data(data)
-          (self.score(ctx).value rescue 0)
+          (@score.run(context.with_root(context.root.roots['result'])).value rescue 0)
         end
       end
     end

data/lib/fabulator/grammar/actions.rb

@@ -7,6 +7,7 @@ module Fabulator
   require 'fabulator/grammar/actions/rule'
   require 'fabulator/grammar/actions/token'
   require 'fabulator/grammar/actions/when'
+  require 'fabulator/grammar/actions/result'
 
   module Grammar
     module Actions
@@ -19,7 +20,7 @@ module Fabulator
         structural 'token', Token
         structural 'when', When
 
-#        action 'result', Result
+        action 'result', Result
 
         ## reference a grammar name
         function 'match' do |ctx, args|

data/lib/fabulator/grammar/cursor.rb

@@ -1,11 +1,12 @@
 module Fabulator
   module Grammar
     class Cursor
-      attr_accessor :mode, :skip
+      attr_accessor :mode, :skip, :start
 
       def initialize(g,ctx,s)
         @source = s
         @grammar = g
+        @start = 0
         @curpos = 0
         @end = @source.length-1
         @line = 0
@@ -14,6 +15,8 @@ module Fabulator
         @mode = :default
         @skip = nil
         @context = ctx.with_root(ctx.root.anon_node(nil))
+        @context.root.roots['result'] = @context.root
+        @context.root.axis = 'result'
       end
 
       def context
@@ -30,7 +33,7 @@ module Fabulator
         end
       end
 
-      def eof
+      def eof?
         @curpos > @end
       end
 
@@ -51,7 +54,10 @@ module Fabulator
       end
 
       def point
-        { :curpos => @curpos, :line => @line, :col => @col, :root => @context.root, :mode => @mode, :anchored => @anchored, :skip => @skip }
+        r = { :curpos => @curpos, :line => @line, :col => @col, :root => @context.root, :mode => @mode, :anchored => @anchored, :skip => @skip, :result => @context.root.roots['result'] }
+        @context.root.roots['result'] = r[:result].anon_node(nil)
+        @context.root = @context.root.roots['result']
+        r
       end
 
       def point=(p)
@@ -62,19 +68,63 @@ module Fabulator
         @anchored = p[:anchored]
         @skip = p[:skip]
         @context.root = p[:root]
+        @context.root.roots['result'] = p[:result]
       end
 
       def attempt(&block)
         saved = self.point
-        ret = yield self
-        if ret.nil?
+        begin
+          yield self
+        rescue Fabulator::Grammar::RejectParse
           self.point = saved
           return nil
         end
-        
+
+        ret = @context.root.roots['result']
+        @context.root = saved[:root]
+        @context.root.roots['result'] = saved[:result]
         return ret
       end
 
+      def set_result(r)
+        r = [ r ] unless r.is_a?(Array)
+        if r.size > 1
+          @context.root = @context.root.anon_node(nil)
+          r.each { |rr| @context.root.add_child(rr) }
+        elsif !r.empty?
+          @context.root = r.first
+        end
+        @context.root.roots['result'] = @context.root
+      end
+
+      def name_result(nom = nil)
+        return if nom.nil?
+        return if @context.root.value.nil? && @context.root.children.empty?
+        if @context.root.value.nil?
+          @context.root.name = nom
+        else
+          if @context.root.name.nil?
+            @context.root.name = nom
+          else
+            n = @context.root.anon_node(nil)
+            n.name = nom
+            n.add_child(@context.root)
+            @context.root = n
+            @context.root.roots['result'] = @context.root
+          end
+        end
+      end
+
+      def rename_result(nom = nil)
+        return if nom.nil?
+        return if @context.root.value.nil? && @context.root.children.empty?
+#        if @context.root.children.select{ |c| !c.name.nil? }.empty?
+#          @context.root.children.each { |c| c.name = nom }
+#        else
+          @context.root.name = nom
+#        end
+      end
+
       def find_rule(nom)
         r = @grammar.get_rule(@mode, nom)
         if r.nil? && @mode.to_s != 'default'
@@ -105,13 +155,13 @@ module Fabulator
       end
 
       def match_token(regex)
-        res = nil
         do_skip
         if @source[@curpos .. @end] =~ %r{^(#{regex})}
-          res = $1.to_s
-          @curpos += res.length
+          @context.root.value = $1.to_s
+          @curpos += @context.root.value.length
+        else
+          raise Fabulator::Grammar::RejectParse
         end
-        res
       end
     end
   end

data/lib/fabulator/grammar/expr/anchor.rb

@@ -11,16 +11,16 @@ module Fabulator
         end
 
         def parse(source)
-          ret = nil
+          ret = false
           case @anchor
             when :start_of_string: 
-              ret = source.pos == 0 ? {} : nil
+              ret = source.pos == 0
             when :start_of_line:
             when :end_of_string:
-              ret = source.eof ? {} : nil
+              ret = source.eof?
             when :end_of_line:
           end
-          ret
+          raise Fabulator::Grammar::RejectParse unless ret
         end
       end
     end

data/lib/fabulator/grammar/expr/look_ahead.rb

@@ -11,12 +11,12 @@ module Fabulator
         end
 
         def parse(source)
-          ret = nil
+          ret = false
           source.attempt do |c|
             ret = @sequence.parse(c)
-            nil
+            raise Fabulator::Grammar::RejectParse
           end
-          ret.nil? ? nil : {}
+          raise Fabulator::Grammar::RejectParse unless ret
         end
       end
 
@@ -30,12 +30,12 @@ module Fabulator
         end
  
         def parse(source)
-          ret = nil
+          ret = false
           source.attempt do |c|
             ret = @sequence.parse(c)
-            nil
+            raise Fabulator::Grammar::RejectParse
           end
-          ret.nil? ? {} : nil
+          raise Fabulator::Grammar::RejectParse if ret
         end
       end
 

data/lib/fabulator/grammar/expr/rule.rb

@@ -19,21 +19,29 @@ module Fabulator
                 cursor.anchored = true 
                 alternative.parse(cursor) 
               }
-              return ret unless ret.nil?
+              if !ret.nil?
+                s.set_result(ret)
+                return
+              end
             end
           else
-            while !s.eof
+            while !s.eof?
+              start = s.pos
               @alternatives.each do |alternative|
                 ret = s.attempt { |cursor| 
                   cursor.anchored = true 
                   alternative.parse(cursor) 
                 }
-                return ret unless ret.nil?
+                if !ret.nil?
+                  s.start = start
+                  s.set_result(ret)
+                  return
+                end
               end
               s.advance_position(1)
             end
           end
-          return nil
+          raise Fabulator::Grammar::RejectParse
         end
       end
     end

data/lib/fabulator/grammar/expr/rule_alternative.rb

@@ -12,32 +12,27 @@ module Fabulator
         end
 
         def parse(source)
-          results = { }
+          results = [ ]
           @sequences.each do |sequence|
-            r = sequence.parse(source)
-            return nil if r.nil? # we fail
-            nom = (sequence.name rescue nil)
-            rr = { }
-            if nom.nil?
-              rr = r
-            elsif !r.nil?
-              if !(r.is_a?(Hash) || r.is_a?(Array)) || !r.empty?
-                rr[nom] = r
-              end
-            end
-            if rr.is_a?(Hash) && !rr.empty?
-              rr.each_pair do |k,v|
-                if results[k].nil?
-                  results[k] = v
-                elsif results[k].is_a?(Array)
-                  results[k] << v
-                else
-                  results[k] = [ results[k], v ]
-                end
+            res = source.attempt{ |s| sequence.parse(s) }
+            raise Fabulator::Grammar::RejectParse if res.nil?
+            res.children.each do |c|
+              if c.name.nil?
+                c.name = sequence.name if c.name.nil? && !sequence.name.nil?
+                res.prune(c)
+                results << c if !c.children.empty? || !c.value.nil?
               end
             end
+            res.name = sequence.name unless sequence.name.nil?
+            results << res if !res.children.empty? || !res.value.nil?
+          end
+          # now we want to merge all of the results
+          if results.size > 1
+            results = results.select{ |r| !r.name.nil? }
+          end
+          if !results.empty?
+            source.set_result(results)
           end
-          results
         end
       end
     end

data/lib/fabulator/grammar/expr/rule_mode.rb

@@ -6,9 +6,12 @@ module Fabulator
           @mode = m
         end
 
+        def name
+          nil
+        end
+
         def parse(s)
           s.mode = @mode
-          {}
         end
       end
     end

data/lib/fabulator/grammar/expr/rule_ref.rb

@@ -16,9 +16,13 @@ module Fabulator::Grammar::Expr
 
     def parse(cursor)
       rule = cursor.find_rule(@name)
-      return nil if rule.nil?
+      raise Fabulator::Grammar::RejectParse if rule.nil?
       # we have @name as the path prefix for this part?
-      cursor.attempt { |c| rule.parse(c) }
+      ret = cursor.attempt { |c| rule.parse(c) }
+
+      raise Fabulator::Grammar::RejectParse if ret.nil?
+
+      cursor.set_result(ret)
     end
   end
 end

data/lib/fabulator/grammar/expr/rule_sequence.rb

@@ -2,55 +2,64 @@ module Fabulator
   module Grammar
     module Expr
       class RuleSequence
+
+## TODO: allow lookahead here so we can bound the greediness
+##       we also need to do non-greedy versions
+##       we don't have reasonable backtracking yet
+
         def initialize(hypo, atom, quant = nil)
           @name = hypo
           @atom = atom
           @quantifier = quant
         end
 
-        # eventually, this can be the hypo name
+        # this is the "hypothetical" name in the grammar
         def name
           @name.nil? ? (@atom.name rescue nil) : @name
         end
 
         def parse(source)
           if @quantifier.nil?
-            return @atom.parse(source)
-          end
-
-          case @quantifier.first
-            when '?'.to_sym: return @atom.parse(source) || { }
-            when :s: 
-              ret = [ ]
-              r = @atom.parse(source)
-              while !r.nil?
-                ret << r
-                if @quantifier[1].nil?
-                  r = @atom.parse(source)
-                else
-                  r = @quantifier[1].parse(source)
-                  if !r.nil?
-                    r = @atom.parse(source)
+            @atom.parse(source)
+          else
+            case @quantifier.first
+              when '?'.to_sym: 
+                r = source.attempt{ |c| @atom.parse(source) }
+                source.set_result(r)
+              when :s: 
+                ret = [ ]
+                r = source.attempt { |c| @atom.parse(c) }
+                while !r.nil?
+                  ret << r
+                  if @quantifier[1].nil?
+                    r = source.attempt { |c| @atom.parse(c) }
+                  else
+                    r = source.attempt{ |c| @quantifier[1].parse(c) }
+                    if !r.nil?
+                      r = source.attempt{ |c| @atom.parse(c) }
+                    end
                   end
                 end
-              end
-              return ret.empty? ? nil : ret
-            when 's?'.to_sym:
-              ret = [ ]
-              r = @atom.parse(source)
-              while !r.nil?
-                ret << r
-                if @quantifier[1].nil?
-                  r = @atom.parse(source)
-                else
-                  r = @quantifier[1].parse(source)
-                  if !r.nil?
-                    r = @atom.parse(source)
+                raise Fabulator::Grammar::RejectParse if ret.empty?
+                source.set_result(ret) 
+              when 's?'.to_sym:
+                ret = [ ]
+                r = source.attempt{ |c| @atom.parse(c) }
+                while !r.nil?
+                  ret << r
+                  if @quantifier[1].nil?
+                    r = source.attempt{ |c| @atom.parse(c) }
+                  else
+                    r = source.attempt{ |c| @quantifier[1].parse(c) }
+                    if !r.nil?
+                      r = source.attempt{ |c| @atom.parse(c) }
+                    end
                   end
                 end
-              end
-              return ret.empty? ? {} : ret
+                source.set_result(ret) unless ret.empty?
+            end
           end
+          source.name_result(@atom.name)
         end
       end
     end

data/lib/fabulator/grammar/expr/set_skip.rb

@@ -8,7 +8,6 @@ module Fabulator
 
         def parse(cursor)
           cursor.skip = @skip
-          {}
         end
       end
     end

data/lib/fabulator/grammar/expr/token.rb

@@ -15,12 +15,7 @@ module Fabulator::Grammar::Expr
     end
 
     def parse(cursor)
-      res = cursor.match_token(self.to_regex)
-      if res.nil?
-        return nil
-      else
-        return res
-      end
+      cursor.match_token(self.to_regex)
     end
   end
 end

data/lib/fabulator/grammar.rb

@@ -21,5 +21,7 @@ module Fabulator
   module Grammar
     class ParserError < StandardError
     end
+    class RejectParse < StandardError
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fabulator-grammar
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - James Smith
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-07 00:00:00 +00:00
+date: 2010-09-11 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,12 +26,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 17
+        hash: 15
         segments: 
         - 0
         - 0
-        - 7
-        version: 0.0.7
+        - 8
+        version: 0.0.8
   type: :runtime
   version_requirements: *id001
 description: The grammar Fabulator extension provides regular expression support.
@@ -48,6 +48,7 @@ files:
 - Rakefile
 - VERSION
 - features/grammar.feature
+- features/library.feature
 - features/step_definitions/expression_steps.rb
 - features/step_definitions/grammar_steps.rb
 - features/step_definitions/template_steps.rb
@@ -58,6 +59,7 @@ files:
 - lib/fabulator/grammar/actions.rb
 - lib/fabulator/grammar/actions/context.rb
 - lib/fabulator/grammar/actions/grammar.rb
+- lib/fabulator/grammar/actions/result.rb
 - lib/fabulator/grammar/actions/rule.rb
 - lib/fabulator/grammar/actions/token.rb
 - lib/fabulator/grammar/actions/when.rb