fhirpath-rb 0.1.1

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require_relative "math_functions"
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of `+`/`-`/`*`/`/`/`div`/`mod`/`&` from fhirpath-py's
+      # fhirpathpy/engine/invocations/math.py, including FP_TimeBase/FP_Quantity date
+      # arithmetic (`+`/`-` between a date/time and a duration quantity). The single-argument
+      # numeric functions (`abs`/`ceiling`/`exp`/`floor`/`ln`/`log`/`power`/`round`/`sqrt`/
+      # `truncate`) live in math_functions.rb, reopening this same module.
+      module Math
+        # Matches Python's decimal module's default context precision (28 significant digits),
+        # which is what fhirpath-py's `/` division relies on implicitly — Ruby's BigDecimal `/`
+        # has no such fixed precision by default, so without this e.g. `1.2 / 1.8` produces a
+        # different (longer, differently-rounded) repeating decimal than the reference.
+        DECIMAL_PRECISION = 28
+
+        class << self
+          def plus(_ctx, left, right)
+            lhs, rhs = resolve_operands(left, right, "+")
+
+            return lhs + rhs if (lhs.is_a?(::String) && rhs.is_a?(::String)) ||
+                                (lhs.is_a?(::Numeric) && rhs.is_a?(::Numeric))
+
+            date_time_plus(lhs, rhs) { raise Fhirpath::Error, "Cannot #{left} + #{right}" }
+          end
+
+          def minus(_ctx, left, right)
+            lhs, rhs = resolve_operands(left, right, "-")
+
+            return lhs - rhs if lhs.is_a?(::Numeric) && rhs.is_a?(::Numeric)
+
+            rhs = Nodes::FPQuantity.new(-rhs.value, rhs.unit) if rhs.is_a?(Nodes::FPQuantity)
+            date_time_plus(lhs, rhs) { raise Fhirpath::Error, "Cannot #{left} - #{right}" }
+          end
+
+          def mul(_ctx, lhs, rhs)
+            lhs * rhs
+          end
+
+          def div(_ctx, lhs, rhs)
+            return [] if rhs.zero?
+
+            Util.to_big_decimal(lhs).div(Util.to_big_decimal(rhs), DECIMAL_PRECISION)
+          end
+
+          def intdiv(_ctx, lhs, rhs)
+            return [] if rhs.zero?
+
+            Util.to_big_decimal(lhs).div(Util.to_big_decimal(rhs), DECIMAL_PRECISION).truncate
+          end
+
+          def mod(_ctx, lhs, rhs)
+            return [] if rhs.zero?
+
+            lhs % rhs
+          end
+
+          def amp(_ctx, lhs, rhs)
+            lhs = "" if lhs == []
+            rhs = "" if rhs == []
+            lhs + rhs
+          end
+
+          private
+
+          # Mirrors fhirpath-py's own `xs = remove_duplicate_extension(xs_)` at the top of
+          # `plus`/`minus`: strip the "Cannot ... " length check down to the primitive operand,
+          # then unwrap it from its ResourceNode.
+          def resolve_operands(left, right, operator)
+            left = Util.remove_duplicate_extension(left)
+            right = Util.remove_duplicate_extension(right)
+            raise Fhirpath::Error, "Cannot #{left} #{operator} #{right}" if left.length != 1 || right.length != 1
+
+            [Util.get_data(left[0]), Util.get_data(right[0])]
+          end
+
+          # A duration quantity added to (or, via `minus`, subtracted from) a date/time value —
+          # https://hl7.org/fhirpath/#datetime-arithmetic. `lhs` may already be an FPDateTime/
+          # FPTime (e.g. the left side was itself a date/time literal), or a raw String that
+          # happens to be date/time-shaped (e.g. a FHIR "date"/"dateTime"/"time" element's raw
+          # value navigated without a model, so it was never converted to an FP_* type) — either
+          # way, if it parses as a date/time and `rhs` is a quantity, delegate to its `#plus`.
+          def date_time_plus(lhs, rhs)
+            return yield unless rhs.is_a?(Nodes::FPQuantity)
+
+            target = lhs.is_a?(::String) ? coerce_date_or_time(lhs) : lhs
+            return yield unless target.is_a?(Nodes::FPDateTime) || target.is_a?(Nodes::FPTime)
+
+            target.plus(rhs)
+          end
+
+          def coerce_date_or_time(str)
+            Nodes::FPDateTime.new(str)
+          rescue Fhirpath::Error
+            begin
+              Nodes::FPTime.new(str)
+            rescue Fhirpath::Error
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/math"
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of `abs`/`ceiling`/`exp`/`floor`/`ln`/`log`/`power`/`round`/`sqrt`/`truncate`
+      # from fhirpath-py's fhirpathpy/engine/invocations/math.py — the single-argument (plus
+      # `log`/`power`/`round`'s second argument) numeric functions. Reopens the Math module
+      # defined in math.rb, which holds the `+`/`-`/`*`/`/`/`div`/`mod`/`&` infix operators.
+      module Math
+        LOG_PRECISION = 30
+        LOG_SCALE = 15
+
+        class << self
+          def abs(_ctx, num)
+            return [] if blank?(num)
+
+            ensure_number_singleton(num).abs
+          end
+
+          def ceiling(_ctx, num)
+            return [] if blank?(num)
+
+            ensure_number_singleton(num).ceil
+          end
+
+          def floor(_ctx, num)
+            return [] if blank?(num)
+
+            ensure_number_singleton(num).floor
+          end
+
+          def truncate(_ctx, num)
+            return [] if blank?(num)
+
+            ensure_number_singleton(num).truncate
+          end
+
+          def exp(_ctx, num)
+            return [] if blank?(num)
+
+            BigMath.exp(Util.to_big_decimal(ensure_number_singleton(num)), LOG_PRECISION)
+          end
+
+          def ln(_ctx, num)
+            return [] if blank?(num)
+
+            BigMath.log(Util.to_big_decimal(ensure_number_singleton(num)), LOG_PRECISION)
+          end
+
+          def log(_ctx, num, base)
+            return [] if blank?(num) || blank?(base)
+
+            value = Util.to_big_decimal(ensure_number_singleton(num))
+            base_value = Util.to_big_decimal(ensure_number_singleton(base))
+
+            (BigMath.log(value, LOG_PRECISION) / BigMath.log(base_value, LOG_PRECISION)).round(LOG_SCALE)
+          end
+
+          def sqrt(_ctx, num)
+            return [] if blank?(num)
+
+            value = ensure_number_singleton(num)
+            return [] if value.negative?
+
+            Util.to_big_decimal(value).sqrt(LOG_PRECISION)
+          end
+
+          def power(_ctx, num, degree)
+            return [] if blank?(num) || blank?(degree)
+
+            base = ensure_number_singleton(num)
+            exponent = ensure_number_singleton(degree)
+            return [] if base.negative? || exponent.to_i != exponent
+
+            base**exponent
+          end
+
+          def round(_ctx, num, precision)
+            return [] if blank?(num)
+
+            value = ensure_number_singleton(num)
+            return value.round if blank?(precision)
+
+            value.round(ensure_number_singleton(precision).to_i)
+          end
+
+          private
+
+          # Mirrors fhirpath-py's is_empty: the argument may be the raw input collection
+          # (always an array) or an already-resolved param value (a raw number, or `[]` if the
+          # param expression itself was empty).
+          def blank?(value)
+            return false if value.is_a?(::Numeric)
+
+            Util.empty?(value)
+          end
+
+          # Mirrors fhirpath-py's ensure_number_singleton: accepts either a raw number
+          # (an already-resolved param) or a singleton collection (the raw input data).
+          def ensure_number_singleton(value)
+            data = Util.get_data(value)
+            return data if data.is_a?(::Numeric)
+
+            unless data.is_a?(::Array) && data.length == 1
+              raise Fhirpath::Error, "Expected list with number, but got #{data.inspect}"
+            end
+
+            item = Util.get_data(data.first)
+            raise Fhirpath::Error, "Expected number, but got #{value.inspect}" unless item.is_a?(::Numeric)
+
+            item
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of `iif`/`trace`/`toInteger`/`toDecimal`/`toString`/`toDate`/`toDateTime`/
+      # `toTime`/`toQuantity` from fhirpath-py's fhirpathpy/engine/invocations/misc.py.
+      # `toBoolean`/the convertsTo* family live in misc_converts_to.rb, reopening this module.
+      module Misc
+        INT_REGEX = /\A[+-]?\d+\z/
+        NUM_REGEX = /\A[+-]?\d+(\.\d+)?\z/
+        QUANTITY_REGEX = /\A([+-]?\d+(?:\.\d+)?)\s*(?:('[^']+')|([a-zA-Z]+))?\z/
+
+        class << self
+          def iif(_ctx, data, cond, on_true, on_false = nil)
+            return on_true.call(data) if Util.true?(cond.call(data))
+            return on_false.call(data) if on_false
+
+            []
+          end
+
+          # Logs the input collection under `label` (via ctx[:trace_fn] if the caller supplied
+          # one, else stdout) and returns it unchanged. Mirrors fhirpath-py: a second
+          # ("projection") argument is accepted but not used for anything — fhirpath-py itself
+          # silently drops it (engine/__init__.py truncates trace's raw_params to the first
+          # element before arity resolution) rather than actually implementing the spec's
+          # "trace with a projected value" behavior.
+          def trace(ctx, coll, label = "", _projection = nil)
+            if ctx[:trace_fn].respond_to?(:call)
+              ctx[:trace_fn].call(label, coll)
+            else
+              puts "TRACE:[#{label}] #{coll}"
+            end
+
+            coll
+          end
+
+          def to_integer(_ctx, coll)
+            return [] if coll.length != 1
+
+            integer_value(Util.get_data(coll.first))
+          end
+
+          def to_decimal(_ctx, coll)
+            return [] if coll.length != 1
+
+            value = Util.get_data(coll.first)
+            return BigDecimal(0) if value == false
+            return BigDecimal(1) if value == true
+            return BigDecimal(value.to_s) if value.is_a?(::Numeric)
+            return BigDecimal(value) if value.is_a?(::String) && NUM_REGEX.match?(value)
+
+            []
+          end
+
+          def to_string(_ctx, coll)
+            return [] if coll.length != 1
+
+            Util.format_number(Util.get_data(coll.first))
+          end
+
+          def to_date_time(_ctx, coll)
+            raise Fhirpath::Error, "to_date_time called for a collection of length #{coll.length}" if coll.length > 1
+            return [] if coll.empty?
+
+            Nodes::FPDateTime.new(Util.get_data(coll.first))
+          rescue Fhirpath::Error
+            []
+          end
+
+          # fhirpath-py's to_date is, as written, identical to to_date_time (no truncation to
+          # date-only precision) — mirrored as-is.
+          def to_date(ctx, coll)
+            to_date_time(ctx, coll)
+          end
+
+          def to_time(_ctx, coll)
+            raise Fhirpath::Error, "to_time called for a collection of length #{coll.length}" if coll.length > 1
+            return [] if coll.empty?
+
+            Nodes::FPTime.new(Util.get_data(coll.first))
+          rescue Fhirpath::Error
+            []
+          end
+
+          def to_quantity(_ctx, coll, to_unit = nil)
+            if coll.length > 1
+              raise Fhirpath::Error, "Could not convert to quantity: input collection contains multiple items"
+            end
+            return [] if coll.empty?
+
+            to_unit = normalize_unit(to_unit) if to_unit
+            result = parse_quantity(Util.val_data_converted(coll.first))
+            result = convert_to_unit(result, to_unit) if result && to_unit
+
+            result || []
+          end
+
+          private
+
+          def integer_value(value)
+            return 0 if value == false
+            return 1 if value == true
+            return value if value.is_a?(::Numeric) && value.to_i == value
+            return value.to_i if value.is_a?(::String) && INT_REGEX.match?(value)
+
+            []
+          end
+
+          def normalize_unit(unit)
+            Nodes::FPQuantity::TIME_UNITS_TO_UCUM.key?(unit) ? unit : "'#{unit}'"
+          end
+
+          def convert_to_unit(result, to_unit)
+            return result if result.unit == to_unit
+
+            Nodes::FPQuantity.conv_unit_to(result.unit, result.value, to_unit)
+          end
+
+          def parse_quantity(value)
+            return Nodes::FPQuantity.new(value, "'1'") if value.is_a?(::Numeric)
+            return value if value.is_a?(Nodes::FPQuantity)
+            return Nodes::FPQuantity.new(value ? 1 : 0, "'1'") if [true, false].include?(value)
+            return parse_quantity_string(value) if value.is_a?(::String)
+
+            nil
+          end
+
+          def parse_quantity_string(value)
+            match = QUANTITY_REGEX.match(value)
+            return nil unless match
+
+            time = match[3]
+            return nil if time && !Nodes::FPQuantity::TIME_UNITS_TO_UCUM.key?(time)
+
+            Nodes::FPQuantity.new(BigDecimal(match[1]), match[2] || time || "'1'")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Reopens Misc (see misc.rb) to add `toBoolean`/the convertsTo* family, ported from
+      # fhirpath-py's fhirpathpy/engine/invocations/misc.py.
+      module Misc
+        class << self
+          TRUE_STRINGS = %w[true t yes y 1 1.0].freeze
+          FALSE_STRINGS = %w[false f no n 0 0.0].freeze
+
+          # Unlike the other to_* conversions, this checks the raw collection item's own type
+          # directly (not Util.get_data-unwrapped) — mirrors fhirpath-py's to_boolean.
+          def to_boolean(_ctx, coll)
+            return [] if coll.length != 1
+
+            value = coll.first
+            return value if [true, false].include?(value)
+            return boolean_from_number(value) if value.is_a?(::Numeric)
+            return boolean_from_string(value) if value.is_a?(::String)
+
+            []
+          end
+
+          # Ports fhirpath-py's create_converts_to_fn: the collection must be a singleton, and
+          # the conversion must both succeed (not fall back to `[]`) and produce a value of the
+          # expected Ruby class.
+          def converts_to?(ctx, coll, expected_class, &converter)
+            return [] if coll.length != 1
+
+            converter.call(ctx, coll).is_a?(expected_class)
+          end
+
+          def converts_to_boolean(ctx, coll)
+            return [] if coll.length != 1
+
+            [true, false].include?(to_boolean(ctx, coll))
+          end
+
+          def converts_to_integer(ctx, coll)
+            converts_to?(ctx, coll, ::Integer) { |c, co| to_integer(c, co) }
+          end
+
+          def converts_to_decimal(ctx, coll)
+            converts_to?(ctx, coll, ::BigDecimal) { |c, co| to_decimal(c, co) }
+          end
+
+          def converts_to_string(ctx, coll)
+            converts_to?(ctx, coll, ::String) { |c, co| to_string(c, co) }
+          end
+
+          def converts_to_date(ctx, coll)
+            converts_to?(ctx, coll, Nodes::FPDateTime) { |c, co| to_date(c, co) }
+          end
+
+          def converts_to_date_time(ctx, coll)
+            converts_to?(ctx, coll, Nodes::FPDateTime) { |c, co| to_date_time(c, co) }
+          end
+
+          def converts_to_time(ctx, coll)
+            converts_to?(ctx, coll, Nodes::FPTime) { |c, co| to_time(c, co) }
+          end
+
+          def converts_to_quantity(ctx, coll)
+            converts_to?(ctx, coll, Nodes::FPQuantity) { |c, co| to_quantity(c, co) }
+          end
+
+          private
+
+          def boolean_from_number(value)
+            return true if [1, 1.0].include?(value)
+            return false if [0, 0.0].include?(value)
+
+            []
+          end
+
+          def boolean_from_string(value)
+            lower = value.downcase
+            return true if TRUE_STRINGS.include?(lower)
+            return false if FALSE_STRINGS.include?(lower)
+
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of `children`/`descendants` from fhirpath-py's
+      # fhirpathpy/engine/invocations/navigation.py.
+      module Navigation
+        class << self
+          def children(ctx, coll)
+            coll.reduce([]) { |acc, res| reduce_children(ctx, acc, res, exclude_primitive_extensions: true) }
+          end
+
+          def descendants(ctx, coll)
+            res = []
+            current = reduce_all_children(ctx, coll)
+
+            until current.empty?
+              res += current
+              current = reduce_all_children(ctx, current)
+            end
+
+            res
+          end
+
+          private
+
+          def reduce_all_children(ctx, coll)
+            coll.reduce([]) { |acc, item| reduce_children(ctx, acc, item, exclude_primitive_extensions: false) }
+          end
+
+          def reduce_children(ctx, acc, res, exclude_primitive_extensions:)
+            model = ctx[:model]
+            data = Util.get_data(res)
+            res = Nodes::ResourceNode.create_node(res)
+
+            data = data.each_with_index.to_h { |value, i| [i, value] } if data.is_a?(::Array)
+            return acc unless data.is_a?(::Hash)
+
+            data.each_key do |prop|
+              next if prop.start_with?("_") && exclude_primitive_extensions
+
+              acc = reduce_child(model, acc, res, prop, data[prop])
+            end
+
+            acc
+          end
+
+          def reduce_child(model, acc, res, prop, value)
+            child_path, full_path = child_paths(model, res, prop)
+
+            if value.is_a?(::Array)
+              value.each_with_index do |item, i|
+                acc += [Nodes::ResourceNode.create_node(item, child_path, prop_name: "#{full_path}[#{i}]", index: i)]
+              end
+            else
+              acc += [Nodes::ResourceNode.create_node(value, child_path, prop_name: full_path)]
+            end
+
+            acc
+          end
+
+          def child_paths(model, res, prop)
+            child_path = res.path ? "#{res.path}.#{prop}" : ""
+            full_path = (res.prop_name ? "#{res.prop_name}.#{prop}" : child_path).delete("_")
+
+            child_path = "Extension" if prop == "extension"
+            child_path = remap(model, "pathsDefinedElsewhere", child_path)
+            child_path = remap(model, "path2Type", child_path)
+            full_path = choice_type_full_path(model, res, prop, child_path) || full_path
+
+            [child_path, full_path]
+          end
+
+          def remap(model, table, child_path)
+            return child_path unless model.is_a?(::Hash) && model[table]
+
+            model[table].fetch(child_path, child_path)
+          end
+
+          # When a property's name already carries its (shrunk-to-a-bare-type) childPath as a
+          # suffix (e.g. prop "valueString" vs childPath "string"), it's really a choice-type
+          # field — fullPath should point at the shared field name ("value"), not "valueString".
+          def choice_type_full_path(model, res, prop, child_path)
+            return nil unless prop.downcase.end_with?(child_path.downcase) && prop.length > child_path.length
+
+            base_prop = prop[0...-child_path.length]
+            return nil if choice_types(model, "#{res.path}.#{base_prop}").empty?
+
+            "#{res.prop_name}.#{base_prop}"
+          end
+
+          def choice_types(model, alt_prop_name)
+            return [] unless model.is_a?(::Hash)
+
+            (model["choiceTypePaths"] || {})[alt_prop_name] || []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # The string functions and single-argument math functions half of REGISTRY (see
+      # invocations.rb, which merges this in) — split out purely to keep that module's line
+      # count down.
+      REGISTRY_STRINGS_AND_MATH = {
+        "indexOf" => { fn: Strings.method(:index_of), arity: { 1 => ["String"] }, nullable_input: true },
+        "substring" => {
+          fn: Strings.method(:substring),
+          arity: { 1 => ["Integer"], 2 => %w[Integer Integer] },
+          nullable_input: true
+        },
+        "startsWith" => { fn: Strings.method(:starts_with), arity: { 1 => ["String"] }, nullable_input: true },
+        "endsWith" => { fn: Strings.method(:ends_with), arity: { 1 => ["String"] }, nullable_input: true },
+        "contains" => { fn: Strings.method(:contains), arity: { 1 => ["String"] }, nullable_input: true },
+        "upper" => { fn: Strings.method(:upper), nullable_input: true },
+        "lower" => { fn: Strings.method(:lower), nullable_input: true },
+        "replace" => { fn: Strings.method(:replace), arity: { 2 => %w[String String] }, nullable_input: true },
+        "matches" => { fn: Strings.method(:matches), arity: { 1 => ["String"] }, nullable_input: true },
+        "replaceMatches" => {
+          fn: Strings.method(:replace_matches),
+          arity: { 2 => %w[String String] },
+          nullable_input: true
+        },
+        "length" => { fn: Strings.method(:length), nullable_input: true },
+        "toChars" => { fn: Strings.method(:to_chars) },
+        "join" => { fn: Strings.method(:join), arity: { 0 => [], 1 => ["String"] } },
+        "split" => { fn: Strings.method(:split), arity: { 1 => ["String"] }, nullable_input: true },
+        "trim" => { fn: Strings.method(:trim), nullable_input: true },
+        "encode" => { fn: Strings.method(:encode), arity: { 1 => ["String"] } },
+        "decode" => { fn: Strings.method(:decode), arity: { 1 => ["String"] } },
+        "abs" => { fn: Math.method(:abs) },
+        "ceiling" => { fn: Math.method(:ceiling) },
+        "exp" => { fn: Math.method(:exp) },
+        "floor" => { fn: Math.method(:floor) },
+        "ln" => { fn: Math.method(:ln) },
+        "log" => { fn: Math.method(:log), arity: { 1 => ["Number"] }, nullable: true },
+        "power" => { fn: Math.method(:power), arity: { 1 => ["Number"] }, nullable: true },
+        "round" => { fn: Math.method(:round), arity: { 1 => ["Number"] } },
+        "sqrt" => { fn: Math.method(:sqrt) },
+        "truncate" => { fn: Math.method(:truncate) }
+      }.freeze
+    end
+  end
+end