rdf-n3 0.2.3.2 → 0.3.0

data/lib/rdf/n3.rb

@@ -24,8 +24,8 @@ module RDF
     require 'rdf/n3/vocab'
     require 'rdf/n3/patches/array_hacks'
     require 'rdf/n3/patches/graph_properties'
-    require 'rdf/n3/patches/qname_hacks'
-    require 'rdf/n3/patches/seq'
+    autoload :Meta,    'rdf/n3/reader/meta'
+    autoload :Parser,  'rdf/n3/reader/parser'
     autoload :Reader,  'rdf/n3/reader'
     autoload :VERSION, 'rdf/n3/version'
     autoload :Writer,  'rdf/n3/writer'

data/lib/rdf/n3/reader.rb

@@ -1,68 +1,88 @@
-require 'treetop'
-
-if defined?(::Encoding)
-  # load full grammar
-  Treetop.load(File.join(File.dirname(__FILE__), "reader", "n3_grammar"))
-else
-  # load 1.8 grammar, doesn't include U00010000-\U000effff
-  Treetop.load(File.join(File.dirname(__FILE__), "reader", "n3_grammar_18"))
-end
-
 module RDF::N3
   ##
   # A Notation-3/Turtle parser in Ruby
   #
+  # N3 Parser, based in librdf version of predictiveParser.py
+  # @see http://www.w3.org/2000/10/swap/grammar/predictiveParser.py
+  # @see http://www.w3.org/2000/10/swap/grammar/n3-selectors.n3
+  #
+  # Separate pass to create branch_table from n3-selectors.n3
+  #
+  # @todo
+  # Existentials, Universals and Formulae
+  #
   # @author [Gregg Kellogg](http://kellogg-assoc.com/)
   class Reader < RDF::Reader
     format Format
 
+    include Meta
+    include Parser
+    
     N3_KEYWORDS = %w(a is of has keywords prefix base true false forSome forAny)
 
-    NC_REGEXP = Regexp.new(
-      %{^
-        (?!\\\\u0301)             # &#x301; is a non-spacing acute accent.
-                                  # It is legal within an XML Name, but not as the first character.
-        (  [a-zA-Z_]
-         | \\\\u[0-9a-fA-F]
-        )
-        (  [0-9a-zA-Z_\.-]
-         | \\\\u([0-9a-fA-F]{4})
-        )*
-      $},
-      Regexp::EXTENDED)
-  
     ##
     # Initializes the N3 reader instance.
     #
-    # @param  [IO, File, String]       input
-    # @option options [Array] :debug Array to place debug messages
-    # @option options [Boolean] :strict Raise Error if true, continue with lax parsing, otherwise
-    # @option options [Boolean] :base_uri (nil) Base URI to use for relative URIs.
+    # @param  [IO, File, String] input
+    #   the input stream to read
+    # @option options [Array] :debug
+    #   Array to place debug messages
+    # @option options [#to_s]    :base_uri     (nil)
+    #   the base URI to use when resolving relative URIs (not supported by
+    #   all readers)
+    # @option options [Boolean]  :validate     (false)
+    #   whether to validate the parsed statements and values
+    # @option options [Boolean]  :canonicalize (false)
+    #   whether to canonicalize parsed literals
+    # @option options [Boolean]  :intern       (true)
+    #   whether to intern all parsed URIs
+    # @option options [Hash]     :prefixes     (Hash.new)
+    #   the prefix mappings to use (not supported by all readers)
     # @return [reader]
-    # @yield  [reader]
-    # @yieldparam [Reader] reader
-    # @raise [Error]:: Raises RDF::ReaderError if _strict_
+    # @yield  [reader] `self`
+    # @yieldparam  [RDF::Reader] reader
+    # @yieldreturn [void] ignored
+    # @raise [Error]:: Raises RDF::ReaderError if _validate_
     def initialize(input = $stdin, options = {}, &block)
       super do
-        @debug = options[:debug]
-        @strict = options[:strict]
-        @uri_mappings = {}
-        @uri = uri(options[:base_uri], nil, false)
-
-        @doc = input.respond_to?(:read) ? (input.rewind; input.read) : input
-        @default_ns = uri("#{options[:base_uri]}#", nil, false) if @uri
-        add_debug("@default_ns", "#{@default_ns.inspect}")
+        @input = input.respond_to?(:read) ? (input.rewind; input) : StringIO.new(input.to_s)
+        @lineno = 0
+        readline  # Prime the pump
+        
+        @memo = {}
+        @keyword_mode = false
+        @keywords = %w(a is of this has)
+        @productions = []
+        @prod_data = []
+
+        @branches = BRANCHES # Get from meta class
+        @regexps = REGEXPS # Get from meta class
         
-        block.call(self) if block_given?
+        @formulae = []      # Nodes used as Formluae context identifiers
+        @variables = {}    # variable definitions along with defining formula
+
+        if options[:base_uri]
+          @uri = uri(options[:base_uri])
+          add_debug("@uri", "#{@uri.inspect}")
+          namespace(nil, uri("#{options[:base_uri]}#"))
+        end
+        add_debug("validate", "#{validate?.inspect}")
+        add_debug("canonicalize", "#{canonicalize?.inspect}")
+        add_debug("intern", "#{intern?.inspect}")
+
+        # Prefixes that may be used without being defined
+        #prefix(:rdf, RDF.to_uri.to_s)
+        #prefix(:xsd, RDF::XSD.to_uri.to_s)
+
+        if block_given?
+          case block.arity
+            when 0 then instance_eval(&block)
+            else block.call(self)
+          end
+        end
       end
     end
 
-    # No need to rewind, as parsing is done in initialize
-    def rewind; end
-    
-    # Document closed when read in initialize
-    def close; end
-    
     ##
     # Iterates the given block for each RDF statement in the input.
     #
@@ -72,17 +92,9 @@ module RDF::N3
     def each_statement(&block)
       @callback = block
 
-      parser = N3GrammerParser.new
-      document = parser.parse(@doc)
-      unless document
-        puts parser.inspect if ::RDF::N3::debug?
-        reason = parser.failure_reason
-        raise RDF::ReaderError, reason
-      end
-
-      process_statements(document)
+      parse(START.to_sym)
     end
-
+    
     ##
     # Iterates the given block for each RDF triple in the input.
     #
@@ -97,129 +109,405 @@ module RDF::N3
       end
     end
     
-    private
+    protected
+    # Start of production
+    def onStart(prod)
+      handler = "#{prod}Start".to_sym
+      add_debug("#{handler}(#{respond_to?(handler)})", prod)
+      @productions << prod
+      send(handler, prod) if respond_to?(handler)
+    end
 
-    # Keep track of allocated BNodes
-    def bnode(value = nil)
-      @bnode_cache ||= {}
-      @bnode_cache[value.to_s] ||= RDF::Node.new(value)
+    # End of production
+    def onFinish
+      prod = @productions.pop()
+      handler = "#{prod}Finish".to_sym
+      add_debug("#{handler}(#{respond_to?(handler)})", "#{prod}: #{@prod_data.last.inspect}")
+      send(handler) if respond_to?(handler)
     end
 
-    # Add debug event to debug array, if specified
-    #
-    # @param [XML Node, any] node:: XML Node or string for showing context
-    # @param [String] message::
-    def add_debug(node, message)
-      puts "#{node}: #{message}" if ::RDF::N3::debug?
-      @debug << "#{node}: #{message}" if @debug.is_a?(Array)
+    # Process of a token
+    def onToken(prod, tok)
+      unless @productions.empty?
+        parentProd = @productions.last
+        handler = "#{parentProd}Token".to_sym
+        add_debug("#{handler}(#{respond_to?(handler)})", "#{prod}, #{tok}: #{@prod_data.last.inspect}")
+        send(handler, prod, tok) if respond_to?(handler)
+      else
+        error("Token has no parent production")
+      end
+    end
+    
+    def booleanToken(prod, tok)
+      lit = RDF::Literal.new(tok.delete("@"), :datatype => RDF::XSD.boolean, :validate => validate?, :canonicalize => canonicalize?)
+      add_prod_data(:literal, lit)
+    end
+    
+    def declarationStart(prod)
+      @prod_data << {}
+    end
+    
+    def declarationToken(prod, tok)
+      case prod
+      when "@prefix", "@base", "@keywords"
+        add_prod_data(:prod, prod)
+      when "prefix"
+        add_prod_data(:prefix, tok[0..-2])
+      when "explicituri"
+        add_prod_data(:explicituri, tok[1..-2])
+      else
+        add_prod_data(prod.to_sym, tok)
+      end
     end
 
-    # add a statement, object can be literal or URI or bnode
-    #
-    # @param [Nokogiri::XML::Node, any] node:: XML Node or string for showing context
-    # @param [URI, Node] subject:: the subject of the statement
-    # @param [URI] predicate:: the predicate of the statement
-    # @param [URI, Node, Literal] object:: the object of the statement
-    # @return [Statement]:: Added statement
-    # @raise [RDF::ReaderError]:: Checks parameter types and raises if they are incorrect if parsing mode is _strict_.
-    def add_triple(node, subject, predicate, object)
-      statement = RDF::Statement.new(subject, predicate, object)
-      add_debug(node, "statement: #{statement}")
-      @callback.call(statement)
+    def declarationFinish
+      decl = @prod_data.pop
+      case decl[:prod]
+      when "@prefix"
+        uri = process_uri(decl[:explicituri])
+        namespace(decl[:prefix], uri)
+      when "@base"
+        # Base, set or update document URI
+        uri = decl[:explicituri]
+        @uri = process_uri(uri)
+        
+        # The empty prefix "" is by default , bound to "#" -- the local namespace of the file.
+        # The parser behaves as though there were a
+        #   @prefix : <#>.
+        # just before the file.
+        # This means that <#foo> can be written :foo and using @keywords one can reduce that to foo.
+        
+        namespace(nil, uri.match(/[\/\#]$/) ? @uri : process_uri("#{uri}#"))
+        add_debug("declarationFinish[@base]", "@base=#{@uri}")
+      when "@keywords"
+        add_debug("declarationFinish[@keywords]", @keywords.inspect)
+        # Keywords are handled in tokenizer and maintained in @keywords array
+        if (@keywords & N3_KEYWORDS) != @keywords
+          error("Undefined keywords used: #{(@keywords - N3_KEYWORDS).to_sentence}") if validate?
+        end
+        @userkeys = true
+      else
+        error("declarationFinish: FIXME #{decl.inspect}")
+      end
+    end
+    
+    # Document start, instantiate
+    def documentStart(prod)
+      @formulae.push(nil)
+      @prod_data << {}
+    end
+    
+    def dtlangToken(prod, tok)
+      add_prod_data(:langcode, tok) if prod == "langcode"
+    end
+    
+    def existentialStart(prod)
+      @prod_data << {}
     end
 
-    def namespace(uri, prefix)
-      uri = uri.to_s
-      if uri == "#"
-        uri = @default_ns
+    # Apart from the set of statements, a formula also has a set of URIs of symbols which are universally quantified,
+    # and a set of URIs of symbols which are existentially quantified.
+    # Variables are then in general symbols which have been quantified.
+    #
+    # Here we allocate a variable (making up a name) and record with the defining formula. Quantification is done
+    # when the formula is completed against all in-scope variables
+    def existentialFinish
+      pd = @prod_data.pop
+      forSome = [pd[:symbol]].flatten.compact
+      forSome.each do |term|
+        @variables[term.to_s] = {:formula => @formulae.last, :var => RDF::Node.new(term.to_s.split(/[\/#]/).last)}
       end
-      add_debug("namesspace", "'#{prefix}' <#{uri}>")
-      @uri_mappings[prefix] = RDF::URI.intern(uri)
     end
+    
+    def expressionStart(prod)
+      @prod_data << {}
+    end
+    
+    # Process path items, and push on the last object for parent processing
+    def expressionFinish
+      expression = @prod_data.pop
+      
+      # If we're in teh middle of a pathtail, append
+      if @prod_data.last[:pathtail] && expression[:pathitem] && expression[:pathtail]
+        path_list = [expression[:pathitem]] + expression[:pathtail]
+        add_debug("expressionFinish(pathtail)", "set pathtail to #{path_list.inspect}")
+        @prod_data.last[:pathtail] = path_list
 
-    def process_statements(document)
-      document.elements.find_all do |e|
-        s = e.elements.first
-        add_debug(*s.info("process_statements"))
+        dir_list = [expression[:direction]] if expression[:direction]
+        dir_list += expression[:directiontail] if expression[:directiontail]
+        @prod_data.last[:directiontail] = dir_list if dir_list
+      elsif expression[:pathitem] && expression[:pathtail]
+        add_prod_data(:expression, process_path(expression))
+      elsif expression[:pathitem]
+        add_prod_data(:expression, expression[:pathitem])
+      else
+        error("expressionFinish: FIXME #{expression.inspect}")
+      end
+    end
+    
+    def literalStart(prod)
+      @prod_data << {}
+    end
+    
+    def literalToken(prod, tok)
+      tok = tok[0, 3] == '"""' ? tok[3..-4] : tok[1..-2]
+      add_prod_data(:string, tok)
+    end
+    
+    def literalFinish
+      lit = @prod_data.pop
+      content = RDF::NTriples.unescape(lit[:string])
+      language = lit[:langcode]
+      datatype = lit[:symbol]
+      
+      lit = RDF::Literal.new(content, :language => language, :datatype => datatype, :validate => validate?, :canonicalize => canonicalize?)
+      add_prod_data(:literal, lit)
+    end
+    
+    def objectStart(prod)
+      @prod_data << {}
+    end
+    
+    def objectFinish
+      object = @prod_data.pop
+      if object[:expression]
+        add_prod_data(:object, object[:expression])
+      else
+        error("objectFinish: FIXME #{object.inspect}")
+      end
+    end
+    
+    def pathitemStart(prod)
+      @prod_data << {}
+    end
+    
+    def pathitemToken(prod, tok)
+      case prod
+      when "numericliteral"
+        nl = RDF::NTriples.unescape(tok)
+        datatype = case nl
+        when /e/i then RDF::XSD.double
+        when /\./ then RDF::XSD.decimal
+        else RDF::XSD.integer
+        end
         
-        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 RDF::ReaderError, %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)
-            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
-            @uri = process_uri(uri)
-            
-            # The empty prefix "" is by default , bound to "#" -- the local namespace of the file.
-            # The parser behaves as though there were a
-            #   @prefix : <#>.
-            # just before the file.
-            # This means that <#foo> can be written :foo and using @keywords one can reduce that to foo.
-            
-            @default_ns =  uri.match(/[\/\#]$/) ? @uri : process_uri("#{uri}#")
-            add_debug("@default_ns", "#{@default_ns.inspect}")
-            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 RDF::ReaderError, "undefined keywords used: #{(@keywords - N3_KEYWORDS).to_sentence}" if @strict
-            end
+        lit = RDF::Literal.new(nl, :datatype => datatype, :validate => validate?, :canonicalize => canonicalize?)
+        add_prod_data(:literal, lit)
+      when "quickvariable"
+        # There is a also a shorthand syntax ?x which is the same as :x except that it implies that x is
+        # universally quantified not in the formula but in its parent formula
+        uri = process_qname(tok.sub('?', ':'))
+        @variables[uri.to_s] = { :formula => @formulae[-2], :var => univar(uri) }
+        add_prod_data(:symbol, uri)
+      when "boolean"
+        lit = RDF::Literal.new(tok.delete("@"), :datatype => RDF::XSD.boolean, :validate => validate?, :canonicalize => canonicalize?)
+        add_prod_data(:literal, lit)
+      when "[", "("
+        # Push on state for content of blank node
+        @prod_data << {}
+      when "]", ")"
+        # Construct
+        symbol = process_anonnode(@prod_data.pop)
+        add_prod_data(:symbol, symbol)
+      when "{"
+        # A new formula, push on a graph as a formula context
+        context = RDF::Graph.new(RDF::Node.new)
+        @formulae << context
+      when "}"
+        # Pop off the formula, and remove any variables defined in this context
+        formula = @formulae.pop
+        @variables.delete_if {|k, v| v[:formula] == formula}
+        add_prod_data(:symbol, formula)
+      else
+        error("pathitemToken(#{prod}, #{tok}): FIXME")
+      end
+    end
+
+    def pathitemFinish
+      pathitem = @prod_data.pop
+      if pathitem[:pathlist]
+        error("pathitemFinish(pathlist): FIXME #{pathitem.inspect}")
+      elsif pathitem[:propertylist]
+        error("pathitemFinish(propertylist): FIXME #{pathitem.inspect}")
+      elsif pathitem[:symbol] || pathitem[:literal]
+        add_prod_data(:pathitem, pathitem[:symbol] || pathitem[:literal])
+      else
+        error("pathitemFinish: FIXME #{pathitem.inspect}")
+      end
+    end
+    
+    def pathlistStart(prod)
+      @prod_data << {:pathlist => []}
+    end
+    
+    def pathlistFinish
+      pathlist = @prod_data.pop
+      # Flatten propertylist into an array
+      expr = @prod_data.last.delete(:expression)
+      add_prod_data(:pathlist, expr) if expr
+      add_prod_data(:pathlist, pathlist[:pathlist]) if pathlist[:pathlist]
+    end
+    
+    def pathtailStart(prod)
+      @prod_data << {:pathtail => []}
+    end
+    
+    def pathtailToken(prod, tok)
+      case tok
+      when "!", "."
+        add_prod_data(:direction, :forward)
+      when "^"
+        add_prod_data(:direction, :reverse)
+      end
+    end
+    
+    def pathtailFinish
+      pathtail = @prod_data.pop
+      add_prod_data(:pathtail, pathtail[:pathtail])
+      add_prod_data(:direction, pathtail[:direction]) if pathtail[:direction]
+      add_prod_data(:directiontail, pathtail[:directiontail]) if pathtail[:directiontail]
+    end
+    
+    def propertylistStart(prod)
+      @prod_data << {}
+    end
+    
+    def propertylistFinish
+      propertylist = @prod_data.pop
+      # Flatten propertylist into an array
+      ary = [propertylist, propertylist.delete(:propertylist)].flatten.compact
+      @prod_data.last[:propertylist] = ary
+    end
+    
+    def simpleStatementStart(prod)
+      @prod_data << {}
+    end
+    
+    # Completion of Simple Statement, all productions include :subject, and :propertyList
+    def simpleStatementFinish
+      statement = @prod_data.pop
+      
+      subject = statement[:subject]
+      properties = [statement[:propertylist]].flatten.compact
+      properties.each do |p|
+        predicate = p[:verb]
+        next unless predicate
+        add_debug("simpleStatementFinish(pred)", predicate)
+        error(%(Illegal statment: "#{predicate}" missing object)) unless p.has_key?(:object)
+        objects =[ p[:object]].flatten.compact
+        objects.each do |object|
+          if p[:invert]
+            add_triple("simpleStatementFinish", object, predicate, subject)
+          else
+            add_triple("simpleStatementFinish", subject, predicate, object)
           end
         end
       end
     end
+
+    def subjectStart(prod)
+      @prod_data << {}
+    end
+    
+    def subjectFinish
+      subject = @prod_data.pop
+      
+      if subject[:expression]
+        add_prod_data(:subject, subject[:expression])
+      else
+        error("unknown expression type")
+      end
+    end
+    
+    def symbolToken(prod, tok)
+      term = case prod
+      when 'explicituri'
+        process_uri(tok[1..-2])
+      when 'qname'
+        process_qname(tok)
+      else
+        error("symbolToken(#{prod}, #{tok}): FIXME #{term.inspect}")
+      end
+      
+      add_prod_data(:symbol, term)
+    end
+
+    def universalStart(prod)
+      @prod_data << {}
+    end
+
+    # Apart from the set of statements, a formula also has a set of URIs of symbols which are universally quantified,
+    # and a set of URIs of symbols which are existentially quantified.
+    # Variables are then in general symbols which have been quantified.
+    #
+    # Here we allocate a variable (making up a name) and record with the defining formula. Quantification is done
+    # when the formula is completed against all in-scope variables
+    def universalFinish
+      pd = @prod_data.pop
+      forAll = [pd[:symbol]].flatten.compact
+      forAll.each do |term|
+        @variables[term.to_s] = { :formula => @formulae.last, :var => univar(term) }
+      end
+    end
+
+    def verbStart(prod)
+      @prod_data << {}
+    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
+    def verbToken(prod, tok)
+      term = case prod
+      when '<='
+        add_prod_data(:expression, RDF::LOG.implies)
+        add_prod_data(:invert, true)
+      when '=>'
+        add_prod_data(:expression, RDF::LOG.implies)
+      when '='
+        add_prod_data(:expression, RDF::OWL.sameAs)
+      when '@a'
+        add_prod_data(:expression, RDF.type)
+      when '@has', "@of"
+        # Syntactic sugar
+      when '@is'
+        add_prod_data(:invert, true)
+      else
+        error("verbToken(#{prod}, #{tok}): FIXME #{term.inspect}")
+      end
+      
+      add_prod_data(:symbol, term)
     end
 
+    def verbFinish
+      verb = @prod_data.pop
+      if verb[:expression]
+        error("Literal may not be used as a predicate") if verb[:expression].is_a?(RDF::Literal)
+        error("Formula may not be used as a peredicate") if verb[:expression].is_a?(RDF::Graph)
+        add_prod_data(:verb, verb[:expression])
+        add_prod_data(:invert, true) if verb[:invert]
+      else
+        error("verbFinish: FIXME #{verb.inspect}")
+      end
+    end
+    
+    private
+    
+    ###################
+    # Utility Functions
+    ###################
+
     def process_anonnode(anonnode)
-      add_debug(*anonnode.info("process_anonnode"))
+      add_debug("process_anonnode", anonnode.inspect)
       bnode = RDF::Node.new
       
-      if anonnode.respond_to?(:property_list)
-        properties = process_properties(anonnode.property_list)
+      if anonnode[:propertylist]
+        properties = anonnode[:propertylist]
         properties.each do |p|
-          predicate = process_verb(p.verb)
-          add_debug(*p.info("anonnode[#{predicate}]"))
-          objects = process_objects(p.object_list)
+          predicate = p[:verb]
+          add_debug("process_anonnode(verb)", predicate.inspect)
+          objects = [p[:object]].flatten.compact
           objects.each { |object| add_triple("anonnode", bnode, predicate, object) }
         end
-      elsif anonnode.respond_to?(:path_list)
-        objects = process_objects(anonnode.path_list)
+      elsif anonnode[:pathlist]
+        objects = [anonnode[:pathlist]].flatten.compact
         last = objects.pop
         first_bnode = bnode
         objects.each do |object|
@@ -238,257 +526,162 @@ module RDF::N3
       bnode
     end
 
-    def process_verb(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 RDF::OWL.sameAs
-      when "=>"           then RDF::LOG.implies
-      when "<="           then RDF::LOG.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_expression(expression)
-      if expression.respond_to?(:pathitem) && expression.respond_to?(:expression)
-        add_debug(*expression.info("process_expression(pathitem && expression)"))
-        process_path(expression)  # Returns last object in chain
-      elsif expression.respond_to?(:uri)
-        add_debug(*expression.info("process_expression(uri)"))
-        process_uri(expression.uri)
-      elsif expression.respond_to?(:localname)
-        add_debug(*expression.info("process_expression(localname)"))
-        build_uri(expression)
-      elsif expression.respond_to?(:anonnode)
-        add_debug(*expression.info("process_expression(anonnode)"))
-        process_anonnode(expression)
-      elsif expression.respond_to?(:literal)
-        add_debug(*expression.info("process_expression(literal)"))
-        process_literal(expression)
-      elsif expression.respond_to?(:numericliteral)
-        add_debug(*expression.info("process_expression(numericliteral)"))
-        process_numeric_literal(expression)
-      elsif expression.respond_to?(:boolean)
-        add_debug(*expression.info("process_expression(boolean)"))
-        barename = expression.text_value.to_s
-        if @keywords && !@keywords.include?(barename)
-          build_uri(barename)
-        else
-          RDF::Literal.new(barename.delete("@"), :datatype => RDF::XSD.boolean, :validate => @strict, :canonicalize => true)
-        end
-      elsif expression.respond_to?(:barename)
-        add_debug(*expression.info("process_expression(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 RDF::Literal.new("true", :datatype => RDF::XSD.boolean)
-        when "false"  then RDF::Literal.new("false", :datatype => RDF::XSD.boolean)
-        else
-          # create URI using barename, unless it's in defined set, in which case it's an error
-          raise RDF::ReaderError, %Q(Keyword "#{barename}" used as expression) if @keywords && @keywords.include?(barename)
-          build_uri(barename)
-        end
-      else
-        add_debug(*expression.info("process_expression(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]
+    #   :a.:b means [is :b of :a] Deprecated
+    #   :a!:b means [is :b of :a] => :a :b []
+    #   :a^:b means [:b :a]       => [] :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"))
+    # Create triple and return property used for next iteration
+    def process_path(expression)
+      add_debug("process_path", expression.inspect)
 
-      object = process_expression(path.pathitem)
+      pathitem = expression[:pathitem]
+      pathtail = expression[:pathtail]
       
-      # 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
+      direction_list = [expression[:direction], expression[:directiontail]].flatten.compact
+
+      pathtail.each do |pred|
+        direction = direction_list.shift
         bnode = RDF::Node.new
-        if reverse
-          add_triple("path(#{reverse})", bnode, pred, object)
+        if direction == :reverse
+          add_triple("process_path(reverse)", bnode, pred, pathitem)
         else
-          add_triple("path(#{reverse})", object, pred, bnode)
+          add_triple("process_path(forward)", pathitem, pred, bnode)
         end
-        object = bnode
+        pathitem = bnode
       end
-      object
+      pathitem
     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)
-      uri = uri.text_value if uri.respond_to?(:text_value)
       uri(@uri, RDF::NTriples.unescape(uri))
     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.flatten
-    end
-
-    def process_objects(objects)
-      add_debug(*objects.info("process_objects"))
-      result = []
-      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)
+    def process_qname(tok)
+      if tok.include?(":")
+        prefix, name = tok.split(":")
+      elsif @userkeys
+        # If the @keywords directive is given, the keywords given will thereafter be recognized
+        # without a "@" prefix, and anything else is a local name in the default namespace.
+        prefix, name = "", tok
+      elsif %w(true false).include?(tok)
+        # The words true and false are boolean literals.
+        #
+        # They were added to Notation3 in 2006-02 in discussion with the SPARQL language developers, the Data
+        # Access Working Group. Note that no existing documents will have used a naked true or false word, without a
+        # @keyword statement which would make it clear that they were not to be treated as keywords. Furthermore any
+        # old parser encountering true or false naked or in a @keywords
+        return RDF::Literal.new(tok, :datatype => RDF::XSD.boolean)
+      else
+        error("Set user @keywords to use barenames.")
       end
-      result << process_objects(objects.object_list) if objects.respond_to?(:object_list)
-      result.flatten
-    end
-
-    def process_literal(object)
-      add_debug(*object.info("process_literal"))
-      encoding, language = nil, nil
-      string, type = object.elements
 
-      unless type.elements.nil?
-        #puts type.elements.inspect
-        if (type.elements[0].text_value=='@')
-          language = type.elements[1].text_value
-        else
-          encoding = process_expression(type.elements[1])
-        end
+      uri = if prefix(prefix)
+        add_debug('process_qname(ns)', "#{prefix(prefix)}, #{name}")
+        ns(prefix, name)
+      elsif prefix == '_'
+        add_debug('process_qname(bnode)', name)
+        bnode(name)
+      else
+        add_debug('process_qname(default_ns)', name)
+        namespace(nil, uri("#{@uri}#")) unless prefix(nil)
+        ns(nil, name)
       end
-
-      # Evaluate text_value to remove redundant escapes
-      #puts string.elements[1].text_value.dump
-      RDF::Literal.new(RDF::NTriples.unescape(string.elements[1].text_value), :language => language, :validate => @strict, :datatype => encoding, :canonicalize => true)
+      add_debug('process_qname', uri.inspect)
+      uri
     end
     
-    def process_numeric_literal(object)
-      add_debug(*object.info("process_numeric_literal"))
+    # Add values to production data, values aranged as an array
+    def add_prod_data(sym, value)
+      case @prod_data.last[sym]
+      when nil
+        @prod_data.last[sym] = value
+      when Array
+        @prod_data.last[sym] << value
+      else
+        @prod_data.last[sym] = [@prod_data.last[sym], value]
+      end
+    end
 
-      RDF::Literal.new(RDF::NTriples.unescape(object.text_value), :datatype => RDF::XSD[object.numericliteral], :validate => @strict, :canonicalize => true)
+    # Keep track of allocated BNodes
+    def bnode(value = nil)
+      @bnode_cache ||= {}
+      @bnode_cache[value.to_s] ||= RDF::Node.new(value)
     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(/^:/, "")
-      localname = nil if localname.empty? # In N3/Turtle "_:" is not named
 
-      if expression.respond_to?(:info)
-        add_debug(*expression.info("build_uri(#{prefix.inspect}, #{localname.inspect})"))
-      else
-        add_debug("", "build_uri(#{prefix.inspect}, #{localname.inspect})")
+    def univar(label)
+      unless label
+        @unnamed_label ||= "var0"
+        label = @unnamed_label = @unnamed_label.succ
       end
+      RDF::Query::Variable.new(label.to_s)
+    end
 
-      uri = if @uri_mappings[prefix]
-        add_debug(*expression.info("build_uri: (ns): #{@uri_mappings[prefix]}, #{localname}")) if expression.respond_to?(:info)
-        ns(prefix, localname.to_s)
-      elsif prefix == '_'
-        add_debug(*expression.info("build_uri: (bnode)")) if expression.respond_to?(:info)
-        bnode(localname)
-      elsif prefix == "rdf"
-        add_debug(*expression.info("build_uri: (rdf)")) if expression.respond_to?(:info)
-        # A special case
-        RDF::RDF[localname.to_s]
-      elsif prefix == "xsd"
-        add_debug(*expression.info("build_uri: (xsd)")) if expression.respond_to?(:info)
-        # A special case
-        RDF::XSD[localname.to_s]
-      else
-        add_debug(*expression.info("build_uri: (default_ns)")) if expression.respond_to?(:info)
-        @default_ns ||= uri("#{@uri}#", nil)
-        ns(nil, localname.to_s)
+    # Add debug event to debug array, if specified
+    #
+    # @param [XML Node, any] node:: XML Node or string for showing context
+    # @param [String] message::
+    def add_debug(node, message)
+      puts "[#{@lineno},#{@pos}]#{' ' * @productions.length}#{node}: #{message}" if ::RDF::N3::debug?
+      @options[:debug] << "[#{@lineno},#{@pos}]#{' ' * @productions.length}#{node}: #{message}" if @options[:debug].is_a?(Array)
+    end
+
+    # add a statement, object can be literal or URI or bnode
+    #
+    # @param [Nokogiri::XML::Node, any] node:: XML Node or string for showing context
+    # @param [URI, Node] subject:: the subject of the statement
+    # @param [URI] predicate:: the predicate of the statement
+    # @param [URI, Node, Literal] object:: the object of the statement
+    # @return [Statement]:: Added statement
+    # @raise [RDF::ReaderError]:: Checks parameter types and raises if they are incorrect if parsing mode is _validate_.
+    def add_triple(node, subject, predicate, object)
+      context_opts = {:context => @formulae.last.context} if @formulae.last
+      
+      # Replace graph with it's context
+      subject = subject.context if subject.graph?
+      object = object.context if object.graph?
+      statement = RDF::Statement.new(subject, predicate, object, context_opts || {})
+      add_debug(node, statement.to_s)
+      @callback.call(statement)
+    end
+
+    def namespace(prefix, uri)
+      uri = uri.to_s
+      if uri == "#"
+        uri = prefix(nil)
       end
-      add_debug(*expression.info("build_uri: #{uri.inspect}")) if expression.respond_to?(:info)
-      uri
+      add_debug("namesspace", "'#{prefix}' <#{uri}>")
+      prefix(prefix, uri(uri))
     end
-    
+
     # Is this an allowable keyword?
     def keyword_check(kw)
       unless (@keywords || %w(a is of has)).include?(kw)
-        raise RDF::ReaderError, "unqualified keyword '#{kw}' used without @keyword directive" if @strict
+        raise RDF::ReaderError, "unqualified keyword '#{kw}' used without @keyword directive" if validate?
       end
     end
     
     # Create URIs
-    def uri(value, append, normalize = false)
-      value = RDF::URI.intern(value)
+    def uri(value, append = nil)
+      value = RDF::URI.new(value)
       value = value.join(append) if append
+      value.validate! if validate? && value.respond_to?(:validate)
+      value.canonicalize! if canonicalize?
+      value = RDF::URI.intern(value) if intern?
+      
+      # Variable substitution for in-scope variables. Variables are in scope if they are defined in anthing other than
+      # the current formula
+      var = @variables[value.to_s]
+      value = var[:var] if var
+
       value
     end
     
     def ns(prefix, suffix)
-      prefix = prefix.nil? ? @default_ns.to_s : @uri_mappings[prefix].to_s
-      suffix = suffix.to_s.sub(/^\#/, "") if prefix.index("#")
-      add_debug("ns", "prefix: '#{prefix}', suffix: '#{suffix}'")
-      RDF::URI.intern(prefix + suffix)
-    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 |mm|
-            v = self.send(mm)
-            v = v.text_value if v.is_a?(SyntaxNode)
-            "#{mm}='#{v}'"
-          end.join(", ") +
-          "]"]
-        end
-      end
+      base = prefix(prefix).to_s
+      suffix = suffix.to_s.sub(/^\#/, "") if base.index("#")
+      add_debug("ns", "base: '#{base}', suffix: '#{suffix}'")
+      uri(base + suffix.to_s)
     end
   end
 end