rdf_context 0.4.8 → 0.5.0

data/lib/rdf_context/literal.rb

@@ -4,7 +4,6 @@ begin
 rescue LoadError
 end
 
-require 'parsedate'
 require File.join(File.dirname(__FILE__), 'duration')
 
 module RdfContext
@@ -93,6 +92,7 @@ module RdfContext
           false
         end
       end
+      alias_method :eql?, :==
 
       # Generate hash of type to determine uniqueness
       def hash
@@ -131,8 +131,25 @@ module RdfContext
       
       # Encode literal contents
       def encode_contents(contents, options)
+        return contents.to_s unless valid?(contents)
+        
         case @value
-        when XSD_NS.boolean   then %w(1 true).include?(contents.to_s) ? "true" : "false"
+        when XSD_NS.boolean then %(1 true).include?(contents.to_s.downcase) ? "true" : "false"
+        when XSD_NS.integer then contents.to_i.to_s
+        when XSD_NS.decimal
+          # Can't use simple %f transformation do to special requirements from N3 tests in representation
+          i, f = contents.to_s.split(".")
+          f = f.to_s[0,16]  # Truncate after 15 decimal places
+          i.sub!(/^\+?0+(\d)$/, '\1')
+          f.sub!(/0*$/, '')
+          f = "0" if f.empty?
+          "#{i}.#{f}"
+        when XSD_NS.double
+          i, f, e = ("%.16E" % contents.to_f).split(/[\.E]/)
+          f.sub!(/0*$/, '')
+          f = "0" if f.empty?
+          e.sub!(/^\+?0+(\d)$/, '\1')
+          "#{i}.#{f}E#{e}"
         when XSD_NS.time      then contents.is_a?(Time) ? contents.strftime("%H:%M:%S%Z").sub(/\+00:00|UTC/, "Z") : contents.to_s
         when XSD_NS.dateTime  then contents.is_a?(DateTime) ? contents.strftime("%Y-%m-%dT%H:%M:%S%Z").sub(/\+00:00|UTC/, "Z") : contents.to_s
         when XSD_NS.date      then contents.is_a?(Date) ? contents.strftime("%Y-%m-%d%Z").sub(/\+00:00|UTC/, "Z") : contents.to_s
@@ -140,6 +157,17 @@ module RdfContext
         else                       contents.to_s
         end
       end
+      
+      # Validate format of content
+      def valid?(contents)
+        case @value
+        when XSD_NS.boolean   then %w(1 true 0 false).include?(contents.to_s.downcase)
+        when XSD_NS.decimal   then !!contents.to_s.match(/^[\+\-]?\d+(\.\d*)?$/)
+        when XSD_NS.double    then !!contents.to_s.match(/^[\+\-]?\d+(\.\d*([eE][\+\-]?\d+)?)?$/)
+        when XSD_NS.integer   then !!contents.to_s.match(/^[\+\-]?\d+$/)
+        else                       true
+        end
+      end
     end
     
     # The null encoding
@@ -365,6 +393,10 @@ module RdfContext
       "#{self.class}[#{self.to_n3}]"
     end
     
+    def valid?
+      encoding.valid?(@contents)
+    end
+    
     # Output literal in TriX format
     def to_trix
       encoding.format_as_trix(@contents, @lang)

data/lib/rdf_context/n3_grammar.treetop

@@ -1,143 +1,227 @@
+#encoding: utf-8'
 grammar N3Grammer
-	rule document
-		statements
-	end
-	
-	rule statements
-		(space / (statement / directive) space* ('.' space*)? )*
-	end
-	
-	rule statement
-		subject space+ property_list
-	end
-	
-	rule subject
-		node
-	end
-	
-	rule verb
-		">-" prop "->"      # has xxx of 
-		/ "<-" prop "<-"    # is xxx of 
-		# / # / operator     # has operator:xxx of??? NOT IMPLMENTED
-		/ prop              # has xxx of -- shorthand
-		# / "has" prop        # has xxx of
-		# / "is" prop "of"    # is xxx of
-		/ "a"               # has rdf:type of
-		# / "="               # has daml:equivaent of
-	end
-	
-	rule prop
-		node
-	end
-	
-	rule node
-		uri_ref / anonnode / 'this'
-	end
-	
-	rule anonnode
-		"[" space* property_list space* "]"  # something which ...
-		/ "{" statementlist "}"  # the statementlist itself as a resource
-		/ "(" nodelist ")" {
-			def anonnode; true; end
-		}
-	end
-	
-	rule property_list
-		verb space+ object_list space* ";" space+ property_list
-		/ verb space+ object_list
-		/ ":-" anonnode  #to allow two anonymous forms to be given eg [ a :Truth; :- { :sky :color :blue } ] )
-		/ ":-" anonnode ";" property_list
-		/ '.'
-	end
-
-	rule object_list
-		object "," space* object_list / object
-	end
-
-	rule directive
-		'@prefix' space+ nprefix:nprefix? ':' space+ uri_ref:uri_ref {
-			def directive; true; end
-		}
-	end
-	
-	rule uri_ref
-		qname / "<" uri:URI_Reference ">"
-	end
-	
-	rule qname
-		nprefix ":" localname / ':' localname
-	end
-	
-	rule object
-		subject / literal
-	end
-	
-	rule literal
-  	(string_single / string_multi) ("^^<" uri:URI_Reference ">" / "@" language )?
-	end
-	
-	rule language
-		[a-z]+ ( "-" [a-z0-9]+ )*
-	end
-
-	rule localname
-		fragid
-	end
-	
-	rule URI_Reference
-		[^{}<>]*
-	end
-	
-	rule nprefix
-		((alpha / "_") alphanumeric*)
-	end
-
-	rule fragid
-		alpha alphanumeric*
-	end
-
-	rule alpha
-		[a-zA-Z]
-	end
-	
-	rule alphanumeric
-		alpha / [0-9] / "_"
-	end
-	
-	rule space
-		[ \t\n\r]+ / comment
-	end
-	
-	rule comment
-	  '#' (![\n\r] .)*
-	end
+  # Entry point to grammer
+  rule document
+    statements
+  end
+
+  rule alpha
+    [A-Z_a-z\p{Alpha}]
+  end
+
+  rule alphanumeric
+    alpha / [0-9]
+  end
+
+  rule barename_csl
+    space+ barename barename_csl_tail
+    / ""
+  end
+
+  rule barename_csl_tail
+    space* "," space* barename space* barename_csl_tail
+    / ""
+  end
+
+  rule boolean
+    "@"* ("true" / "false")
+  end
+  
+  rule comment
+    '#' (![\n\r] .)*
+  end
+
+  rule declaration
+    "@"? 'keywords' barename_csl {
+      def declaration; true; end
+      def keywords; true;end
+    }
+    / "@"? 'base' space+ explicituri:explicituri {
+      def declaration; true; end
+      def base; true; end
+    }
+    / "@"? 'prefix' space+ nprefix:nprefix? ':' space* explicituri:explicituri {
+      def declaration; true; end
+    }
+  end
+  
+  rule decimal
+    integer '.' [0-9]+
+  end
+  
+  rule double
+    decimal [eE] integer
+  end
+  
+  rule existential
+    "@"? "forSome" space+ symbol_csl
+  end
+  
+  rule explicituri
+   "<" uri:URI_Reference ">"
+  end
+  
+  rule expression
+    pathitem space* '.' expression  
+    / pathitem space* "!" space* expression
+    / pathitem space* "^" space* expression { def reverse; true; end }
+    / pathitem
+  end
+
+  rule barename
+    alpha (alphanumeric / '-')*
+  end
+
+  rule hexdigit
+    [0-9a-fA-F]
+  end
+  
+  rule integer
+     [+-]? [0-9]+
+  end
+  
+  rule language
+    [a-z]+ ( "-" [a-z0-9]+ )*
+  end
+
+  rule literal
+    (string_single / string_multi) ("^^" symbol / "@" language )?
+  end
+  
+  rule localname
+    alpha (alphanumeric / '-')*
+  end
+  
+  rule nprefix
+    alpha (alphanumeric / '-')*
+  end
+
+  rule numericliteral
+    double { def numericliteral; "double"; end}
+    / decimal { def numericliteral; "decimal"; end}
+    / integer { def numericliteral; "integer"; end}
+  end
+  
+  rule object
+    expression
+  end
+  
+  rule object_list
+    object space* "," space* object_list
+    / object
+  end
 
+  rule pathitem
+    boolean { def boolean; true; end }
+    / literal { def literal; true; end }
+    / numericliteral
+    #/ quickvariable
+    / symbol
+    / "[" space* "]" { def anonnode; true; end }
+    / "[" space* property_list space* "]" { def anonnode; true; end }
+    / "{" space* statements space* "}" { def anonnode; true; end }
+    / "(" space* path_list space* ")" { def anonnode; true; end }
+  end
+  
+  rule path_list
+    expression space* path_list
+    / ""
+  end
+  
+  rule prop
+    expression
+  end
+  
+  rule property_list
+    verb space* object_list space* ";"+ space* property_list
+    / verb space* object_list space* ";"*
+    / verb space* ";"* {def object_missing; true; end}
+    / ""
+  end
+
+  rule qname
+    nprefix ":" localname
+    / nprefix ':' { def text_value; ""; end }
+    / ':' localname*
+    / localname { def barename; true; end }
+  end
+  
+  rule simpleStatement
+    subject space+ property_list
+    / subject # For [] and a.b
+  end
+  
+  rule space
+    [ \t\n\r]+ / comment
+  end
+  
+  rule statement
+    declaration
+    / existential
+    / simpleStatement
+    / universal
+  end
+  
+  rule statements
+    (space / statement space* ('.' space*)? )*
+  end
+  
   # " constant-value-with-escaping "
-	rule string_single
-		'""' !["] / '"' string_single_char+ '"'
-	end
+  rule string_single
+    '""' !["] / '"' string_single_char+ '"'
+  end
 
-	rule string_single_char
+  rule string_single_char
     !["\n\r] (
       ("\\"
-        [\\\"nrt]
+        [\\\"bfnrt]
       / ( "u" hexdigit hexdigit hexdigit hexdigit )
       / ( "U" "00" hexdigit hexdigit hexdigit hexdigit hexdigit hexdigit)
       )
     / .)
-	end
+  end
 
-  rule hexdigit
-    [0-9a-fA-F]
+  # """ constant value with escaping including single or double occurrences of quotes and/or newlines """ 
+  rule string_multi
+    '"""' string_multi_single_char* '"""'
+  end
+
+  rule string_multi_single_char
+    "\\\""
+    / !('"""') .
   end
-  
-  # """ constant value with escaping including single or double occurrences of quotes and/or newlines """	
-	rule string_multi
-		'"""' string_multi_char* '"""'
-	end
 
-	rule string_multi_char
-		!'"""' . # something like this; need to think about it some more	
-	end
-		
+  rule subject
+    expression
+  end
+  
+  rule symbol
+    qname / explicituri
+  end
+  
+  rule symbol_csl
+    symbol space* "," space* symbol_csl
+    / symbol
+  end
+  
+  rule verb
+    "@"? "has" space+ prop                    # has xxx
+    / "@"? "is" space+ prop space+ "@"? "of" { # is xxx of
+      def invert; true; end
+    }
+    / "@"? "a" !":"                           # has rdf:type
+    / "=>"                                    # has log:implies
+    / "<=" { def invert; true; end }          # is log:implies of
+    / "="                                     # has owl:sameAs
+    / prop                                    # has xxx of -- shorthand
+  end
+  
+  rule universal
+    "@"? "forAll" space+ symbol_csl
+  end
+  
+  rule URI_Reference
+    [^{}<>]*
+  end
+  
 end

data/lib/rdf_context/n3parser.rb

@@ -6,6 +6,7 @@ Treetop.load(File.join(File.dirname(__FILE__), "n3_grammar"))
 module RdfContext
   class Parser; end
   class N3Parser < Parser
+    N3_KEYWORDS = %w(a is of has keywords prefix base true false forSome forAny)
 
     # Parse N3 document from a string or input stream to closure or graph.
     #
@@ -27,102 +28,274 @@ module RdfContext
       @callback = block
       parser = N3GrammerParser.new
 
-      @doc = stream.respond_to?(:read) ? stream.read : stream
-      
+      @doc = stream.respond_to?(:read) ? (stream.rewind; stream.read) : stream
+      @default_ns = Namespace.new("#{uri}#", "")  if uri
+      add_debug("@default_ns", "#{@default_ns.inspect}")
+
+      @graph.allow_n3 = true
       document = parser.parse(@doc)
       unless document
+        puts parser.inspect if $DEBUG
         reason = parser.failure_reason
         raise ParserException.new(reason)
       end
       
-      process_directives(document)
       process_statements(document)
       @graph
     end
 
     protected
 
-    def process_directives(document)
-      directives = document.elements.find_all { |e| e.elements.first.respond_to? :directive }
-      directives.map! { |d| d.elements.first }
-      directives.each { |d| namespace(d.uri_ref.uri.text_value, d.nprefix.text_value) }
-    end
-
     def namespace(uri, prefix)
-      uri = @uri if uri == '#'
-      prefix = '__local__' if prefix == ''
+      add_debug("namesspace", "'#{prefix}' <#{uri}>")
+      uri = @default_ns.uri if uri == '#'
       @graph.bind(Namespace.new(uri, prefix))
     end
 
     def process_statements(document)
-      subjects = document.elements.find_all { |e| e.elements.first.respond_to? :subject }
-      subjects.map! { |s| s.elements.first }
-      subjects.each do |s|
-        subject = process_node(s.subject)
-        properties = process_properties(s.property_list)
-        properties.each do |p|      
-          predicate = process_verb(p.verb)
-          objects = process_objects(p.object_list)
-          objects.each { |object| add_triple("statement", subject, predicate, object) }
+      document.elements.find_all do |e|
+        s = e.elements.first
+        add_debug(*s.info("process_statements"))
+        
+        if s.respond_to?(:subject)
+          subject = process_expression(s.subject)
+          add_debug(*s.info("process_statements(#{subject})"))
+          properties = process_properties(s.property_list)
+          properties.each do |p|
+            predicate = process_verb(p.verb)
+            add_debug(*p.info("process_statements(#{subject}, #{predicate})"))
+            raise ParserException, %Q(Illegal statment: "#{predicate}" missing object) unless p.respond_to?(:object_list)
+            objects = process_objects(p.object_list)
+            objects.each do |object|
+              if p.verb.respond_to?(:invert)
+                add_triple("statement", object, predicate, subject)
+              else
+                add_triple("statement", subject, predicate, object)
+              end
+            end
+          end
+        elsif s.respond_to?(:anonnode)
+          process_anonnode(s)
+        elsif s.respond_to?(:pathitem)
+          process_path(s)
+        elsif s.respond_to?(:declaration)
+          if s.respond_to?(:nprefix)
+            add_debug(*s.info("process_statements(namespace)"))
+            keyword_check("prefix") if s.text_value.index("prefix") == 0
+            uri = process_uri(s.explicituri.uri, false)
+            namespace(uri, s.nprefix.text_value)
+          elsif s.respond_to?(:base)
+            add_debug(*s.info("process_statements(base)"))
+            keyword_check("base") if s.text_value.index("base") == 0
+            # Base, set or update document URI
+            uri = s.explicituri.uri.text_value
+            @default_ns = Namespace.new(process_uri(uri, false), "")  # Don't normalize
+            add_debug("@default_ns", "#{@default_ns.inspect}")
+            @uri = process_uri(uri)
+            add_debug("@base", "#{@uri}")
+            @uri
+          elsif s.respond_to?(:keywords)
+            add_debug(*s.info("process_statements(keywords)"))
+            keyword_check("keywords") if s.text_value.index("keywords") == 0
+            @keywords = process_barename_csl(s.barename_csl) ||[]
+            add_debug("@keywords", @keywords.inspect)
+            if (@keywords & N3_KEYWORDS) != @keywords
+              raise ParserException, "undefined keywords used: #{(@keywords - N3_KEYWORDS).to_sentence}" if @strict
+            end
+          end
         end
       end
     end
+    
+    def process_barename_csl(list)
+      #add_debug(*list.info("process_barename_csl(list)"))
+      res = [list.barename.text_value] if list.respond_to?(:barename)
+      rest = process_barename_csl(list.barename_csl_tail) if list.respond_to?(:barename_csl_tail)
+      rest ? res + rest : res
+    end
 
     def process_anonnode(anonnode)
+      add_debug(*anonnode.info("process_anonnode"))
       bnode = BNode.new
-      properties = process_properties(anonnode.property_list)
-      properties.each do |p|      
-        predicate = process_node(p.verb)
-        objects = process_objects(p.object_list)
-        objects.each { |object| add_triple("anonnode", bnode, predicate, object) }
+      
+      if anonnode.respond_to?(:property_list)
+        properties = process_properties(anonnode.property_list)
+        properties.each do |p|
+          predicate = process_verb(p.verb)
+          add_debug(*p.info("anonnode[#{predicate}]"))
+          objects = process_objects(p.object_list)
+          objects.each { |object| add_triple("anonnode", bnode, predicate, object) }
+        end
+      elsif anonnode.respond_to?(:path_list)
+        objects = process_objects(anonnode.path_list)
+        last = objects.pop
+        first_bnode = bnode
+        objects.each do |object|
+          add_triple("anonnode", first_bnode, RDF_NS.first, object)
+          rest_bnode = BNode.new
+          add_triple("anonnode", first_bnode, RDF_NS.rest, rest_bnode)
+          first_bnode = rest_bnode
+        end
+        if last
+          add_triple("anonnode", first_bnode, RDF_NS.first, last)
+          add_triple("anonnode", first_bnode, RDF_NS.rest, RDF_NS.nil)
+        else
+          bnode = RDF_NS.nil
+        end
       end
       bnode
     end
 
     def process_verb(verb)
-      return URIRef.new('http://www.w3.org/1999/02/22-rdf-syntax-ns#type') if (verb.text_value=='a')
-      return process_node(verb)
+      add_debug(*verb.info("process_verb"))
+      case verb.text_value
+      when "a"
+        # If "a" is a keyword, then it's RDF_TYPE, otherwise it's expanded from the default namespace
+        if @keywords.nil? || @keywords.include?("a")
+          RDF_TYPE
+        else
+          build_uri("a")
+        end
+      when "@a"           then RDF_TYPE
+      when "="            then OWL_NS.sameAs
+      when "=>"           then LOG_NS.implies
+      when "<="           then LOG_NS.implies
+      when /^(@?is)\s+.*\s+(@?of)$/
+        keyword_check("is") if $1 == "is"
+        keyword_check("of") if $2 == "of"
+        process_expression(verb.prop)
+      when /^has\s+/
+        keyword_check("has")
+        process_expression(verb.prop)
+      else
+        if verb.respond_to?(:prop)
+          process_expression(verb.prop)
+        else
+          process_expression(verb)
+        end
+      end
     end
 
-    def process_node(node)
-      if (node.respond_to? :uri)
-        URIRef.new(node.uri.text_value)
-      else      
-        prefix = (node.respond_to? :nprefix) ? node.nprefix.text_value : nil
-        localname = node.localname.text_value
-        build_uri(prefix, localname)
+    def process_expression(expression)
+      add_debug(*expression.info("process_expression"))
+      if expression.respond_to?(:pathitem) && expression.respond_to?(:expression)
+        process_path(expression)  # Returns last object in chain
+      elsif expression.respond_to?(:uri)
+        process_uri(expression.uri)
+      elsif expression.respond_to?(:localname)
+        build_uri(expression)
+      elsif expression.respond_to?(:anonnode)
+        process_anonnode(expression)
+      elsif expression.respond_to?(:literal)
+        process_literal(expression)
+      elsif expression.respond_to?(:numericliteral)
+        process_numeric_literal(expression)
+      elsif expression.respond_to?(:boolean)
+        barename = expression.text_value.to_s
+        if @keywords && !@keywords.include?(barename)
+          build_uri(barename)
+        else
+          Literal.typed(barename.delete("@"), XSD_NS.boolean)
+        end
+      elsif expression.respond_to?(:barename)
+        barename = expression.text_value.to_s
+        
+        # Should only happen if @keywords is defined, and text_value is not a defined keyword
+        case barename
+        when "true"   then Literal.typed("true", XSD_NS.boolean)
+        when "false"  then Literal.typed("false", XSD_NS.boolean)
+        else
+          # create URI using barename, unless it's in defined set, in which case it's an error
+          raise ParserException, %Q(Keyword "#{barename}" used as expression) if @keywords && @keywords.include?(barename)
+          build_uri(barename)
+        end
+      else
+        build_uri(expression)
       end
     end
 
+    # Process a path, such as:
+    #   :a.:b means [is :b of :a]
+    #   :a!:b means [is :b of :a]
+    #   :a^:b means [:b :a]
+    #
+    # Elements may be strug together, with the last element the verb applied to the previous expression:
+    #   :a.:b.:c means [is :c of [ is :b of :a]]
+    #   :a!:b^:c meands [:c [ is :b of :a]]
+    def process_path(path)
+      add_debug(*path.info("process_path"))
+
+      object = process_expression(path.pathitem)
+      
+      # Create a list of direction/predicate pairs
+      path_list = process_path_list(path.expression, path.respond_to?(:reverse))
+      #puts path_list.inspect
+      # Now we should have the following
+      # [
+      #   [:forward, b]
+      #   [:forward, c]
+      # ]
+      path_list.each do |p|
+        reverse, pred = p
+        bnode = BNode.new
+        if reverse
+          add_triple("path(#{reverse})", bnode, pred, object)
+        else
+          add_triple("path(#{reverse})", object, pred, bnode)
+        end
+        object = bnode
+      end
+      object
+    end
+
+    # Returns array of [:forward/:reverse, element] pairs
+    def process_path_list(path, reverse)
+      add_debug(*path.info("process_path_list(#{reverse})"))
+      if path.respond_to?(:pathitem)
+        [[reverse, process_expression(path.pathitem)]] + process_path_list(path.expression, path.respond_to?(:reverse))
+      else
+        [[reverse, process_expression(path)]]
+      end
+    end
+    
+    def process_uri(uri, normalize = true)
+      uri = uri.text_value if uri.respond_to?(:text_value)
+      # Use non-normalized URI from @default_ns when constructing URIs
+      if uri.match(/^\#/) && @default_ns
+        @default_ns + uri.rdf_escape
+      else
+        base_uri = @default_ns ? @default_ns.uri : @uri
+        URIRef.new(uri, base_uri, :normalize => normalize)
+      end
+    end
+    
     def process_properties(properties)
+      add_debug(*properties.info("process_properties"))
       result = []
-      result << properties if (properties.respond_to? :verb)
-      result << process_properties(properties.property_list) if (properties.respond_to? :property_list)
+      result << properties if properties.respond_to?(:verb)
+      result << process_properties(properties.property_list) if properties.respond_to?(:property_list)
       result.flatten
     end
 
     def process_objects(objects)
+      add_debug(*objects.info("process_objects"))
       result = []
-      if (objects.respond_to? :object)
-        result << process_object(objects.object)
-      else
-        result << process_object(objects)
+      if objects.respond_to?(:object)
+        result << process_expression(objects.object)
+      elsif objects.respond_to?(:pathitem)
+        result << process_expression(objects)
+      elsif objects.respond_to?(:expression)
+        result << process_expression(objects.expression)
+        result << process_objects(objects.path_list) if objects.respond_to?(:path_list)
+      elsif !objects.text_value.empty? || objects.respond_to?(:nprefix)
+        result << process_expression(objects)
       end
-      result << process_objects(objects.object_list) if (objects.respond_to? :object_list)
+      result << process_objects(objects.object_list) if objects.respond_to?(:object_list)
       result.flatten
     end
 
-    def process_object(object)
-      if (object.respond_to? :localname or object.respond_to? :uri)
-        process_node(object)
-      elsif (object.respond_to? :property_list)
-        process_anonnode(object)
-      else
-        process_literal(object)
-      end
-    end
-    
     def process_literal(object)
+      add_debug(*object.info("process_literal"))
       encoding, language = nil, nil
       string, type = object.elements
 
@@ -131,21 +304,72 @@ module RdfContext
         if (type.elements[0].text_value=='@')
           language = type.elements[1].text_value
         else
-          encoding = type.elements[1].text_value
+          encoding = process_expression(type.elements[1])
         end
       end
 
       # Evaluate text_value to remove redundant escapes
       #puts string.elements[1].text_value.dump
-      Literal.n3_encoded(string.elements[1].text_value, language, encoding)
+      lit = Literal.n3_encoded(string.elements[1].text_value, language, encoding)
+      raise ParserException, %(Typed literal has an invalid lexical value: #{encoding.to_n3} "#{lit.contents}") if @strict && !lit.valid?
+      lit
     end
     
-    def build_uri(prefix, localname)
-      prefix = '__local__' if prefix.nil?
-      if (prefix=='_')
+    def process_numeric_literal(object)
+      add_debug(*object.info("process_numeric_literal"))
+
+      Literal.typed(object.text_value, XSD_NS.send(object.numericliteral))
+    end
+    
+    def build_uri(expression)
+      prefix = expression.respond_to?(:nprefix) ? expression.nprefix.text_value.to_s : ""
+      localname = expression.localname.text_value if expression.respond_to?(:localname)
+      localname ||= (expression.respond_to?(:text_value) ? expression.text_value : expression).to_s.sub(/^:/, "")
+
+#      add_debug(*expression.info("build_uri(#{prefix.inspect}, #{localname.inspect})"))
+
+      uri = if @graph.nsbinding[prefix]
+        @graph.nsbinding[prefix] + localname.to_s.rdf_escape
+      elsif prefix == '_'
         BNode.new(localname, @named_bnodes)
+      elsif prefix == "rdf"
+        # A special case
+        RDF_NS + localname.to_s.rdf_escape
       else
-        @graph.nsbinding[prefix].send(localname)
+        @default_ns ||= Namespace.new("#{@uri}#", "")
+        @default_ns + localname.to_s.rdf_escape
+      end
+      add_debug(*expression.info("build_uri: #{uri.inspect}")) if expression.respond_to?(:info)
+      uri
+    end
+    
+    # Is this an allowable keyword?
+    def keyword_check(kw)
+      unless (@keywords || %w(a is of has)).include?(kw)
+        raise ParserException, "unqualified keyword '#{kw}' used without @keyword directive" if @strict
+      end
+    end
+  end
+end
+
+
+module Treetop
+  module Runtime
+    class SyntaxNode
+      # Brief information about a syntax node
+      def info(ctx = "")
+        m = self.singleton_methods(true)
+        if m.empty?
+          ["@#{self.interval.first}", "#{ctx}['#{self.text_value}']"]
+        else
+          ["@#{self.interval.first}", "#{ctx}[" +
+          self.singleton_methods(true).map do |m|
+            v = self.send(m)
+            v = v.text_value if v.is_a?(SyntaxNode)
+            "#{m}='#{v}'"
+          end.join(", ") +
+          "]"]
+        end
       end
     end
   end