fhirpath-rb 0.1.1

data/lib/fhirpath/engine/invocations/strings.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative "strings_encoding"
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of fhirpath-py's fhirpathpy/engine/invocations/strings.py (FHIRPath spec
+      # section 5.6). `encode`/`decode` live in strings_encoding.rb. `escape`/`unescape` aren't
+      # ported (fhirpath-py's own tests disable them too, as "not implemented yet").
+      module Strings
+        class << self
+          def index_of(_ctx, coll, substr)
+            string = ensure_string_singleton(coll)
+            string.index(substr) || -1
+          end
+
+          def substring(_ctx, coll, start, length = nil)
+            string = ensure_string_singleton(coll)
+            return [] if start.is_a?(::Array) || start.nil?
+
+            start = start.to_i
+            return [] if start.negative? || start >= string.length
+            return string[start..] if length.nil? || length.is_a?(::Array)
+
+            string[start, length.to_i]
+          end
+
+          def starts_with(_ctx, coll, prefix)
+            return [] if Util.empty?(prefix)
+
+            string = ensure_string_singleton(coll)
+            return false if string.empty? || !prefix.is_a?(::String)
+
+            string.start_with?(prefix)
+          end
+
+          def ends_with(_ctx, coll, suffix)
+            return [] if Util.empty?(suffix)
+
+            string = ensure_string_singleton(coll)
+            return false if string.empty? || !suffix.is_a?(::String)
+
+            string.end_with?(suffix)
+          end
+
+          def contains(_ctx, coll, substr)
+            ensure_string_singleton(coll).include?(substr)
+          end
+
+          def upper(_ctx, coll)
+            ensure_string_singleton(coll).upcase
+          end
+
+          def lower(_ctx, coll)
+            ensure_string_singleton(coll).downcase
+          end
+
+          # `pattern` is matched literally, not as a regex — see `replace_matches` for the
+          # regex-based counterpart.
+          def replace(_ctx, coll, pattern, repl)
+            string = ensure_string_singleton(coll)
+            return repl + string.chars.join(repl) + repl if pattern == "" && repl.is_a?(::String)
+            return [] if blank?(string) || blank?(pattern)
+
+            string.gsub(pattern, repl)
+          end
+
+          def matches(_ctx, coll, regex)
+            return [] if blank?(regex) || coll.empty?
+
+            string = ensure_string_singleton(coll)
+            string.match?(Regexp.new(regex, Regexp::MULTILINE))
+          end
+
+          def replace_matches(_ctx, coll, regex, repl)
+            string = ensure_string_singleton(coll)
+            return [] if regex.is_a?(::Array) || repl.is_a?(::Array)
+
+            # FHIRPath substitution refers to capture groups as $1, $2, ...; Ruby (like Python)
+            # spells that \1, \2, ... in a gsub replacement string.
+            substitution = repl.gsub(/\$(\d+)/) { "\\#{::Regexp.last_match(1)}" }
+            string.gsub(Regexp.new(regex), substitution)
+          end
+
+          def length(_ctx, coll)
+            ensure_string_singleton(coll).length
+          end
+
+          def to_chars(_ctx, coll)
+            return [] if coll.empty?
+
+            ensure_string_singleton(coll).chars
+          end
+
+          def split(_ctx, coll, delimiter)
+            # -1 keeps trailing empty fields, matching Python's str.split (Ruby's split drops
+            # them by default).
+            ensure_string_singleton(coll).split(delimiter, -1)
+          end
+
+          def trim(_ctx, coll)
+            ensure_string_singleton(coll).strip
+          end
+
+          def join(_ctx, coll, separator = "")
+            return [] if coll.empty?
+
+            coll.map { |item| string_value(item) }.join(separator)
+          end
+
+          private
+
+          def ensure_string_singleton(coll)
+            if coll.length == 1
+              data = Util.get_data(coll.first)
+              return data if data.is_a?(::String)
+
+              raise Fhirpath::Error, "Expected string, but got #{data.inspect}"
+            end
+
+            raise Fhirpath::Error, "Expected string, but got #{coll.inspect}"
+          end
+
+          def string_value(item)
+            data = Util.get_data(item)
+            raise Fhirpath::Error, "Join requires a collection of strings." unless data.is_a?(::String)
+
+            data
+          end
+
+          def blank?(value)
+            value.respond_to?(:empty?) ? value.empty? : value.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/invocations/strings_encoding.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # `encode`/`decode` from fhirpath-py's fhirpathpy/engine/invocations/strings.py. Split
+      # out of strings.rb to keep that file's module body short; reopens the same Strings
+      # module.
+      module Strings
+        class << self
+          def encode(_ctx, coll, encoding)
+            return [] if coll.empty?
+
+            value = Util.get_data(coll.first)
+            return [] if blank?(value)
+
+            encode_value(value, encoding)
+          end
+
+          def decode(_ctx, coll, encoding)
+            return [] if coll.empty?
+
+            value = Util.get_data(coll.first)
+            return [] if blank?(value)
+
+            decode_value(value, encoding)
+          end
+
+          private
+
+          def encode_value(value, encoding)
+            case encoding
+            when "urlbase64", "base64url"
+              Base64.strict_encode64(value).tr("+/", "-_")
+            when "base64"
+              Base64.strict_encode64(value)
+            when "hex"
+              value.each_byte.map { |byte| byte.to_s(16).rjust(2, "0") }.join
+            else
+              []
+            end
+          end
+
+          def decode_value(value, encoding)
+            case encoding
+            when "urlbase64", "base64url"
+              Base64.strict_decode64(value.tr("-_", "+/")).force_encoding(::Encoding::UTF_8)
+            when "base64"
+              Base64.strict_decode64(value).force_encoding(::Encoding::UTF_8)
+            when "hex"
+              decode_hex(value)
+            else
+              []
+            end
+          end
+
+          def decode_hex(value)
+            raise Fhirpath::Error, "Decode 'hex' requires an even number of characters." if value.length.odd?
+
+            value.each_char.each_slice(2).map { |pair| pair.join.to_i(16).chr }.join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/invocations/subsetting.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of `intersect` from fhirpath-py's fhirpathpy/engine/invocations/subsetting.py.
+      module Subsetting
+        def self.intersect(_ctx, coll1, coll2)
+          intersection = coll1.select { |item| coll2.include?(item) }
+          intersection.each_with_object([]) { |item, acc| acc << item unless acc.include?(item) }
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/invocations/types.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of `is`/`as`/`type` from fhirpath-py's fhirpathpy/engine/invocations/types.py.
+      module Types
+        class << self
+          # Each item's TypeInfo, as a plain Hash so ".name"/".namespace" member navigation
+          # (see evaluators/member_invocation.rb's generic Hash handling) works on the result —
+          # mirrors fhirpath-py's type_fn returning TypeInfo.__dict__ for each value.
+          def type(ctx, coll)
+            coll.map do |item|
+              type_info = Nodes::TypeInfo.from_value(item, ctx[:model])
+              { "name" => type_info.name, "namespace" => type_info.namespace }
+            end
+          end
+
+          def is(ctx, coll, type_info)
+            return [] if coll.empty?
+            raise Fhirpath::Error, "Expected singleton on left side of 'is', got #{coll.inspect}" if coll.length > 1
+
+            Nodes::TypeInfo.from_value(coll.first, ctx[:model]).is_(type_info, ctx[:model])
+          end
+
+          def as(ctx, coll, type_info)
+            return [] if coll.empty?
+            raise Fhirpath::Error, "Expected singleton on left side of 'as', got #{coll.inspect}" if coll.length > 1
+
+            Nodes::TypeInfo.from_value(coll.first, ctx[:model]).is_(type_info, ctx[:model]) ? coll : []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/invocations.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "invocations/navigation"
+require_relative "invocations/filtering"
+require_relative "invocations/equality"
+require_relative "invocations/existence"
+require_relative "invocations/combining"
+require_relative "invocations/math"
+require_relative "invocations/subsetting"
+require_relative "invocations/misc"
+require_relative "invocations/misc_converts_to"
+require_relative "invocations/strings"
+require_relative "invocations/datetime"
+require_relative "invocations/types"
+require_relative "invocations/collections"
+require_relative "invocations/logic"
+require_relative "invocations/aggregate"
+require_relative "invocations/registry_strings_and_math"
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of the base `invocation_registry` built in fhirpath-py's
+      # fhirpathpy/engine/invocations/__init__.py. Only entries needed so far are ported; see
+      # the category modules required above. Split across two constants purely to keep this
+      # module's line count down — REGISTRY_STRINGS_AND_MATH (the string functions and the
+      # single-argument math functions) lives in registry_strings_and_math.rb, which reopens
+      # this module.
+      REGISTRY_CORE = {
+        "where" => { fn: Filtering.method(:where), arity: { 1 => ["Expr"] } },
+        "select" => { fn: Filtering.method(:select), arity: { 1 => ["Expr"] } },
+        "repeat" => { fn: Filtering.method(:repeat), arity: { 1 => ["Expr"] } },
+        "ofType" => { fn: Filtering.method(:of_type), arity: { 1 => ["TypeSpecifier"] } },
+        "extension" => { fn: Filtering.method(:extension), arity: { 1 => ["String"] } },
+        "type" => { fn: Types.method(:type) },
+        "is" => { fn: Types.method(:is), arity: { 1 => ["TypeSpecifier"] } },
+        "as" => { fn: Types.method(:as), arity: { 1 => ["TypeSpecifier"] } },
+        "isOp" => { fn: Types.method(:is), arity: { 2 => %w[Any TypeSpecifier] } },
+        "asOp" => { fn: Types.method(:as), arity: { 2 => %w[Any TypeSpecifier] } },
+        "single" => { fn: Filtering.method(:single) },
+        "first" => { fn: Filtering.method(:first) },
+        "last" => { fn: Filtering.method(:last) },
+        "tail" => { fn: Filtering.method(:tail) },
+        "take" => { fn: Filtering.method(:take), arity: { 1 => ["Integer"] } },
+        "skip" => { fn: Filtering.method(:skip), arity: { 1 => ["Integer"] } },
+        "children" => { fn: Navigation.method(:children) },
+        "descendants" => { fn: Navigation.method(:descendants) },
+        "combine" => { fn: Combining.method(:combine), arity: { 1 => ["AnyAtRoot"] } },
+        "coalesce" => { fn: Combining.method(:coalesce), variadic: "Expr" },
+        "|" => { fn: Combining.method(:union), arity: { 2 => %w[Any Any] } },
+        "union" => { fn: Combining.method(:union), arity: { 1 => ["AnyAtRoot"] } },
+        "intersect" => { fn: Subsetting.method(:intersect), arity: { 1 => ["AnyAtRoot"] } },
+        "empty" => { fn: Existence.method(:empty) },
+        "not" => { fn: Existence.method(:not) },
+        "exists" => { fn: Existence.method(:exists), arity: { 0 => [], 1 => ["Expr"] } },
+        "all" => { fn: Existence.method(:all), arity: { 1 => ["Expr"] } },
+        "allTrue" => { fn: Existence.method(:all_true) },
+        "anyTrue" => { fn: Existence.method(:any_true) },
+        "allFalse" => { fn: Existence.method(:all_false) },
+        "anyFalse" => { fn: Existence.method(:any_false) },
+        "subsetOf" => { fn: Existence.method(:subset_of), arity: { 1 => ["AnyAtRoot"] } },
+        "supersetOf" => { fn: Existence.method(:superset_of), arity: { 1 => ["AnyAtRoot"] } },
+        "isDistinct" => { fn: Existence.method(:distinct?) },
+        "distinct" => { fn: Existence.method(:distinct) },
+        "count" => { fn: Existence.method(:count) },
+        "=" => { fn: Equality.method(:equal), arity: { 2 => %w[Any Any] }, nullable: true },
+        "!=" => { fn: Equality.method(:unequal), arity: { 2 => %w[Any Any] }, nullable: true },
+        "~" => { fn: Equality.method(:equival), arity: { 2 => %w[Any Any] } },
+        "!~" => { fn: Equality.method(:unequival), arity: { 2 => %w[Any Any] } },
+        "<" => { fn: Equality.method(:lt), arity: { 2 => %w[Any Any] }, nullable: true },
+        ">" => { fn: Equality.method(:gt), arity: { 2 => %w[Any Any] }, nullable: true },
+        "<=" => { fn: Equality.method(:lte), arity: { 2 => %w[Any Any] }, nullable: true },
+        ">=" => { fn: Equality.method(:gte), arity: { 2 => %w[Any Any] }, nullable: true },
+        "containsOp" => { fn: Collections.method(:contains), arity: { 2 => %w[Any Any] } },
+        "inOp" => { fn: Collections.method(:in), arity: { 2 => %w[Any Any] } },
+        "or" => { fn: Logic.method(:or_op), arity: { 2 => %w[Boolean Boolean] } },
+        "and" => { fn: Logic.method(:and_op), arity: { 2 => %w[Boolean Boolean] } },
+        "xor" => { fn: Logic.method(:xor_op), arity: { 2 => %w[Boolean Boolean] } },
+        "implies" => { fn: Logic.method(:implies_op), arity: { 2 => %w[Boolean Boolean] } },
+        "+" => { fn: Math.method(:plus), arity: { 2 => %w[Any Any] }, nullable: true },
+        "-" => { fn: Math.method(:minus), arity: { 2 => %w[Any Any] }, nullable: true },
+        "*" => { fn: Math.method(:mul), arity: { 2 => %w[Number Number] }, nullable: true },
+        "/" => { fn: Math.method(:div), arity: { 2 => %w[Number Number] }, nullable: true },
+        "div" => { fn: Math.method(:intdiv), arity: { 2 => %w[Number Number] }, nullable: true },
+        "mod" => { fn: Math.method(:mod), arity: { 2 => %w[Number Number] }, nullable: true },
+        "&" => { fn: Math.method(:amp), arity: { 2 => %w[String String] } },
+        "iif" => { fn: Misc.method(:iif), arity: { 2 => %w[Expr Expr], 3 => %w[Expr Expr Expr] } },
+        "trace" => { fn: Misc.method(:trace), arity: { 0 => [], 1 => ["String"], 2 => %w[String Expr] } },
+        "toInteger" => { fn: Misc.method(:to_integer) },
+        "toDecimal" => { fn: Misc.method(:to_decimal) },
+        "toString" => { fn: Misc.method(:to_string) },
+        "toDate" => { fn: Misc.method(:to_date) },
+        "toDateTime" => { fn: Misc.method(:to_date_time) },
+        "toTime" => { fn: Misc.method(:to_time) },
+        "toQuantity" => { fn: Misc.method(:to_quantity), arity: { 0 => [], 1 => ["String"] } },
+        "toBoolean" => { fn: Misc.method(:to_boolean) },
+        "convertsToBoolean" => { fn: Misc.method(:converts_to_boolean) },
+        "convertsToInteger" => { fn: Misc.method(:converts_to_integer) },
+        "convertsToDecimal" => { fn: Misc.method(:converts_to_decimal) },
+        "convertsToString" => { fn: Misc.method(:converts_to_string) },
+        "convertsToDate" => { fn: Misc.method(:converts_to_date) },
+        "convertsToDateTime" => { fn: Misc.method(:converts_to_date_time) },
+        "convertsToTime" => { fn: Misc.method(:converts_to_time) },
+        "convertsToQuantity" => { fn: Misc.method(:converts_to_quantity) },
+        "aggregate" => { fn: Aggregate.method(:aggregate), arity: { 1 => ["Expr"], 2 => %w[Expr Any] } },
+        "sum" => { fn: Aggregate.method(:sum) },
+        "avg" => { fn: Aggregate.method(:avg) },
+        "min" => { fn: Aggregate.method(:min) },
+        "max" => { fn: Aggregate.method(:max) },
+        "now" => { fn: Datetime.method(:now) },
+        "today" => { fn: Datetime.method(:today) },
+        "timeOfDay" => { fn: Datetime.method(:time_of_day) }
+      }.freeze
+
+      REGISTRY = REGISTRY_CORE.merge(REGISTRY_STRINGS_AND_MATH).freeze
+    end
+  end
+end

data/lib/fhirpath/engine/nodes/fp_date_time.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Fhirpath
+  module Engine
+    module Nodes
+      # Minimal Ruby port of fhirpath-py's FP_DateTime (fhirpathpy/engine/nodes.py): printing a
+      # date/time literal back out verbatim, and the FHIRPath equals() comparison
+      # (https://hl7.org/fhirpath/#equals): each specified precision level is compared in turn,
+      # starting from year; a mismatch there is `false`, but if one side simply doesn't specify
+      # a precision level the other does, the result is empty (`nil` here) rather than `false`.
+      # `#plus` (date/time + duration quantity arithmetic) lives in fp_date_time_arithmetic.rb,
+      # which reopens this class.
+      class FPDateTime
+        FORMAT = /
+          \A(?<year>\d{4})
+          (?:-(?<month>\d{2})(?:-(?<day>\d{2}))?)?
+          (?:T(?<hour>\d{2})(?::(?<minute>\d{2})(?::(?<second>\d{2})(?:\.(?<fraction>\d+))?)?)?
+            (?<timezone>Z|[+-]\d{2}:\d{2})?
+          )?\z
+        /x
+
+        COMPONENTS = %i[year month day hour minute second].freeze
+        DEFAULTS = { year: "0", month: "1", day: "1", hour: "0", minute: "0", second: "0" }.freeze
+        TIME_READERS = { year: :year, month: :month, day: :day, hour: :hour, minute: :min, second: :sec }.freeze
+
+        attr_reader :source
+
+        def initialize(source)
+          @source = source
+          @match = FORMAT.match(source)
+          raise Fhirpath::Error, "Invalid date/time literal: #{source}" unless @match
+        end
+
+        def to_s
+          source
+        end
+
+        def ==(other)
+          equals(other) == true
+        end
+
+        # Per https://hl7.org/fhirpath/#equals: compare each precision level present on either
+        # side, starting from year. A field both sides specify but disagree on is `false`; a
+        # field only one side specifies is `nil` (spec: empty). If every field up to the lower
+        # precision matches and both sides specify the same precision, fall back to comparing
+        # the full instant (this is what distinguishes e.g. differing sub-second precision).
+        def equals(other)
+          return false unless other.is_a?(self.class)
+
+          fields = shared_fields(other)
+          self_precision, other_precision = precisions(other, fields)
+
+          return to_instant == other.to_instant if self_precision == other_precision
+
+          compare_up_to_min_precision(other, fields, [self_precision, other_precision].min)
+        end
+
+        def to_instant
+          Time.new(component_value(:year), component_value(:month), component_value(:day),
+                   component_value(:hour), component_value(:minute), second_value, timezone).getutc
+        end
+
+        # Per https://hl7.org/fhirpath/#comparison: -1/0/1, or nil (spec: empty) when ordering
+        # can't be resolved at a shared precision (fields match up to the lower precision, but
+        # neither is a prefix of the other so which sorts first is undefined).
+        def compare(other)
+          fields = shared_fields(other)
+          self_precision, other_precision = precisions(other, fields)
+
+          return to_instant <=> other.to_instant if self_precision == other_precision
+
+          compare_by_field(other, fields, [self_precision, other_precision].min)
+        end
+
+        protected
+
+        # UTC-shifted calendar fields, revealing only the components this literal actually
+        # specifies — lets e.g. "22:00-04:00" and "06:00+04:00" compare correctly across the
+        # day boundary the timezone shift crosses.
+        def normalized
+          @normalized ||= begin
+            utc = to_instant
+            COMPONENTS.to_h { |c| [c, @match[c] ? utc.public_send(TIME_READERS[c]) : nil] }
+          end
+        end
+
+        def timezone?
+          !@match[:timezone].nil?
+        end
+
+        private
+
+        def shared_fields(other)
+          COMPONENTS.reject { |c| normalized[c].nil? && other.normalized[c].nil? }
+        end
+
+        def precisions(other, fields)
+          [fields.count { |c| !normalized[c].nil? }, fields.count { |c| !other.normalized[c].nil? }]
+        end
+
+        def compare_up_to_min_precision(other, fields, min_precision)
+          fields.first(min_precision).each do |c|
+            return nil if normalized[c].nil? || other.normalized[c].nil?
+            return false if normalized[c] != other.normalized[c]
+          end
+
+          return false if timezone? != other.timezone?
+
+          nil
+        end
+
+        def compare_by_field(other, fields, min_precision)
+          fields.first(min_precision).each do |c|
+            return -1 if normalized[c].nil? || other.normalized[c].nil?
+
+            ordinal = normalized[c] <=> other.normalized[c]
+            return ordinal unless ordinal.zero?
+          end
+
+          nil
+        end
+
+        def component_value(component)
+          (@match[component] || DEFAULTS[component]).to_i
+        end
+
+        def second_value
+          component_value(:second) + (@match[:fraction] ? Rational("0.#{@match[:fraction]}") : 0)
+        end
+
+        def timezone
+          value = @match[:timezone]
+          value.nil? || value == "Z" ? "+00:00" : value
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/nodes/fp_date_time_arithmetic.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Fhirpath
+  module Engine
+    module Nodes
+      # Reopens FPDateTime (see fp_date_time.rb) to add `#plus` — ports fhirpath-py's
+      # FP_TimeBase#plus for FP_DateTime (https://hl7.org/fhirpath/#datetime-arithmetic): adding
+      # a duration quantity respects this literal's own precision — a quantity finer than what's
+      # specified is converted up to that precision using calendar approximations (365 days/
+      # year, 30 days/month, ...) rather than exact calendar math, per the spec's rules for
+      # imprecise date/time arithmetic. `value` is always truncated to an integer first (the
+      # spec: "the decimal portion... is ignored").
+      class FPDateTime
+        PRECISION_FORMATS = {
+          1 => "%Y", 2 => "%Y-%m", 3 => "%Y-%m-%d",
+          4 => "%Y-%m-%dT%H", 5 => "%Y-%m-%dT%H:%M", 6 => "%Y-%m-%dT%H:%M:%S"
+        }.freeze
+
+        def plus(quantity)
+          value = quantity.value.to_i
+          unit = FPQuantity::ARITHMETIC_DURATION_UNITS[quantity.unit]
+          raise Fhirpath::Error, "Cannot add #{quantity} to #{self}" unless unit
+
+          precision = date_precision
+          result = add_duration(base_time, unit, value, precision)
+          self.class.new(result.strftime(PRECISION_FORMATS.fetch(precision, PRECISION_FORMATS[6])))
+        end
+
+        private
+
+        DATE_ARITHMETIC_FIELDS = %i[year month day hour minute second fraction].freeze
+        SUB_HOUR_DIVISORS = { minute: 60, second: 3600, millisecond: 3_600_000 }.freeze
+
+        def date_precision
+          DATE_ARITHMETIC_FIELDS.count { |c| @match[c] }
+        end
+
+        def base_time
+          Time.utc(component_value(:year), component_value(:month), component_value(:day),
+                   component_value(:hour), component_value(:minute), component_value(:second))
+        end
+
+        def add_duration(base, unit, value, precision)
+          case unit
+          when :year then add_months(base, value * 12)
+          when :month then add_months(base, value)
+          when :day, :week then add_day_or_week(base, unit, value, precision)
+          when :hour then add_hour(base, value, precision)
+          when :minute, :second, :millisecond then add_sub_hour(base, unit, value, precision)
+          end
+        end
+
+        def add_day_or_week(base, unit, value, precision)
+          days_value = unit == :week ? value * 7 : value
+          case precision
+          when 1 then add_months(base, trunc_div(days_value, 365) * 12)
+          when 2 then add_months(base, trunc_div(days_value, 30))
+          else base + (days_value * 86_400)
+          end
+        end
+
+        def add_hour(base, value, precision)
+          case precision
+          when 2 then add_months(base, trunc_div(value, 24 * 30))
+          when 3 then base + (trunc_div(value, 24) * 86_400)
+          when 7 then base + (value * 3600)
+          else
+            raise Fhirpath::Error, "Cannot add hours at precision #{precision} to #{self}"
+          end
+        end
+
+        def add_sub_hour(base, unit, value, precision)
+          case precision
+          when 4 then base + (trunc_div(value, SUB_HOUR_DIVISORS[unit]) * 3600)
+          when 5 then add_sub_hour_at_minute_precision(base, unit, value)
+          when 7 then add_sub_hour_at_full_precision(base, unit, value)
+          else
+            raise Fhirpath::Error, "Cannot add #{unit} at precision #{precision} to #{self}"
+          end
+        end
+
+        def add_sub_hour_at_minute_precision(base, unit, value)
+          minutes = case unit
+                    when :minute then value
+                    when :second then trunc_div(value, 60)
+                    when :millisecond then trunc_div(value, 60_000)
+                    end
+          base + (minutes * 60)
+        end
+
+        def add_sub_hour_at_full_precision(base, unit, value)
+          case unit
+          when :minute then base + (value * 60)
+          when :second then base + value
+          when :millisecond then base + (value / 1000.0)
+          end
+        end
+
+        def add_months(time, months)
+          date = Date.new(time.year, time.month, time.day) >> months
+          Time.utc(date.year, date.month, date.day, time.hour, time.min, time.sec)
+        end
+
+        def trunc_div(numerator, denominator)
+          numerator.fdiv(denominator).truncate
+        end
+      end
+    end
+  end
+end