openehr 2.0.2 → 2.3.0

data/lib/openehr/parser/xml_primitive_parsing.rb

@@ -0,0 +1,145 @@
+module OpenEHR
+  module Parser
+    # The 8 C_PRIMITIVE readers (boolean/string/integer/real/date/
+    # date_time/time/duration), shared between OPTParser and
+    # XMLArchetypeParser - both read a <item xsi:type="C_*">-wrapped
+    # element with the same internal shape. Extracted from opt_parser.rb
+    # without behavior changes, except C_REAL's range now reads Float
+    # bounds instead of silently truncating them to Integer via
+    # numeric_interval(real: true) (see xml_constraint_parsing.rb).
+    module XMLPrimitiveParsing
+      private
+
+      def c_date(xml)
+        pattern = xml.at('pattern')
+        range = xml.at('range')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDate.new(pattern: pattern.text)
+        elsif range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDate.new(range: occurrences(range))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDate.new
+        end
+      end
+
+      def c_date_time(xml)
+        pattern = xml.at('pattern')
+        range = xml.at('range')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDateTime.new(pattern: pattern.text)
+        elsif range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDateTime.new(range: occurrences(range))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDateTime.new
+        end
+      end
+
+      def c_integer(xml)
+        range = xml.at('range')
+        list = xml.xpath('list')
+        if range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CInteger.new(range: occurrences(range))
+        elsif !list.empty?
+          list_values = list.map { |item| item.text.to_i }
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CInteger.new(list: list_values)
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CInteger.new
+        end
+      end
+
+      def c_real(xml)
+        range = xml.at('range')
+        list = xml.xpath('list')
+        if range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new(range: numeric_interval(range, real: true))
+        elsif !list.empty?
+          list_values = list.map { |item| item.text.to_f }
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new(list: list_values)
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new
+        end
+      end
+
+      def c_duration(xml)
+        pattern = xml.at('pattern')
+        range_xml = xml.at('range')
+        list = xml.xpath('list')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(pattern: pattern.text)
+        elsif range_xml
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(range: duration_range(range_xml))
+        elsif !list.empty?
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(list: list.map(&:text))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new
+        end
+      end
+
+      # A C_DURATION range's bounds are ISO8601 duration strings (e.g.
+      # PT24H), not plain numbers, so occurrences() (built for numeric
+      # Interval bounds) doesn't apply here; wrap each bound as a
+      # DV_DURATION instead, matching what CDuration#valid_value?
+      # already expects its range bounds to be.
+      def duration_range(range_xml)
+        lower = duration_bound(range_xml.at('lower'), range_xml.at('lower_unbounded'))
+        upper = duration_bound(range_xml.at('upper'), range_xml.at('upper_unbounded'))
+        return nil if lower.nil? && upper.nil?
+
+        OpenEHR::AssumedLibraryTypes::Interval.new(
+          lower: lower, upper: upper,
+          lower_included: lower.nil? ? nil : bool_node(range_xml.at('lower_included'), true),
+          upper_included: upper.nil? ? nil : bool_node(range_xml.at('upper_included'), true))
+      end
+
+      def duration_bound(value_node, unbounded_node)
+        return nil if bool_node(unbounded_node, false)
+        return nil if value_node.nil? || value_node.text.empty?
+
+        OpenEHR::RM::DataTypes::Quantity::DateTime::DvDuration.new(value: value_node.text)
+      end
+
+      def bool_node(node, default)
+        node ? to_bool(node.text) : default
+      end
+
+      def c_time(xml)
+        pattern = xml.at('pattern')
+        range = xml.at('range')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new(pattern: pattern.text)
+        elsif range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new(range: occurrences(range))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new
+        end
+      end
+
+      def c_boolean(xml)
+        true_valid = xml.at('true_valid')
+        false_valid = xml.at('false_valid')
+        assumed_value = xml.at('assumed_value')
+
+        true_valid_value = true_valid ? to_bool(true_valid.text) : nil
+        false_valid_value = false_valid ? to_bool(false_valid.text) : nil
+        assumed_value_value = assumed_value ? to_bool(assumed_value.text) : nil
+
+        OpenEHR::AM::Archetype::ConstraintModel::Primitive::CBoolean.new(
+          true_valid: true_valid_value,
+          false_valid: false_valid_value,
+          assumed_value: assumed_value_value
+        )
+      end
+
+      def c_string(attr_xml)
+        if attr_xml.at('pattern')
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(pattern: attr_xml.at('pattern').text)
+        else
+          list = attr_xml.xpath('.//list').map do |str|
+            str.text
+          end
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(list: list)
+        end
+      end
+    end
+  end
+end

data/lib/openehr/parser.rb

@@ -19,6 +19,7 @@ module OpenEHR
     require_relative 'parser/exception'
     require_relative 'parser/adl_parser'
     require_relative 'parser/opt_parser'
+    require_relative 'parser/xml_archetype_parser'
     require_relative 'parser/archetype_validator'
   end
 end

data/lib/openehr/rm/common/generic.rb

@@ -167,8 +167,8 @@ module OpenEHR
         end
 
         class Participation
-          attr_reader :performer, :function, :mode
-          attr_accessor :time
+          attr_reader :performer, :function
+          attr_accessor :time, :mode
 
           def initialize(args ={ })
             self.performer = args[:performer]
@@ -186,16 +186,13 @@ module OpenEHR
             raise ArgumentError, 'function is mandatory' if function.nil?
             @function = function
           end
-
-          def mode=(mode)
-            raise ArgumentError, 'mode is mandatory' if mode.nil?
-            @mode = mode
-          end
+          # mode is optional (0..1) since RM 1.0.4 - attr_accessor above
+          # covers it, no validation needed.
         end
 
         class Attestation < AuditDetails
-          attr_reader :reason
-          attr_accessor :proof, :attested_view, :is_pending, :items
+          attr_reader :reason, :items
+          attr_accessor :proof, :attested_view, :is_pending
 
           def initialize(args = { })
             super(args)

data/lib/openehr/rm/common/resource.rb

@@ -1,4 +1,3 @@
-require 'set'
 
 module OpenEHR
   module RM

data/lib/openehr/rm/composition/content/entry.rb

@@ -258,9 +258,12 @@ module OpenEHR
               @current_state = current_state
             end
 
+            # transition is optional (0..1) since RM 1.1.0; when present
+            # its code is still validated against the terminology.
             def transition=(transition)
               if transition.nil?
-                raise ArgumentError, 'transition is mandatory'
+                @transition = nil
+                return
               end
               unless OpenEHR::TerminologyService.has_code_for_group?('ism transition careflow transition', transition.defining_code.code_string)
                 raise ArgumentError, 'transition code is invalid'

data/lib/openehr/rm/data_structures/item_structure/representation.rb

@@ -21,12 +21,13 @@ module OpenEHR
             NULL_FLAVOUR_CODES = %w[271 272 273 253].freeze
 
             attr_accessor :value
-            attr_reader :null_flavor
-            path_attribute :value, :null_flavour
+            attr_reader :null_flavor, :null_reason
+            path_attribute :value, :null_flavour, :null_reason
             def initialize(args = {})
               super(args)
               self.value = args[:value]
               self.null_flavor= args[:null_flavor]
+              self.null_reason = args[:null_reason]
             end
 
             def null_flavor=(null_flavor)
@@ -40,6 +41,15 @@ module OpenEHR
             alias null_flavour null_flavor
             alias null_flavour= null_flavor=
 
+            # null_reason is DV_TEXT [0..1] since RM 1.1.0. Invariant: if
+            # set, null_flavor must also be set.
+            def null_reason=(null_reason)
+              if !null_reason.nil? && @null_flavor.nil?
+                raise ArgumentError, 'null_reason requires null_flavor to be set'
+              end
+              @null_reason = null_reason
+            end
+
             def is_null?
               return @value.nil?
             end

data/lib/openehr/rm/data_structures/item_structure.rb

@@ -2,7 +2,6 @@
 # ItemStructure module
 # http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109346709572_859750_3810Report.html
 # refs #54
-require 'set'
 
 require_relative '../data_structures'
 require_relative 'item_structure/representation'

data/lib/openehr/rm/data_types/basic.rb

@@ -25,20 +25,11 @@ module OpenEHR
         end
 
         class DvBoolean < DataValue
-          def initialize(args)
-            super(args)
-          end
-
           def value=(value)
             raise ArgumentError, "value must not be nil" if value.nil?
-            if value == true
-              @value = true
-            elsif  value == false
-              @value = false
-            elsif /TRUE/i =~ value
-              @value = true
-            elsif /FALSE/i =~ value
-              @value = false
+            case value
+            when true, /TRUE/i then @value = true
+            when false, /FALSE/i then @value = false
             end
           end
 
@@ -84,17 +75,17 @@ module OpenEHR
             self.type = args[:type]
           end
 
+          # issuer/assigner/type are optional (0..1) since RM 1.0.4 - only
+          # id is mandatory. A non-nil value must still not be empty.
           def issuer=(issuer)
-            if issuer.nil? or issuer.empty?
-              raise ArgumentError, 'issuer is mandatory'
-            end
+            raise ArgumentError, 'issuer must not be empty' if !issuer.nil? && issuer.empty?
+
             @issuer = issuer
           end
 
           def assigner=(assigner)
-            if assigner.nil? or assigner.empty?
-              raise ArgumentError, 'assigner is mandatory'
-            end
+            raise ArgumentError, 'assigner must not be empty' if !assigner.nil? && assigner.empty?
+
             @assigner = assigner
           end
 
@@ -106,9 +97,8 @@ module OpenEHR
           end
 
           def type=(type)
-            if type.nil? or type.empty?
-              raise ArgumentError, 'type is mandatory'
-            end
+            raise ArgumentError, 'type must not be empty' if !type.nil? && type.empty?
+
             @type = type
           end
         end #end of DvIdentifier

data/lib/openehr/rm/data_types/encapsulated.rb

@@ -37,10 +37,10 @@ module OpenEHR
             @charset = charset
           end
 
-          private
-
           CHARSET_LIST_PATH = File.expand_path('charset.lst', __dir__)
 
+          private
+
           def charset_valid?(charset)
             result = false
             File.open(CHARSET_LIST_PATH) do |file|
@@ -65,6 +65,7 @@ module OpenEHR
           def initialize(args = {})
             super(args)
             self.media_type = args[:media_type]
+            self.size = args[:size]
             self.uri = args[:uri]
             self.data = args[:data]
             self.compression_algorithm = args[:compression_algorithm]
@@ -81,6 +82,21 @@ module OpenEHR
             @media_type = media_type
           end
 
+          # size is Integer [1..1] since RM 1.1.0 (size in bytes of the raw
+          # data content). Left unset (nil), it falls back to the inherited
+          # DvEncapsulated#size (@value.size) for backward compatibility.
+          def size
+            @size.nil? ? super : @size
+          end
+
+          def size=(size)
+            unless size.nil?
+              raise ArgumentError, 'size must be an Integer' unless size.is_a?(Integer)
+              raise ArgumentError, 'size must not be negative' if size.negative?
+            end
+            @size = size
+          end
+
           def is_external?
             !@uri.nil?
           end

data/lib/openehr/rm/data_types/quantity/date_time.rb

@@ -30,6 +30,17 @@ module OpenEHR
             end
 
             undef magnitude=
+
+            private
+
+            # Shared guard for add/subtract on DvDate/DvTime/DvDateTime:
+            # DvAbsoluteQuantity#add/subtract assume magnitude=-based
+            # reconstruction, which DvTemporal subclasses can't support
+            # (see the undef above), so each subclass implements its own
+            # add/subtract against a DvDuration directly instead.
+            def validate_duration_operand(a_diff)
+              raise ArgumentError, 'a_diff must be a DvDuration' unless a_diff.is_a?(DvDuration)
+            end
           end
 
           class DvDate < DvTemporal
@@ -55,20 +66,8 @@ module OpenEHR
               else
                 past, future = self, other
               end
-              year, month, day = 0, 0, 0
-              if (future.day >= past.day)
-                day = future.day - past.day
-              else
-                month = -1
-                previous_month = future.month - 1
-                if previous_month == 0
-                  previous_month = 12
-                end
-                day = DAYS_IN_MONTH[previous_month] + future.day - past.day
-                if leapyear?(future.year) && (previous_month == 2)
-                  day += 1
-                end
-              end
+              year = 0
+              month, day = day_borrow(past, future)
               week = day / 7
               if (future.month >= past.month)
                 month += future.month - past.month
@@ -82,11 +81,48 @@ module OpenEHR
               end
               year += future.year - past.year
               return DvDuration.new(:value =>
-                   'P' + year.to_s + 'Y' + month.to_s + 'M' + 
+                   'P' + year.to_s + 'Y' + month.to_s + 'M' +
                          week.to_s + 'W' + day.to_s + 'D')
             end
+
+            def add(a_diff)
+              validate_duration_operand(a_diff)
+              raise ArgumentError, 'a_diff must not have a time component' if time_component?(a_diff)
+
+              DvDate.new(:value => shift_by(a_diff).iso8601)
+            end
+
+            def subtract(a_diff)
+              add(-a_diff)
+            end
+
+            private
+
+            def time_component?(a_diff)
+              [a_diff.hours, a_diff.minutes, a_diff.seconds].any? { |v| v && !v.zero? }
+            end
+
+            def shift_by(a_diff)
+              sign = a_diff.negative? ? -1 : 1
+              months = (((a_diff.years || 0) * MONTH_IN_YEAR) + (a_diff.months || 0)) * sign
+              days = (((a_diff.weeks || 0) * DAYS_IN_WEEK) + (a_diff.days || 0)) * sign
+              (Date.new(@year, @month, @day) >> months) + days
+            end
+
+            # Returns [month_adjustment, day] for diff: when future's
+            # day-of-month is behind past's, a month is borrowed from
+            # future's calendar to make day non-negative.
+            def day_borrow(past, future)
+              return [0, future.day - past.day] if future.day >= past.day
+
+              previous_month = future.month - 1
+              previous_month = 12 if previous_month == 0
+              day = DAYS_IN_MONTH[previous_month] + future.day - past.day
+              day += 1 if leapyear?(future.year) && previous_month == 2
+              [-1, day]
+            end
           end
-          
+
           class DvTime < DvTemporal
             include OpenEHR::AssumedLibraryTypes::ISO8601TimeModule
 
@@ -104,19 +140,19 @@ module OpenEHR
               if @fractional_second.nil? && @second.nil? && @minute.nil?
                 return @hour * 60 * 60
               elsif @fractional_second.nil? && @second.nil?
-                return @hour * 60 * 60 + @minute * 60
+                return (@hour * 60 * 60) + (@minute * 60)
               elsif @fractional_second.nil?
-                return @hour * 60 * 60 + @minute * 60 + @second
+                return (@hour * 60 * 60) + (@minute * 60) + @second
               else
-                return @hour*60*60+@minute* 60 + @second + @fractional_second
+                return (@hour*60*60)+(@minute* 60) + @second + @fractional_second
               end
             end
 
             def diff(other)
               diff = (other.magnitude - self.magnitude).abs
               hour = (diff / 60 / 60).to_i
-              minute = ((diff - hour*60*60)/60).to_i
-              second = (diff - hour * 60 * 60 - minute * 60).to_i
+              minute = ((diff - (hour*60*60))/60).to_i
+              second = (diff - (hour * 60 * 60) - (minute * 60)).to_i
               fractional_second = ((diff - diff.to_i)*1000000.0).to_i/1000000.0
               str = 'P0Y0M0W0DT' + hour.to_s + 'H' +
                 minute.to_s + 'M' + second.to_s
@@ -127,6 +163,48 @@ module OpenEHR
               end
               return DvDuration.new(:value => str)
             end
+
+            def add(a_diff)
+              validate_duration_operand(a_diff)
+              raise ArgumentError, 'a_diff must not have a date component' if date_component?(a_diff)
+
+              DvTime.new(:value => shifted_time_string(a_diff))
+            end
+
+            def subtract(a_diff)
+              add(-a_diff)
+            end
+
+            private
+
+            def date_component?(a_diff)
+              [a_diff.years, a_diff.months, a_diff.weeks, a_diff.days].any? { |v| v && !v.zero? }
+            end
+
+            def duration_seconds(a_diff)
+              ((a_diff.hours || 0) * MINUTES_IN_HOUR * SECONDS_IN_MINUTE) +
+                ((a_diff.minutes || 0) * SECONDS_IN_MINUTE) +
+                (a_diff.seconds || 0) +
+                (a_diff.fractional_second || 0)
+            end
+
+            def shifted_time_string(a_diff)
+              sign = a_diff.negative? ? -1 : 1
+              day_seconds = HOURS_IN_DAY * MINUTES_IN_HOUR * SECONDS_IN_MINUTE
+              total = (magnitude + (sign * duration_seconds(a_diff))) % day_seconds
+              formatted_time(total) + timezone
+            end
+
+            def formatted_time(total_seconds)
+              hour = (total_seconds / (MINUTES_IN_HOUR * SECONDS_IN_MINUTE)).to_i
+              remainder = total_seconds - (hour * MINUTES_IN_HOUR * SECONDS_IN_MINUTE)
+              minute = (remainder / SECONDS_IN_MINUTE).to_i
+              second_with_fraction = remainder - (minute * SECONDS_IN_MINUTE)
+              second = second_with_fraction.to_i
+              fractional = (second_with_fraction - second).round(6)
+              str = format('%02d:%02d:%02d', hour, minute, second)
+              fractional.zero? ? str : str + fractional.to_s[1..]
+            end
           end
 
           class DvDateTime < DvTemporal
@@ -156,11 +234,11 @@ module OpenEHR
                   minute += @timezone.minute
                 end
               end
-              seconds = (((@year * 365.24 +
-                           @month * 30.42 +
-                           @day) * 24 +
-                           hour) * 60 +
-                           minute) * 60 + @second
+              seconds = (((((((@year * 365.24) +
+                           (@month * 30.42) +
+                           @day) * 24) +
+                           hour) * 60) +
+                           minute) * 60) + @second
               if @fractional_second.nil?
                 return seconds
               else
@@ -168,6 +246,9 @@ module OpenEHR
               end
             end
 
+            # rubocop:disable Metrics/AbcSize -- dense calendar arithmetic; refactoring
+            # without broader leap-year/borrow coverage (only 1 example exercises this
+            # method) is riskier than the lint value gained
             def diff(other)
               if self.magnitude >= other.magnitude
                 past, future = other, self
@@ -183,8 +264,8 @@ module OpenEHR
               end
               date_duration = past_date.diff(future_date)
               hour = (time_diff / 60 / 60).to_i
-              minute = ((time_diff - hour*60*60)/60).to_i
-              second = (time_diff - hour * 60 * 60 - minute * 60).to_i
+              minute = ((time_diff - (hour*60*60))/60).to_i
+              second = (time_diff - (hour * 60 * 60) - (minute * 60)).to_i
               str = date_duration.value + 'T' + hour.to_s + 'H' +
                 minute.to_s + 'M' + second.to_s
               if @fractional_second.nil?
@@ -196,12 +277,57 @@ module OpenEHR
                                       fractional_second.to_s[1..-1] + 'S')
               end
             end
+            # rubocop:enable Metrics/AbcSize
+
+            def add(a_diff)
+              validate_duration_operand(a_diff)
+
+              shifted_date = date_part_shifted_by(a_diff)
+              day_carry, wrapped_seconds = time_of_day_seconds_shifted_by(a_diff).divmod(day_seconds)
+              DvDateTime.new(:value => combine(shifted_date + day_carry, wrapped_seconds) + timezone)
+            end
+
+            def subtract(a_diff)
+              add(-a_diff)
+            end
 
             private
+
             def split_date_time(date_time)
               /^(.*)T(.*)$/ =~ date_time.as_string
               return DvDate.new(:value => $1), DvTime.new(:value => $2)
             end
+
+            def day_seconds
+              HOURS_IN_DAY * MINUTES_IN_HOUR * SECONDS_IN_MINUTE
+            end
+
+            def date_part_shifted_by(a_diff)
+              sign = a_diff.negative? ? -1 : 1
+              months = (((a_diff.years || 0) * MONTH_IN_YEAR) + (a_diff.months || 0)) * sign
+              days = (((a_diff.weeks || 0) * DAYS_IN_WEEK) + (a_diff.days || 0)) * sign
+              (Date.new(@year, @month, @day) >> months) + days
+            end
+
+            def time_of_day_seconds_shifted_by(a_diff)
+              sign = a_diff.negative? ? -1 : 1
+              own_seconds = (@hour * MINUTES_IN_HOUR * SECONDS_IN_MINUTE) + (@minute * SECONDS_IN_MINUTE) +
+                @second + (@fractional_second || 0)
+              diff_seconds = ((a_diff.hours || 0) * MINUTES_IN_HOUR * SECONDS_IN_MINUTE) +
+                ((a_diff.minutes || 0) * SECONDS_IN_MINUTE) + (a_diff.seconds || 0) + (a_diff.fractional_second || 0)
+              own_seconds + (sign * diff_seconds)
+            end
+
+            def combine(date, total_seconds)
+              hour = (total_seconds / (MINUTES_IN_HOUR * SECONDS_IN_MINUTE)).to_i
+              remainder = total_seconds - (hour * MINUTES_IN_HOUR * SECONDS_IN_MINUTE)
+              minute = (remainder / SECONDS_IN_MINUTE).to_i
+              second_with_fraction = remainder - (minute * SECONDS_IN_MINUTE)
+              second = second_with_fraction.to_i
+              fractional = (second_with_fraction - second).round(6)
+              str = date.iso8601 + format('T%02d:%02d:%02d', hour, minute, second)
+              fractional.zero? ? str : str + fractional.to_s[1..]
+            end
           end
 
           class DvDuration < DvTemporal
@@ -254,6 +380,55 @@ module OpenEHR
               text = value.start_with?('-') ? value[1..-1] : "-#{value}"
               DvDuration.new(:value => text)
             end
+
+            # DV_DURATION is a DV_AMOUNT in the openEHR RM even though it
+            # inherits DvAbsoluteQuantity's add/subtract/diff method names
+            # here (see DvTemporal); those assume magnitude=-based
+            # reconstruction, which DvTemporal subclasses can't support,
+            # so +/-/multiply are implemented directly instead, going
+            # through magnitude (already sign-aware and nominal-month
+            # aware) and reconstructing via an ISO8601 string.
+            def +(other)
+              raise ArgumentError, 'type mismatch' unless is_strictly_comparable_to?(other)
+
+              self.class.from_seconds(magnitude + other.magnitude)
+            end
+
+            def -(other)
+              raise ArgumentError, 'type mismatch' unless is_strictly_comparable_to?(other)
+
+              self.class.from_seconds(magnitude - other.magnitude)
+            end
+
+            def multiply(factor)
+              raise ArgumentError, 'factor must be Numeric' unless factor.is_a?(Numeric)
+
+              self.class.from_seconds(magnitude * factor)
+            end
+            alias * multiply
+
+            def self.from_seconds(total_seconds)
+              sign = total_seconds.negative? ? '-' : ''
+              days, hours, minutes, seconds_part = duration_components(total_seconds.abs)
+              new(:value => "#{sign}P0Y0M0W#{days}DT#{hours}H#{minutes}M#{seconds_part}S")
+            end
+
+            def self.duration_components(total_seconds)
+              days, remainder = total_seconds.divmod(HOURS_IN_DAY * MINUTES_IN_HOUR * SECONDS_IN_MINUTE)
+              hours, remainder = remainder.divmod(MINUTES_IN_HOUR * SECONDS_IN_MINUTE)
+              minutes, remainder = remainder.divmod(SECONDS_IN_MINUTE)
+              [days, hours, minutes, seconds_with_fraction(remainder)]
+            end
+            private_class_method :duration_components
+
+            def self.seconds_with_fraction(remainder)
+              seconds = remainder.to_i
+              fractional = (remainder - seconds).round(6)
+              seconds += 1 if fractional >= 1.0
+              fractional = 0.0 if fractional >= 1.0
+              fractional.zero? ? seconds.to_s : "#{seconds}#{fractional.to_s[1..]}"
+            end
+            private_class_method :seconds_with_fraction
           end
         end # of DateTime
       end # of Quantity