rdf 3.2.2 → 3.2.5

data/lib/rdf/model/literal/time.rb

@@ -9,91 +9,41 @@ module RDF; class Literal
   #
   # @see   http://www.w3.org/TR/xmlschema11-2/#time
   # @since 0.2.1
-  class Time < Literal
+  class Time < Temporal
     DATATYPE = RDF::URI("http://www.w3.org/2001/XMLSchema#time")
     GRAMMAR  = %r(\A(\d{2}:\d{2}:\d{2}(?:\.\d+)?)((?:[\+\-]\d{2}:\d{2})|UTC|GMT|Z)?\Z).freeze
-    FORMAT   = '%H:%M:%S.%L%:z'.freeze
+    FORMAT   = '%H:%M:%S.%L'.freeze
 
     ##
+    # Internally, a `DateTime` is represented using a native `::DateTime`. If initialized from a `::DateTime`, the timezone is taken from that native object, otherwise, a timezone (or no timezone) is taken from the string representation having a matching `zzzzzz` component.
+    #
     # @param  [String, DateTime, #to_datetime] value
     # @param  (see Literal#initialize)
     def initialize(value, datatype: nil, lexical: nil, **options)
       @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
       @string   = lexical || (value if value.is_a?(String))
       @object   = case
-        when value.is_a?(::DateTime)         then value
-        when value.respond_to?(:to_datetime) then value.to_datetime rescue ::DateTime.parse(value.to_s)
-        else ::DateTime.parse(value.to_s)
-      end rescue ::DateTime.new
-    end
-
-    ##
-    # Converts this literal into its canonical lexical representation.
-    #
-    # §3.2.8.2 Canonical representation
-    #
-    # The canonical representation for time is defined by prohibiting
-    # certain options from the Lexical representation (§3.2.8.1).
-    # Specifically, either the time zone must be omitted or, if present, the
-    # time zone must be Coordinated Universal Time (UTC) indicated by a "Z".
-    # Additionally, the canonical representation for midnight is 00:00:00.
-    #
-    # @return [RDF::Literal] `self`
-    # @see    http://www.w3.org/TR/xmlschema11-2/#time
-    def canonicalize!
-      if self.valid?
-        @string = if timezone?
-          @object.new_offset.new_offset.strftime(FORMAT[0..-4] + 'Z').sub('.000', '')
+        when value.respond_to?(:to_datetime)
+          dt = value.to_datetime
+          @zone = dt.zone
+          # Normalize to 1972-12-31 dateTime base
+          hms = dt.strftime(FORMAT)
+          ::DateTime.parse("1972-12-31T#{hms}#{@zone}")
         else
-          @object.strftime(FORMAT[0..-4]).sub('.000', '')
-        end
-      end
-      self
-    end
-
-    ##
-    # Returns the timezone part of arg as a simple literal. Returns the empty string if there is no timezone.
-    #
-    # @return [RDF::Literal]
-    # @see http://www.w3.org/TR/sparql11-query/#func-tz
-    def tz
-      zone =  timezone? ? object.zone : ""
-      zone = "Z" if zone == "+00:00"
-      RDF::Literal(zone)
-    end
-
-    ##
-    # Returns `true` if the value adheres to the defined grammar of the
-    # datatype.
-    #
-    # Special case for date and dateTime, for which '0000' is not a valid year
-    #
-    # @return [Boolean]
-    # @since  0.2.1
-    def valid?
-      super && !object.nil?
-    end
-
-    ##
-    # Does the literal representation include a timezone? Note that this is only possible if initialized using a string, or `:lexical` option.
-    #
-    # @return [Boolean]
-    # @since 1.1.6
-    def timezone?
-      md = self.to_s.match(GRAMMAR)
-      md && !!md[2]
-    end
-    alias_method :tz?, :timezone?
-    alias_method :has_tz?, :timezone?
-    alias_method :has_timezone?, :timezone?
-
-    ##
-    # Returns the value as a string.
-    # Does not normalize timezone
-    #
-    # @return [String]
-    def to_s
-      @string || @object.strftime(FORMAT).sub("+00:00", 'Z').sub('.000', '')
+          md = value.to_s.match(GRAMMAR)
+          _, tm, tz = Array(md)
+          if tz
+            @zone = tz == 'Z' ? '+00:00' : tz
+          else
+            @zone = nil # No timezone
+          end
+          # Normalize 24:00:00 to 00:00:00
+          hr, mi, se = tm.split(':')
+          hr = "%.2i" % (hr.to_i % 24) if hr.to_i > 23
+          value = "#{hr}:#{mi}:#{se}"
+          # Normalize to 1972-12-31 dateTime base
+          ::DateTime.parse("1972-12-31T#{hr}:#{mi}:#{se}#{@zone}")
+      end rescue ::DateTime.new
     end
 
     ##
@@ -104,32 +54,10 @@ module RDF; class Literal
     def humanize(lang = :en)
       t = object.strftime("%r")
       if timezone?
-        t += if self.tz == 'Z'
-          " UTC"
-        else
-          " #{self.tz}"
-        end
+        z = @zone == '+00:00' ? "UTC" : @zone
+        t += " #{z}"
       end
       t
     end
-
-    ##
-    # Equal compares as Time objects
-    def ==(other)
-      # If lexically invalid, use regular literal testing
-      return super unless self.valid?
-
-      case other
-      when Literal::Time
-        return super unless other.valid?
-        # Compare as strings, as time includes a date portion, and adjusting for UTC
-        # can create a mismatch in the date portion.
-        self.object.new_offset.strftime('%H%M%S.%L') == other.object.new_offset.strftime('%H%M%S.%L')
-      when Literal::DateTime, Literal::Date
-        false
-      else
-        super
-      end
-    end
   end # Time
 end; end # RDF::Literal

data/lib/rdf/model/literal.rb

@@ -77,6 +77,7 @@ module RDF
     require 'rdf/model/literal/decimal'
     require 'rdf/model/literal/integer'
     require 'rdf/model/literal/double'
+    require 'rdf/model/literal/temporal'
     require 'rdf/model/literal/date'
     require 'rdf/model/literal/datetime'
     require 'rdf/model/literal/time'
@@ -295,7 +296,7 @@ module RDF
         when self.simple? && other.simple?
           self.value_hash == other.value_hash && self.value == other.value
         when other.comperable_datatype?(self) || self.comperable_datatype?(other)
-          # Comoparing plain with undefined datatypes does not generate an error, but returns false
+          # Comparing plain with undefined datatypes does not generate an error, but returns false
           # From data-r2/expr-equal/eq-2-2.
           false
         else

data/lib/rdf/model/statement.rb

@@ -71,6 +71,7 @@ module RDF
     #   @option options [RDF::Term]  :graph_name   (nil)
     #     Note, in RDF 1.1, a graph name MUST be an {Resource}.
     #   @option options [Boolean] :inferred used as a marker to record that this statement was inferred based on semantic relationships (T-Box).
+    #   @option options [Boolean] :quoted used as a marker to record that this statement quoted and appears as the subject or object of another RDF::Statement.
     #   @return [RDF::Statement]
     #
     # @overload initialize(subject, predicate, object, **options)
@@ -83,6 +84,7 @@ module RDF
     #   @option options [RDF::Term]  :graph_name   (nil)
     #     Note, in RDF 1.1, a graph name MUST be an {Resource}.
     #   @option options [Boolean] :inferred used as a marker to record that this statement was inferred based on semantic relationships (T-Box).
+    #   @option options [Boolean] :quoted used as a marker to record that this statement quoted and appears as the subject or object of another RDF::Statement.
     #   @return [RDF::Statement]
     def initialize(subject = nil, predicate = nil, object = nil, options = {})
       if subject.is_a?(Hash)
@@ -209,7 +211,7 @@ module RDF
     ##
     # @return [Boolean]
     def quoted?
-      false
+      !!@options[:quoted]
     end
 
     ##

data/lib/rdf/model/uri.rb

@@ -111,6 +111,11 @@ module RDF
       tag tel turn turns tv urn javascript
     ).freeze
 
+    # Characters in a PName which must be escaped
+    # 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
+    
     ##
     # Cache size may be set through {RDF.config} using `uri_cache_size`.
     #
@@ -627,10 +632,14 @@ module RDF
     #   RDF::URI('http://www.w3.org/2000/01/rdf-schema#').qname       #=> [:rdfs, nil]
     #   RDF::URI('http://www.w3.org/2000/01/rdf-schema#label').qname  #=> [:rdfs, :label]
     #   RDF::RDFS.label.qname                                         #=> [:rdfs, :label]
+    #   RDF::Vocab::DC.title.qname(
+    #     prefixes: {dcterms: 'http://purl.org/dc/terms/'})           #=> [:dcterms, :title]
+    #
+    # @note within this software, the term QName is used to describe the tuple of prefix and suffix for a given IRI, where the prefix identifies some defined vocabulary. This somewhat contrasts with the notion of a [Qualified Name](https://www.w3.org/TR/2006/REC-xml-names11-20060816/#ns-qualnames) from XML, which are a subset of Prefixed Names.
     #
     # @param [Hash{Symbol => String}] prefixes
     #   Explicit set of prefixes to look for matches, defaults to loaded vocabularies.
-    # @return [Array(Symbol, Symbol)] or `nil` if no QName found
+    # @return [Array(Symbol, Symbol)] or `nil` if no QName found. The suffix component will not have [reserved characters](https://www.w3.org/TR/turtle/#reserved) escaped.
     def qname(prefixes: nil)
       if prefixes
         prefixes.each do |prefix, uri|
@@ -659,13 +668,25 @@ module RDF
     end
 
     ##
-    # Returns a string version of the QName or the full IRI
+    # Returns a Prefixed Name (PName) or the full IRI with any [reserved characters](https://www.w3.org/TR/turtle/#reserved) in the suffix escaped.
+    #
+    # @example Using a custom prefix for creating a PNname.
+    #   RDF::URI('http://purl.org/dc/terms/creator').
+    #     pname(prefixes: {dcterms: 'http://purl.org/dc/terms/'})
+    #     #=> "dcterms:creator"
     #
     # @param [Hash{Symbol => String}] prefixes
     #   Explicit set of prefixes to look for matches, defaults to loaded vocabularies.
     # @return [String] or `nil`
+    # @see #qname
+    # @see https://www.w3.org/TR/rdf-sparql-query/#prefNames
     def pname(prefixes: nil)
-      (q = self.qname(prefixes: prefixes)) ? q.join(":") : to_s
+      q = self.qname(prefixes: prefixes)
+      return self.to_s unless q
+      prefix, suffix = q
+      suffix = suffix.to_s.gsub(PN_ESCAPE_CHARS) {|c| "\\#{c}"} if
+        suffix.to_s.match?(PN_ESCAPE_CHARS)
+      [prefix, suffix].join(":")
     end
 
     ##

data/lib/rdf/ntriples/reader.rb

@@ -255,7 +255,7 @@ module RDF::NTriples
         if !match(ST_END)
           log_error("Expected end of statement (found: #{current_line.inspect})", lineno: lineno, exception: RDF::ReaderError)
         end
-        RDF::Statement.new(subject, predicate, object)
+        RDF::Statement.new(subject, predicate, object, quoted: true)
       end
     end