rdf-n3 3.0.1 → 3.1.0

data/lib/rdf/n3/algebra/str/greaterThan.rb

@@ -0,0 +1,9 @@
+module RDF::N3::Algebra::Str
+  ##
+  # True iff the string is greater than the object when ordered according to Unicode(tm) code order
+  class GreaterThan < SPARQL::Algebra::Operator::Binary
+    include RDF::Util::Logger
+
+    NAME = :strGreaterThan
+  end
+end

data/lib/rdf/n3/algebra/str/lessThan.rb

@@ -0,0 +1,9 @@
+module RDF::N3::Algebra::Str
+  ##
+  # True iff the string is less than the object when ordered according to Unicode(tm) code order.
+  class LessThan < SPARQL::Algebra::Operator::Binary
+    include RDF::Util::Logger
+
+    NAME = :strLessThan
+  end
+end

data/lib/rdf/n3/algebra/str/matches.rb

@@ -0,0 +1,9 @@
+module RDF::N3::Algebra::Str
+  ##
+  # The subject is a string; the object is is a regular expression in the perl, python style. It is true iff the string matches the regexp.
+  class Matches < SPARQL::Algebra::Operator::Binary
+    include RDF::Util::Logger
+
+    NAME = :strMatches
+  end
+end

data/lib/rdf/n3/algebra/str/notEqualIgnoringCase.rb

@@ -0,0 +1,9 @@
+module RDF::N3::Algebra::Str
+  ##
+  # True iff the subject string is the NOT same as object string ignoring differences between upper and lower case.
+  class NotEqualIgnoringCase < SPARQL::Algebra::Operator::Binary
+    include RDF::Util::Logger
+
+    NAME = :strNotEqualIgnoringCase
+  end
+end

data/lib/rdf/n3/algebra/str/notGreaterThan.rb

@@ -0,0 +1,9 @@
+module RDF::N3::Algebra::Str
+  ##
+  # True iff the string is NOT greater than the object when ordered according to Unicode(tm) code order.
+  class NotGreaterThan < SPARQL::Algebra::Operator::Binary
+    include RDF::Util::Logger
+
+    NAME = :strNotGreaterThan
+  end
+end

data/lib/rdf/n3/algebra/str/notLessThan.rb

@@ -0,0 +1,9 @@
+module RDF::N3::Algebra::Str
+  ##
+  # True iff the string is NOT less than the object when ordered according to Unicode(tm) code order.
+  class NotLessThan < SPARQL::Algebra::Operator::Binary
+    include RDF::Util::Logger
+
+    NAME = :strNotLessThan
+  end
+end

data/lib/rdf/n3/algebra/str/notMatches.rb

@@ -0,0 +1,9 @@
+module RDF::N3::Algebra::Str
+  ##
+  # The subject string; the object is is a regular expression in the perl, python style. It is true iff the string does NOT match the regexp.
+  class NotMatches < SPARQL::Algebra::Operator::Binary
+    include RDF::Util::Logger
+
+    NAME = :strNotMatches
+  end
+end

data/lib/rdf/n3/algebra/str/replace.rb

@@ -0,0 +1,12 @@
+module RDF::N3::Algebra::Str
+  ##
+  # A built-in for replacing characters or sub. takes a list of 3 strings; the first is the input data, the second the old and the third the new string. The object is calculated as the rplaced string.
+  #
+  # @example
+  #     ("fofof bar", "of", "baz") string:replace "fbazbaz bar"
+  class Replace < SPARQL::Algebra::Operator::Binary
+    include RDF::Util::Logger
+
+    NAME = :strReplace
+  end
+end

data/lib/rdf/n3/algebra/str/scrape.rb

@@ -0,0 +1,9 @@
+module RDF::N3::Algebra::Str
+  ##
+  # The subject is a list of two strings. The second string is a regular expression in the perl, python style. It must contain one group (a part in parentheses).  If the first string in the list matches the regular expression, then the object is calculated as being thepart of the first string which matches the group.
+  class Scrape < SPARQL::Algebra::Operator::Binary
+    include RDF::Util::Logger
+
+    NAME = :strScrape
+  end
+end

data/lib/rdf/n3/algebra/str/startsWith.rb

@@ -0,0 +1,56 @@
+module RDF::N3::Algebra::Str
+  ##
+  # True iff the subject string starts with the object string.
+  class StartsWith < SPARQL::Algebra::Operator::Binary
+    include SPARQL::Algebra::Query
+    include SPARQL::Algebra::Update
+    include RDF::Enumerable
+    include RDF::Util::Logger
+
+    NAME = :strStartsWith
+
+    ##
+    # The string:startsWith operator corresponds to the XPath fn:starts-with function. The arguments must be argument compatible otherwise an error is raised.
+    #
+    # For constant inputs that evaulate to true, the original solutions are returned.
+    #
+    # For constant inputs that evaluate to false, the empty solution set is returned. XXX
+    #
+    # Otherwise, for variable operands, it binds matching variables to the solution set.
+    #
+    # @param [RDF::Queryable] queryable
+    # @param [RDF::Query::Solutions] solutions
+    # @return [RDF::Query::Solutions]
+    # @raise  [TypeError] if operands are not compatible
+    def execute(queryable, solutions:, **options)
+      log_debug {"strStartsWith #{operands.to_sxp}"}
+      @solutions = solutions.filter do |solution|
+        left, right = operands.map {|op| op.evaluate(solution.bindings)}
+        if !left.compatible?(right)
+          log_debug {"(strStartsWith incompatible operands #{[left, right].to_sxp})"}
+          false
+        elsif !left.to_s.start_with?(right.to_s)
+          log_debug {"(strStartsWith false #{[left, right].to_sxp})"}
+          false
+        else
+          log_debug {"(strStartsWith true #{[left, right].to_sxp})"}
+          true
+        end
+      end
+    end
+
+    ##
+    # Does not yield statements.
+    #
+    # @yield  [statement]
+    #   each matching statement
+    # @yieldparam  [RDF::Statement] solution
+    # @yieldreturn [void] ignored
+    def each(&block)
+    end
+
+    # Graph name associated with this operation, using the name of the parent
+    # @return [RDF::Resource]
+    def graph_name; parent.graph_name; end
+  end
+end

data/lib/rdf/n3/extensions.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require 'rdf'
+
+# Monkey-patch RDF::Enumerable to add `:existentials` and `:univerals` accessors
+module RDF
+  module Enumerable
+    # Existential quantifiers defined on this enumerable
+    # @return [Array<RDF::Query::Variable>]
+    attr_accessor :existentials
+
+    # Universal quantifiers defined on this enumerable
+    # @return [Array<RDF::Query::Variable>]
+    attr_accessor :universals
+
+    ##
+    # An enumerable contains another enumerable if every statement in other is a statement in self
+    #
+    # @param [RDF::Enumerable] other
+    # @return [Boolean]
+    def contain?(other)
+      other.all? {|statement| has_statement?(statement)}
+    end
+  end
+
+  class Statement
+    # Override variable?
+    def variable?
+      to_a.any? {|term| !term.is_a?(RDF::Term) || term.variable?} || graph_name && graph_name.variable?
+    end
+
+    # Transform Statement into an SXP
+    # @return [Array]
+    def to_sxp_bin
+      [(variable? ? :pattern : :triple), subject, predicate, object, graph_name].compact
+    end
+
+    ##
+    # Returns an S-Expression (SXP) representation
+    #
+    # @return [String]
+    def to_sxp
+      to_sxp_bin.to_sxp
+    end
+  end
+
+  class Query::Solution
+
+    # Transform Statement into an SXP
+    # @return [Array]
+    def to_sxp_bin
+      [:solution] + bindings.map {|k, v| Query::Variable.new(k, v).to_sxp_bin}
+    end
+
+    ##
+    # Returns an S-Expression (SXP) representation
+    #
+    # @return [String]
+    def to_sxp
+      to_sxp_bin.to_sxp
+    end
+  end
+
+  class Query::Variable
+
+    # Transform Statement into an SXP
+    # @return [Array]
+    def to_sxp_bin
+      [:var, name, (value.to_sxp_bin if value)].compact
+    end
+
+    ##
+    # Returns an S-Expression (SXP) representation
+    #
+    # @return [String]
+    def to_sxp
+      to_sxp_bin.to_sxp
+    end
+  end
+end

data/lib/rdf/n3/format.rb

@@ -15,7 +15,7 @@ module RDF::N3
   # @example Obtaining serialization format file extension mappings
   #     RDF::Format.file_extensions    #=> {n3: "text/n3"}
   #
-  # @see http://www.w3.org/TR/rdf-testcases/#ntriples
+  # @see https://www.w3.org/TR/rdf-testcases/#ntriples
   class Format < RDF::Format
     content_type     'text/n3',             extension: :n3, aliases: %w(text/rdf+n3;q=0.2 application/rdf+n3;q=0.2)
     content_encoding 'utf-8'

data/lib/rdf/n3/reader.rb

@@ -9,6 +9,8 @@ module RDF::N3
   #
   # Separate pass to create branch_table from n3-selectors.n3
   #
+  # This implementation uses distinguished variables for both universal and explicit existential variables (defined with `@forSome`). Variables created from blank nodes are non-distinguished. Distinguished existential variables are tracked using `$`, internally, as the RDF `query_pattern` logic looses details of the variable definition in solutions, where the variable is represented using a symbol.
+  #
   # @todo
   # * Formulae as RDF::Query representations
   # * Formula expansion similar to SPARQL Construct
@@ -20,9 +22,13 @@ module RDF::N3
     include RDF::Util::Logger
     include Meta
     include Parser
-    
+
     N3_KEYWORDS = %w(a is of has keywords prefix base true false forSome forAny)
 
+    # The Blank nodes allocated for formula
+    # @return [Array<RDF::Node>]
+    attr_reader :formulae
+
     ##
     # Initializes the N3 reader instance.
     #
@@ -50,27 +56,40 @@ module RDF::N3
         @input = input.respond_to?(:read) ? input : StringIO.new(input.to_s)
         @lineno = 0
         readline  # Prime the pump
-        
+
         @memo = {}
         @keyword_mode = false
-        @keywords = %w(a is of this has)
+        @keywords = %w(a is of this has).map(&:freeze).freeze
         @productions = []
         @prod_data = []
 
         @branches = BRANCHES # Get from meta class
         @regexps = REGEXPS # Get from meta class
 
-        @formulae = []      # Nodes used as Formluae graph names
+        @formulae = []      # Nodes used as Formulae graph names
         @formulae_nodes = {}
-        @variables = {}    # variable definitions along with defining formula
+        @label_uniquifier ||= "#{Random.new_seed}_000000"
+        @bnodes = {}  # allocated bnodes by formula
+        @variables = {}  # allocated variables by formula
 
         if options[:base_uri]
-          log_debug("@uri") { base_uri.inspect}
+          log_info("@uri") { base_uri.inspect}
           namespace(nil, uri("#{base_uri}#"))
         end
-        log_debug("validate") {validate?.inspect}
-        log_debug("canonicalize") {canonicalize?.inspect}
-        log_debug("intern") {intern?.inspect}
+
+        # Prepopulate operator namespaces unless validating
+        unless validate?
+          namespace(:crypto, RDF::N3::Crypto)
+          namespace(:list, RDF::N3::List)
+          namespace(:log, RDF::N3::Log)
+          namespace(:math, RDF::N3::Math)
+          namespace(:rei, RDF::N3::Rei)
+          #namespace(:string, RDF::N3::String)
+          namespace(:time, RDF::N3::Time)
+        end
+        log_info("validate") {validate?.inspect}
+        log_info("canonicalize") {canonicalize?.inspect}
+        log_info("intern") {intern?.inspect}
 
         if block_given?
           case block.arity
@@ -87,7 +106,6 @@ module RDF::N3
 
     ##
     # Iterates the given block for each RDF statement in the input.
-    #
     # @yield  [statement]
     # @yieldparam [RDF::Statement] statement
     # @return [void]
@@ -101,9 +119,9 @@ module RDF::N3
           raise RDF::ReaderError, "Errors found during processing"
         end
       end
-      enum_for(:each_triple)
+      enum_for(:each_statement)
     end
-    
+
     ##
     # Iterates the given block for each RDF triple in the input.
     #
@@ -112,29 +130,30 @@ module RDF::N3
     # @yieldparam [RDF::URI]      predicate
     # @yieldparam [RDF::Value]    object
     # @return [void]
-    def each_triple(&block)
+    def each_triple
       if block_given?
         each_statement do |statement|
-          block.call(*statement.to_triple)
+          yield(*statement.to_triple)
         end
       end
       enum_for(:each_triple)
     end
-    
+
     protected
     # Start of production
     def onStart(prod)
       handler = "#{prod}Start".to_sym
-      log_debug("#{handler}(#{respond_to?(handler, true)})", prod)
+      log_info("#{handler}(#{respond_to?(handler, true)})", prod, depth: depth)
       @productions << prod
       send(handler, prod) if respond_to?(handler, true)
+
     end
 
     # End of production
     def onFinish
       prod = @productions.pop()
       handler = "#{prod}Finish".to_sym
-      log_debug("#{handler}(#{respond_to?(handler, true)})") {"#{prod}: #{@prod_data.last.inspect}"}
+      log_info("#{handler}(#{respond_to?(handler, true)})", depth: depth) {"#{prod}: #{@prod_data.last.inspect}"}
       send(handler) if respond_to?(handler, true)
     end
 
@@ -143,22 +162,22 @@ module RDF::N3
       unless @productions.empty?
         parentProd = @productions.last
         handler = "#{parentProd}Token".to_sym
-        log_debug("#{handler}(#{respond_to?(handler, true)})") {"#{prod}, #{tok}: #{@prod_data.last.inspect}"}
+        log_info("#{handler}(#{respond_to?(handler, true)})", depth: depth) {"#{prod}, #{tok}: #{@prod_data.last.inspect}"}
         send(handler, prod, tok) if respond_to?(handler, true)
       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"
@@ -182,17 +201,17 @@ module RDF::N3
         # Base, set or update document URI
         uri = decl[:explicituri]
         options[:base_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(/[\/\#]$/) ? base_uri : process_uri("#{uri}#"))
-        log_debug("declarationFinish[@base]") {"@base=#{base_uri}"}
+        log_debug("declarationFinish[@base]", depth: depth) {"@base=#{base_uri}"}
       when "@keywords"
-        log_debug("declarationFinish[@keywords]") {@keywords.inspect}
+        log_debug("declarationFinish[@keywords]", depth: depth) {@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?
@@ -202,17 +221,17 @@ module RDF::N3
         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
@@ -227,22 +246,23 @@ module RDF::N3
       pd = @prod_data.pop
       forSome = Array(pd[:symbol])
       forSome.each do |term|
-        @variables[term.to_s] = {formula: @formulae.last, var: RDF::Node.new(term.to_s.split(/[\/#]/).last)}
+        var = univar(term, existential: true)
+        add_var_to_formula(@formulae.last, term, var)
       end
     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]
-        log_debug("expressionFinish(pathtail)") {"set pathtail to #{path_list.inspect}"}
+        log_debug("expressionFinish(pathtail)", depth: depth) {"set pathtail to #{path_list.inspect}"}
         @prod_data.last[:pathtail] = path_list
 
         dir_list = [expression[:direction]] if expression[:direction]
@@ -256,31 +276,31 @@ module RDF::N3
         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] if lit[:langcode]
       language = language.downcase if language && canonicalize?
       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]
@@ -289,11 +309,11 @@ module RDF::N3
         error("objectFinish: FIXME #{object.inspect}")
       end
     end
-    
+
     def pathitemStart(prod)
       @prod_data << {}
     end
-    
+
     def pathitemToken(prod, tok)
       case prod
       when "numericliteral"
@@ -303,15 +323,19 @@ module RDF::N3
         when /\./ then RDF::XSD.decimal
         else RDF::XSD.integer
         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)
+        var = uri.variable? ? uri : univar(uri)
+        add_var_to_formula(@formulae[-2], uri, var)
+        # Also add var to this formula
+        add_var_to_formula(@formulae.last, uri, var)
+
+        add_prod_data(:symbol, var)
       when "boolean"
         lit = RDF::Literal.new(tok.delete("@"), datatype: RDF::XSD.boolean, validate: validate?, canonicalize: canonicalize?)
         add_prod_data(:literal, lit)
@@ -324,13 +348,18 @@ module RDF::N3
         add_prod_data(:symbol, symbol)
       when "{"
         # A new formula, push on a node as a named graph
-        node = RDF::Node.new
+        node = RDF::Node.new(".form_#{unique_label}")
         @formulae << node
         @formulae_nodes[node] = true
+
+        # Promote variables defined on the earlier formula to this formula
+        @variables[node] = {}
+        @variables[@formulae[-2]].each do |name, var|
+          @variables[node][name] = var
+        end
       when "}"
-        # Pop off the formula, and remove any variables defined in this graph
+        # Pop off the formula
         formula = @formulae.pop
-        @variables.delete_if {|k, v| v[:formula] == formula}
         add_prod_data(:symbol, formula)
       else
         error("pathitemToken(#{prod}, #{tok}): FIXME")
@@ -349,11 +378,11 @@ module RDF::N3
         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
@@ -361,11 +390,11 @@ module RDF::N3
       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 "!", "."
@@ -374,46 +403,46 @@ module RDF::N3
         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 = Array(statement[:propertylist])
       properties.each do |p|
         predicate = p[:verb]
         next unless predicate
-        log_debug("simpleStatementFinish(pred)") {predicate.to_s}
+        log_debug("simpleStatementFinish(pred)", depth: depth) {predicate.to_s}
         error(%(Illegal statment: "#{predicate}" missing object)) unless p.has_key?(:object)
         objects = Array(p[:object])
         objects.each do |object|
           if p[:invert]
-            add_triple("simpleStatementFinish", object, predicate, subject)
+            add_statement("simpleStatementFinish", object, predicate, subject)
           else
-            add_triple("simpleStatementFinish", subject, predicate, object)
+            add_statement("simpleStatementFinish", subject, predicate, object)
           end
         end
       end
@@ -422,17 +451,17 @@ module RDF::N3
     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'
@@ -442,7 +471,7 @@ module RDF::N3
       else
         error("symbolToken(#{prod}, #{tok}): FIXME #{term.inspect}")
       end
-      
+
       add_prod_data(:symbol, term)
     end
 
@@ -460,21 +489,21 @@ module RDF::N3
       pd = @prod_data.pop
       forAll = Array(pd[:symbol])
       forAll.each do |term|
-        @variables[term.to_s] = { formula: @formulae.last, var: univar(term) }
+        add_var_to_formula(@formulae.last, term, univar(term))
       end
     end
 
     def verbStart(prod)
       @prod_data << {}
     end
-    
+
     def verbToken(prod, tok)
       term = case prod
       when '<='
-        add_prod_data(:expression, RDF::LOG.implies)
+        add_prod_data(:expression, RDF::N3::Log.implies)
         add_prod_data(:invert, true)
       when '=>'
-        add_prod_data(:expression, RDF::LOG.implies)
+        add_prod_data(:expression, RDF::N3::Log.implies)
       when '='
         add_prod_data(:expression, RDF::OWL.sameAs)
       when '@a'
@@ -486,7 +515,7 @@ module RDF::N3
       else
         error("verbToken(#{prod}, #{tok}): FIXME #{term.inspect}")
       end
-      
+
       add_prod_data(:symbol, term)
     end
 
@@ -501,32 +530,39 @@ module RDF::N3
         error("verbFinish: FIXME #{verb.inspect}")
       end
     end
-    
+
     private
-    
+
     ###################
     # Utility Functions
     ###################
 
     def process_anonnode(anonnode)
-      log_debug("process_anonnode") {anonnode.inspect}
-      
+      log_debug("process_anonnode", depth: depth) {anonnode.inspect}
+
       if anonnode[:propertylist]
         properties = anonnode[:propertylist]
-        bnode = RDF::Node.new
+        bnode = bnode()
         properties.each do |p|
           predicate = p[:verb]
-          log_debug("process_anonnode(verb)") {predicate.inspect}
+          log_debug("process_anonnode(verb)", depth: depth) {predicate.inspect}
           objects = Array(p[:object])
-          objects.each { |object| add_triple("anonnode", bnode, predicate, object) }
+          objects.each do |object|
+            if p[:invert]
+              add_statement("anonnode", object, predicate, bnode)
+            else
+              add_statement("anonnode", bnode, predicate, object)
+            end
+          end
         end
         bnode
       elsif anonnode[:pathlist]
         objects = Array(anonnode[:pathlist])
         list = RDF::List[*objects]
+        list_subjects = {}
         list.each_statement do |statement|
           next if statement.predicate == RDF.type && statement.object == RDF.List
-          add_triple("anonnode(list)", statement.subject, statement.predicate, statement.object)
+          add_statement("anonnode(list)", statement.subject, statement.predicate, statement.object)
         end
         list.subject
       end
@@ -539,20 +575,20 @@ module RDF::N3
     #
     # Create triple and return property used for next iteration
     def process_path(expression)
-      log_debug("process_path") {expression.inspect}
+      log_debug("process_path", depth: depth) {expression.inspect}
 
       pathitem = expression[:pathitem]
       pathtail = expression[:pathtail]
-      
+
       direction_list = [expression[:direction], expression[:directiontail]].flatten.compact
 
       pathtail.each do |pred|
         direction = direction_list.shift
         bnode = RDF::Node.new
         if direction == :reverse
-          add_triple("process_path(reverse)", bnode, pred, pathitem)
+          add_statement("process_path(reverse)", bnode, pred, pathitem)
         else
-          add_triple("process_path(forward)", pathitem, pred, bnode)
+          add_statement("process_path(forward)", pathitem, pred, bnode)
         end
         pathitem = bnode
       end
@@ -562,7 +598,7 @@ module RDF::N3
     def process_uri(uri)
       uri(base_uri, RDF::NTriples.unescape(uri))
     end
-    
+
     def process_qname(tok)
       if tok.include?(":")
         prefix, name = tok.split(":")
@@ -579,24 +615,26 @@ module RDF::N3
         # 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.")
+        error("Set user @keywords to use barenames (#{tok}).")
       end
 
       uri = if prefix(prefix)
-        log_debug('process_qname(ns)') {"#{prefix(prefix)}, #{name}"}
+        log_debug('process_qname(ns)', depth: depth) {"#{prefix(prefix)}, #{name}"}
         ns(prefix, name)
       elsif prefix == '_'
-        log_debug('process_qname(bnode)', name)
+        log_debug('process_qname(bnode)', name, depth: depth)
+        # If we're in a formula, create a non-distigushed variable instead
+        # Note from https://www.w3.org/TeamSubmission/n3/#bnodes, it seems the blank nodes are scoped to the formula, not the file.
         bnode(name)
       else
-        log_debug('process_qname(default_ns)', name)
+        log_debug('process_qname(default_ns)', name, depth: depth)
         namespace(nil, uri("#{base_uri}#")) unless prefix(nil)
         ns(nil, name)
       end
-      log_debug('process_qname') {uri.inspect}
+      log_debug('process_qname', depth: depth) {uri.inspect}
       uri
     end
-    
+
     # Add values to production data, values aranged as an array
     def add_prod_data(sym, value)
       case @prod_data.last[sym]
@@ -609,33 +647,38 @@ module RDF::N3
       end
     end
 
-    # Keep track of allocated BNodes
-    def bnode(value = nil)
-      @bnode_cache ||= {}
-      @bnode_cache[value.to_s] ||= RDF::Node.new(value)
+    # Keep track of allocated BNodes. Blank nodes are allocated to the formula.
+    def bnode(label = nil)
+      if label
+        value = "#{label}_#{unique_label}"
+        (@bnodes[@formulae.last] ||= {})[label.to_s] ||= RDF::Node.new(value)
+      else
+        RDF::Node.new
+      end
     end
 
-    def univar(label)
-      unless label
-        @unnamed_label ||= "var0"
-        label = @unnamed_label = @unnamed_label.succ
-      end
-      RDF::Query::Variable.new(label.to_s)
+    def univar(label, existential: false)
+      # Label using any provided label, followed by seed, followed by incrementing index
+      value = "#{label}_#{unique_label}"
+      RDF::Query::Variable.new(value, existential: existential)
     end
 
-    # add a statement, object can be literal or URI or bnode
+    # add a pattern or statement
     #
     # @param [any] node string for showing graph_name
-    # @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
+    # @param [RDF::Term] subject the subject of the statement
+    # @param [RDF::URI] predicate the predicate of the statement
+    # @param [RDF::Term] 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)
-      graph_name_opts = @formulae.last ? {graph_name: @formulae.last} : {}
-      
-      statement = RDF::Statement(subject, predicate, object, graph_name_opts)
-      log_debug(node) {statement.to_s}
+    def add_statement(node, subject, predicate, object)
+      statement = if @formulae.last
+        # It's a pattern in a formula
+        RDF::Query::Pattern.new(subject, predicate, object, graph_name: @formulae.last)
+      else
+        RDF::Statement(subject, predicate, object)
+      end
+      log_debug("statement(#{node})", depth: depth) {statement.to_s}
       @callback.call(statement)
     end
 
@@ -644,7 +687,7 @@ module RDF::N3
       if uri == '#'
         uri = prefix(nil).to_s + '#'
       end
-      log_debug("namespace") {"'#{prefix}' <#{uri}>"}
+      log_debug("namespace", depth: depth) {"'#{prefix}' <#{uri}>"}
       prefix(prefix, uri(uri))
     end
 
@@ -654,7 +697,7 @@ module RDF::N3
         raise RDF::ReaderError, "unqualified keyword '#{kw}' used without @keyword directive" if validate?
       end
     end
-    
+
     # Create URIs
     def uri(value, append = nil)
       value = RDF::URI(value)
@@ -662,20 +705,42 @@ module RDF::N3
       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
+
+      # Variable substitution for in-scope variables. Variables are in scope if they are defined in anthing other than the current formula
+      var = find_var(@formulae.last, value)
+      value = var if var
 
       value
     end
-    
+
     def ns(prefix, suffix)
       base = prefix(prefix).to_s
       suffix = suffix.to_s.sub(/^\#/, "") if base.index("#")
-      log_debug("ns") {"base: '#{base}', suffix: '#{suffix}'"}
+      log_debug("ns", depth: depth) {"base: '#{base}', suffix: '#{suffix}'"}
       uri(base + suffix.to_s)
     end
+
+    # Returns a unique label
+    def unique_label
+      label, @label_uniquifier = @label_uniquifier, @label_uniquifier.succ
+      label
+    end
+
+    # Find any variable that may be defined in the formula identified by `bn`
+    # @param [RDF::Node] bn name of formula
+    # @param [#to_s] name
+    # @return [RDF::Query::Variable]
+    def find_var(sym, name)
+      (@variables[sym] ||= {})[name.to_s]
+    end
+
+    # Add a variable to the formula identified by `bn`, returning the variable. Useful as an LRU for variable name lookups
+    # @param [RDF::Node] bn name of formula
+    # @param [#to_s] name of variable for lookup
+    # @param [RDF::Query::Variable] var
+    # @return [RDF::Query::Variable]
+    def add_var_to_formula(bn, name, var)
+      (@variables[bn] ||= {})[name.to_s] = var
+    end
   end
 end