fhirpath 0.2.0.pre1

data/lib/fhirpath/functions.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module FHIRPath
+  FunctionSpec = Struct.new(:name, :arity, :parameters, :receiver, :delayed,
+                            :implementation, keyword_init: true) do
+    def initialize(**kwargs)
+      super
+      self.name = name.to_s.freeze
+      self.parameters = Array(parameters).map(&:to_sym).freeze
+      freeze
+    end
+  end
+
+  class FunctionRegistry
+    STANDARD_NAMES = %w[
+      where select first last tail take skip
+      exists count empty not all
+      allTrue anyTrue allFalse anyFalse
+      sum avg max min
+    ].freeze
+    DELAYED_NAMES = %w[where select exists all].freeze
+
+    def self.standard
+      @standard ||= new(STANDARD_NAMES.each_with_object({}) do |name, specs|
+        specs[name] = standard_spec(name)
+      end)
+    end
+
+    def self.standard_spec(name)
+      FunctionSpec.new(
+        name: name,
+        arity: standard_arity(name),
+        parameters: DELAYED_NAMES.include?(name) ? [:expression] : [],
+        receiver: :collection,
+        delayed: DELAYED_NAMES.include?(name)
+      )
+    end
+
+    def self.standard_arity(name)
+      return 0..1 if name == 'exists'
+      return 1 if name == 'all' || %w[where select take skip].include?(name)
+
+      0
+    end
+    private_class_method :standard_arity, :standard_spec
+
+    def initialize(specs = {})
+      @specs = specs.transform_keys(&:to_s).dup.freeze
+      freeze
+    end
+
+    def find(name)
+      @specs[name.to_s]
+    end
+
+    def include?(name)
+      !find(name).nil?
+    end
+
+    def register(spec)
+      key = spec.name.to_s
+      raise ArgumentError, "cannot replace standard function: #{key}" if STANDARD_NAMES.include?(key)
+
+      self.class.new(@specs.merge(key => spec))
+    end
+
+    def names
+      @specs.keys.freeze
+    end
+  end
+end

data/lib/fhirpath/host_services.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module FHIRPath
+  # Explicit boundary for external constant lookup. Implementations may perform
+  # I/O, but only when an expression requests a constant through this object.
+  class ConstantProvider
+    def fetch(_name, mode:, context:)
+      raise NotImplementedError, 'constant providers must implement #fetch'
+    end
+
+    def call(name, mode:, context:)
+      fetch(name, mode: mode, context: context)
+    end
+  end
+
+  # Optional host work is explicit and absent from pure evaluation by default.
+  class HostServices
+    attr_reader :constants, :constant_provider, :resolve_reference, :terminology, :element_children, :trace
+
+    def self.default
+      @default ||= new
+    end
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(constants: nil, constant_provider: nil, resolve_reference: nil, terminology: nil,
+                   element_children: nil, trace: nil)
+      raise ArgumentError, 'provide either constants or constant_provider, not both' if constants && constant_provider
+
+      @constant_provider = constant_provider || constants
+      @constants = @constant_provider
+      @resolve_reference = resolve_reference
+      @terminology = terminology
+      @element_children = element_children
+      @trace = trace
+      freeze
+    end
+
+    def constant(name, mode: nil, context: nil)
+      unless constants
+        raise UnknownConstantError.new("unknown external constant: %#{name}",
+                                       code: :unknown_constant)
+      end
+
+      begin
+        constants.call(name, mode: mode, context: context)
+      rescue StandardError
+        raise HostError.new('constant provider failed', code: :host_error), cause: nil
+      end
+    end
+    # rubocop:enable Metrics/ParameterLists
+  end
+end

data/lib/fhirpath/model.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module FHIRPath
+  # Adapter boundary for navigating host objects without FHIR dependencies.
+  class ModelProvider
+    def property(_element, _logical_name)
+      raise NotImplementedError
+    end
+
+    def root_type(_resource)
+      nil
+    end
+
+    # Model type name of the value that `property` resolves for +logical_name+
+    # on +element+, or nil when the model does not declare one (e.g. a
+    # non-choice field or an absent choice). Safe default: no metadata, no
+    # access to the element contents.
+    def property_logical_type(_element, _logical_name)
+      nil
+    end
+  end
+
+  class PlainModel < ModelProvider
+    def root_type(resource)
+      return resource['resourceType'] if resource.is_a?(Hash) && resource.key?('resourceType')
+      return resource[:resourceType] if resource.is_a?(Hash) && resource.key?(:resourceType)
+
+      resource.class.name
+    end
+
+    def property(element, logical_name)
+      case element
+      when Hash
+        return element[logical_name] if element.key?(logical_name)
+
+        symbol = logical_name.to_sym
+        element[symbol] if element.key?(symbol)
+      when Struct
+        symbol = logical_name.to_sym
+        element[symbol] if element.members.include?(symbol)
+      end
+      # No dynamic method dispatch: expression-selected paths must not trigger
+      # arbitrary application behavior. Custom object navigation belongs in a
+      # ModelProvider.
+    end
+  end
+end

data/lib/fhirpath/model_registry.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FHIRPath
+  # Named, versioned model providers available to the public API.
+  module ModelRegistry
+    module_function
+
+    def fetch(release)
+      case release.to_s.downcase
+      when 'r4', '4', '4.0.1'
+        FHIR::R4::ModelProvider.new
+      else
+        raise ArgumentError, "unknown FHIR model release: #{release}"
+      end
+    end
+  end
+end

data/lib/fhirpath/models_r4.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module FHIRPath
+  module FHIR
+    module R4
+      # Dependency-free adapter for the FHIR R4 JSON representation.
+      #
+      # The evaluator only knows the ModelProvider protocol. FHIR release
+      # metadata stays in this adapter so a different release can provide its
+      # own provider without changing the language core.
+      class ModelProvider < FHIRPath::ModelProvider
+        RELEASE = 'R4'
+        VERSION = '4.0.1'
+
+        CHOICE_FIELDS = {
+          'Observation' => {
+            'value' => %w[
+              valueQuantity valueCodeableConcept valueString valueBoolean
+              valueInteger valueRange valueRatio valueSampledData valueTime
+              valueDateTime valuePeriod
+            ].freeze
+          }
+        }.freeze
+        CHOICE_TYPES = {
+          'Observation' => {
+            'value' => %w[
+              Quantity CodeableConcept string boolean integer Range Ratio SampledData time dateTime Period
+            ].freeze
+          }
+        }.freeze
+
+        def root_type(resource)
+          return resource['resourceType'] if resource.is_a?(Hash) && resource.key?('resourceType')
+          return resource[:resourceType] if resource.is_a?(Hash) && resource.key?(:resourceType)
+
+          resource.class.name
+        end
+
+        def property(element, logical_name)
+          return direct_property(element, logical_name) if direct_property?(element, logical_name)
+
+          choice_names = CHOICE_FIELDS.fetch(root_type(element).to_s, {}).fetch(logical_name.to_s, [])
+          choice_names.each do |choice_name|
+            return element[choice_name] if element.is_a?(Hash) && element.key?(choice_name)
+            return element[choice_name.to_sym] if element.is_a?(Hash) && element.key?(choice_name.to_sym)
+          end
+          nil
+        end
+
+        def choice_types(parent_type, logical_name)
+          CHOICE_TYPES.fetch(parent_type.to_s, {}).fetch(logical_name.to_s, []).freeze
+        end
+
+        # Model type name of the choice variant that `property` resolves for
+        # +logical_name+ on +element+, using the same key order as CHOICE_FIELDS
+        # so the concrete variant maps to its declared type (valueQuantity ->
+        # Quantity, valueString -> string). Returns nil when no choice variant
+        # is present or the property is not a declared choice.
+        def property_logical_type(element, logical_name)
+          choice_names = CHOICE_FIELDS.fetch(root_type(element).to_s, {}).fetch(logical_name.to_s, [])
+          return nil if choice_names.empty?
+
+          index = choice_names.index do |choice_name|
+            element.is_a?(Hash) &&
+              (element.key?(choice_name) || element.key?(choice_name.to_sym))
+          end
+          return nil if index.nil?
+
+          CHOICE_TYPES.fetch(root_type(element).to_s, {}).fetch(logical_name.to_s, [])[index]
+        end
+
+        def type_of(element)
+          root_type(element)
+        end
+
+        private
+
+        def direct_property?(element, logical_name)
+          element.is_a?(Hash) &&
+            (element.key?(logical_name.to_s) || element.key?(logical_name.to_sym))
+        end
+
+        def direct_property(element, logical_name)
+          return element[logical_name.to_s] if element.key?(logical_name.to_s)
+
+          element[logical_name.to_sym]
+        end
+      end
+    end
+  end
+end