fhirpath-rb 0.1.1

data/lib/fhirpath/engine/param_resolution.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  # Resolves a raw AST param node into the value/lambda an invocation function expects, given
+  # its declared param type ("Expr", "Any", "AnyAtRoot", "TypeSpecifier", "Integer", "String").
+  # Ported from fhirpath-py's fhirpathpy/engine/__init__.py make_param + type_specifier. Split
+  # out of engine.rb to keep that file's module body short; reopens the same Engine module.
+  module Engine
+    class << self
+      SINGLETON_PARAM_CHECKS = {
+        "Integer" => ->(data) { data.is_a?(::Numeric) && data.to_i == data },
+        "Number" => ->(data) { data.is_a?(::Numeric) },
+        "String" => ->(data) { data.is_a?(::String) },
+        "Boolean" => ->(data) { [true, false].include?(data) }
+      }.freeze
+
+      def make_param(ctx, parent_data, node_type, param)
+        return build_expr_param(ctx, param) if node_type == "Expr"
+        return eval_param(ctx, parent_data, param) if node_type == "Any"
+        return eval_param(ctx, ctx[:this] || ctx[:root], param) if node_type == "AnyAtRoot"
+        return type_specifier(param) if node_type == "TypeSpecifier"
+        return check_singleton_param(ctx, parent_data, param, node_type) if SINGLETON_PARAM_CHECKS.key?(node_type)
+
+        raise Fhirpath::Error, "Implement me for #{node_type}"
+      end
+
+      private
+
+      # Ports fhirpath-py's make_param's singleton + param_check_table handling: evaluate the
+      # param as a singleton against parent_data, then require it to satisfy the given type.
+      def check_singleton_param(ctx, parent_data, param, type_name)
+        ctx[:this] = parent_data
+        res = do_eval(ctx, parent_data, param)
+        return [] if res.empty?
+
+        raise Fhirpath::Error, "Unexpected collection; expected singleton of type #{type_name}" if res.length > 1
+
+        data = Util.get_data(res.first)
+        unless SINGLETON_PARAM_CHECKS[type_name].call(data)
+          raise Fhirpath::Error, "Expected #{type_name.downcase}, got: #{data.inspect}"
+        end
+
+        data
+      end
+
+      # Ports fhirpath-py's module-level type_specifier: regardless of how the parameter node
+      # is shaped internally, its source text (e.g. "string", "FHIR.Patient") is what matters.
+      def type_specifier(node)
+        identifiers = node["text"].delete("`").split(".")
+
+        case identifiers.length
+        when 1
+          Nodes::TypeInfo.new(identifiers.first, nil)
+        when 2
+          Nodes::TypeInfo.new(identifiers[1], identifiers[0])
+        else
+          raise Fhirpath::Error, "Expected TypeSpecifier node, got #{node}"
+        end
+      end
+
+      def build_expr_param(ctx, param)
+        lambda do |data|
+          ctx[:this] = Util.arraify(data)
+          do_eval(ctx, ctx[:this], param)
+        end
+      end
+
+      def eval_param(ctx, data, param)
+        ctx[:this] = data
+        do_eval(ctx, data, param)
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/util.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Fhirpath
+  module Engine
+    # Ruby port of fhirpath-py's fhirpathpy/engine/util.py: small helpers shared across the
+    # evaluator, invocation dispatch, and invocation implementations.
+    module Util
+      class << self
+        def get_data(value)
+          value.is_a?(Nodes::ResourceNode) ? value.data : value
+        end
+
+        def val_data_converted(value)
+          value.is_a?(Nodes::ResourceNode) ? value.convert_data : value
+        end
+
+        def capitalized?(value)
+          value.is_a?(::String) && !value.empty? && value[0] == value[0].upcase
+        end
+
+        def empty?(value)
+          value.is_a?(::Array) && value.empty?
+        end
+
+        def some?(value)
+          !value.nil? && !empty?(value)
+        end
+
+        def nullable?(value)
+          value.nil? || empty?(value)
+        end
+
+        def arraify(value, instead_none = nil)
+          return value if value.is_a?(::Array)
+          return [value] if some?(value)
+
+          instead_none.nil? ? [] : [instead_none]
+        end
+
+        def flatten(values)
+          values.each_with_object([]) do |value, acc|
+            value.is_a?(::Array) ? acc.concat(value) : acc << value
+          end
+        end
+
+        def true?(value)
+          value == true || (value.is_a?(::Array) && value.length == 1 && value.first == true)
+        end
+
+        # BigDecimal#to_s always includes a fractional part (e.g. "7.0"); FHIRPath's decimal
+        # string representation (used by `toString`, FP_Quantity#to_s, ...) drops it for
+        # whole-number values (e.g. "7"), matching Python's Decimal str().
+        def format_number(value)
+          return value.to_s unless value.is_a?(::BigDecimal)
+
+          value.frac.zero? ? value.to_i.to_s : value.to_s("F")
+        end
+
+        def to_big_decimal(value)
+          return value if value.is_a?(::BigDecimal)
+          return BigDecimal(value) if value.is_a?(::Integer)
+
+          BigDecimal(value.to_s)
+        end
+
+        # Dedupes values that compare equal after normalizing hash key order (so
+        # `{"a"=>1,"b"=>2}` and `{"b"=>2,"a"=>1}` collapse together), preserving first-seen
+        # order — mirrors fhirpath-py's util.uniq (JSON-with-sorted-keys as the dedup key).
+        # A FHIR primitive element with an "_x" extension companion (e.g. "birthDate" +
+        # "_birthDate") navigates to a 2-item collection: the primitive value, then a
+        # ResourceNode wrapping just its `{"extension" => [...]}` sibling. Mirrors fhirpath-py's
+        # equality.remove_duplicate_extension (its own comment calls this "a temporary
+        # solution... needs to be fixed to a better solution") — used wherever only the
+        # primitive value matters (`+`/`-`, singleton type/length checks for `<`/`>`/`<=`/`>=`).
+        def remove_duplicate_extension(list)
+          second = list[1]
+          return list unless list.length == 2 && second.is_a?(Nodes::ResourceNode) &&
+                             second.data.is_a?(::Hash) && second.data.key?("extension")
+
+          list.first(1)
+        end
+
+        def uniq(values)
+          seen = {}
+          values.each_with_object([]) do |value, acc|
+            key = canonical_key(value)
+            next if seen[key]
+
+            seen[key] = true
+            acc << value
+          end
+        end
+
+        private
+
+        def canonical_key(value)
+          sorted_keys(value).to_s
+        rescue ::StandardError
+          value.to_s
+        end
+
+        def sorted_keys(value)
+          case value
+          when ::Hash
+            value.keys.sort_by(&:to_s).each_with_object({}) { |k, h| h[k] = sorted_keys(value[k]) }
+          when ::Array
+            value.map { |v| sorted_keys(v) }
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "engine/nodes/resource_node"
+require_relative "engine/nodes/fp_quantity"
+require_relative "engine/nodes/fp_quantity_deep_equal"
+require_relative "engine/nodes/fp_date_time"
+require_relative "engine/nodes/fp_date_time_arithmetic"
+require_relative "engine/nodes/fp_time"
+require_relative "engine/nodes/fp_time_arithmetic"
+require_relative "engine/nodes/type_info"
+require_relative "engine/util"
+require_relative "engine/invocations"
+require_relative "engine/evaluators"
+require_relative "engine/param_resolution"
+
+module Fhirpath
+  # Ruby port of fhirpath-py's fhirpathpy/engine/__init__.py: walks the AST built by
+  # Fhirpath::Parser (see Evaluators::DISPATCH for the per-node-type evaluators) and dispatches
+  # function/operator calls to Invocations::REGISTRY.
+  module Engine
+    class << self
+      def do_eval(ctx, parent_data, node)
+        evaluator = Evaluators::DISPATCH[node["type"]]
+        raise Fhirpath::Error, "No #{node["type"]} evaluator" unless evaluator
+
+        evaluator.call(ctx, parent_data, node)
+      end
+
+      def do_invoke(ctx, fn_name, data, raw_params)
+        fn_name, invocation = lookup_invocation(ctx, fn_name)
+        return [] if invocation[:nullable_input] && Util.nullable?(data)
+        return invoke_variadic(ctx, invocation, data, raw_params) if invocation[:variadic]
+        return call_niladic(ctx, fn_name, invocation, data, raw_params) unless invocation[:arity]
+
+        invoke_with_arity(ctx, fn_name, invocation, data, raw_params)
+      end
+
+      def infix_invoke(ctx, fn_name, data, raw_params)
+        invocation = invocation_registry(ctx)[fn_name]
+        raise Fhirpath::Error, "Not implemented #{fn_name}" unless invocation&.fetch(:fn, nil)
+        raise Fhirpath::Error, "Infix invoke should have arity 2" if raw_params.length != 2
+
+        params = [ctx] + positional_params(ctx, data, invocation[:arity][2], raw_params, 2)
+        call_invocation(invocation, params)
+      end
+
+      private
+
+      def lookup_invocation(ctx, fn_name)
+        registry = invocation_registry(ctx)
+        fn_name = fn_name.first if fn_name.is_a?(::Array) && fn_name.length == 1
+        raise Fhirpath::Error, "Not implemented: #{fn_name}" unless fn_name.is_a?(::String) && registry.key?(fn_name)
+
+        [fn_name, registry[fn_name]]
+      end
+
+      def call_niladic(ctx, fn_name, invocation, data, raw_params)
+        raise Fhirpath::Error, "#{fn_name} expects no params" unless raw_params.nil? || Util.empty?(raw_params)
+
+        Util.arraify(invocation[:fn].call(ctx, Util.arraify(data)))
+      end
+
+      def invoke_variadic(ctx, invocation, data, raw_params)
+        raw_params_list = raw_params.is_a?(::Array) ? raw_params : []
+        this_value = ctx[:this] || ctx[:root]
+        params = raw_params_list.map { |param| make_param(ctx, this_value, invocation[:variadic], param) }
+
+        Util.arraify(invocation[:fn].call(ctx, Util.arraify(data), *params))
+      end
+
+      def invoke_with_arity(ctx, fn_name, invocation, data, raw_params)
+        params_number = raw_params.is_a?(::Array) ? raw_params.length : 0
+        unless invocation[:arity].key?(params_number)
+          raise Fhirpath::Error,
+                "#{fn_name} wrong arity: got #{params_number}"
+        end
+
+        this_value = ctx[:this] || ctx[:root]
+        arg_types = invocation[:arity][params_number]
+        params = [ctx, data] + positional_params(ctx, this_value, arg_types, raw_params, params_number)
+
+        call_invocation(invocation, params)
+      end
+
+      def call_invocation(invocation, params)
+        return [] if invocation[:nullable] && params.any? { |param| Util.nullable?(param) }
+
+        Util.arraify(invocation[:fn].call(*params))
+      end
+
+      def positional_params(ctx, base_data, arg_types, raw_params, count)
+        (0...count).map { |i| make_param(ctx, base_data, arg_types[i], raw_params[i]) }
+      end
+
+      def invocation_registry(ctx)
+        Invocations::REGISTRY.merge(ctx[:user_invocation_table] || {})
+      end
+    end
+  end
+end