rdf 3.2.10 → 3.3.0

data/lib/rdf/model/uri.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 require 'cgi'
 
 module RDF
@@ -28,27 +29,27 @@ module RDF
     include RDF::Resource
 
     # IRI components
-    UCSCHAR = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
-      [\\u00A0-\\uD7FF]|[\\uF900-\\uFDCF]|[\\uFDF0-\\uFFEF]|
-      [\\u{10000}-\\u{1FFFD}]|[\\u{20000}-\\u{2FFFD}]|[\\u{30000}-\\u{3FFFD}]|
-      [\\u{40000}-\\u{4FFFD}]|[\\u{50000}-\\u{5FFFD}]|[\\u{60000}-\\u{6FFFD}]|
-      [\\u{70000}-\\u{7FFFD}]|[\\u{80000}-\\u{8FFFD}]|[\\u{90000}-\\u{9FFFD}]|
-      [\\u{A0000}-\\u{AFFFD}]|[\\u{B0000}-\\u{BFFFD}]|[\\u{C0000}-\\u{CFFFD}]|
-      [\\u{D0000}-\\u{DFFFD}]|[\\u{E1000}-\\u{EFFFD}]
-    EOS
-    IPRIVATE = Regexp.compile("[\\uE000-\\uF8FF]|[\\u{F0000}-\\u{FFFFD}]|[\\u100000-\\u10FFFD]").freeze
+    UCSCHAR = %(
+      \\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF
+      \\u{10000}-\\u{1FFFD}\\u{20000}-\\u{2FFFD}\\u{30000}-\\u{3FFFD}
+      \\u{40000}-\\u{4FFFD}\\u{50000}-\\u{5FFFD}\\u{60000}-\\u{6FFFD}
+      \\u{70000}-\\u{7FFFD}\\u{80000}-\\u{8FFFD}\\u{90000}-\\u{9FFFD}
+      \\u{A0000}-\\u{AFFFD}\\u{B0000}-\\u{BFFFD}\\u{C0000}-\\u{CFFFD}
+      \\u{D0000}-\\u{DFFFD}\\u{E1000}-\\u{EFFFD}
+    ).gsub(/\s+/, '')
+    IPRIVATE = Regexp.compile("[\\uE000-\\uF8FF\\u{F0000}-\\u{FFFFD}\\u{100000}-\\u{10FFFD}]").freeze
     SCHEME = Regexp.compile("[A-Za-z](?:[A-Za-z0-9+-\.])*").freeze
     PORT = Regexp.compile("[0-9]*").freeze
     IP_literal = Regexp.compile("\\[[0-9A-Fa-f:\\.]*\\]").freeze  # Simplified, no IPvFuture
     PCT_ENCODED = Regexp.compile("%[0-9A-Fa-f][0-9A-Fa-f]").freeze
-    GEN_DELIMS = Regexp.compile("[:/\\?\\#\\[\\]@]").freeze
-    SUB_DELIMS = Regexp.compile("[!\\$&'\\(\\)\\*\\+,;=]").freeze
-    RESERVED = Regexp.compile("(?:#{GEN_DELIMS}|#{SUB_DELIMS})").freeze
+    GEN_DELIMS = Regexp.compile(%q{[:/\?\#\[\]@]}).freeze
+    SUB_DELIMS = Regexp.compile(%q{[!\$&'\(\)\*\+,;=]}).freeze
+    RESERVED = Regexp.union(GEN_DELIMS, SUB_DELIMS).freeze
     UNRESERVED = Regexp.compile("[A-Za-z0-9\._~-]").freeze
 
-    IUNRESERVED = Regexp.compile("[A-Za-z0-9\._~-]|#{UCSCHAR}").freeze
+    IUNRESERVED = Regexp.union(UNRESERVED, Regexp.compile("[#{UCSCHAR}]")).freeze
 
-    IPCHAR = Regexp.compile("(?:#{IUNRESERVED}|#{PCT_ENCODED}|#{SUB_DELIMS}|:|@)").freeze
+    IPCHAR = Regexp.union(IUNRESERVED, PCT_ENCODED, SUB_DELIMS, /[:|@]/).freeze
 
     IQUERY = Regexp.compile("(?:#{IPCHAR}|#{IPRIVATE}|/|\\?)*").freeze
 
@@ -65,7 +66,7 @@ module RDF
     IPATH_EMPTY = Regexp.compile("").freeze
 
     IREG_NAME   = Regexp.compile("(?:(?:#{IUNRESERVED})|(?:#{PCT_ENCODED})|(?:#{SUB_DELIMS}))*").freeze
-    IHOST = Regexp.compile("(?:#{IP_literal})|(?:#{IREG_NAME})").freeze
+    IHOST = Regexp.union(IP_literal, IREG_NAME).freeze
     IUSERINFO = Regexp.compile("(?:(?:#{IUNRESERVED})|(?:#{PCT_ENCODED})|(?:#{SUB_DELIMS})|:)*").freeze
     IAUTHORITY = Regexp.compile("(?:#{IUSERINFO}@)?#{IHOST}(?::#{PORT})?").freeze
     
@@ -116,7 +117,21 @@ module RDF
     # Note: not all reserved characters need to be escaped in SPARQL/Turtle, but they must be unescaped when encountered
     PN_ESCAPE_CHARS      = /[~\.!\$&'\(\)\*\+,;=\/\?\#@%]/.freeze
     PN_ESCAPES           = /\\#{Regexp.union(PN_ESCAPE_CHARS, /[\-_]/)}/.freeze
-    
+
+    # For URI encoding
+    # iuserinfo = *( iunreserved / pct-encoded / sub-delims / ":" )
+    ENCODE_USER = 
+    ENCODE_PASSWORD = Regexp.compile("[^A-Za-z0-9\._~#{UCSCHAR}!$&'\(\)\*\+,;=:-]").freeze
+    # isegment = *ipchar
+    # ipchar = iunreserved / pct-encoded / sub-delims / ":" / "@"
+    ENCODE_ISEGMENT = Regexp.compile("[^A-Za-z0-9\._~#{UCSCHAR}!$&'\(\)\*\+,;=:-]").freeze
+    # isegment-nz-nc = 1*( iunreserved / pct-encoded / sub-delims / "@" )
+    ENCODE_ISEGMENT_NC = Regexp.compile("[^A-Za-z0-9\._~#{UCSCHAR}!$&'\(\)\*\+,;=-]").freeze
+    # iquery         = *( ipchar / iprivate / "/" / "?" )
+    ENCODE_IQUERY = Regexp.compile("[^A-Za-z0-9\._~#{UCSCHAR}\\uE000-\\uF8FF\\u{F0000}-\\u{FFFFD}\\u{100000}-\\u{10FFFD}/?=]").freeze
+    # ifragment      = *( ipchar / "/" / "?" )
+    ENCODE_IFRAGMENT = Regexp.compile("[^A-Za-z0-9\._~#{UCSCHAR}/?]").freeze
+
     ##
     # Cache size may be set through {RDF.config} using `uri_cache_size`.
     #
@@ -170,7 +185,7 @@ module RDF
     # @return [String] normalized path
     # @see http://tools.ietf.org/html/rfc3986#section-5.2.4
     def self.normalize_path(path)
-      output, input = "", path.to_s
+      output, input = String.new, path.to_s
       if input.encoding != Encoding::ASCII_8BIT
         input = input.dup.force_encoding(Encoding::ASCII_8BIT)
       end
@@ -353,7 +368,7 @@ module RDF
     # @return [Boolean] `true` or `false`
     # @since 0.3.9
     def valid?
-      RDF::URI::IRI.match(to_s) || false
+      RDF::URI::IRI.match?(to_s) || false
     end
 
     ##
@@ -920,7 +935,7 @@ module RDF
     # Return normalized version of scheme, if any
     # @return [String]
     def normalized_scheme
-      normalize_segment(scheme.strip, SCHEME, true) if scheme
+      scheme.strip.downcase if scheme
     end
 
     ##
@@ -946,7 +961,7 @@ module RDF
     # Normalized version of user
     # @return [String]
     def normalized_user
-      URI.encode(CGI.unescape(user), /[^#{IUNRESERVED}|#{SUB_DELIMS}]/).force_encoding(Encoding::UTF_8) if user
+      URI.encode(CGI.unescape(user), ENCODE_USER).force_encoding(Encoding::UTF_8) if user
     end
 
     ##
@@ -972,7 +987,7 @@ module RDF
     # Normalized version of password
     # @return [String]
     def normalized_password
-      URI.encode(CGI.unescape(password), /[^#{IUNRESERVED}|#{SUB_DELIMS}]/).force_encoding(Encoding::UTF_8) if password
+      URI.encode(CGI.unescape(password), ENCODE_PASSWORD).force_encoding(Encoding::UTF_8) if password
     end
 
     HOST_FROM_AUTHORITY_RE = /(?:[^@]+@)?([^:]+)(?::.*)?$/.freeze
@@ -1000,7 +1015,7 @@ module RDF
     # @return [String]
     def normalized_host
       # Remove trailing '.' characters
-      normalize_segment(host, IHOST, true).chomp('.') if host
+      host.sub(/\.*$/, '').downcase if host
     end
 
     PORT_FROM_AUTHORITY_RE = /:(\d+)$/.freeze
@@ -1028,12 +1043,8 @@ module RDF
     # @return [String]
     def normalized_port
       if port
-        np = normalize_segment(port.to_s, PORT)
-        if PORT_MAPPING[normalized_scheme] == np.to_i
-          nil
-        else
-          np.to_i
-        end
+        np = port.to_i
+        PORT_MAPPING[normalized_scheme] != np ? np : nil
       end
     end
 
@@ -1064,30 +1075,36 @@ module RDF
     # Normalized version of path
     # @return [String]
     def normalized_path
+      if normalized_scheme == "urn"
+        # Special-case URI. Normalize the NID component only
+        nid, p = path.to_s.split(':', 2)
+        return "#{nid.downcase}:#{p}"
+      end
+
       segments = path.to_s.split('/', -1) # preserve null segments
 
       norm_segs = case
       when authority
         # ipath-abempty
-        segments.map {|s| normalize_segment(s, ISEGMENT)}
+        segments.map {|s| normalize_segment(s, ENCODE_ISEGMENT)}
       when segments[0].nil?
         # ipath-absolute
         res = [nil]
-        res << normalize_segment(segments[1], ISEGMENT_NZ) if segments.length > 1
-        res += segments[2..-1].map {|s| normalize_segment(s, ISEGMENT)} if segments.length > 2
+        res << normalize_segment(segments[1], ENCODE_ISEGMENT) if segments.length > 1
+        res += segments[2..-1].map {|s| normalize_segment(s, ENCODE_ISEGMENT)} if segments.length > 2
         res
       when segments[0].to_s.index(':')
         # ipath-noscheme
         res = []
-        res << normalize_segment(segments[0], ISEGMENT_NZ_NC)
-        res += segments[1..-1].map {|s| normalize_segment(s, ISEGMENT)} if segments.length > 1
+        res << normalize_segment(segments[0], ENCODE_ISEGMENT_NC)
+        res += segments[1..-1].map {|s| normalize_segment(s, ENCODE_ISEGMENT)} if segments.length > 1
         res
       when segments[0]
         # ipath-rootless
         # ipath-noscheme
         res = []
-        res << normalize_segment(segments[0], ISEGMENT_NZ)
-        res += segments[1..-1].map {|s| normalize_segment(s, ISEGMENT)} if segments.length > 1
+        res << normalize_segment(segments[0], ENCODE_ISEGMENT)
+        res += segments[1..-1].map {|s| normalize_segment(s, ENCODE_ISEGMENT)} if segments.length > 1
         res
       else
         # Should be empty
@@ -1096,7 +1113,7 @@ module RDF
 
       res = self.class.normalize_path(norm_segs.join("/"))
       # Special rules for specific protocols having empty paths
-      normalize_segment(res.empty? ? (%w(http https ftp tftp).include?(normalized_scheme) ? '/' : "") : res, IHIER_PART)
+      (res.empty? && %w(http https ftp tftp).include?(normalized_scheme)) ? '/' : res
     end
 
     ##
@@ -1120,7 +1137,7 @@ module RDF
     # Normalized version of query
     # @return [String]
     def normalized_query
-      normalize_segment(query, IQUERY) if query
+      normalize_segment(query, ENCODE_IQUERY) if query
     end
 
     ##
@@ -1144,7 +1161,7 @@ module RDF
     # Normalized version of fragment
     # @return [String]
     def normalized_fragment
-      normalize_segment(fragment, IFRAGMENT) if fragment
+      normalize_segment(fragment, ENCODE_IFRAGMENT) if fragment
     end
 
     ##
@@ -1274,7 +1291,7 @@ module RDF
       self.query = case value
       when Array, Hash
         value.map do |(k,v)|
-          k = normalize_segment(k.to_s, UNRESERVED)
+          k = normalize_segment(k.to_s, /[^A-Za-z0-9\._~-]/)
           if v.nil?
             k
           else
@@ -1282,7 +1299,7 @@ module RDF
               if vv === TrueClass
                 k
               else
-                "#{k}=#{normalize_segment(vv.to_s, UNRESERVED)}"
+                "#{k}=#{normalize_segment(vv.to_s, /[^A-Za-z0-9\._~-]/)}"
               end
             end.join("&")
           end
@@ -1331,7 +1348,7 @@ module RDF
     # Normalize a segment using a character range
     #
     # @param [String] value
-    # @param [Regexp] expr
+    # @param [Regexp] expr matches characters to be encoded
     # @param [Boolean] downcase
     # @return [String]
     def normalize_segment(value, expr, downcase = false)
@@ -1339,7 +1356,7 @@ module RDF
         value = value.dup.force_encoding(Encoding::UTF_8)
         decoded = CGI.unescape(value)
         decoded.downcase! if downcase
-        URI.encode(decoded, /[^(?:#{expr})]/).force_encoding(Encoding::UTF_8)
+        URI.encode(decoded, expr).force_encoding(Encoding::UTF_8)
       end
     end
 
@@ -1364,7 +1381,7 @@ module RDF
     def self.encode(str, expr)
       str.gsub(expr) do
         us = $&
-        tmp = ''
+        tmp = String.new
         us.each_byte do |uc|
           tmp << sprintf('%%%02X', uc)
         end

data/lib/rdf/nquads.rb

@@ -22,7 +22,6 @@ module RDF
     class Format < RDF::Format
       content_type     'application/n-quads',
                        extension: :nq,
-                       alias: 'text/x-nquads;q=0.2',
                        uri: RDF::URI("http://www.w3.org/ns/formats/N-Quads")
       content_encoding 'utf-8'
 

data/lib/rdf/ntriples/format.rb

@@ -18,7 +18,6 @@ module RDF::NTriples
   class Format < RDF::Format
     content_type     'application/n-triples',
                      extension: :nt,
-                     alias: 'text/plain;q=0.2',
                      uri: RDF::URI("http://www.w3.org/ns/formats/N-Triples")
     content_encoding 'utf-8'
 

data/lib/rdf/ntriples/reader.rb

@@ -28,7 +28,7 @@ module RDF::NTriples
   #     end
   #   end
   #
-  # ** RDFStar (RDF*)
+  # ** RDF=star
   #
   # Supports statements as resources using `<<s p o>>`.
   #
@@ -60,24 +60,16 @@ module RDF::NTriples
     U_CHARS2         = Regexp.compile("\\u00B7|[\\u0300-\\u036F]|[\\u203F-\\u2040]").freeze
     IRI_RANGE        = Regexp.compile("[[^<>\"{}\|\^`\\\\]&&[^\\x00-\\x20]]").freeze
 
-    # 163s
     PN_CHARS_BASE        = /[A-Z]|[a-z]|#{U_CHARS1}/.freeze
-    # 164s
     PN_CHARS_U           = /_|#{PN_CHARS_BASE}/.freeze
-    # 166s
     PN_CHARS             = /-|[0-9]|#{PN_CHARS_U}|#{U_CHARS2}/.freeze
-    # 159s
     ECHAR                = /\\[tbnrf"'\\]/.freeze
-    # 18
+
     IRIREF               = /<((?:#{IRI_RANGE}|#{UCHAR})*)>/.freeze
-    # 141s
     BLANK_NODE_LABEL     = /_:((?:[0-9]|#{PN_CHARS_U})(?:(?:#{PN_CHARS}|\.)*#{PN_CHARS})?)/.freeze
-    # 144s
-    LANGTAG              = /@([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)/.freeze
-    # 22
+    LANG_DIR             = /@([a-zA-Z]+(?:-[a-zA-Z0-9]+)*(?:--[a-zA-Z]+)?)/.freeze
     STRING_LITERAL_QUOTE = /"((?:[^\"\\\n\r]|#{ECHAR}|#{UCHAR})*)"/.freeze
 
-    # RDF*
     ST_START              = /^<</.freeze
     ST_END                = /^\s*>>/.freeze
 
@@ -86,7 +78,7 @@ module RDF::NTriples
     NODEID                = /^#{BLANK_NODE_LABEL}/.freeze
     URIREF                = /^#{IRIREF}/.freeze
     LITERAL_PLAIN         = /^#{STRING_LITERAL_QUOTE}/.freeze
-    LITERAL_WITH_LANGUAGE = /^#{STRING_LITERAL_QUOTE}#{LANGTAG}/.freeze
+    LITERAL_WITH_LANGUAGE = /^#{STRING_LITERAL_QUOTE}#{LANG_DIR}/.freeze
     LITERAL_WITH_DATATYPE = /^#{STRING_LITERAL_QUOTE}\^\^#{IRIREF}/.freeze
     DATATYPE_URI          = /^\^\^#{IRIREF}/.freeze
     LITERAL               = Regexp.union(LITERAL_WITH_LANGUAGE, LITERAL_WITH_DATATYPE, LITERAL_PLAIN).freeze
@@ -95,6 +87,9 @@ module RDF::NTriples
     OBJECT                = Regexp.union(URIREF, NODEID, LITERAL).freeze
     END_OF_STATEMENT      = /^\s*\.\s*(?:#.*)?$/.freeze
 
+    # LANGTAG is deprecated
+    LANGTAG               = LANG_DIR
+
     ##
     # Reconstructs an RDF value from its serialized N-Triples
     # representation.
@@ -299,8 +294,10 @@ module RDF::NTriples
       if literal_str = match(LITERAL_PLAIN)
         literal_str = self.class.unescape(literal_str)
         literal = case
-          when language = match(LANGTAG)
-            RDF::Literal.new(literal_str, language: language)
+          when lang_dir = match(LANG_DIR)
+            language, direction = lang_dir.split('--')
+            raise ArgumentError if direction && !@options[:rdfstar]
+            RDF::Literal.new(literal_str, language: language, direction: direction)
           when datatype = match(/^(\^\^)/) # FIXME
             RDF::Literal.new(literal_str, datatype: read_uriref || fail_object)
           else
@@ -310,6 +307,10 @@ module RDF::NTriples
         literal.canonicalize! if canonicalize?
         literal
       end
+    rescue ArgumentError
+      v = literal_str
+      v += "@#{lang_dir}" if lang_dir
+      log_error("Invalid Literal (found: \"#{v}\")", lineno: lineno, token: "#v", exception: RDF::ReaderError)
     end
 
     ##

data/lib/rdf/ntriples/writer.rb

@@ -224,7 +224,7 @@ module RDF::NTriples
     end
 
     ##
-    # Returns the N-Triples representation of an RDF* reified statement.
+    # Returns the N-Triples representation of an RDF-star quoted triple.
     #
     # @param  [RDF::Statement] statement
     # @param  [Hash{Symbol => Object}] options ({})
@@ -312,6 +312,7 @@ module RDF::NTriples
           # Note, escaping here is more robust than in Term
           text = quoted(escaped(literal.value))
           text << "@#{literal.language}" if literal.language?
+          text << "--#{literal.direction}" if literal.direction?
           text << "^^<#{uri_for(literal.datatype)}>" if literal.datatype?
           text
         else

data/lib/rdf/ntriples.rb

@@ -8,14 +8,14 @@ module RDF
   # [Turtle](http://www.w3.org/TeamSubmission/turtle/) and
   # [Notation3](http://www.w3.org/TeamSubmission/n3/) (N3).
   #
-  # The MIME content type for N-Triples files is `text/plain` and the
+  # The MIME content type for N-Triples files is `application/n-triples` and the
   # recommended file extension is `.nt`.
   #
   # An example of an RDF statement in N-Triples format:
   #
   #     <https://rubygems.org/gems/rdf> <http://purl.org/dc/terms/title> "rdf" .
   #
-  # ## RDFStar (RDF*)
+  # ## Quoted Triples
   #
   # Supports statements as resources using `<<s p o>>`.
   #

data/lib/rdf/query/solution.rb

@@ -209,7 +209,7 @@ class RDF::Query
     # Merges the bindings from the given `other` query solution into this
     # one, overwriting any existing ones having the same name.
     #
-    # ## RDFStar (RDF*)
+    # ## RDF-star
     #
     # If merging a binding for a statement to a pattern,
     # merge their embedded solutions.

data/lib/rdf/reader.rb

@@ -133,7 +133,7 @@ module RDF
           on: ["--canonicalize"],
           control: :checkbox,
           default: false,
-          description: "Canonicalize input/output.") {true},
+          description: "Canonicalize URI/literal forms") {true},
         RDF::CLI::Option.new(
           symbol: :encoding,
           datatype: Encoding,
@@ -163,7 +163,7 @@ module RDF
           datatype: TrueClass,
           control: :checkbox,
           on: ["--rdfstar"],
-          description: "Parse RDF*."),
+          description: "Parse RDF-star for preliminary RDF 1.2 support."),
         RDF::CLI::Option.new(
           symbol: :validate,
           datatype: TrueClass,
@@ -271,13 +271,13 @@ module RDF
     #   the base URI to use when resolving relative URIs (not supported by
     #   all readers)
     # @param [Boolean]  canonicalize (false)
-    #   whether to canonicalize parsed literals
+    #   whether to canonicalize parsed URIs and Literals.
     # @param [Encoding] encoding     (Encoding::UTF_8)
     #   the encoding of the input stream
     # @param [Boolean]  intern       (true)
     #   whether to intern all parsed URIs
     # @param [Boolean] rdfstar      (false)
-    #   support parsing RDF* statement resources.
+    #   Preliminary support for RDF 1.2.
     # @param [Hash]     prefixes     (Hash.new)
     #   the prefix mappings to use (not supported by all readers)
     # @param  [Hash{Symbol => Object}] options
@@ -608,7 +608,9 @@ module RDF
     end
 
     ##
-    # Returns `true` if parsed values should be canonicalized.
+    # Returns `true` if parsed values should be in canonical form.
+    #
+    # @note This is for term canonicalization, for graph/dataset canonicalization use `RDF::Normalize`.
     #
     # @return [Boolean] `true` or `false`
     # @since  0.3.0

data/lib/rdf/repository.rb

@@ -182,7 +182,8 @@ module RDF
       when :validity         then @options.fetch(:with_validity, true)
       when :literal_equality then true
       when :atomic_write     then false
-      when :rdfstar          then false
+      when :quoted_triples   then false
+      when :base_direction   then false
       when :snapshots        then false
       else false
       end
@@ -269,7 +270,8 @@ module RDF
         when :validity         then @options.fetch(:with_validity, true)
         when :literal_equality then true
         when :atomic_write     then true
-        when :rdfstar          then true
+        when :quoted_triples   then true
+        when :base_direction   then true
         when :snapshots        then true
         else false
         end

data/lib/rdf/util/cache.rb

@@ -110,7 +110,7 @@ module RDF; module Util
 
     ##
     # This implementation uses the `WeakRef` class from Ruby's standard
-    # library, and provides adequate performance on JRuby and on Ruby 2.x.
+    # library, and provides adequate performance on JRuby and on Ruby 3.x.
     #
     # @see http://ruby-doc.org/stdlib-2.2.0/libdoc/weakref/rdoc/WeakRef.html
     class WeakRefCache < Cache
@@ -127,7 +127,7 @@ module RDF; module Util
       def [](key)
         if (ref = @cache[key])
           if ref.weakref_alive?
-            value = ref.__getobj__ rescue nil
+            ref.__getobj__ rescue nil
           else
             @cache.delete(key)
             nil

data/lib/rdf/util/uuid.rb

@@ -22,11 +22,11 @@ module RDF; module Util
       begin
         require 'uuid'
         ::UUID.generate(format)
-      rescue LoadError => e
+      rescue LoadError
         begin
           require 'uuidtools'
           ::UUIDTools::UUID.random_create.hexdigest
-        rescue LoadError => e
+        rescue LoadError
           raise LoadError.new("no such file to load -- uuid or uuidtools")
         end
       end

data/lib/rdf/vocab/rdfv.rb

@@ -92,6 +92,10 @@ module RDF
   #     # @return [RDF::Vocabulary::Term]
   #     # @attr_reader :langString
   #
+  #     # The datatype of directional language-tagged string values.
+  #     # @return [RDF::Vocabulary::Term]
+  #     # @attr_reader :dirLangString
+  #
   #     # RDF/XML node element.
   #     # @return [RDF::Vocabulary::Term]
   #     # @attr_reader :Description
@@ -283,6 +287,13 @@ module RDF
       "http://www.w3.org/2000/01/rdf-schema#seeAlso": %(http://www.w3.org/TR/rdf11-concepts/#section-Graph-Literal).freeze,
       subClassOf: "http://www.w3.org/2000/01/rdf-schema#Literal".freeze,
       type: "http://www.w3.org/2000/01/rdf-schema#Datatype".freeze
+    term :dirLangString,
+      comment: %(The datatype of directional language-tagged string values).freeze,
+      label: "dirLangString".freeze,
+      isDefinedBy: %(http://www.w3.org/1999/02/22-rdf-syntax-ns#).freeze,
+      "http://www.w3.org/2000/01/rdf-schema#seeAlso": %(http://www.w3.org/TR/rdf11-concepts/#section-Graph-Literal).freeze,
+      subClassOf: "http://www.w3.org/2000/01/rdf-schema#Literal".freeze,
+      type: "http://www.w3.org/2000/01/rdf-schema#Datatype".freeze
 
     # Extra definitions
    term :Description,

data/lib/rdf/writer.rb

@@ -392,7 +392,9 @@ module RDF
     end
 
     ##
-    # Returns `true` if terms should be canonicalized.
+    # Returns `true` if terms should be in canonical form.
+    #
+    # @note This is for term canonicalization, for graph/dataset canonicalization use `RDF::Normalize`.
     #
     # @return [Boolean] `true` or `false`
     # @since  1.0.8

data/lib/rdf.rb

@@ -5,7 +5,6 @@ require 'time'
 require "ostruct"
 
 require 'rdf/version'
-require 'rdf/extensions'
 
 module RDF
   # RDF mixins