fabulator 0.0.1 → 0.0.2

data/features/types.feature

@@ -0,0 +1,64 @@
+@types
+Feature: Type unification
+
+  Scenario: A single type
+    Given the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+    When I unify the type f:numeric
+    Then I should get the type f:numeric
+
+  Scenario: A single type multiple times
+    Given the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+    When I unify the type f:numeric, f:numeric, f:numeric
+    Then I should get the type f:numeric
+
+  Scenario: Two types sharing a possible target type
+    Given the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+    When I unify the type f:numeric, f:numeric, f:boolean
+    Then I should get the type f:numeric
+
+  Scenario: Three types sharing a possible target type
+    Given the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+    When I unify the type f:numeric, f:numeric, f:boolean, f:string
+    Then I should get the type f:string
+
+  Scenario: Converting boolean to a string
+    Given a context
+      And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+    When I run the expression (f:string(f:true()))
+    Then I should get 1 item
+      And item 0 should be ['true']
+
+  Scenario: Use uri-prefix
+    Given a context
+      And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+    When I run the expression (f:uri-prefix('f'))
+    Then I should get 1 item
+      And item 0 should be ["http://dh.tamu.edu/ns/fabulator/1.0#"]
+
+  Scenario: Get the type of a boolean value
+    Given a context
+      And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+    When I run the expression (f:true()/@type)
+    Then I should get 1 item
+      And item 0 should be [f:uri-prefix('f') + 'boolean']
+
+  Scenario: Get the type of a string value
+    Given a context
+      And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+    When I run the expression ("foo"/@type)
+    Then I should get 1 item
+      And item 0 should be [f:uri-prefix('f') + 'string']
+
+  Scenario: Get the type of a numeric value
+    Given a context
+      And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+    When I run the expression (3/@type)
+    Then I should get 1 item
+      And item 0 should be [f:uri-prefix('f') + 'numeric']
+
+  Scenario: Get the type of a uri value
+    Given a context
+      And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+    When I run the expression (3/@type/@type)
+    Then I should get 1 item
+      And item 0 should be [f:uri-prefix('f') + 'uri']

data/features/xsm-inheritance.feature

@@ -0,0 +1,46 @@
+@isa
+Feature: IS-A State machine inheritance
+
+  Scenario: simple machine with just one state and no transitions
+    Given the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#" />
+      """
+      And the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#">
+          <f:view f:name="start">
+            <f:goes-to f:view="stop">
+              <f:params>
+                <f:param f:name="foo"/>
+              </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   |
+    Then it should be in the 'stop' state
+     And the expression (/foo) should equal ['bar']
+    When I run it with the following params:
+      | key   | value |
+      | foo   | bar   |
+    Then it should be in the 'stop' state
+     And the expression (/foo) should equal ['bar']
+
+  Scenario: simple machine with just one state and no transitions
+    Given the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#">
+          <f:value f:path="/foo" f:select="'bar'" />
+        </f:application>
+      """
+      And the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#"/>
+      """
+    Then it should be in the 'start' state
+     And the expression (/foo) should equal ['bar']

data/init.rb

@@ -0,0 +1,6 @@
+# This file makes it possible to install Fabulator as a Rails plugin.
+
+$: << File.expand_path(File.dirname(__FILE__))+'/lib'
+
+require 'fabulator'
+

data/lib/fabulator/action_lib.rb

@@ -218,6 +218,14 @@ module Fabulator
           ret = args.flatten.collect { |a| send "fctn:#{nom}", context, a }
         when :reduction
           ret = send "fctn:#{nom}", context, args.flatten
+        when :consolidation
+          if respond_to?("fctn:#{nom}")
+            ret = send "fctn:#{nom}", context, args.flatten
+          elsif nom =~ /^consolidation:(.*)$/
+            ret = send "fctn:#{$1}", context, args.flatten
+          else
+            ret = [ ]
+          end
         else
           ret = send "fctn:#{nom}", context, args
         end
@@ -252,7 +260,15 @@ module Fabulator
     end
 
     def function_run_type(name)
-      (self.function_descriptions[name][:type] rescue nil)
+      r = (self.function_descriptions[name][:type] rescue nil)
+      if r.nil? && !self.function_descriptions.has_key?(name)
+        if name =~ /^consolidation:(.*)/
+          if function_run_scaling($1) != :flat
+            return :consolidation
+          end
+        end
+      end
+      r
     end
 
     def function_args
@@ -369,6 +385,20 @@ module Fabulator
         self.function_descriptions[name][:description] = Fabulator::ActionLib.last_description if Fabulator::ActionLib.last_description
         Fabulator::ActionLib.last_description = nil
         define_method("fctn:#{name}", &block)
+        cons = self.function_descriptions[name][:consolidation]
+        if !cons.nil?
+          Fabulator::ActionLib.last_description = self.function_descriptions[name][:description]
+          consolidation name do |ctx, args|
+            send "fctn:#{cons}", ctx, args
+          end
+        end
+      end
+
+      def consolidation(name, opts = {}, &block)
+        self.function_descriptions[name] = { :type => :consolidation }.merge(opts)
+        self.function_descriptions[name][:description] = Fabulator::ActionLib.last_description if Fabulator::ActionLib.last_description
+        Fabulator::ActionLib.last_description = nil
+        define_method("fctn:consolidation:#{name}", &block)
       end
 
       def mapping(name, opts = {}, &block)

data/lib/fabulator/core/actions.rb

@@ -143,7 +143,7 @@ module Fabulator
       [ res ]
     end
 
-    reduction 'avg' do |ctx, args|
+    reduction 'avg', { :scaling => :flat } do |ctx, args|
       res = 0.0
       n = 0.0
       args.each do |a|
@@ -176,7 +176,7 @@ module Fabulator
       [ctx.root.anon_node(res, NUMERIC)]
     end
 
-    function 'histogram' do |ctx, args|
+    reduction 'histogram', { :scaling => :log } do |ctx, args|
       acc = { }
       args.flatten.each do |a|
         acc[a.to_s] ||= 0
@@ -191,11 +191,11 @@ module Fabulator
     # the code here is the consolidation function for histogram
     # f:sum is the consolidation function for f:sum
     #
-    reduction 'consolidate', { :scaling => :log } do |ctx, args|
+    consolidation 'histogram', { :scaling => :log } do |ctx, args|
       acc = { }
       attrs = { }
       children = { }
-      args.each do |a|
+      args.flatten.each do |a|
         a.children.each do |c|
           acc[c.name] ||= 0
           acc[c.name] = acc[c.name] + c.value
@@ -421,7 +421,7 @@ module Fabulator
       arg.is_a?(Array) && arg.size == 1
     end
 
-    reduction 'count' do |ctx, args|
+    reduction 'count', { :consolidation => :sum } do |ctx, args|
       args.size
     end
 

data/lib/fabulator/core/state_machine.rb

@@ -16,17 +16,20 @@ module Fabulator
     attr_accessor :states, :missing_params, :errors, :namespaces, :updated_at
     attr_accessor :state
 
-    def compile_xml(xml, context = nil, callbacks = { })
-      # /statemachine/states
-      @states ||= { }
+    def initialize
+      @states = { }
+      @context = Fabulator::Expr::Context.new
       @state = 'start'
+    end
 
+    def compile_xml(xml, context = nil, callbacks = { })
+      # /statemachine/states
       if xml.is_a?(String)
         xml = LibXML::XML::Document.string xml
       end
 
       if context.nil?
-        @context = Fabulator::Expr::Context.new.merge(xml.root)
+        @context = @context.merge(xml.root)
       else
         @context = context.merge(xml.root)
       end

data/lib/fabulator/expr/function.rb

@@ -5,6 +5,9 @@ module Fabulator
         bits = nom.split(/:/, 2)
         @ns = ctx.get_ns(bits[0])
         @name = bits[1]
+        if @name =~ /^(.+)\*$/
+          @name = "consolidation:#{$1}"
+        end
         @args = args
         @ctx = ctx
       end

data/lib/fabulator/expr/function.rb.old

@@ -0,0 +1,85 @@
+module Fabulator
+  module XSM
+    class Function
+      @@function_handlers = { 
+#        'http://dh.tamu.edu/ns/fn#' => Fabulator::XSM::StdFunctions
+      }
+
+      def initialize(fname, args)
+        @function_name = fname.split(':',2)
+        @args = args
+      end
+
+      def self.register_function_handler(ns, c)
+        @@function_handlers[ns] = c
+      end
+
+      def run(context)
+        # we want to look up the function name ([namespace, local_name])
+        # and run it, or raise an error
+        fn_obj = @@function_handlers[@function_name[0]]
+        return nil if fn_obj.nil?
+
+        return fn_obj.run(@function_name[1], @args.collect{ |a| a.run(context) })
+      end
+    end
+
+    class StdFunctions
+
+      Fabulator::XSM::Function.register_function_handler(
+        'http://dh.tamu.edu/ns/fn#', self
+      )
+
+      def self.run(fn, args)
+        case fn
+          when 'node-name':
+            return args[0].select {|a| a.is_a?(Fabulator::XSM::Context) }.collect { |a| a.name }
+          when 'abs':
+            return args[0].select {|a| a.is_a?(Fabulator::XSM::Context) }.collect { |a| ac = a.clone; ac.value = Math.abs(ac.value) }
+          when 'ceiling':
+          when 'floor':
+          when 'round':
+          when 'round-half-to-even':
+          when 'round-half-to-odd':
+          when 'concat':
+          when 'string-join':
+          when 'substring':
+          when 'string-length':
+          when 'normalize-space':
+          when 'upper-case':
+          when 'lower-case':
+          when 'translate':
+          when 'escape-html-uri':
+          when 'contains':
+          when 'starts-with':
+          when 'ends-with':
+          when 'substring-before':
+          when 'substring-after':
+          when 'matches':
+          when 'replace':
+          when 'tokenize':
+          when 'resolve-uri':
+          when 'true':
+          when 'false':
+          when 'empty':
+          when 'not':
+          when 'reverse':
+          when 'zero-or-one':
+          when 'one-or-more':
+          when 'exactly-one':
+          when 'count':
+          when 'avg':
+          when 'max':
+          when 'min':
+          when 'sum':
+          when 'position':
+          when 'last':
+          when 'create-url-for':
+          when 'review-url-for':
+          when 'update-url-for':
+          when 'delete-url-for':
+        end
+      end
+    end
+  end
+end

data/lib/fabulator/expr/parser.rb

@@ -18,7 +18,7 @@ module_eval(<<'...end xsm_expression_parser.racc/module_eval...', 'xsm_expressio
   def parse(t, ctx)
     @source = t
     @curpos = 0
-    @context = ctx #.class.new(ctx)
+    @context = ctx
     @line = 0
     @col = 0
 
@@ -48,7 +48,7 @@ module_eval(<<'...end xsm_expression_parser.racc/module_eval...', 'xsm_expressio
   @@regex[:qname] = %r{((?:#{@@regex[:ncname]}:)?#{@@regex[:ncname]})}
   @@regex[:dollar_qname] = %r{\$#{@@regex[:qname]}}
   @@regex[:dollar_int] = %r{\$([0-9]+)}
-  @@regex[:function_name] = %r{#{@@regex[:qname]}\s*(?=\([^:])}
+  @@regex[:function_name] = %r{#{@@regex[:qname]}\*?\s*(?=\([^:])}
 
   @@ops = {
     '..' => :DOT_DOT,
@@ -221,7 +221,11 @@ module_eval(<<'...end xsm_expression_parser.racc/module_eval...', 'xsm_expressio
           if res[1] == 'if'
             @token = [ :IF, 'if' ]
           else
-            @token = [ :FUNCTION_NAME, res[1] ]
+            if @source[@curpos+res[1].length .. @curpos+res[1].length] == '*'
+              @token = [ :FUNCTION_NAME, res[1]+'*' ]
+            else
+              @token = [ :FUNCTION_NAME, res[1] ]
+            end
           end
         elsif !res[2].nil?
           @token = [ res[2] == 'method' ? :AXIS_METHOD : :AXIS_NAME, res[2] ]

data/lib/fabulator/template/parse_result.rb

@@ -1,13 +1,15 @@
 require 'xml/libxml'
-require 'xml/xslt'
+require 'libxslt'
 
-@@fabulator_xslt_file = File.join(File.dirname(__FILE__), "..", "..", "..", "xslt", "form.xsl")
+module Fabulator::Template
+  class ParseResult
 
-@@fabulator_xmlt = LibXML::XML::Document.file(@@fabulator_xslt_file)
+    @@fabulator_xslt_file = File.join(File.dirname(__FILE__), "..", "..", "..", "xslt", "form.xsl")
+
+    @@fabulator_xslt_doc = LibXML::XML::Document.file(@@fabulator_xslt_file)
+    @@fabulator_xslt = LibXSLT::XSLT::Stylesheet.new(@@fabulator_xslt_doc)
 
 
-module Fabulator::Template
-  class ParseResult
     def initialize(text)
       @doc = LibXML::XML::Document.string text
     end
@@ -110,11 +112,7 @@ module Fabulator::Template
     end
 
     def to_html
-      xslt = XML::XSLT.new
-      xslt.parameters = { }
-      xslt.xml = @doc
-      xslt.xsl = @@fabulator_xslt
-      xslt.serve
+      @@fabulator_xslt.apply(@doc).to_s
     end
 
 protected

data/xsm_expression_parser.racc

@@ -0,0 +1,462 @@
+class Fabulator::Expr::Parser
+  # based on XSM expression grammer from 
+  #    http://cpansearch.perl.org/src/JSMITH/Gestinanna-0.02/parser.PL
+
+  # instead of compiling ruby code, we'll instantiate objects to handle the
+  # run-time performance
+
+  start statements
+
+rule
+  statements: statement { result = Fabulator::Expr::StatementList.new; result.add_statement(val[0]) }
+    | statements SEMI statement { result = val[0]; result.add_statement(val[2]) }
+
+  statement: 
+    | expr
+    | let_expr
+
+  expr: or_expr
+    | range_expr
+    | if_expr
+    | for_expr
+    | quant_expr
+    | with_expr
+
+  with_expr: expr WITH expr_set_list { result = Fabulator::Expr::WithExpr.new(val[0], val[2]) }
+
+  expr_set_list: expr_set { result = Fabulator::Expr::StatementList.new; result.add_statement(val[0]) }
+    | expr_set_list COMMA expr_set { result = val[0]; result.add_statement(val[2]) }
+
+  expr_set: path_expr COLON_EQUAL expr { result = Fabulator::Expr::DataSet.new(val[0], val[2]) }
+
+    #| absolute_location_path COLON_EQUAL expr { result = Fabulator::Expr::DataSet.new(val[0], val[2]) }
+
+  num_expr: additive_expr
+    | range_expr
+
+  num_list: num_expr { result = [ val[0] ] }
+    | num_list COMMA num_expr { result = val[0] + [ val[2] ] }
+
+  let_expr: LET DOLLAR_QNAME COLON_EQUAL expr { result = Fabulator::Expr::LetExpr.new(val[1], val[3]) }
+
+  if_expr: IF LP expr RP THEN expr ELSE expr { result = Fabulator::Expr::IfExpr.new(val[2], val[5], val[7]) }
+    | IF LP expr RP THEN expr { result = Fabulator::Expr::IfExpr.new(val[2], val[5], nil) }
+
+  for_expr: FOR for_vars RETURN expr { result = Fabulator::Expr::ForExpr.new(val[1], val[3]) }
+
+  for_vars: for_var { result = [ val[0] ] }
+    | for_vars COMMA for_var { result = val[0] + [ val[2] ] }
+
+  for_var: DOLLAR_QNAME IN expr { result = Fabulator::Expr::ForVar.new(val[0], val[2]) }
+
+  quant_expr: SOME for_vars SATISFIES expr { result = Fabulator::Expr::SomeExpr.new(val[1], val[3]) }
+    | EVERY for_vars SATISFIES expr { result = Fabulator::Expr::EveryExpr.new(val[1], val[3]) }
+
+  or_expr: and_expr
+    | or_expr OR and_expr { result = Fabulator::Expr::OrExpr.new(val[0], val[2]) }
+
+  and_expr: equality_expr
+    | and_expr AND equality_expr { result = Fabulator::Expr::AndExpr.new(val[0], val[2]) }
+    | and_expr EXCEPT equality_expr { result = Fabulator::Expr::ExceptExpr.new(val[0], val[2]) }
+
+  equality_expr: relational_expr
+    | additive_expr EQ additive_expr { result = Fabulator::Expr::EqExpr.new(val[0], val[2]) }
+    | additive_expr NEQ additive_expr { result = Fabulator::Expr::NeqExpr.new(val[0], val[2]) }
+
+  tuple: LP LB args RB RP { result = Fabulator::Expr::Tuple.new(val[2]) }
+
+#    | LT args GT { result = Fabulator::Expr::Tuple.new(val[1]) }
+
+  relational_expr: additive_expr
+    | additive_expr LT additive_expr { result = Fabulator::Expr::LtExpr.new(val[0], val[2]) }
+    | additive_expr GT additive_expr { result = Fabulator::Expr::LtExpr.new(val[2], val[0]) }
+    | additive_expr LTE additive_expr { result = Fabulator::Expr::LteExpr.new(val[0], val[2]) }
+    | additive_expr GTE additive_expr { result = Fabulator::Expr::LteExpr.new(val[2], val[0]) }
+
+#    | additive_expr LT additive_expr LT additive_expr { result = Fabulator::Expr::Between.new(val[2], val[0], val[4]) }
+#    | additive_expr LT additive_expr LTE additive_expr { }
+#    | additive_expr LTE additive_expr LT additive_expr { }
+#    | additive_expr LTE additive_expr LTE additive_expr { }
+#    | additive_expr GT additive_expr GT additive_expr { result = Fabulator::Expr::Between.new(val[2], val[4], val[0]) }
+#    | additive_expr GT additive_expr GTE additive_expr { }
+#    | additive_expr GTE additive_expr GT additive_expr { }
+#    | additive_expr GTE additive_expr GTE additive_expr { }
+
+  range_expr: additive_expr DOT_DOT additive_expr { result = Fabulator::Expr::RangeExpr.new(val[0], val[2]) }
+    | additive_expr TO additive_expr { result = Fabulator::Expr::RangeExpr.new(val[0], val[2]) }
+
+  additive_expr: multiplicative_expr
+    | additive_expr PLUS multiplicative_expr { result = Fabulator::Expr::AddExpr.new(val[0], val[2]) }
+    | additive_expr MINUS multiplicative_expr { result = Fabulator::Expr::SubExpr.new(val[0], val[2]) }
+
+  multiplicative_expr: unary_expr
+    | multiplicative_expr STAR unary_expr { result = Fabulator::Expr::MpyExpr.new(val[0], val[2]) }
+    | multiplicative_expr DIV unary_expr { result = Fabulator::Expr::DivExpr.new(val[0], val[2]) }
+    | multiplicative_expr MOD unary_expr { result = Fabulator::Expr::ModExpr.new(val[0], val[2]) }
+
+  unary_expr: union_expr
+    | MINUS unary_expr { result = Fabulator::Expr::NegExpr.new(val[1]) }
+
+  union_expr: path_expr
+    | union_expr_x { result = Fabulator::Expr::UnionExpr.new(val[0]) }
+
+  union_expr_x: path_expr PIPE path_expr { result = [ val[0], val[2] ] }
+    | union_expr_x PIPE path_expr { result = val[0] + [ val[2] ] }
+
+  path_expr: location_path { result = Fabulator::Expr::PathExpr.new(nil, [], val[0]) } #result = Fabulator::Expr::PathExpr.new(nil, [], val[0]) }
+    | primary_expr predicates segment { result = Fabulator::Expr::PathExpr.new(val[0], val[1], val[2]) }
+
+  segment:
+    | SLASH relative_location_path { result = val[1] }
+    | SLASH_SLASH relative_location_path { result = [ Fabulator::Expr::AxisDescendentOrSelf.new ] + val[1] }
+
+  location_path: relative_location_path 
+    | absolute_location_path
+
+  # / => local data root
+  # // => local data descendent or self
+
+  absolute_location_path: SLASH { result = Fabulator::Expr::RootContext.new }
+    | SLASH relative_location_path { result = Fabulator::Expr::PathExpr.new(Fabulator::Expr::RootContext.new, [], val[1]) }
+    | SLASH_SLASH relative_location_path { result = [ Fabulator::Expr::RootContext.new, Fabulator::Expr::AxisDescendentOrSelf.new(val[1][0]) ] + val[1][1..val[1].size-1] }
+    | axis_name SLASH relative_location_path { result = [ Fabulator::Expr::RootContext.new(val[0]) ] + val[2] }
+    | axis_name SLASH_SLASH relative_location_path { result = [ Fabulator::Expr::RootContext.new(val[0]), Fabulator::Expr::AxisDescendentOrSelf.new(val[2][0]) ] + val[2][1..val[2].size-1] }
+
+  relative_location_path: step { result = [ val[0] ] }
+    | relative_location_path SLASH step { result = val[0] + [ val[2] ] }
+    | relative_location_path SLASH_SLASH step { result = val[0] + [ Fabulator::Expr::AxisDescendentOrSelf.new(val[2]) ] }
+
+  step: axis predicates { result = val[1].nil? || val[1].empty? ? val[0] : Fabulator::Expr::Predicates.new(val[0], val[1]) }
+    | DOT { result = Fabulator::Expr::CurrentContext.new }
+    | DOT_DOT { result = Fabulator::Expr::AxisParent.new }
+
+    #| AXIS_METHOD COLON_COLON node_test predicates { result = Fabulator::Expr::Predicates.new(Fabulator::Expr::Function.new(@context, val[2], []), val[3]) }
+    #| AXIS_METHOD COLON_COLON FUNCTION_NAME list predicates { result = Fabulator::Expr::Predicates.new(Fabulator::Expr::Function.new(@context, val[2], val[3]), val[4]) }
+    #| axis LC DOLLAR_QNAME RC predicates { result = Fabulator::Expr::Predicates.new(Fabulator::Expr::Step.new(val[0], Fabulator::Expr::QName.new(val[3])), val[4]) }
+
+  axis: node_test { result = Fabulator::Expr::AxisChild.new(val[0]) }
+    | axis_name node_test { result = Fabulator::Expr::Axis.new(val[0], val[1]) }
+    | AT node_test { result = Fabulator::Expr::AxisAttribute.new(val[1]) }
+
+  axis_name: AXIS_NAME COLON_COLON { result = Fabulator::Expr::Axis.new(val[0]) }
+
+  predicates: { result = [ ] }
+    | predicates predicate { result = val[0] + [ val[1] ] }
+
+  predicate: LB expr RB { result = val[1] }
+    | LB num_list RB { result = Fabulator::Expr::IndexPredicate.new(val[1]) }
+
+    #| '<' expr '>'
+  primary_expr:
+    DOLLAR_QNAME { result = Fabulator::Expr::Var.new(val[0]) }
+    | LP expr RP { result = val[1] }
+    | list
+    | tuple
+    | LITERAL { result = Fabulator::Expr::Literal.new(val[0], [ Fabulator::FAB_NS, 'string' ]) }
+    | NUMBER { result = Fabulator::Expr::Literal.new(val[0] =~ /\./ ? val[0].to_d.to_r : val[0].to_i.to_r, [ Fabulator::FAB_NS, 'numeric' ]) }
+    | FUNCTION_NAME list { result = Fabulator::Expr::Function.new(@context, val[0], val[1]) }
+
+  list: LP opt_args RP { result = Fabulator::Expr::List.new(val[1]) }
+
+
+  opt_args: { result = [ ] }
+    | args 
+
+  args: expr { result = [ val[0] ] }
+    | args COMMA expr { result = val[0] + [ val[2] ] }
+
+  node_test: QNAME
+    | NUMBER { result = val[0].to_s }
+    | LC expr RC { result = val[1] }
+    | STAR
+
+end
+
+---- inner 
+  require 'fabulator/expr'
+  require 'rational'
+  require 'bigdecimal'
+  require 'bigdecimal/util'
+
+  def parse(t, ctx)
+    @source = t
+    @curpos = 0
+    @context = ctx
+    @line = 0
+    @col = 0
+
+    @yydebug = true
+
+    @last_token = nil
+      
+    do_parse
+  end
+
+  def on_error(*args)
+    raise Fabulator::Expr::ParserError.new("unable to parse '#{args[1]}' near line #{@line + 1}, column #{@col}")
+  end
+
+
+  @@regex = {
+    :simple_tokens => %r{\.\.|::|!=|>=|<=|\/\/|:=|\.|@|[*]|\(|\)|\[|\]|\{|\}|\/|\||\+|-|=|>|<|&|,|;},
+    :ncname => %r{(?:[a-zA-Z_][-a-zA-Z0-9_.]*)},
+    :event_type => %r{(?:processing-instruction|comment|text|node)},
+    :axis_name => %r{(?:attribute|child|child-or-self|descendant|descendant-or-self|method|self)},
+    :namespace_name => %r{(?:context|global|local|session|universal)},
+    :number => %r{(-?\d+(?:\.\d+)?|\.\d+)},
+  }
+
+  @@regex[:axis] = %r{(#{@@regex[:ncname]})\s*(?=::)}
+  @@regex[:name_colon_star] = %r{(#{@@regex[:ncname]}:\*)}
+  @@regex[:qname] = %r{((?:#{@@regex[:ncname]}:)?#{@@regex[:ncname]})}
+  @@regex[:dollar_qname] = %r{\$#{@@regex[:qname]}}
+  @@regex[:dollar_int] = %r{\$([0-9]+)}
+  @@regex[:function_name] = %r{#{@@regex[:qname]}\*?\s*(?=\([^:])}
+
+  @@ops = {
+    '..' => :DOT_DOT,
+    '::' => :COLON_COLON,
+    '!=' => :NEQ,
+    '>=' => :GTE,
+    '<=' => :LTE,
+    '//' => :SLASH_SLASH,
+    ':=' => :COLON_EQUAL,
+    '.'  => :DOT,
+    '@'  => :AT,
+    '*'  => :STAR,
+    '('  => :LP,
+    ')'  => :RP,
+    '['  => :LB,
+    ']'  => :RB,
+    '{'  => :LC,
+    '}'  => :RC,
+    '/'  => :SLASH,
+    '|'  => :PIPE,
+    '+'  => :PLUS,
+    '-'  => :MINUS,
+    '='  => :EQ,
+    '>'  => :GT,
+    '<'  => :LT,
+    '&'  => :AMP,
+    ','  => :COMMA,
+    ';'  => :SEMI
+  }
+
+  @@preceding_tokens = { }
+  [%{
+    @ :: ( 
+    and or mod div 
+    * 
+    / // | + - = != < <= > >=
+    == & && ||
+  }.split(/\s*/), '[', ',', '$' ].each { |t| @@preceding_tokens[t] = true }
+
+  @@regex[:general] = Regexp.compile(%{^(?:#{@@regex[:function_name]}|#{@@regex[:axis]}|#{@@regex[:name_colon_star]}|#{@@regex[:qname]}|('[^']*'|"[^"]*")|#{@@regex[:number]}|#{@@regex[:dollar_qname]}|#{@@regex[:dollar_int]}|(#{@@regex[:simple_tokens]}))})
+
+  def next_token  
+    @token = nil
+    white_space = 0
+    new_line = 0
+    while @curpos < @source.length && @source[@curpos..@curpos] =~ /\s/ do
+      if @source[@curpos..@curpos] =~ /\n/
+        new_line = new_line + 1
+        @line = @line + 1
+        @col = 0
+      else
+        @col = @col + 1
+      end
+      @curpos = @curpos + 1
+      white_space = white_space + 1
+    end
+
+    # skip comments delimited by (:  :)
+    # comments can be nested
+    # these are XPath 2.0 comments
+    #
+    if @curpos < @source.length && @source[@curpos..@curpos+1] == '(:'
+      comment_depth = 1
+      @curpos = @curpos + 2
+      @col = @col + 2
+      while comment_depth > 0 && @curpos < @source.length
+        if @source[@curpos..@curpos+1] == '(:'
+          comment_depth = comment_depth + 1
+          @curpos = @curpos + 1
+          @col = @col + 1
+        end
+        if @source[@curpos..@curpos+1] == ':)'
+          comment_depth = comment_depth - 1
+          @curpos = @curpos + 1
+          @col = @col + 1
+        end
+        @curpos = @curpos + 1
+        @col = @col + 1
+      end
+      white_space = white_space + 1
+    end
+
+    while @curpos < @source.length && @source[@curpos..@curpos] =~ /\s/ do
+      if @source[@curpos..@curpos] =~ /\n/
+        new_line = new_line + 1
+        @line = @line + 1
+        @col = 0
+      else
+        @col = @col + 1
+      end
+      @curpos = @curpos + 1
+      white_space = white_space + 1
+    end
+        
+    if @curpos >= @source.length
+      @last_token = nil
+      return [ false, false ]
+    end
+
+    #if new_line > 0 || white_space > 0
+    #  @token = [ :SP, '' ]
+    #end
+
+    if @token.nil? && @last_token && ! @@preceding_tokens[@last_token[1]]
+      if @source[@curpos..@curpos] == '*'
+        @token = [ :STAR, '*' ]
+      else
+        if @source[@curpos..@source.length-1] =~ /^(#{@@regex[:ncname]})/
+          ncname = $1
+          case ncname
+            when 'for':
+              @token = [ :FOR, 'for' ]
+            when 'return':
+              @token = [ :RETURN, 'return' ]
+            when 'in':
+              @token = [ :IN, 'in' ]
+            when 'let':
+              @token = [ :LET, 'let' ]
+            when 'except':
+              @token = [ :EXCEPT, 'except' ]
+            when 'every':
+              @token = [ :EVERY, 'every' ]
+            when 'some':
+              @token = [ :SOME, 'some' ]
+            when 'satisfies':
+              @token = [ :SATISFIES, 'satisfies' ]
+            when 'if':
+              @token = [ :IF, 'if' ]
+            when 'then':
+              @token = [ :THEN, 'then' ]
+            when 'else':
+              @token = [ :ELSE, 'else' ]
+            when 'to':
+              @token = [ :TO, 'to' ]
+            when 'and':
+              @token = [ :AND, 'and' ]
+            when 'or':
+              @token = [ :OR, 'or' ]
+            when 'mod':
+              @token = [ :MOD, 'mod' ]
+            when 'div':
+              @token = [ :DIV, 'div' ]
+            #when '*doh*':
+            #  # do nothing
+            #  @token = nil
+            else
+              @token = nil
+          end
+        end
+      end
+    end
+ 
+    if @token.nil? && @source[@curpos..@curpos+1] == '..'
+      @token = [ :DOT_DOT, '..' ]
+    end
+
+    if @token.nil?
+      if @curpos >= @source.length
+        @token = [false, false]
+        return @token
+      end
+
+      res = @@regex[:general].match(@source[@curpos..@source.length-1])
+      #@source[@curpos..@source.length-1] =~ @@regex[:general]
+      #res = [ nil, $1, $2, $3, $4, $5, $6, $7, $8 ]
+      if res.nil?
+        raise "Failed to parse '#{@source}' at #{@curpos}': #{@source[@curpos..@source.length-1]}"
+      else
+        if !res[1].nil?
+          if res[1] == 'if'
+            @token = [ :IF, 'if' ]
+          else
+            if @source[@curpos+res[1].length .. @curpos+res[1].length] == '*'
+              @token = [ :FUNCTION_NAME, res[1]+'*' ]
+            else
+              @token = [ :FUNCTION_NAME, res[1] ]
+            end
+          end
+        elsif !res[2].nil?
+          @token = [ res[2] == 'method' ? :AXIS_METHOD : :AXIS_NAME, res[2] ]
+        elsif !res[3].nil?
+          @token = [ :NAME_COLON_STAR, res[3] ]
+        elsif !res[4].nil?
+          qname = res[4]
+          case qname
+            when 'for':
+              @token = [ :FOR, 'for' ]
+            when 'return':
+              @token = [ :RETURN, 'return' ]
+            when 'in':
+              @token = [ :IN, 'in' ]
+            when 'let':
+              @token = [ :LET, 'let' ]
+            when 'except':
+              @token = [ :EXCEPT, 'except' ]
+            when 'every':
+              @token = [ :EVERY, 'every' ]
+            when 'some':
+              @token = [ :SOME, 'some' ]   
+            when 'satisfies':
+              @token = [ :SATISFIES, 'satisfies' ]
+            when 'if':
+              @token = [ :IF, 'if' ]
+            when 'then':
+              @token = [ :THEN, 'then' ]
+            when 'else':
+              @token = [ :ELSE, 'else' ]
+            when 'with':
+              @token = [ :WITH, 'with' ]
+            else
+              @token = [ :QNAME, res[4] ]
+          end
+        elsif !res[5].nil?
+          s = res[5]
+          s = s[1..s.length-2]
+          @curpos = @curpos + s.length
+          @col = @col + s.length
+          s.gsub!(/\\n/, "\n")
+          @curpos = @curpos - s.length
+          @col = @col - s.length
+          @token = [ :LITERAL, s ]
+          @curpos = @curpos + 2  # the quotes
+          @col = @col + 2
+        elsif !res[6].nil?
+          @token = [ :NUMBER, res[6] ]
+        elsif !res[7].nil?
+          @curpos = @curpos + 1
+          @col = @col + 1
+          @token = [ :DOLLAR_QNAME, res[7] ]
+        elsif !res[8].nil?
+          @curpos = @curpos + 1
+          @col = @col + 1
+          @token = [ :DOLLAR_QNAME, res[8] ]
+        elsif !res[9].nil?
+          @token = [ @@ops[res[9]] || res[9], res[9] ]
+        else
+          raise "Failed to parse '#{@source}' at #{@curpos}: #{@source[@curpos..@source.length-1]}"
+        end
+      end
+    end
+
+    if !@token[1].nil?
+      @curpos = @curpos + @token[1].length
+      @col = @col + @token[1].length
+    end
+    @last_token = @token
+    return @token
+  end