fhirpath-rb 0.1.1

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "existence"
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of `combine`/`union_op`/`coalesce_fn` from fhirpath-py's
+      # fhirpathpy/engine/invocations/combining.py.
+      module Combining
+        def self.combine(_ctx, coll1, coll2)
+          coll1 + coll2
+        end
+
+        def self.union(ctx, coll1, coll2)
+          Existence.distinct(ctx, coll1 + coll2)
+        end
+
+        def self.coalesce(_ctx, data, *exprs)
+          exprs.each do |expr|
+            result = expr.call(data)
+            return result unless Util.empty?(result)
+          end
+
+          []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of `now`/`today`/`timeOfDay` from fhirpath-py's
+      # fhirpathpy/engine/invocations/datetime.py. fhirpath-py caches these on a module-level
+      # `constants` singleton reset at the start of each evaluate() call, so that repeated calls
+      # within one expression see the same instant; here that's just a `ctx` entry, since `ctx`
+      # is already fresh per evaluate() call.
+      module Datetime
+        class << self
+          def now(ctx, _data)
+            snapshot(ctx).strftime("%Y-%m-%dT%H:%M:%S.%L%:z")
+          end
+
+          def today(ctx, _data)
+            snapshot(ctx).strftime("%Y-%m-%d")
+          end
+
+          def time_of_day(ctx, _data)
+            snapshot(ctx).strftime("%H:%M:%S.%L")
+          end
+
+          private
+
+          def snapshot(ctx)
+            ctx[:now_time] ||= Time.now
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "equivalence"
+require_relative "inequality"
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of `=`/`!=` from fhirpath-py's fhirpathpy/engine/invocations/equality.py.
+      # `~`/`!~` (equivalence) live in equivalence.rb and `<`/`>`/`<=`/`>=` in inequality.rb,
+      # both of which reopen this module (and use datetime_value?/coerce_datetime, below).
+      module Equality
+        class << self
+          def equal(_ctx, left, right)
+            equality(left, right)
+          end
+
+          def unequal(_ctx, left, right)
+            result = equality(left, right)
+            result.nil? ? nil : !result
+          end
+
+          private
+
+          # Per https://hl7.org/fhirpath/#equals. Returns true/false, or nil (spec: empty) when
+          # a DateTime/Time comparison can't be resolved at a shared precision. Collections with
+          # more than one item are compared pairwise, in order (fhirpath-py's own equality()
+          # only ever compares the first pair — a narrower reading no test here happens to
+          # probe — so this compares every pair instead, per the spec text quoted in this task's
+          # own fixture: "Each item must be equal. Comparison is order dependent.").
+          def equality(left, right)
+            return false if Util.empty?(left) || Util.empty?(right)
+
+            x0 = Util.get_data(left.first)
+            y0 = Util.get_data(right.first)
+            return datetime_equals(x0, y0) if datetime_value?(x0) || datetime_value?(y0)
+            return false if left.length != right.length
+
+            pairwise_equal?(left, right)
+          end
+
+          def pairwise_equal?(left, right)
+            left.zip(right).all? { |a, b| values_equal?(Util.val_data_converted(a), Util.val_data_converted(b)) }
+          end
+
+          # A raw FHIR Quantity element, converted to a System.Quantity, keeps its UCUM `code`
+          # quoted as-is (e.g. "'a'") — comparing that against a literal using the calendar
+          # *word* form ("year") needs FPQuantity#deep_equal instead of plain `==`; see there.
+          def values_equal?(left_value, right_value)
+            if left_value.is_a?(Nodes::FPQuantity) && right_value.is_a?(Nodes::FPQuantity) &&
+               Nodes::FPQuantity::CALENDAR_WORDS.include?(right_value.unit)
+              return left_value.deep_equal(right_value)
+            end
+
+            left_value == right_value
+          end
+
+          def datetime_value?(value)
+            value.is_a?(Nodes::FPDateTime) || value.is_a?(Nodes::FPTime)
+          end
+
+          def datetime_equals(left_value, right_value)
+            x = coerce_datetime(left_value)
+            y = coerce_datetime(right_value)
+            return false if x.nil? || y.nil?
+
+            x.equals(y)
+          end
+
+          # A string operand being compared against an already-parsed FPDateTime/FPTime is
+          # itself parsed as a date/time (trying DateTime first, then Time) before comparing;
+          # anything else (including an unparseable string) can't be compared this way.
+          def coerce_datetime(value)
+            return value if datetime_value?(value)
+            return nil unless value.is_a?(::String)
+
+            parse_date_time(value) || parse_time(value)
+          end
+
+          def parse_date_time(value)
+            Nodes::FPDateTime.new(value)
+          rescue Fhirpath::Error
+            nil
+          end
+
+          def parse_time(value)
+            Nodes::FPTime.new(value)
+          rescue Fhirpath::Error
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # `~`/`!~` from fhirpath-py's fhirpathpy/engine/invocations/equality.py. Split out of
+      # equality.rb to keep that file's module body short; reopens the same Equality module
+      # (datetime_value?/datetime_equals/coerce_datetime are defined there).
+      module Equality
+        class << self
+          def equival(_ctx, left, right)
+            result = equivalence(left, right)
+            result.nil? ? [false] : [result]
+          end
+
+          def unequival(_ctx, left, right)
+            result = equivalence(left, right)
+            result.nil? ? [true] : [!result]
+          end
+
+          private
+
+          # Per https://hl7.org/fhirpath/#equivalence. Unlike `=`, `{} ~ {}` is true, and a
+          # DateTime/Time precision mismatch is handled by the `[false]`/`[true]` fallback above
+          # rather than staying empty. Collections with more than one item are compared as a
+          # multiset (order-independent) — fhirpath-py's own equivalence() only ever compares
+          # the first pair once both collections are the same Mapping/list-shaped type, a
+          # narrower reading no test here happens to probe (see equality.rb's `equality` for the
+          # analogous `=` case).
+          def equivalence(left, right)
+            both_empty = equivalence_for_empty(left, right)
+            return both_empty unless both_empty.nil?
+
+            return false if left.length != right.length
+
+            x0 = Util.val_data_converted(left.first)
+            y0 = Util.val_data_converted(right.first)
+            return datetime_equals(x0, y0) if datetime_value?(x0) || datetime_value?(y0)
+
+            left.length == 1 ? value_equivalent?(x0, y0) : multiset_equivalent?(left, right)
+          end
+
+          def equivalence_for_empty(left, right)
+            return true if Util.empty?(left) && Util.empty?(right)
+            return false if Util.empty?(left) || Util.empty?(right)
+
+            nil
+          end
+
+          def multiset_equivalent?(left, right)
+            remaining = right.map { |item| Util.val_data_converted(item) }
+
+            left.all? do |item|
+              value = Util.val_data_converted(item)
+              index = remaining.index { |candidate| value_equivalent?(value, candidate) == true }
+              next false unless index
+
+              remaining.delete_at(index)
+              true
+            end
+          end
+
+          def value_equivalent?(left, right)
+            return normalize_string(left) == normalize_string(right) if both_strings?(left, right)
+            return numbers_equivalent?(left, right) if left.is_a?(::BigDecimal) || right.is_a?(::BigDecimal)
+            return left.deep_equal(right) if both_quantities?(left, right)
+            return deep_equivalent?(left, right) if collection_like?(left) && collection_like?(right)
+
+            left == right
+          end
+
+          def both_strings?(left, right)
+            left.is_a?(::String) && right.is_a?(::String)
+          end
+
+          def both_quantities?(left, right)
+            left.is_a?(Nodes::FPQuantity) && right.is_a?(Nodes::FPQuantity)
+          end
+
+          def collection_like?(value)
+            value.is_a?(::Hash) || value.is_a?(::Array)
+          end
+
+          # Structural equivalence: hash keys compared as sets (order-independent), array
+          # elements compared as a sorted sequence, strings via normalize_string, and numbers
+          # within a small tolerance — mirrors fhirpath-py's nested deep_equal.
+          def deep_equivalent?(left, right)
+            case left
+            when ::Hash then hashes_equivalent?(left, right)
+            when ::Array then arrays_equivalent?(left, right)
+            when ::String then right.is_a?(::String) && normalize_string(left) == normalize_string(right)
+            when ::Numeric then right.is_a?(::Numeric) && (left - right).abs < 0.5
+            else left == right
+            end
+          end
+
+          def hashes_equivalent?(left, right)
+            return false unless right.is_a?(::Hash) && left.keys.sort == right.keys.sort
+
+            left.keys.all? { |key| deep_equivalent?(left[key], right[key]) }
+          end
+
+          def arrays_equivalent?(left, right)
+            return false unless right.is_a?(::Array) && left.length == right.length
+
+            sort_for_compare(left).zip(sort_for_compare(right)).all? { |x, y| deep_equivalent?(x, y) }
+          end
+
+          def sort_for_compare(array)
+            array.sort
+          rescue ::ArgumentError
+            array.sort_by(&:to_s)
+          end
+
+          def normalize_string(value)
+            value.downcase.split.join(" ")
+          end
+
+          # Values are compared rounded to the precision of the less-precise operand (trailing
+          # zeroes don't count as precision) — https://hl7.org/fhirpath/#equivalence.
+          def numbers_equivalent?(left, right)
+            places = [decimal_places(left), decimal_places(right)].min
+            return Util.to_big_decimal(left).round == Util.to_big_decimal(right).round if places.zero?
+
+            Util.to_big_decimal(left).round(places) == Util.to_big_decimal(right).round(places)
+          end
+
+          def decimal_places(value)
+            str = Util.to_big_decimal(value).to_s("F")
+            return 0 unless str.include?(".")
+
+            str.split(".").last.sub(/0+\z/, "").length
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "filtering"
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of fhirpath-py's fhirpathpy/engine/invocations/existence.py (FHIRPath spec
+      # section 5.1).
+      module Existence
+        class << self
+          def empty(_ctx, value)
+            Util.empty?(value)
+          end
+
+          def count(_ctx, value)
+            value.is_a?(::Array) ? value.length : 0
+          end
+
+          def not(_ctx, coll)
+            return [] if coll.empty?
+
+            if coll.length > 1
+              raise Fhirpath::Error, "Unexpected collection #{coll.inspect}; expected singleton of type Boolean"
+            end
+
+            !singleton_truthy?(coll.first)
+          end
+
+          def exists(ctx, coll, expr = nil)
+            return !Util.empty?(coll) if expr.nil?
+
+            exists(ctx, Filtering.where(ctx, coll, expr))
+          end
+
+          def all(ctx, colls, expr)
+            colls.each_with_index do |coll, index|
+              ctx[:index] = index
+              return [false] unless Util.true?(expr.call(coll))
+            end
+
+            [true]
+          end
+
+          def all_true(_ctx, items)
+            items.all? { |item| boolean_value(item) }
+          end
+
+          def any_true(_ctx, items)
+            items.any? { |item| boolean_value(item) }
+          end
+
+          def all_false(_ctx, items)
+            items.all? { |item| !boolean_value(item) }
+          end
+
+          def any_false(_ctx, items)
+            items.any? { |item| !boolean_value(item) }
+          end
+
+          # `coll2.include?(item)` would be asymmetric here: Ruby's String#== (unlike Python's
+          # equality protocol, which falls back to the other side's __eq__) just returns false
+          # when compared against a non-String, so a raw-string coll2 checked against a
+          # ResourceNode-wrapped item would wrongly report "not found" even when the underlying
+          # data matches. Comparing unwrapped data on both sides avoids that.
+          def subset_of(_ctx, coll1, coll2)
+            coll2_data = coll2.map { |item| Util.get_data(item) }
+            coll1.all? { |item| coll2_data.include?(Util.get_data(item)) }
+          end
+
+          def superset_of(ctx, coll1, coll2)
+            subset_of(ctx, coll2, coll1)
+          end
+
+          def distinct?(ctx, coll)
+            coll.length == distinct(ctx, coll).length
+          end
+
+          def distinct(_ctx, coll)
+            return distinct_resource_nodes(coll) if coll.any? && coll.all? { |v| v.is_a?(Nodes::ResourceNode) }
+            return distinct_quantities(coll) if coll.any? && coll.all? { |v| v.is_a?(Nodes::FPQuantity) }
+
+            Util.uniq(coll)
+          end
+
+          private
+
+          def boolean_value(item)
+            value = Util.get_data(item)
+            raise Fhirpath::Error, "Expected boolean, but got: #{value.inspect}" unless [true, false].include?(value)
+
+            value
+          end
+
+          # Mirrors fhirpath-py's boolean_singleton (used only by `not`, unlike the strict
+          # boolean_value above used by allTrue/anyTrue/allFalse/anyFalse): a present non-empty
+          # singleton coerces to `true` unless it's literally the boolean `false`.
+          def singleton_truthy?(item)
+            value = Util.get_data(item)
+            [true, false].include?(value) ? value : true
+          end
+
+          def distinct_resource_nodes(coll)
+            Util.uniq(coll.map(&:data)).map { |item| Nodes::ResourceNode.create_node(item) }
+          end
+
+          # FP_Quantity#== already treats e.g. "1 year" and "12 months" as equal
+          # (https://hl7.org/fhirpath/#equals); dedupe with a linear scan since quantities
+          # aren't otherwise hashable/canonicalizable the way Util.uniq's values are.
+          def distinct_quantities(coll)
+            coll.each_with_object([]) { |value, acc| acc << value unless acc.include?(value) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of `where`/`select`/`repeat`/`ofType`/`single`/`first`/`last`/`tail`/`take`/
+      # `skip`/`extension` from fhirpath-py's fhirpathpy/engine/invocations/filtering.py.
+      module Filtering
+        class << self
+          def single(_ctx, coll)
+            return coll if coll.length == 1
+            return [] if coll.empty?
+
+            { "$status" => "error", "$error" => "Expected single" }
+          end
+
+          def first(_ctx, coll)
+            coll.empty? ? [] : coll.first
+          end
+
+          def last(_ctx, coll)
+            coll.empty? ? [] : coll.last
+          end
+
+          def tail(_ctx, coll)
+            coll.empty? ? [] : coll[1..]
+          end
+
+          def take(_ctx, coll, num)
+            coll.empty? ? [] : coll.first([num.to_i, 0].max)
+          end
+
+          def skip(_ctx, coll, num)
+            coll.empty? ? [] : coll.drop([num.to_i, 0].max)
+          end
+
+          def where(ctx, data, expr)
+            return [] unless data.is_a?(::Array)
+
+            result = data.each_with_index.select do |item, index|
+              ctx[:index] = index
+              truthy?(expr.call(item))
+            end.map(&:first)
+
+            Util.flatten(result)
+          end
+
+          def select(ctx, data, expr)
+            return [] unless data.is_a?(::Array)
+
+            result = data.each_with_index.map do |item, index|
+              ctx[:index] = index
+              expr.call(item)
+            end
+
+            Util.flatten(result)
+          end
+
+          def repeat(_ctx, data, expr)
+            return [] unless data.is_a?(::Array)
+
+            result = []
+            seen = []
+            items = data.dup
+
+            advance_repeat(items, seen, result, expr) until items.empty?
+
+            result
+          end
+
+          def of_type(ctx, coll, type_info)
+            coll.select { |value| Nodes::TypeInfo.from_value(value, ctx[:model]).is_(type_info, ctx[:model]) }
+          end
+
+          def extension(_ctx, data, url)
+            data.each_with_object([]) do |item, acc|
+              element = Util.get_data(item)
+              next unless element.is_a?(::Hash)
+
+              match = (element["extension"] || []).find { |ext| ext["url"] == url }
+              acc << Nodes::ResourceNode.create_node(match, "Extension") if match
+            end
+          end
+
+          private
+
+          def truthy?(result)
+            return false if result.empty?
+
+            value = result.first
+            !(value.nil? || value == false)
+          end
+
+          def advance_repeat(items, seen, result, expr)
+            next_item = items.shift
+            new_items = expr.call(next_item).reject { |elem| seen.include?(elem) }
+            return if new_items.empty?
+
+            seen.concat(new_items)
+            result.concat(new_items)
+            items.concat(new_items)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # `<`/`>`/`<=`/`>=` from fhirpath-py's fhirpathpy/engine/invocations/equality.py
+      # (typecheck/lt/gt/lte/gte). Split out of equality.rb to keep that file's module body
+      # short; reopens the same Equality module (datetime_value?/coerce_datetime are defined
+      # there).
+      module Equality
+        class << self
+          def lt(_ctx, left, right)
+            compare(left, right) { |ordinal| ordinal == -1 }
+          end
+
+          def gt(_ctx, left, right)
+            compare(left, right) { |ordinal| ordinal == 1 }
+          end
+
+          def lte(_ctx, left, right)
+            compare(left, right) { |ordinal| ordinal <= 0 }
+          end
+
+          def gte(_ctx, left, right)
+            compare(left, right) { |ordinal| ordinal >= 0 }
+          end
+
+          private
+
+          # Per https://hl7.org/fhirpath/#comparison. Returns [] for an empty operand or a
+          # DateTime/Time comparison that can't be resolved at a shared precision.
+          def compare(left, right)
+            return [] if Util.empty?(left) || Util.empty?(right)
+
+            left_value, right_value = typecheck(left, right)
+            ordinal = ordinal_compare(left_value, right_value)
+            return [] if ordinal.nil?
+
+            yield ordinal
+          end
+
+          def ordinal_compare(left_value, right_value)
+            return left_value.compare(right_value) if datetime_value?(left_value)
+
+            left_value <=> right_value
+          end
+
+          # Singleton-checks both sides and requires them to be the same type (numbers are
+          # cross-comparable regardless of exact class); a string compared against a
+          # DateTime/Time is itself parsed as one first.
+          def typecheck(left, right)
+            left = Util.remove_duplicate_extension(left)
+            right = Util.remove_duplicate_extension(right)
+            check_length(left)
+            check_length(right)
+
+            a = Util.get_data(left.first)
+            b = Util.get_data(right.first)
+            return [a, b] if a.instance_of?(b.class) || (a.is_a?(::Numeric) && b.is_a?(::Numeric))
+
+            coerce_mismatched_types(a, b) || raise_type_mismatch(a, b)
+          end
+
+          def check_length(coll)
+            return unless coll.length > 1
+
+            raise Fhirpath::Error,
+                  "Was expecting no more than one element but got #{coll.inspect}. Singleton was expected"
+          end
+
+          def coerce_mismatched_types(left, right)
+            return coerce_left_string(left, right) if left.is_a?(::String) && datetime_value?(right)
+            return coerce_left_string(right, left)&.reverse if right.is_a?(::String) && datetime_value?(left)
+
+            nil
+          end
+
+          def coerce_left_string(string_value, datetime)
+            coerced = coerce_datetime(string_value)
+            coerced ? [coerced, datetime] : nil
+          end
+
+          def raise_type_mismatch(left, right)
+            raise Fhirpath::Error,
+                  "Type of \"#{left}\" (#{left.class}) did not match type of \"#{right}\" (#{right.class}). " \
+                  "InequalityExpression"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of `and`/`or`/`xor`/`implies` from fhirpath-py's
+      # fhirpathpy/engine/invocations/logic.py (three-valued Boolean logic — each operand is
+      # `true`, `false`, or `[]` for empty, per https://hl7.org/fhirpath/#boolean-logic).
+      module Logic
+        class << self
+          def or_op(_ctx, left, right)
+            return or_with_empty_right(left) if right.is_a?(::Array)
+            return or_with_empty_left(right) if left.is_a?(::Array)
+
+            left || right
+          end
+
+          def and_op(_ctx, left, right)
+            return and_with_empty_right(left) if right.is_a?(::Array)
+            return and_with_empty_left(right) if left.is_a?(::Array)
+
+            left && right
+          end
+
+          def xor_op(_ctx, left, right)
+            return [] if left.is_a?(::Array) || right.is_a?(::Array)
+
+            (left && !right) || (!left && right)
+          end
+
+          def implies_op(_ctx, left, right)
+            return implies_with_empty_right(left) if right.is_a?(::Array)
+            return implies_with_empty_left(right) if left.is_a?(::Array)
+            return true if left == false
+
+            left && right
+          end
+
+          private
+
+          def or_with_empty_right(left)
+            return true if left == true
+
+            []
+          end
+
+          def or_with_empty_left(right)
+            right == true ? true : []
+          end
+
+          def and_with_empty_right(left)
+            return false if left == false
+
+            []
+          end
+
+          def and_with_empty_left(right)
+            right == true ? [] : false
+          end
+
+          def implies_with_empty_right(left)
+            return true if left == false
+
+            []
+          end
+
+          def implies_with_empty_left(right)
+            right == true ? true : []
+          end
+        end
+      end
+    end
+  end
+end