rdf-n3 3.1.2 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c53b64b52fa5a16fdfe462a270e5eb861c8cbd432aadc0df0aedaf057accb3f3
-  data.tar.gz: 2e7537cc0ab6084f7a321ffe4347a5071e6d9204025a746b21856c786fd491d4
+  metadata.gz: c5082274015223c285074d961b1de134d76a9e4b4174ec70cabb326161609ec8
+  data.tar.gz: a8df856b348d43664a99d1ce183da15082cb803b271eafd6f98abf3b8ac2f0eb
 SHA512:
-  metadata.gz: b8fd2b701f9eb17083ca81884f98de32435068e494445d14ffdbb7fff7f323a0c32a507e6490466b56f77abb3b7d3cd523861f50e82cb494236537871be8f840
-  data.tar.gz: f68c2f4a5f91ecb35d95ad9e58f58adb9ade18b66fd24ad04bfb34482f49cb245e98f27660e46b5bfc4adf72da1c6e534ae903deec35d07fe1419949cefc5312
+  metadata.gz: 561febe8dde9ad892eab9eda2cdf957c1d79c350be900a35c487ee6d3362c780aa5eee9868ba07c2c66d201f4f2a16a5bb0bb7853c366d2ab9b1593e50b25b0b
+  data.tar.gz: c15291bf10df5b98eb5f02f859b2c5d00d25b145f9effcf7c256b6a0d2edce32b1a66e9254308d6674131a84322fa33068bb9c661236b8c1ee26468ca26ee8fc

data/README.md

@@ -3,7 +3,7 @@ Notation-3 reader/writer for [RDF.rb][RDF.rb] .
 
 [![Gem Version](https://badge.fury.io/rb/rdf-n3.png)](https://badge.fury.io/rb/rdf-n3)
 [![Build Status](https://github.com/ruby-rdf/rdf-n3/workflows/CI/badge.svg?branch=develop)](https://github.com/ruby-rdf/rdf-n3/actions?query=workflow%3ACI)
-[![Coverage Status](https://coveralls.io/repos/ruby-rdf/rdf-n3/badge.svg)](https://coveralls.io/github/ruby-rdf/rdf-n3)
+[![Coverage Status](https://coveralls.io/repos/github/ruby-rdf/rdf-n3/badge.svg?branch=develop)](https://coveralls.io/github/ruby-rdf/rdf-n3?branch=develop)
 [![Gitter chat](https://badges.gitter.im/ruby-rdf/rdf.png)](https://gitter.im/ruby-rdf/rdf)
 
 ## Description
@@ -19,6 +19,7 @@ This version tracks the [W3C N3 Community Group][] [Specification][N3] which has
 * The modifier `<-` is introduced as a synonym for `is ... of`.
 * The SPARQL `BASE` and `PREFIX` declarations are supported.
 * Implicit universal variables are defined at the top-level, rather than in the parent formula of the one in which they are defined.
+* Support for explicit existential and universal variables (`@forAll` and `@forSome`) has been removed. Quick variables are the standard for universal quantification and blank nodes for existential, but scoping rules are different: Quickvars have top-level scope, and blank nodes formula scope.
 
 This brings N3 closer to compatibility with Turtle.
 
@@ -27,6 +28,8 @@ RDF::N3 parses [Notation-3][N3], [Turtle][] and [N-Triples][] into statements or
 
 Install with `gem install rdf-n3`
 
+[Implementation Report](https://ruby-rdf.github.io/rdf-n3/etc/earl.html)
+
 ## Limitations
 * Support for Variables in Formulae. Existential variables are quantified to RDF::Node instances, Universals to RDF::Query::Variable, with the URI of the variable target used as the variable name.
 
@@ -69,6 +72,7 @@ Reasoning is discussed in the [Design Issues][] document.
   * `list:append` (See {RDF::N3::Algebra::List::Append})
   * `list:first`  (See {RDF::N3::Algebra::List::First})
   * `list:in`     (See {RDF::N3::Algebra::List::In})
+  * `list:iterate`     (See {RDF::N3::Algebra::List::Iterate})
   * `list:last`   (See {RDF::N3::Algebra::List::Last})
   * `list:length` (See {RDF::N3::Algebra::List::Length})
   * `list:member` (See {RDF::N3::Algebra::List::Member})
@@ -78,9 +82,11 @@ Reasoning is discussed in the [Design Issues][] document.
   * `log:conclusion`    (See {RDF::N3::Algebra::Log::Conclusion})
   * `log:conjunction`   (See {RDF::N3::Algebra::Log::Conjunction})
   * `log:content`       (See {RDF::N3::Algebra::Log::Content})
+  * `log:dtlit`       (See {RDF::N3::Algebra::Log::DtLit})
   * `log:equalTo`       (See {RDF::N3::Algebra::Log::EqualTo})
   * `log:implies`       (See {RDF::N3::Algebra::Log::Implies})
   * `log:includes`      (See {RDF::N3::Algebra::Log::Includes})
+  * `log:langlit`       (See {RDF::N3::Algebra::Log::LangLit})
   * `log:n3String`      (See {RDF::N3::Algebra::Log::N3String})
   * `log:notEqualTo`    (See {RDF::N3::Algebra::Log::NotEqualTo})
   * `log:notIncludes`   (See {RDF::N3::Algebra::Log::NotIncludes})
@@ -139,7 +145,7 @@ Reasoning is discussed in the [Design Issues][] document.
   * `string:scrape`               (See {RDF::N3::Algebra::Str::Scrape})
   * `string:startsWith`           (See {RDF::N3::Algebra::Str::StartsWith})
 
-#### RDF Time vocabulary <>
+#### RDF Time vocabulary <http://www.w3.org/2000/10/swap/time#>
 
   * `time:dayOfWeek`              (See {RDF::N3::Algebra::Time::DayOfWeek})
   * `time:day`                    (See {RDF::N3::Algebra::Time::Day})
@@ -173,15 +179,8 @@ when turned into an RDF Repository results in the following quads
 Reasoning uses a Notation3 Algebra, similar to [SPARQL S-Expressions][]. This implementation considers formulae to be patterns, which may be asserted on statements made in the default graph, possibly loaded from a separate file. The logical relationships are reduced to algebraic operators. 
 
 ### Variables
-N3 Variables are introduced with `@forAll`, `@forSome`, or `?x`. Variables reference URIs described in formulae, typically defined in the default vocabulary (e.g., `":x"`). Existential variables are replaced with an allocated `RDF::Node` instance. Universal variables are replaced with a `RDF::Query::Variable` instance. For example, the following N3 generates the associated statements:
-
-    @forAll <#h>. @forSome <#g>. <#g> <#loves> <#h> .
-
-results in:
-
-    h = RDF::Query::Variable.new(<#h>)
-    g = RDF::Node.new()
-    RDF::Statement(f, <#loves>, h)
+The latest version of N3 supports only quickVars (e.g., `?x`). THe former explicit `@forAll` and `@forSome` of been removed.
+Existential variables are replaced with an allocated `RDF::Node` instance.
 
 Note that the behavior of both existential and universal variables is not entirely in keeping with the [Team Submission][], and neither work quite like SPARQL variables. When used in the antecedent part of an implication, universal variables should behave much like SPARQL variables. This area is subject to a fair amount of change.
 
@@ -194,11 +193,11 @@ Formulae are typically used to query the knowledge-base, which is set from the b
 Blank nodes associated with rdf:List statements used as part of a built-in are made _non-distinguished_ existential variables, and patters containing these variables become optional. If they are not bound as part of the query, the implicitly are bound as the original blank nodes defined within the formula, which allows for both constant list arguments, list arguments that contain variables, or arguments which are variables expanding to lists.
 
 ## Dependencies
-* [Ruby](https://ruby-lang.org/) (>= 2.4)
-* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.1, >= 3.1.4)
-* [EBNF][EBNF gem] (~> 2.1)
+* [Ruby](https://ruby-lang.org/) (>= 2.6)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.2)
+* [EBNF][EBNF gem] (~> 2.2)
 * [SPARQL][SPARQL gem] (~> 3.1)
-* [SXP][SXP gem] (~> 1.1)
+* [SXP][SXP gem] (~> 1.2)
 
 ## Documentation
 Full documentation available on [RubyDoc.info](https://rubydoc.info/github/ruby-rdf/rdf-n3)

data/VERSION

@@ -1 +1 @@
-3.1.2
+3.2.0

data/lib/rdf/n3/algebra/list/iterate.rb

@@ -0,0 +1,96 @@
+module RDF::N3::Algebra::List
+  ##
+  # Generates a list of lists when each constituent list is composed of the index and value of each element in the subject.
+  #
+  # Binds variables in the object list.
+  #
+  # @example
+  #     { (1 2 3) list:iterate ((0 1) (1 2) (2 3)) } => { :test4a a :SUCCESS }.
+  class Iterate < RDF::N3::Algebra::ListOperator
+    NAME = :listIterate
+    URI = RDF::N3::List.iterate
+
+    ##
+    # Evaluates this operator using the given variable `bindings`.
+    # The subject MUST evaluate to a list and the object to a list composed of two components: index and value.
+    #
+    # @example
+    #    {(1 2 3) list:iterate (?x ?y)} => {:solution :is (?x ?y)} .
+    #
+    # @example
+    #    {(1 2 3) list:iterate ?L} => {:solution :is ?L} .
+    #
+    # @example
+    #    {(1 2 3) list:iterate (1 ?y)} => {:value :is ?y} .
+    #
+    # @example
+    #    {(1 2 3) list:iterate (?x 2)} => {:index :is ?x} .
+    #
+    # @param  [RDF::Queryable] queryable
+    #   the graph or repository to query
+    # @param [RDF::Query::Solutions] solutions
+    #   solutions for chained queries
+    # @return [RDF::Query::Solutions]
+    def execute(queryable, solutions:, **options)
+      RDF::Query::Solutions(solutions.map do |solution|
+        subject = operand(0).evaluate(solution.bindings, formulae: formulae) || operand(0)
+        # Might be a variable or node evaluating to a list in queryable, or might be a list with variables
+        # If subject evaluated to a BNode, re-expand as a list
+        subject = RDF::N3::List.try_list(subject, queryable).evaluate(solution.bindings, formulae: formulae)
+        next unless validate(subject)
+
+        object = operand(1).evaluate(solution.bindings, formulae: formulae) || operand(1)
+        next unless object
+        # If object evaluated to a BNode, re-expand as a list
+        object = RDF::N3::List.try_list(object, queryable).evaluate(solution.bindings, formulae: formulae) || object
+
+        if object.list? && object.variable?
+          # Create a solution for those entries in subject that match object
+          if object.length != 2
+            log_error(NAME) {"object is not a list with two entries: #{object.to_sxp}"}
+            next
+          end
+          if object.first.variable? && object.last.variable?
+            solutions = RDF::Query::Solutions.new
+            subject.each_with_index do |r, i|
+              s = solution.merge(object.first.to_sym => RDF::Literal(i), object.last.to_sym => r)
+              log_debug(self.class.const_get(:NAME), "result: #{s.to_sxp}")
+              solutions << s
+            end
+            solutions
+          elsif object.first.variable?
+            # Solution binds indexes to all matching values
+            solutions = RDF::Query::Solutions.new
+            subject.each_with_index do |r, i|
+              next unless r == object.last
+              s = solution.merge(object.first.to_sym => RDF::Literal(i))
+              log_debug(self.class.const_get(:NAME), "result: #{s.to_sxp}")
+              solutions << s
+            end
+            solutions
+          elsif object.last.variable?
+            # Solution binds value at specified index
+            next unless v = subject.at(object.first)
+            s = solution.merge(object.last.to_sym => v)
+            log_debug(self.class.const_get(:NAME), "result: #{s.to_sxp}")
+            s
+          end
+        elsif object.variable?
+          # Create a solution for each index/value pair in subject
+          solutions = RDF::Query::Solutions.new
+          subject.each_with_index do |r, i|
+            s = solution.merge(object.to_sym => RDF::N3::List[RDF::Literal(i), r])
+            log_debug(self.class.const_get(:NAME), "result: #{s.to_sxp}")
+            solutions << s
+          end
+          solutions
+        else
+          # Evaluates to true if the subject has a matching entry
+          same = subject.at(object.first) == object.last
+          log_debug(self.class.const_get(:NAME), "result: #{same.inspect}")
+          solution if same
+        end
+      end.flatten.compact.uniq)
+    end
+  end
+end

data/lib/rdf/n3/algebra/list_operator.rb

@@ -79,5 +79,18 @@ module RDF::N3::Algebra
         false
       end
     end
+
+    ##
+    # Returns a literal for the numeric argument.
+    def as_literal(object)
+      case object
+      when Float
+        literal = RDF::Literal(object, canonicalize: true)
+        literal.instance_variable_set(:@string, literal.to_s.downcase)
+        literal
+      else
+        RDF::Literal(object, canonicalize: true)
+      end
+    end
   end
 end

data/lib/rdf/n3/algebra/log/dtlit.rb

@@ -0,0 +1,41 @@
+module RDF::N3::Algebra::Log
+  ##
+  # Takes a list of a string and an IRI and creates a datatyped literal.
+  class DtLit < RDF::N3::Algebra::ListOperator
+    NAME = :dtlit
+    URI = RDF::N3::Log.dtlit
+
+    ##
+    # Reads the subject into the object.
+    #
+    # Returns nil if resource does not validate, given its position
+    #
+    # @param [RDF::N3::List] resource
+    # @return [RDF::Term]
+    def resolve(resource, position: :subject)
+      case position
+      when :subject
+        RDF::Literal(as_literal(resource.first).to_s, datatype: resource.last)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+
+    def validate(list)
+      if super(list)
+        if list.length != 2
+          log_error(NAME) {"operand is not a list with two elements: #{list.to_sxp}"}
+          false
+        elsif !list.last.uri?
+          log_error(NAME) {"second component of subject must be an IRI: #{list.last.to_sxp}"}
+          false
+        else
+          true
+        end
+      else
+        false
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/langlit.rb

@@ -0,0 +1,41 @@
+module RDF::N3::Algebra::Log
+  ##
+  # Takes a list of two strings creates a language-tagged literal.
+  class LangLit < RDF::N3::Algebra::ListOperator
+    NAME = :langlit
+    URI = RDF::N3::Log.langlit
+
+    ##
+    # Reads the subject into the object.
+    #
+    # Returns nil if resource does not validate, given its position
+    #
+    # @param [RDF::N3::List] resource
+    # @return [RDF::Term]
+    def resolve(resource, position: :subject)
+      case position
+      when :subject
+        RDF::Literal(as_literal(resource.first).to_s, language: resource.last.to_s.to_sym)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+
+    def validate(list)
+      if super(list)
+        if list.length != 2
+          log_error(NAME) {"operand is not a list with two elements: #{list.to_sxp}"}
+          false
+        elsif !list.last.to_s.match?(/^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/)
+          log_warn(NAME) {"second component of subject should be BCP47 language tag: #{list.last.to_sxp}"}
+          false
+        else
+          true
+        end
+      else
+        false
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/resource_operator.rb

@@ -49,7 +49,6 @@ module RDF::N3::Algebra
           res = apply(lhs, rhs)
           log_debug(self.class.const_get(:NAME), "result") {SXP::Generator.string(res.to_sxp_bin).strip}
           # Return the result applying subject and object
-          #require 'byebug'; byebug
           case res
           when RDF::Literal::TRUE
             solution

data/lib/rdf/n3/algebra.rb

@@ -19,6 +19,7 @@ module RDF::N3
       autoload :Append,               'rdf/n3/algebra/list/append'
       autoload :First,                'rdf/n3/algebra/list/first'
       autoload :In,                   'rdf/n3/algebra/list/in'
+      autoload :Iterate,              'rdf/n3/algebra/list/iterate'
       autoload :Last,                 'rdf/n3/algebra/list/last'
       autoload :Length,               'rdf/n3/algebra/list/length'
       autoload :Member,               'rdf/n3/algebra/list/member'
@@ -30,9 +31,11 @@ module RDF::N3
       autoload :Conclusion,           'rdf/n3/algebra/log/conclusion'
       autoload :Conjunction,          'rdf/n3/algebra/log/conjunction'
       autoload :Content,              'rdf/n3/algebra/log/content'
+      autoload :DtLit,                'rdf/n3/algebra/log/dtlit'
       autoload :EqualTo,              'rdf/n3/algebra/log/equal_to'
       autoload :Implies,              'rdf/n3/algebra/log/implies'
       autoload :Includes,             'rdf/n3/algebra/log/includes'
+      autoload :LangLit,              'rdf/n3/algebra/log/langlit'
       autoload :N3String,             'rdf/n3/algebra/log/n3_string'
       autoload :NotEqualTo,           'rdf/n3/algebra/log/not_equal_to'
       autoload :NotIncludes,          'rdf/n3/algebra/log/not_includes'
@@ -117,6 +120,7 @@ module RDF::N3
         RDF::N3::List.append              => List.const_get(:Append),
         RDF::N3::List.first               => List.const_get(:First),
         RDF::N3::List.in                  => List.const_get(:In),
+        RDF::N3::List.iterate             => List.const_get(:Iterate),
         RDF::N3::List.last                => List.const_get(:Last),
         RDF::N3::List.length              => List.const_get(:Length),
         RDF::N3::List.member              => List.const_get(:Member),
@@ -124,9 +128,11 @@ module RDF::N3
         RDF::N3::Log.conclusion           => Log.const_get(:Conclusion),
         RDF::N3::Log.conjunction          => Log.const_get(:Conjunction),
         RDF::N3::Log.content              => Log.const_get(:Content),
+        RDF::N3::Log.dtlit                => Log.const_get(:DtLit),
         RDF::N3::Log.equalTo              => Log.const_get(:EqualTo),
         RDF::N3::Log.implies              => Log.const_get(:Implies),
         RDF::N3::Log.includes             => Log.const_get(:Includes),
+        RDF::N3::Log.langlit              => Log.const_get(:LangLit),
         RDF::N3::Log.n3String             => Log.const_get(:N3String),
         RDF::N3::Log.notEqualTo           => Log.const_get(:NotEqualTo),
         RDF::N3::Log.notIncludes          => Log.const_get(:NotIncludes),

data/lib/rdf/n3/extensions.rb

@@ -33,8 +33,8 @@ module RDF
     # Returns an S-Expression (SXP) representation
     #
     # @return [String]
-    def to_sxp
-      to_a.to_sxp_bin.to_sxp
+    def to_sxp(**options)
+      to_a.to_sxp_bin.to_sxp(**options)
     end
   end
 

data/lib/rdf/n3/reader.rb

@@ -12,7 +12,7 @@ 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 named using an `_ext` suffix, internally, as the RDF `query_pattern` logic looses details of the variable definition in solutions, where the variable is represented using a symbol.
+  # This implementation only supports quickVars at the document scope.
   #
   # Non-distinguished blank node variables are created as part of reasoning.
   #
@@ -200,7 +200,6 @@ module RDF::N3
                                                  |<-|<=|=>|=
                                                  | true|false
                                                  | has|is|of
-                                                 |@forAll|@forSome
                                                 )x)
 
     terminal(:PREFIX,                           PREFIX)
@@ -244,7 +243,6 @@ module RDF::N3
     def read_n3Statement
       prod(:n3Statement, %w{.}) do
         error("read_n3Doc", "Unexpected end of file") unless token = @lexer.first
-        read_uniext ||
         read_triples ||
         error("Expected token", production: :statement, token: token)
       end
@@ -573,12 +571,6 @@ module RDF::N3
           formula_nodes[node] = true
           debug(:formula, depth: @options[:depth]) {"id: #{node}, depth: #{formulae.length}"}
 
-          # Promote variables defined on the earlier formula to this formula
-          variables[node] = {}
-          variables.fetch(formulae[-2], {}).each do |name, var|
-            variables[node][name] = var
-          end
-
           read_formulaContent
 
           # Pop off the formula
@@ -664,54 +656,7 @@ module RDF::N3
         prod(:quickVar) do
           token = @lexer.shift
           value = token.value.sub('?', '')
-          iri = ns(nil, "#{value}_quick")
-          variables[nil][iri] ||= univar(iri, scope: nil)
-        end
-      end
-    end
-
-    ##
-    # Read a list of IRIs
-    #
-    #     [27] iriList ::= iri ( ',' iri )*
-    #
-    # @return [Array<RDF::URI>] the list of IRIs
-    def read_irilist
-      iris = []
-      prod(:iriList, %{,}) do
-        while iri = read_iri
-          iris << iri
-          break unless @lexer.first === ','
-          @lexer.shift while @lexer.first === ','
-        end
-      end
-      iris
-    end
-
-    ##
-    # Read a univeral or existential
-    #
-    # 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
-    #
-    #     [31] existential ::=  '@forSome' iriList
-    #     [32] universal   ::=  '@forAll' iriList
-    #
-    # @return [void]
-    def read_uniext
-      if %w(@forSome @forAll).include?(@lexer.first.value)
-        token = @lexer.shift
-        prod(token === '@forAll' ? :universal : :existential) do
-          iri_list = read_irilist 
-          iri_list.each do |iri|
-            # Note, this might re-create an equivalent variable already defined in this formula, and replaces an equivalent variable that may have been defined in the parent formula.
-            var = univar(iri, scope: formulae.last, existential: token === '@forSome')
-            add_var_to_formula(formulae.last, iri, var)
-          end
+          variables[value] ||= RDF::Query::Variable.new(value)
         end
       end
     end
@@ -786,10 +731,9 @@ module RDF::N3
     end
 
     # If not in ground formula, note scope, and if existential
-    def univar(label, scope:, existential: false)
-      value = existential ? "#{label}_ext" : label
-      value = "#{value}#{scope.id}" if scope
-      RDF::Query::Variable.new(value, existential: existential)
+    def univar(label, scope:)
+      value = label
+      RDF::Query::Variable.new(value)
     end
 
     # add a pattern or statement
@@ -865,20 +809,11 @@ module RDF::N3
       label
     end
 
-    # Find any variable that may be defined in the formula identified by `bn`
+    # Find any variable that may be defined identified by `name`
     # @param [RDF::Node] name of formula
     # @return [RDF::Query::Variable]
     def find_var(name)
-      (variables[@formulae.last] ||= {})[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
+      variables[name.to_s]
     end
 
     def prod(production, recover_to = [])

data/lib/rdf/n3/terminals.rb

@@ -74,7 +74,5 @@ module RDF::N3
     WS                   = /(?:\s|(?:#[^\n\r]*))+/um.freeze
     # 162s
     ANON                 = /\[\s*\]/u.freeze
-
-    FORALL               = /@forAll/u.freeze
   end
 end

data/lib/rdf/n3/writer.rb

@@ -273,13 +273,26 @@ module RDF::N3
       case literal
       when RDF::Literal
         case literal.valid? ? literal.datatype : false
-        when RDF::XSD.boolean, RDF::XSD.integer, RDF::XSD.decimal
-          literal.canonicalize.to_s
+        when RDF::XSD.boolean
+          %w(true false).include?(literal.value) ? literal.value : literal.canonicalize.to_s
+        when RDF::XSD.integer
+          literal.value.match?(/^[\+\-]?\d+$/) && !canonicalize? ? literal.value : literal.canonicalize.to_s
+        when RDF::XSD.decimal
+          literal.value.match?(/^[\+\-]?\d+\.\d+?$/) && !canonicalize? ?
+            literal.value :
+            literal.canonicalize.to_s
         when RDF::XSD.double
           if literal.nan? || literal.infinite?
             quoted(literal.value) + "^^#{format_uri(literal.datatype)}"
           else
-            literal.canonicalize.to_s
+            in_form = case literal.value
+            when /[\+\-]?\d+\.\d*E[\+\-]?\d+$/i then true
+            when /[\+\-]?\.\d+E[\+\-]?\d+$/i    then true
+            when /[\+\-]?\d+E[\+\-]?\d+$/i      then true
+            else false
+            end && !canonicalize?
+
+            in_form ? literal.value : literal.canonicalize.to_s.sub('E', 'e')
           end
         else
           text = quoted(literal.value)
@@ -331,19 +344,6 @@ module RDF::N3
       prefixes.keys.sort_by(&:to_s).each do |prefix|
         @output.write("@prefix #{prefix}: <#{prefixes[prefix]}> .\n")
       end
-
-      # Universals and extentials at top-level
-      unless @universals.empty?
-        log_debug("start_document: universals") { @universals.inspect}
-        terms = @universals.map {|v| format_uri(RDF::URI(v.name.to_s))}
-        @output.write("@forAll #{terms.join(', ')} .\n") 
-      end
-
-      unless @existentials.empty?
-        log_debug("start_document: existentials") { @existentials.inspect}
-        terms = @existentials.map {|v| format_uri(RDF::URI(v.name.to_s.sub(/_ext$/, '')))}
-        @output.write("@forSome #{terms.join(', ')} .\n") 
-      end
     end
 
     # Defines rdf:type of subjects to be emitted at the beginning of the graph. Defaults to rdfs:Class
@@ -424,10 +424,6 @@ module RDF::N3
 
       @options[:prefixes] = {}  # Will define actual used when matched
       repo.each {|statement| preprocess_statement(statement)}
-
-      vars = repo.enum_term.to_a.uniq.select {|r| r.is_a?(RDF::Query::Variable) && !r.to_s.end_with?('_quick')}
-      @universals = vars.reject(&:existential?)
-      @existentials = vars - @universals
     end
 
     # Perform any statement preprocessing required. This is used to perform reference counts and determine required
@@ -462,7 +458,6 @@ module RDF::N3
 
     # Reset internal helper instance variables
     def reset
-      @universals, @existentials = [], []
       @lists = {}
       @references = {}
       @serialized = {}
@@ -521,11 +516,7 @@ module RDF::N3
     def p_term(resource, position)
       #log_debug("p_term") {"#{resource.to_sxp}, #{position}"}
       l = if resource.is_a?(RDF::Query::Variable)
-        if resource.to_s.end_with?('_quick')
-          '?' + RDF::URI(resource.name).fragment.sub(/_quick$/, '')
-        else
-          format_term(RDF::URI(resource.name.to_s.sub(/_ext$/, '')))
-        end
+        "?#{resource.name}"
       elsif resource == RDF.nil
         "()"
       else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf-n3
 version: !ruby/object:Gem::Version
-  version: 3.1.2
+  version: 3.2.0
 platform: ruby
 authors:
 - Gregg
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-25 00:00:00.000000000 Z
+date: 2021-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ebnf
@@ -17,138 +17,126 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: rdf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.1.8
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.1.8
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: sparql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.1.4
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.1.4
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: sxp
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: json-ld
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: rdf-isomorphic
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: rdf-trig
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: rdf-vocab
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -208,6 +196,7 @@ files:
 - lib/rdf/n3/algebra/list/append.rb
 - lib/rdf/n3/algebra/list/first.rb
 - lib/rdf/n3/algebra/list/in.rb
+- lib/rdf/n3/algebra/list/iterate.rb
 - lib/rdf/n3/algebra/list/last.rb
 - lib/rdf/n3/algebra/list/length.rb
 - lib/rdf/n3/algebra/list/member.rb
@@ -215,9 +204,11 @@ files:
 - lib/rdf/n3/algebra/log/conclusion.rb
 - lib/rdf/n3/algebra/log/conjunction.rb
 - lib/rdf/n3/algebra/log/content.rb
+- lib/rdf/n3/algebra/log/dtlit.rb
 - lib/rdf/n3/algebra/log/equal_to.rb
 - lib/rdf/n3/algebra/log/implies.rb
 - lib/rdf/n3/algebra/log/includes.rb
+- lib/rdf/n3/algebra/log/langlit.rb
 - lib/rdf/n3/algebra/log/n3_string.rb
 - lib/rdf/n3/algebra/log/not_equal_to.rb
 - lib/rdf/n3/algebra/log/not_includes.rb
@@ -305,14 +296,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Notation3 reader/writer and reasoner for RDF.rb.