rdf-xsd 3.2.0 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 171331f779259dbadcce5879cc66d99684b13bee789bb681621aad87c72d0baa
-  data.tar.gz: 4b043323c4f66549b0dbeec293bdf462b753960836f23e6c1b33c43d7a519ac3
+  metadata.gz: 8a344fd7adc4bd8ca84e939dcf26daf656c19e5f60d04b2026ed18393b07a6d9
+  data.tar.gz: fd035fb32fb4719ebcc72f7a133d64c690d20c9f8a8276b18d801625317119b2
 SHA512:
-  metadata.gz: 1d9d455005767e17091c7c20721fd72058d5520e47676cced291ff81824a083886ae49913830d0a404bc3ea3098bdcc6ab02638b0d3098c73753d95bf2aab81d
-  data.tar.gz: cfb0f759ef10a18d4036671f9ee5ab90630d58b55233b2f9ab9b1be775921d77d6045100a1aef0a97ae21d3ba085eda063269ada7d88f31fad9ffc82b9e812a2
+  metadata.gz: 303a3003b754327c637caf02ca34c27fc52e50b25302dee1f2cf0d2f820d61e431814c92a5e6af4b9af8511de699f5f841c789a1719dbbe0f36a1a3c96db29ce
+  data.tar.gz: 63cf8178d9118864fc09b26539e95a33062309e10de38eed5b1f0c769d7bd6be47eca8a51d77e77d2faf2545bcd7e032f020a6e326400c804941d0ebc7b0f34f

data/README.md

@@ -1,6 +1,6 @@
-# Extended XSD Datatypes for RDF.rb
+# Extended XSD Datatypes and XQuery functions for RDF.rb
 
-This gem adds additional RDF::Literal subclasses for extended [XSD datatypes][]
+This gem adds additional RDF::Literal subclasses for extended [XSD datatypes][] along with methods implementing many [XPath and XQuery Functions][]
 
 [![Gem Version](https://badge.fury.io/rb/rdf-xsd.png)](https://badge.fury.io/rb/rdf-xsd)
 [![Build Status](https://github.com/ruby-rdf/rdf-xsd/workflows/CI/badge.svg?branch=develop)](https://github.com/ruby-rdf/rdf-xsd/actions?query=workflow%3ACI)
@@ -11,10 +11,10 @@ This gem adds additional RDF::Literal subclasses for extended [XSD datatypes][]
 
 * Additional xsd:integer subtypes
 * xsd:float based on xsd:double
-* xsd:duration
+* xsd:duration, xsd:yearMonthDuration, and xsd:dayTimeDuration.
 * rdf:XMLLiteral
 * XML Exclusive Canonicalization (Nokogiri & REXML)
-* XML Literal comparisions (EquivalentXml, ActiveSupport or String)
+* XML Literal comparisons (EquivalentXml, ActiveSupport or String)
 
 ## Examples
 
@@ -29,25 +29,27 @@ This gem adds additional RDF::Literal subclasses for extended [XSD datatypes][]
 * Soft dependency on [ActiveSupport](https://rubygems.org/gems/activesupport) (~> 6.2)
 
 ## Documentation
-Full documentation available on [Rubydoc.info][XSD doc]
+Full documentation available on [GitHub][XSD doc]
 
 ### Principle Classes
 * {RDF::Literal::Base64Binary}
 * {RDF::Literal::Duration}
+    * {RDF::Literal::YearMonthDuration}
+    * {RDF::Literal::DayTimeDuration}
 * {RDF::Literal::Float}
 * {RDF::Literal::HexBinary}
 * {RDF::Literal::NonPositiveInteger}
-  * {RDF::Literal::NegativeInteger}
+    * {RDF::Literal::NegativeInteger}
 * {RDF::Literal::Long}
-  * {RDF::Literal::Int}
-    * {RDF::Literal::Short}
-      * {RDF::Literal::Byte}
+    * {RDF::Literal::Int}
+        * {RDF::Literal::Short}
+            * {RDF::Literal::Byte}
 * {RDF::Literal::NonNegativeInteger}
-  * {RDF::Literal::PositiveInteger}
-  * {RDF::Literal::UnsignedLong}
-    * {RDF::Literal::UnsignedInt}
-      * {RDF::Literal::UnsignedShort}
-        * {RDF::Literal::UnsignedByte}
+    * {RDF::Literal::PositiveInteger}
+    * {RDF::Literal::UnsignedLong}
+        * {RDF::Literal::UnsignedInt}
+            * {RDF::Literal::UnsignedShort}
+                * {RDF::Literal::UnsignedByte}
 * {RDF::Literal::YearMonth}
 * {RDF::Literal::Year}
 * {RDF::Literal::MonthDay}
@@ -100,4 +102,6 @@ Portions of tests are derived from [W3C DAWG tests](https://www.w3.org/2001/sw/D
 [YARD-GS]:    https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
 [PDD]:              https://unlicense.org/#unlicensing-contributions
 [Backports]:  https://rubygems.org/gems/backports
-[XSD Datatypes]: https://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#built-in-datatypes
+[XSD Datatypes]: https://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#built-in-datatypes
+[XPath and XQuery Functions]: https://www.w3.org/TR/xpath-functions/
+[XSD Doc]: https://ruby-rdf.github.io/rdf-xsd

data/VERSION

@@ -1 +1 @@
-3.2.0
+3.2.1

data/lib/rdf/xsd/date.rb

@@ -11,7 +11,7 @@ module RDF; class Literal
   class DateTimeStamp < RDF::Literal::DateTime
     DATATYPE = RDF::XSD.dateTimeStamp
     GRAMMAR  = %r(\A(-?\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?)((?:[\+\-]\d{2}:\d{2})|UTC|GMT|Z)\Z).freeze
-    FORMAT   = '%Y-%m-%dT%H:%M:%SZ'.freeze
+    FORMAT   = '%Y-%m-%dT%H:%M:%S'.freeze
   end
 
   ##
@@ -24,7 +24,7 @@ module RDF; class Literal
   class YearMonth < RDF::Literal::Date
     DATATYPE = RDF::XSD.gYearMonth
     GRAMMAR  = %r(\A(-?\d{4,}-\d{2})((?:[\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
-    FORMAT   = '%Y-%m%Z'.freeze
+    FORMAT   = '%Y-%m'.freeze
     
     def initialize(value, datatype: nil, lexical: nil, **options)
       @string = lexical || value.to_s
@@ -42,7 +42,7 @@ module RDF; class Literal
   class Year < RDF::Literal::Date
     DATATYPE = RDF::XSD.gYear
     GRAMMAR  = %r(\A(-?\d{4,})((?:[\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
-    FORMAT   = '%Y%Z'.freeze
+    FORMAT   = '%Y'.freeze
 
     def initialize(value, datatype: nil, lexical: nil, **options)
       @string = lexical || value.to_s
@@ -60,7 +60,7 @@ module RDF; class Literal
   class MonthDay < RDF::Literal::Date
     DATATYPE = RDF::XSD.gMonthDay
     GRAMMAR  = %r(\A--(\d{2}-\d{2})((?:[\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
-    FORMAT   = '%m-%d%Z'.freeze
+    FORMAT   = '%m-%d'.freeze
 
     def initialize(value, datatype: nil, lexical: nil, **options)
       @string = lexical || value.to_s
@@ -78,7 +78,7 @@ module RDF; class Literal
   class Day < RDF::Literal::Date
     DATATYPE = RDF::XSD.gDay
     GRAMMAR  = %r(\A---(\d{2})((?:[\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
-    FORMAT   = '%d%Z'.freeze
+    FORMAT   = '%d'.freeze
 
     def initialize(value, datatype: nil, lexical: nil, **options)
       @string = lexical || value.to_s
@@ -95,7 +95,7 @@ module RDF; class Literal
   class Month < RDF::Literal::Date
     DATATYPE = RDF::XSD.gMonth
     GRAMMAR  = %r(\A--(\d{2})((?:[\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
-    FORMAT   = '%m%Z'.freeze
+    FORMAT   = '%m'.freeze
 
     def initialize(value, datatype: nil, lexical: nil, **options)
       @string = lexical || value.to_s

data/lib/rdf/xsd/duration.rb

@@ -5,6 +5,8 @@ module RDF; class Literal
   ##
   # A duration literal.
   #
+  # `duration` is a datatype that represents durations of time.  The concept of duration being captured is drawn from those of [ISO 8601](https://www.w3.org/TR/xmlschema11-2/#ISO8601), specifically durations without fixed endpoints.
+  #
   # @see   https://www.w3.org/TR/xmlschema11-2/#duration
   class Duration < Literal
     DATATYPE = RDF::XSD.duration
@@ -14,12 +16,12 @@ module RDF; class Literal
           |  (?:(?:(?<mo>\d+)M)(?:(?<da>\d+)D)?)
           |  (?:(?<da>\d+)D)
           )
-          (?:T(?:(?:(?:(?<hr>\d+)H)(?:(?<mi>\d+)M)?(?<se>\d+(?:\.\d+)?S)?)
+          (?:T(?:(?:(?:(?<hr>\d+)H)(?:(?<mi>\d+)M)?(?:(?<se>\d+(?:\.\d+)?)S)?)
               |  (?:(?:(?<mi>\d+)M)(?:(?<se>\d+(?:\.\d+)?)S)?)
               |  (?:(?<se>\d+(?:\.\d+)?)S)
               )
           )?
-       |(?:T(?:(?:(?:(?<hr>\d+)H)(?:(?<mi>\d+)M)?(?<se>\d+(?:\.\d+)?S)?)
+       |(?:T(?:(?:(?:(?<hr>\d+)H)(?:(?<mi>\d+)M)?(?:(?<se>\d+(?:\.\d+)?)S)?)
             |  (?:(?:(?<mi>\d+)M)(?:(?<se>\d+(?:\.\d+)?)S)?)
             |   (?:(?<se>\d+(?:\.\d+)?)S)
             )
@@ -28,66 +30,59 @@ module RDF; class Literal
     \z)x.freeze
 
     ##
-    # * Given a Numeric, assumes that it is milliseconds
-    # * Given a String, parse as xsd:duration
-    # * Hash form is used for internal representation
-    # @param  [Duration, Hash, Numeric, #to_s] value
-    # @option options [String] :lexical (nil)
+    # Creates a new Duration instance.
+    #
+    # * Given a `String`, parse as `xsd:duration` into months and seconds
+    # * Given a `Hash` containing any of `:yr`, `:mo`, :da`, `:hr`, `:mi` and `:si`, it is transformed into months and seconds
+    # * Given a Rational, the result is interpreted as days, hours, minutes, and seconds.
+    # * Given an Integer, the result is interpreted as years and months.
+    # * Object representation is the `Array(months, seconds)`
+    #
+    # @param  [Literal::Duration, Hash, Array, Literal::Numeric, #to_s] value
+    #   If provided an Array, it is the same as the object form of this literal, an array of two integers, the first of which may be negative.
+    # @param [String]  lexical (nil)
+    #   Supplied lexical representation of this literal,
+    #   otherwise it comes from transforming `value` to a string form..
+    # @param [URI]     datatype (nil)
+    # @param [Hash{Symbol => Object}] options other options passed to `RDF::Literal#initialize`.
+    # @option options [Boolean] :validate (false)
+    # @option options [Boolean] :canonicalize (false)
     def initialize(value, datatype: nil, lexical: nil, **options)
       super
       @object   = case value
       when Hash
-        value = value.dup
-        value[:yr] ||= value[:years]
-        value[:mo] ||= value[:months]
-        value[:da] ||= value[:days]
-        value[:hr] ||= value[:hours]
-        value[:mi] ||= value[:minutes]
-        value[:se] ||= value[:seconds]
-        
-        value
-      when Duration, Numeric
-        {:se => value.to_f}
-      else
-        parse(value.to_s)
+        months = value[:yr].to_i * 12 + value[:mo].to_i
+        seconds = value[:da].to_i * 3600 * 24 +
+                  value[:hr].to_i * 3600 +
+                  value[:mi].to_i * 60 +
+                  value[:se].to_f
+
+        if value[:si]
+          if months != 0
+            months = -months
+          else
+            seconds = -seconds
+          end
+        end
+        [months, seconds]
+      when Rational
+        [0, value * 24 * 3600]
+      when Integer, ::Integer
+        [value.to_i, 0]
+      when Literal::Duration then value.object
+      when Array then    value
+      else               parse(value.to_s)
       end
     end
 
     ##
     # Converts this literal into its canonical lexical representation.
     #
-    # Also normalizes elements
-    #
-    # @return [RDF::Literal] `self`
+    # @return [Literal] `self`
     # @see    https://www.w3.org/TR/xmlschema11-2/#dateTime
     def canonicalize!
-      @string = @humanize = nil
-      if @object[:se].to_i > 60
-        m_r = (@object[:se].to_f / 60) - 1
-        @object[:se] -=  m_r * 60
-        @object[:mi] = @object[:mi].to_i + m_r
-      end
-      if @object[:mi].to_i > 60
-        h_r = (@object[:mi].to_i / 60) - 1
-        @object[:mi] -=  h_r * 60
-        @object[:hr] = @object[:hr].to_i +  h_r
-      end
-      if @object[:hr].to_i > 24
-        d_r = (@object[:hr].to_i / 24) - 1
-        @object[:hr] -=  d_r * 24
-        @object[:da] = @object[:da].to_i + d_r
-      end
-      if @object[:da].to_i > 30
-        m_r = (@object[:da].to_i / 30) - 1
-        @object[:da] -=  m_r * 30
-        @object[:mo] = @object[:mo].to_i + m_r
-      end
-      if @object[:mo].to_i > 12
-        y_r = (@object[:mo].to_i / 12) - 1
-        @object[:mo] -=  y_r * 12
-        @object[:yr] = @object[:yr].to_i + y_r
-      end
-      @object.to_s  # side-effect
+      @string = @humanize = @hash = nil
+      self.to_s  # side-effect
       self
     end
 
@@ -99,7 +94,23 @@ module RDF; class Literal
     #
     # @return [Boolean]
     def valid?
-      !!(value =~ GRAMMAR)
+      !!value.match?(self.class.const_get(:GRAMMAR))
+    end
+
+    ##
+    # Returns a hash representation.
+    #
+    # @return [Hash]
+    def to_h
+      @hash ||= {
+        si: ('-' if (@object.first == 0 ? @object.last : @object.first) < 0),
+        yr: (@object.first.abs / 12),
+        mo: (@object.first.abs % 12),
+        da: (@object.last.abs.to_i / (3600 * 24)),
+        hr: ((@object.last.abs.to_i / 3600) % 24),
+        mi: ((@object.last.abs.to_i / 60) % 60),
+        se: sec_str.to_f
+      }
     end
 
     ##
@@ -108,14 +119,22 @@ module RDF; class Literal
     # @return [String]
     def to_s
       @string ||= begin
-        str = @object[:si] == '-' ? "-P" : "P"
-        str << "%dY" % @object[:yr].to_i if @object[:yr]
-        str << "%dM" % @object[:mo].to_i if @object[:mo]
-        str << "%dD" % @object[:da].to_i if @object[:da]
-        str << "T" if @object[:hr] || @object[:mi] || @object[:se]
-        str << "%dH" % @object[:hr].to_i if @object[:hr]
-        str << "%dM" % @object[:mi].to_i if @object[:mi]
-        str << "#{sec_str}S" if @object[:se]
+        hash = to_h
+        str = (@object.first == 0 ? @object.last : @object.first) < 0 ? '-P' : 'P'
+        hash = to_h
+        str << "%dY" % hash[:yr] if hash[:yr] > 0
+        str << "%dM" % hash[:mo] if hash[:mo] > 0
+        str << "%dD" % hash[:da] if hash[:da] > 0
+        str << "T" if (hash[:hr] + hash[:mi] + hash[:se]) > 0
+        str << "%dH" % hash[:hr] if hash[:hr] > 0
+        str << "%dM" % hash[:mi] if hash[:mi] > 0
+        str << sec_str + 'S' if hash[:se] > 0
+        # Ensure some legal representation
+        if str.end_with?('P')
+          is_a?(Literal::YearMonthDuration) ? 'P0M' : 'PT0S'
+        else
+          str
+        end
       end
     end
 
@@ -129,57 +148,85 @@ module RDF; class Literal
       @humanize ||= {}
       @humanize[lang] ||= begin
         # Just english, for now
+        return "Invalid duration #{value.to_s.inspect}" unless valid?
+
+        md = value.match(GRAMMAR)
         ar = []
-        ar << plural(@object[:yr], "year")
-        ar << plural(@object[:mo], "month")
-        ar << plural(@object[:da], "day")
-        ar << plural(@object[:hr], "hour")
-        ar << plural(@object[:mi], "minute")
-        ar << plural(sec_str, "second") if @object[:se]
-        ar = ar.compact
+        ar << plural(md[:yr], "year") if md[:yr]
+        ar << plural(md[:mo], "month") if md[:mo]
+        ar << plural(md[:da], "day") if md[:da]
+        ar << plural(md[:hr], "hour") if md[:hr]
+        ar << plural(md[:mi], "minute") if md[:mi]
+        ar << plural(md[:se], "second") if md[:se]
         last = ar.pop
         first = ar.join(" ")
         res = first.empty? ? last : "#{first} and #{last}"
-        @object[:si] == '-' ? "#{res} ago" : res
+        md[:si] == '-' ? "#{res} ago" : res
       end
     end
 
     ##
-    # Equal compares as DateTime objects
+    # Returns `true` if `self` and `other` are durations of the same length.
+    #
+    # From the XQuery function [op:duration-equal](https://www.w3.org/TR/xpath-functions/#func-duration-equal).
+    #
+    # @see https://www.w3.org/TR/xpath-functions/#func-duration-equal
     def ==(other)
       # If lexically invalid, use regular literal testing
       return super unless self.valid?
 
-      case other
-      when Duration
-        return super unless other.valid?
-        self.to_f == other.to_f
-      when String
-        self.to_s(:xml) == other
-      when Numeric
-        self.to_f == other
-      when Literal::DateTime, Literal::Time, Literal::Date
-        false
-      else
-        super
-      end
+      other.is_a?(Literal::Duration) && other.valid? ? @object == other.object : super
     end
 
-    # @return [Float]
-    def to_f
-      ( @object[:yr].to_i * 365 * 24 * 3600 +
-        @object[:mo].to_i * 30 * 24 * 3600 +
-        @object[:da].to_i * 24 * 3600 +
-        @object[:hr].to_i * 3600 +
-        @object[:mi].to_i * 60 +
-        @object[:se].to_f
-      ) * (@object[:si] == '-' ? -1 : 1)
-    end
+    # Years
+    #
+    # From the XQuery function [fn:years-from-duration](https://www.w3.org/TR/xpath-functions/#func-years-from-duration).
+    #
+    # @return [Integer]
+    # @see https://www.w3.org/TR/xpath-functions/#func-years-from-duration
+    def years; Integer.new(to_h[:yr] * (to_h[:si] ? -1 : 1)); end
 
+    # Months
+    #
+    # From the XQuery function [fn:months-from-duration](https://www.w3.org/TR/xpath-functions/#func-months-from-duration).
+    #
     # @return [Integer]
-    def to_i; Integer(self.to_f); end
-    
-    private
+    # @see https://www.w3.org/TR/xpath-functions/#func-months-from-duration
+    def months; Integer.new(to_h[:mo] * (to_h[:si] ? -1 : 1)); end
+
+    # Days
+    #
+    # From the XQuery function [fn:days-from-duration](https://www.w3.org/TR/xpath-functions/#func-days-from-duration).
+    #
+    # @return [Integer]
+    # @see https://www.w3.org/TR/xpath-functions/#func-days-from-duration
+    def days; Integer.new(to_h[:da] * (to_h[:si] ? -1 : 1)); end
+
+    # Hours
+    #
+    # From the XQuery function [fn:hours-from-duration](https://www.w3.org/TR/xpath-functions/#func-hours-from-duration).
+    #
+    # @return [Integer]
+    # @see https://www.w3.org/TR/xpath-functions/#func-hours-from-duration
+    def hours; Integer.new(to_h[:hr] * (to_h[:si] ? -1 : 1)); end
+
+    # Minutes
+    #
+    # From the XQuery function [fn:minutes-from-duration](https://www.w3.org/TR/xpath-functions/#func-minutes-from-duration).
+    #
+    # @return [Integer]
+    # @see https://www.w3.org/TR/xpath-functions/#func-minutes-from-duration
+    def minutes; Integer.new(to_h[:mi] * (to_h[:si] ? -1 : 1)); end
+
+    # Seconds
+    #
+    # From the XQuery function [fn:seconds-from-duration](https://www.w3.org/TR/xpath-functions/#func-seconds-from-duration).
+    #
+    # @return [Decimal]
+    # @see https://www.w3.org/TR/xpath-functions/#func-seconds-from-duration
+    def seconds; Decimal.new(to_h[:se] * (to_h[:si] ? -1 : 1)); end
+
+  private
     # Reverse convert from XSD version of duration
     # XSD allows -P1111Y22M33DT44H55M66.666S with any combination in regular order
     # We assume 1M == 30D, but are out of spec in this regard
@@ -188,22 +235,137 @@ module RDF; class Literal
     # @param [String] value XSD formatted duration
     # @return [Duration]
     def parse(value)
-      value.to_s.match(GRAMMAR)
+      return [0, 0] unless md = value.to_s.match(GRAMMAR)
+
+      months  = md[:yr].to_i * 12 + md[:mo].to_i
+      seconds = md[:da].to_i * 3600 * 24 +
+                md[:hr].to_i * 3600 +
+                md[:mi].to_i * 60 +
+                md[:se].to_f
+
+      if md[:si]
+        if months != 0
+          months = -months
+        else
+          seconds = -seconds
+        end
+      end
+
+      [months, seconds]
     end
     
     def sec_str
-      sec = @object[:se].to_f
+      sec = @object.last.abs % 60
       ((sec.truncate == sec ? "%d" : "%2.3f") % sec).sub(/(\.[1-9]+)0+$/, '\1')
     end
   end # Duration
 
+  ##
+  # A `YearMonthDuration` literal.
+  #
+  # `yearMonthDuration` is a datatype ·derived· from `xsd:duration` by restricting its ·lexical representations· to instances of `yearMonthDurationLexicalRep`.  The ·value space· of `yearMonthDuration` is therefore that of `duration` restricted to those whose ·seconds· property is 0.  This results in a `duration` datatype which is totally ordered.
+  #
+  # @see   https://www.w3.org/TR/xmlschema11-2/#yearMonthDuration
+  class YearMonthDuration < Duration
+    DATATYPE = RDF::XSD.yearMonthDuration
+    GRAMMAR  = %r(\A
+      (?<si>-)?
+      P(?:(?:(?:(?:(?<yr>\d+)Y)(?:(?<mo>\d+)M)?)
+          |  (?:(?:(?<mo>\d+)M))
+          )
+       )
+    \z)x.freeze
+
+    ##
+    # Returns the sum of two xs:yearMonthDuration values.
+    #
+    # From the XQuery function [op:add-yearMonthDurations](https://www.w3.org/TR/xpath-functions/#func-add-yearMonthDurations).
+    #
+    # @param [YearMonthDuration] other
+    # @return [YearMonthDuration] 
+    # @see https://www.w3.org/TR/xpath-functions/#func-add-yearMonthDurations
+    def +(other)
+      return type_error("#{other.inspect} is not a valid YearMonthDuration") unless other.is_a?(Literal::YearMonthDuration) && other.valid?
+      self.class.new([object.first + other.object.first, 0])
+    end
+
+    ##
+    # Returns the result of subtracting one xs:yearMonthDuration value from another.
+    #
+    # From the XQuery function [op:subtract-yearMonthDurations](https://www.w3.org/TR/xpath-functions/#func-subtract-yearMonthDurations).
+    #
+    # @param [YearMonthDuration] other
+    # @return [YearMonthDuration] 
+    # @see https://www.w3.org/TR/xpath-functions/#func-subtract-yearMonthDurations
+    def -(other)
+      return type_error("#{other.inspect} is not a valid YearMonthDuration") unless other.is_a?(Literal::YearMonthDuration) && other.valid?
+      self.class.new([object.first - other.object.first, 0])
+    end
+
+    ##
+    # Returns the result of multiplying the value of self by `other`. The result is rounded to the nearest month.
+    #
+    # From the XQuery function [op:multiply-yearMonthDuration](https://www.w3.org/TR/xpath-functions/#func-multiply-yearMonthDuration).
+    #
+    # @param [Literal::Numeric, ::Numeric, DayTimeDuration] other
+    # @return [YearMonthDuration] 
+    # @see https://www.w3.org/TR/xpath-functions/#func-multiply-yearMonthDuration
+    def *(other)
+      return type_error("#{other.inspect} is not a valid Numeric") unless (other.is_a?(::Numeric) || other.is_a?(Literal::Numeric))
+      self.class.new([(object.first * other.to_f).round, 0])
+    end
+
+    ##
+    # Returns the result of dividing the value of self by `other`. The result is rounded to the nearest month.
+    #
+    # From the XQuery functions [op:divide-yearMonthDuration](https://www.w3.org/TR/xpath-functions/#func-divide-yearMonthDuration) and [op:divide-yearMonthDuration-by-yearMonthDuration](https://www.w3.org/TR/xpath-functions/#func-divide-yearMonthDuration-by-yearMonthDuration).
+    #
+    # @param [Literal::Numeric, ::Numeric, YearMonthDuration] other
+    # @return [YearMonthDuration, Decimal] 
+    # @see https://www.w3.org/TR/xpath-functions/#func-divide-yearMonthDuration
+    # @see https://www.w3.org/TR/xpath-functions/#func-divide-yearMonthDuration-by-yearMonthDuration
+    def /(other)
+      case other
+      when Literal::YearMonthDuration
+        return type_error("#{other.inspect} is not a valid YearMonthDuration or Numeric") unless other.valid?
+        Decimal.new(object.first / other.object.first.to_f)
+      when Literal::Numeric, ::Numeric
+        self.class.new([(object.first / other.to_f).round, 0])
+      else
+        type_error("#{other.inspect} is not a valid YearMonthDuration or Numeric")
+      end
+    end
+
+    ##
+    # Compares this literal to `other` for sorting purposes.
+    #
+    # From the XQuery function [op:yearMonthDuration-greater-than](https://www.w3.org/TR/xpath-functions/#func-yearMonthDuration-less-than).
+    #
+    # @param [Literal::YearMonthDuration] other
+    # @return [Boolean] `true` if less than other for defined datatypes
+    # @see https://www.w3.org/TR/xpath-functions/#func-yearMonthDuration-less-than
+    # @see https://www.w3.org/TR/xpath-functions/#func-yearMonthDuration-greater-than
+    def <=>(other)
+      return type_error("#{other.inspect} is not a valid YearMonthDuration") unless other.is_a?(Literal::YearMonthDuration) && other.valid?
+      @object.first <=> other.object.first
+    end
+
+    ##
+    # Converts the dayTimeDuration into rational seconds.
+    #
+    # @return [Rational]
+    def to_i
+      object.first.to_i
+    end
+  end # YearMonthDuration
+
   ##
   # A DayTimeDuration literal.
   #
-  # dayTimeDuration is a datatype ·derived· from duration by restricting its ·lexical representations· to instances of dayTimeDurationLexicalRep. The ·value space· of dayTimeDuration is therefore that of duration restricted to those whose ·months· property is 0.  This results in a duration datatype which is totally ordered.
+  # `dayTimeDuration` is a datatype ·derived· from `duration` by restricting its ·lexical representations· to instances of `dayTimeDurationLexicalRep`. The ·value space· of `dayTimeDuration` is therefore that of `duration` restricted to those whose ·months· property is 0.  This results in a duration datatype which is totally ordered.
   #
   # @see   https://www.w3.org/TR/xmlschema11-2/#dayTimeDuration
-  class DayTimeDuration < Literal
+  class DayTimeDuration < Duration
     DATATYPE = RDF::XSD.dayTimeDuration
     GRAMMAR  = %r(\A
       (?<si>-)?
@@ -221,22 +383,87 @@ module RDF; class Literal
         )
        )
     \z)x.freeze
-  end # DayTimeDuration
 
-  ##
-  # A YearMonthDuration literal.
-  #
-  # yearMonthDuration is a datatype ·derived· from duration by restricting its ·lexical representations· to instances of yearMonthDurationLexicalRep.  The ·value space· of yearMonthDuration is therefore that of duration restricted to those whose ·seconds· property is 0.  This results in a duration datatype which is totally ordered.
-  #
-  # @see   https://www.w3.org/TR/xmlschema11-2/#yearMonthDuration
-  class YearMonthDuration < Literal
-    DATATYPE = RDF::XSD.yearMonthDuration
-    GRAMMAR  = %r(\A
-      (?<si>-)?
-      P(?:(?:(?:(?:(?<yr>\d+)Y)(?:(?<mo>\d+)M)?)
-          |  (?:(?:(?<mo>\d+)M))
-          )
-       )
-    \z)x.freeze
+    ##
+    # Returns the sum of two xs:dayTimeDuration values.
+    #
+    # From the XQuery function [op:add-dayTimeDurations](https://www.w3.org/TR/xpath-functions/#func-add-dayTimeDurations).
+    #
+    # @param [DayTimeDuration] other
+    # @return [DayTimeDuration] 
+    # @see https://www.w3.org/TR/xpath-functions/#func-add-dayTimeDurations
+    def +(other)
+      return type_error("#{other.inspect} is not a valid DayTimeDuration") unless other.is_a?(Literal::DayTimeDuration) && other.valid?
+      self.class.new([0, object.last + other.object.last])
+    end
+
+    ##
+    # Returns the result of subtracting one xs:dayTimeDuration value from another.
+    #
+    # From the XQuery function [op:subtract-dayTimeDurationss](https://www.w3.org/TR/xpath-functions/#func-subtract-dayTimeDurations).
+    #
+    # @param [DayTimeDuration] other
+    # @return [DayTimeDuration] 
+    # @see https://www.w3.org/TR/xpath-functions/#func-subtract-dayTimeDurations
+    def -(other)
+      return type_error("#{other.inspect} is not a valid DayTimeDuration")  unless other.is_a?(Literal::DayTimeDuration) && other.valid?
+      self.class.new([0, object.last - other.object.last])
+    end
+
+    ##
+    # Returns the result of multiplying the value of self by `other`. The result is rounded to the nearest month.
+    #
+    # From the XQuery function [op:multiply-dayTimeDuration](https://www.w3.org/TR/xpath-functions/#func-multiply-dayTimeDuration).
+    #
+    # @param [Literal::Numeric, ::Numeric] other
+    # @return [DayTimeDuration] 
+    # @see https://www.w3.org/TR/xpath-functions/#func-multiply-dayTimeDuration
+    def *(other)
+      return type_error("#{other.inspect} is not a valid Numeric")  unless (other.is_a?(::Numeric) || other.is_a?(Literal::Numeric))
+      self.class.new([0, object.last * other.to_f])
+    end
+
+    ##
+    # Returns the result of dividing the value of self by `other`. The result is rounded to the nearest month.
+    #
+    # From the XQuery functions [op:divide-yearMonthDuration](https://www.w3.org/TR/xpath-functions/#func-divide-dayTimeDuration) and [op:divide-yearMonthDuration-by-yearMonthDuration](https://www.w3.org/TR/xpath-functions/#func-divide-dayTimeDuration-by-dayTimeDuration).
+    #
+    # @param [Literal::Numeric, ::Numeric, DayTimeDuration] other
+    # @return [DayTimeDuration, Decimal] 
+    # @see https://www.w3.org/TR/xpath-functions/#func-divide-dayTimeDuration
+    # @see https://www.w3.org/TR/xpath-functions/#func-divide-dayTimeDuration-by-dayTimeDuration
+    def /(other)
+      case other
+      when DayTimeDuration
+        return type_error("#{other.inspect} is not a valid DayTimeDuration or Numeric")  unless other.valid?
+        Decimal.new(object.last / other.object.last.to_f)
+      when Literal::Numeric, ::Numeric
+        self.class.new([0, object.last / other.to_f])
+      else
+        type_error("#{other.inspect} is not a valid DayTimeDuration or Numeric") 
+      end
+    end
+
+    ##
+    # Compares this literal to `other` for sorting purposes.
+    #
+    # From the XQuery function [op:dayTimeDuration-less-than](https://www.w3.org/TR/xpath-functions/#func-dayTimeDuration-less-than).
+    #
+    # @param [DayTimeDuration] other
+    # @return [Boolean] `true` if less than other for defined datatypes
+    # @see https://www.w3.org/TR/xpath-functions/#func-dayTimeDuration-less-than
+    # @see https://www.w3.org/TR/xpath-functions/#func-dayTimeDuration-greater-than
+    def <=>(other)
+      return type_error("#{other.inspect} is not a valid DayTimeDuration") unless other.is_a?(Literal::DayTimeDuration) && other.valid?
+      @object.last <=> other.object.last
+    end
+
+    ##
+    # Converts the dayTimeDuration into rational seconds.
+    #
+    # @return [Rational]
+    def to_r
+      Rational(object.last) / (24 * 3600)
+    end
   end # DayTimeDuration
 end; end # RDF::Literal

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf-xsd
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.2.1
 platform: ruby
 authors:
 - Gregg
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-06 00:00:00.000000000 Z
+date: 2022-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -109,7 +109,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-description: Adds RDF::Literal subclasses for extended XSD datatypes.
+description: Adds RDF::Literal subclasses for extended XSD datatypes with methods
+  for many XPath and XQuery functions.
 email: public-rdf-ruby@w3.org
 executables: []
 extensions: []
@@ -132,7 +133,12 @@ files:
 homepage: https://github.com/ruby-rdf/rdf-xsd
 licenses:
 - Unlicense
-metadata: {}
+metadata:
+  documentation_uri: https://ruby-rdf.github.io/rdf-xsd
+  bug_tracker_uri: https://github.com/ruby-rdf/rdf-xsd/issues
+  homepage_uri: https://github.com/ruby-rdf/rdf-xsd
+  mailing_list_uri: https://lists.w3.org/Archives/Public/public-rdf-ruby/
+  source_code_uri: https://github.com/ruby-rdf/rdf-xsd
 post_install_message: |2
 
     For best results, use nokogiri and equivalent-xml gems as well.
@@ -154,5 +160,5 @@ requirements: []
 rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
-summary: Extended XSD Datatypes for RDF.rb.
+summary: Extended XSD Datatypes and XPath and XQuery functions for RDF.rb.
 test_files: []