fhirpath-rb 0.1.1

data/lib/fhirpath/models/stu3/pathsDefinedElsewhere.json

@@ -0,0 +1,37 @@
+{
+  "Bundle.entry.link": "Bundle.link",
+  "CapabilityStatement.rest.searchParam": "CapabilityStatement.rest.resource.searchParam",
+  "ClaimResponse.addItem.adjudication": "ClaimResponse.item.adjudication",
+  "ClaimResponse.addItem.detail.adjudication": "ClaimResponse.item.adjudication",
+  "ClaimResponse.item.detail.adjudication": "ClaimResponse.item.adjudication",
+  "ClaimResponse.item.detail.subDetail.adjudication": "ClaimResponse.item.adjudication",
+  "CodeSystem.concept.concept": "CodeSystem.concept",
+  "Composition.section.section": "Composition.section",
+  "ConceptMap.group.element.target.product": "ConceptMap.group.element.target.dependsOn",
+  "Contract.term.group": "Contract.term",
+  "ExplanationOfBenefit.addItem.adjudication": "ExplanationOfBenefit.item.adjudication",
+  "ExplanationOfBenefit.addItem.detail.adjudication": "ExplanationOfBenefit.item.adjudication",
+  "ExplanationOfBenefit.item.detail.adjudication": "ExplanationOfBenefit.item.adjudication",
+  "ExplanationOfBenefit.item.detail.subDetail.adjudication": "ExplanationOfBenefit.item.adjudication",
+  "GraphDefinition.link.target.link": "GraphDefinition.link",
+  "ImplementationGuide.page.page": "ImplementationGuide.page",
+  "Observation.component.referenceRange": "Observation.referenceRange",
+  "OperationDefinition.parameter.part": "OperationDefinition.parameter",
+  "Parameters.parameter.part": "Parameters.parameter",
+  "PlanDefinition.action.action": "PlanDefinition.action",
+  "Provenance.entity.agent": "Provenance.agent",
+  "Questionnaire.item.item": "Questionnaire.item",
+  "QuestionnaireResponse.item.answer.item": "QuestionnaireResponse.item",
+  "QuestionnaireResponse.item.item": "QuestionnaireResponse.item",
+  "RequestGroup.action.action": "RequestGroup.action",
+  "StructureMap.group.rule.rule": "StructureMap.group.rule",
+  "TestReport.teardown.action.operation": "TestReport.setup.action.operation",
+  "TestReport.test.action.assert": "TestReport.setup.action.assert",
+  "TestReport.test.action.operation": "TestReport.setup.action.operation",
+  "TestScript.teardown.action.operation": "TestScript.setup.action.operation",
+  "TestScript.test.action.assert": "TestScript.setup.action.assert",
+  "TestScript.test.action.operation": "TestScript.setup.action.operation",
+  "ValueSet.compose.exclude": "ValueSet.compose.include",
+  "ValueSet.expansion.contains.contains": "ValueSet.expansion.contains",
+  "ValueSet.expansion.contains.designation": "ValueSet.compose.include.concept.designation"
+}

data/lib/fhirpath/models/stu3/type2Parent.json

@@ -0,0 +1,173 @@
+{
+  "Account": "DomainResource",
+  "ActivityDefinition": "DomainResource",
+  "Address": "Element",
+  "AdverseEvent": "DomainResource",
+  "Age": "Quantity",
+  "AllergyIntolerance": "DomainResource",
+  "Annotation": "Element",
+  "Appointment": "DomainResource",
+  "AppointmentResponse": "DomainResource",
+  "Attachment": "Element",
+  "AuditEvent": "DomainResource",
+  "BackboneElement": "Element",
+  "Basic": "DomainResource",
+  "Binary": "Resource",
+  "BodySite": "DomainResource",
+  "Bundle": "Resource",
+  "CapabilityStatement": "DomainResource",
+  "CarePlan": "DomainResource",
+  "CareTeam": "DomainResource",
+  "ChargeItem": "DomainResource",
+  "Claim": "DomainResource",
+  "ClaimResponse": "DomainResource",
+  "ClinicalImpression": "DomainResource",
+  "CodeSystem": "DomainResource",
+  "CodeableConcept": "Element",
+  "Coding": "Element",
+  "Communication": "DomainResource",
+  "CommunicationRequest": "DomainResource",
+  "CompartmentDefinition": "DomainResource",
+  "Composition": "DomainResource",
+  "ConceptMap": "DomainResource",
+  "Condition": "DomainResource",
+  "Consent": "DomainResource",
+  "ContactDetail": "Element",
+  "ContactPoint": "Element",
+  "Contract": "DomainResource",
+  "Contributor": "Element",
+  "Count": "Quantity",
+  "Coverage": "DomainResource",
+  "DataElement": "DomainResource",
+  "DataRequirement": "Element",
+  "DetectedIssue": "DomainResource",
+  "Device": "DomainResource",
+  "DeviceComponent": "DomainResource",
+  "DeviceMetric": "DomainResource",
+  "DeviceRequest": "DomainResource",
+  "DeviceUseStatement": "DomainResource",
+  "DiagnosticReport": "DomainResource",
+  "Distance": "Quantity",
+  "DocumentManifest": "DomainResource",
+  "DocumentReference": "DomainResource",
+  "DomainResource": "Resource",
+  "Dosage": "Element",
+  "Duration": "Quantity",
+  "ElementDefinition": "Element",
+  "EligibilityRequest": "DomainResource",
+  "EligibilityResponse": "DomainResource",
+  "Encounter": "DomainResource",
+  "Endpoint": "DomainResource",
+  "EnrollmentRequest": "DomainResource",
+  "EnrollmentResponse": "DomainResource",
+  "EpisodeOfCare": "DomainResource",
+  "ExpansionProfile": "DomainResource",
+  "ExplanationOfBenefit": "DomainResource",
+  "Extension": "Element",
+  "FamilyMemberHistory": "DomainResource",
+  "Flag": "DomainResource",
+  "Goal": "DomainResource",
+  "GraphDefinition": "DomainResource",
+  "Group": "DomainResource",
+  "GuidanceResponse": "DomainResource",
+  "HealthcareService": "DomainResource",
+  "HumanName": "Element",
+  "Identifier": "Element",
+  "ImagingManifest": "DomainResource",
+  "ImagingStudy": "DomainResource",
+  "Immunization": "DomainResource",
+  "ImmunizationRecommendation": "DomainResource",
+  "ImplementationGuide": "DomainResource",
+  "Library": "DomainResource",
+  "Linkage": "DomainResource",
+  "List": "DomainResource",
+  "Location": "DomainResource",
+  "Measure": "DomainResource",
+  "MeasureReport": "DomainResource",
+  "Media": "DomainResource",
+  "Medication": "DomainResource",
+  "MedicationAdministration": "DomainResource",
+  "MedicationDispense": "DomainResource",
+  "MedicationRequest": "DomainResource",
+  "MedicationStatement": "DomainResource",
+  "MessageDefinition": "DomainResource",
+  "MessageHeader": "DomainResource",
+  "Meta": "Element",
+  "Money": "Quantity",
+  "NamingSystem": "DomainResource",
+  "Narrative": "Element",
+  "NutritionOrder": "DomainResource",
+  "Observation": "DomainResource",
+  "OperationDefinition": "DomainResource",
+  "OperationOutcome": "DomainResource",
+  "Organization": "DomainResource",
+  "ParameterDefinition": "Element",
+  "Parameters": "Resource",
+  "Patient": "DomainResource",
+  "PaymentNotice": "DomainResource",
+  "PaymentReconciliation": "DomainResource",
+  "Period": "Element",
+  "Person": "DomainResource",
+  "PlanDefinition": "DomainResource",
+  "Practitioner": "DomainResource",
+  "PractitionerRole": "DomainResource",
+  "Procedure": "DomainResource",
+  "ProcedureRequest": "DomainResource",
+  "ProcessRequest": "DomainResource",
+  "ProcessResponse": "DomainResource",
+  "Provenance": "DomainResource",
+  "Quantity": "Element",
+  "Questionnaire": "DomainResource",
+  "QuestionnaireResponse": "DomainResource",
+  "Range": "Element",
+  "Ratio": "Element",
+  "Reference": "Element",
+  "ReferralRequest": "DomainResource",
+  "RelatedArtifact": "Element",
+  "RelatedPerson": "DomainResource",
+  "RequestGroup": "DomainResource",
+  "ResearchStudy": "DomainResource",
+  "ResearchSubject": "DomainResource",
+  "RiskAssessment": "DomainResource",
+  "SampledData": "Element",
+  "Schedule": "DomainResource",
+  "SearchParameter": "DomainResource",
+  "Sequence": "DomainResource",
+  "ServiceDefinition": "DomainResource",
+  "Signature": "Element",
+  "SimpleQuantity": "Quantity",
+  "Slot": "DomainResource",
+  "Specimen": "DomainResource",
+  "StructureDefinition": "DomainResource",
+  "StructureMap": "DomainResource",
+  "Subscription": "DomainResource",
+  "Substance": "DomainResource",
+  "SupplyDelivery": "DomainResource",
+  "SupplyRequest": "DomainResource",
+  "Task": "DomainResource",
+  "TestReport": "DomainResource",
+  "TestScript": "DomainResource",
+  "Timing": "Element",
+  "TriggerDefinition": "Element",
+  "UsageContext": "Element",
+  "ValueSet": "DomainResource",
+  "VisionPrescription": "DomainResource",
+  "base64Binary": "Element",
+  "boolean": "Element",
+  "code": "string",
+  "date": "Element",
+  "dateTime": "Element",
+  "decimal": "Element",
+  "id": "string",
+  "instant": "Element",
+  "integer": "Element",
+  "markdown": "string",
+  "oid": "uri",
+  "positiveInt": "integer",
+  "string": "Element",
+  "time": "Element",
+  "unsignedInt": "integer",
+  "uri": "Element",
+  "uuid": "uri",
+  "xhtml": "Element"
+}

data/lib/fhirpath/models.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Fhirpath
+  # Ruby port of fhirpath-py's fhirpathpy/models/__init__.py: loads the per-FHIR-version model
+  # data (choice-type expansion, path-to-type mapping, ...) used to disambiguate polymorphic
+  # fields like `Patient.deceased[x]`. Each subdirectory here (r4, r5, stu3, dstu2) holds the
+  # JSON files copied verbatim from fhirpath-py's model data for that version.
+  module Models
+    DIR = File.join(__dir__, "models")
+
+    REGISTRY = Dir.children(DIR).sort.each_with_object({}) do |version, models|
+      next unless File.directory?(File.join(DIR, version))
+
+      models[version] = Dir.glob(File.join(DIR, version, "*.json")).each_with_object({}) do |path, data|
+        data[File.basename(path, ".json")] = JSON.parse(File.read(path))
+      end
+    end.freeze
+
+    def self.[](name)
+      REGISTRY[name]
+    end
+  end
+end

data/lib/fhirpath/parser/FHIRPath.g4

@@ -0,0 +1,172 @@
+grammar FHIRPath;
+
+// Grammar rules
+// [FHIRPath](http://hl7.org/fhirpath/N1) Normative Release
+
+//prog: line (line)*;
+//line: ID ( '(' expr ')') ':' expr '\r'? '\n';
+entireExpression
+    : expression EOF
+    ;
+
+expression
+        : term                                                      #termExpression
+        | expression '.' invocation                                 #invocationExpression
+        | expression '[' expression ']'                             #indexerExpression
+        | ('+' | '-') expression                                    #polarityExpression
+        | expression ('*' | '/' | 'div' | 'mod') expression         #multiplicativeExpression
+        | expression ('+' | '-' | '&') expression                   #additiveExpression
+        | expression '|' expression                                 #unionExpression
+        | expression ('<=' | '<' | '>' | '>=') expression           #inequalityExpression
+        | expression ('is' | 'as') typeSpecifier                    #typeExpression
+        | expression ('=' | '~' | '!=' | '!~') expression           #equalityExpression
+        | expression ('in' | 'contains') expression                 #membershipExpression
+        | expression 'and' expression                               #andExpression
+        | expression ('or' | 'xor') expression                      #orExpression
+        | expression 'implies' expression                           #impliesExpression
+        //| (IDENTIFIER)? '=>' expression                             #lambdaExpression
+        ;
+
+term
+        : invocation                                            #invocationTerm
+        | literal                                               #literalTerm
+        | externalConstant                                      #externalConstantTerm
+        | '(' expression ')'                                    #parenthesizedTerm
+        ;
+
+literal
+        : '{' '}'                                               #nullLiteral
+        | ('true' | 'false')                                    #booleanLiteral
+        | STRING                                                #stringLiteral
+        | NUMBER                                                #numberLiteral
+        | DATETIME                                              #dateTimeLiteral
+        | TIME                                                  #timeLiteral
+        | quantity                                              #quantityLiteral
+        ;
+
+externalConstant
+        : '%' ( identifier | STRING )
+        ;
+
+invocation                          // Terms that can be used after the function/member invocation '.'
+        : identifier                                            #memberInvocation
+        | functn                                              #functionInvocation
+        | '$this'                                               #thisInvocation
+        | '$index'                                              #indexInvocation
+        | '$total'                                              #totalInvocation
+        ;
+
+functn
+        : identifier '(' paramList? ')'
+        ;
+
+paramList
+        : expression (',' expression)*
+        ;
+
+quantity
+        : NUMBER unit?
+        ;
+
+unit
+        : dateTimePrecision
+        | pluralDateTimePrecision
+        | STRING // UCUM syntax for units of measure
+        ;
+
+dateTimePrecision
+        : 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond'
+        ;
+
+pluralDateTimePrecision
+        : 'years' | 'months' | 'weeks' | 'days' | 'hours' | 'minutes' | 'seconds' | 'milliseconds'
+        ;
+
+typeSpecifier
+        : qualifiedIdentifier
+        ;
+
+qualifiedIdentifier
+        : identifier ('.' identifier)*
+        ;
+
+identifier
+        : IDENTIFIER
+        | DELIMITEDIDENTIFIER
+        | 'as'
+        | 'is'
+        | 'contains'
+        | 'in'
+        ;
+
+
+/****************************************************************
+    Lexical rules
+*****************************************************************/
+
+DATETIME
+        : '@'
+            [0-9][0-9][0-9][0-9] // year
+            (
+                '-'[0-9][0-9] // month
+                (
+                    '-'[0-9][0-9] // day
+                    (
+                        'T' TIMEFORMAT
+                    )?
+                 )?
+             )?
+             'Z'? // UTC specifier
+        ;
+
+TIME
+        : '@' 'T' TIMEFORMAT
+        ;
+
+fragment TIMEFORMAT
+        :
+            [0-9][0-9] (':'[0-9][0-9] (':'[0-9][0-9] ('.'[0-9]+)?)?)?
+            ('Z' | ('+' | '-') [0-9][0-9]':'[0-9][0-9])? // timezone
+        ;
+
+IDENTIFIER
+        : ([A-Za-z] | '_')([A-Za-z0-9] | '_')*            // Added _ to support CQL (FHIR could constrain it out)
+        ;
+
+DELIMITEDIDENTIFIER
+        : '`' (ESC | ~[\\`])* '`'
+        ;
+
+STRING
+        : '\'' (ESC | ~['])* '\''
+        ;
+
+// Also allows leading zeroes now (just like CQL and XSD)
+NUMBER
+        : [0-9]+('.' [0-9]+)?
+        ;
+
+// Pipe whitespace to the HIDDEN channel to support retrieving source text through the parser.
+WS
+        : [ \r\n\t]+ -> channel(HIDDEN)
+        ;
+
+COMMENT
+        : '/*' .*? '*/' -> channel(HIDDEN)
+        ;
+
+LINE_COMMENT
+        : '//' ~[\r\n]* -> channel(HIDDEN)
+        ;
+
+fragment ESC
+        : '\\' ([`'\\/fnrt] | UNICODE)    // allow \`, \', \\, \/, \f, etc. and \uXXX
+        ;
+
+fragment UNICODE
+        : 'u' HEX HEX HEX HEX
+        ;
+
+fragment HEX
+        : [0-9a-fA-F]
+        ;

data/lib/fhirpath/parser/ast_builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Parser
+    # Walks the native ANTLR4 parse tree (see Fhirpath::Parser.parse) and builds the same
+    # generic AST shape as fhirpath-py's ASTPathListener: each node is a Hash with "type",
+    # optional "text", "terminalNodeText" (direct terminal children's text), and optional
+    # "children" (present only when there's at least one non-terminal child).
+    module AstBuilder
+      # Port of ASTPathListener.py's has_node_type_text: which node types carry source text.
+      TEXT_NODE_TYPES = %w[
+        LiteralTerm
+        Identifier
+        TypeSpecifier
+        InvocationExpression
+        TermExpression
+      ].freeze
+
+      class << self
+        def build(ctx)
+          type = node_type(ctx)
+          node = { "type" => type, "terminalNodeText" => terminal_text(ctx) }
+          node["text"] = ctx.text if text_node?(type)
+
+          children = rule_children(ctx).map { |child| build(child) }
+          node["children"] = children unless children.empty?
+
+          node
+        end
+
+        private
+
+        def terminal_text(ctx)
+          ctx.children.select { |child| child.is_a?(::FHIRPathParser::TerminalNodeImpl) }.map(&:text)
+        end
+
+        def rule_children(ctx)
+          ctx.children.reject { |child| child.is_a?(::FHIRPathParser::TerminalNodeImpl) }
+        end
+
+        def node_type(ctx)
+          ctx.type_name.split("::").last.delete_suffix("Context")
+        end
+
+        def text_node?(type)
+          type.end_with?("Literal") || TEXT_NODE_TYPES.include?(type)
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/parser.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../../ext/fhir_path_parser/fhir_path_parser"
+require_relative "parser/ast_builder"
+
+module Fhirpath
+  # Ruby port of fhirpath-py's fhirpathpy/parser package. Parses a FHIRPath expression string
+  # into the same generic AST shape fhirpath-py produces (see AstBuilder), using a native
+  # ANTLR4 parser generated from FHIRPath.g4 via the antlr4-native gem — run
+  # `rake parser:setup compile` once before requiring this file (see rakelib/parser.rake).
+  module Parser
+    def self.parse(expression)
+      parser = FHIRPathParser::Parser.parse(expression)
+      root = parser.expression
+
+      raise Fhirpath::Error, "Failed to parse #{expression.inspect}" if parser.syntax_error_count.positive?
+
+      { "children" => [AstBuilder.build(root)] }
+    end
+  end
+end

data/lib/fhirpath/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  VERSION = "0.1.1"
+end

data/lib/fhirpath.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "fhir_models"
+
+require_relative "fhirpath/version"
+require_relative "fhirpath/parser"
+require_relative "fhirpath/engine"
+require_relative "fhirpath/models"
+
+# Ruby implementation of FHIRPath (https://hl7.org/fhirpath/), a port of fhirpath-py
+# (https://github.com/beda-software/fhirpath-py).
+module Fhirpath
+  class Error < StandardError; end
+
+  # `path` may be a plain FHIRPath expression string, or (mirroring fhirpath-py's evaluate) a
+  # {"expression" => ..., "base" => ...} Hash: "base" tags the resource with the FHIRPath it
+  # would have been reached at (e.g. "QuestionnaireResponse.item") without actually navigating
+  # there, so model-based navigation (e.g. choice-type resolution) below that point works when
+  # evaluating just a fragment of a resource.
+  def self.evaluate(resource, path, context = {}, model = nil, options = {})
+    if path.is_a?(::Hash)
+      node = Parser.parse(path["expression"])
+      resource = Engine::Nodes::ResourceNode.create_node(resource, path["base"]) if path["base"]
+    else
+      node = Parser.parse(path)
+    end
+
+    apply_parsed_path(resource, node, context, model, options)
+  end
+
+  def self.compile(path, model = nil, options = {})
+    node = Parser.parse(path)
+    ->(resource, context = nil) { apply_parsed_path(resource, node, context || {}, model, options) }
+  end
+
+  # Ruby port of fhirpath-py's compile_as_array (fhirpathpy/__init__.py): like `compile`, but
+  # the returned callable accepts a fhir_models `input_type` instance instead of a plain Hash,
+  # and wraps each result item as an `output_type` instance instead of returning raw data.
+  def self.compile_as_array(expression, input_type, output_type, model = nil)
+    path_fn = compile(expression, model)
+    lambda do |resource, context = nil|
+      data = path_fn.call(prepare_data(resource, input_type), context)
+      format_result(data, output_type, array: true)
+    end
+  end
+
+  def self.compile_as_first(expression, input_type, output_type, model = nil)
+    path_fn = compile(expression, model)
+    lambda do |resource, context = nil|
+      data = path_fn.call(prepare_data(resource, input_type), context)
+      format_result(data, output_type, array: false)
+    end
+  end
+
+  def self.prepare_data(resource, input_type)
+    raise Error, "Resource type is #{resource.class}, expected #{input_type}" unless resource.is_a?(input_type)
+
+    return resource if resource.is_a?(::Hash)
+    return resource.to_hash if resource.respond_to?(:to_hash)
+
+    raise Error, "Don't know how to work with type #{resource.class}"
+  end
+  private_class_method :prepare_data
+
+  def self.format_result(result, output_type, array:)
+    formatted = result.map { |item| format_item(item, output_type) }
+    return formatted if array
+
+    formatted.first
+  end
+  private_class_method :format_result
+
+  def self.format_item(item, output_type)
+    return item if item.is_a?(output_type)
+    return output_type.new(item) if item.is_a?(::Hash) && output_type.is_a?(::Class) && output_type <= ::FHIR::Model
+
+    raise Error, "Expected result to be #{output_type}, but got #{item.class}"
+  end
+  private_class_method :format_item
+
+  # Ruby port of fhirpath-py's apply_parsed_path (fhirpathpy/__init__.py): builds the
+  # evaluation context and resolves the AST, then unwraps internal ResourceNode wrappers back
+  # into plain data.
+  def self.apply_parsed_path(resource, node, context, model, _options)
+    data_root = Engine::Util.arraify(resource)
+    ctx = {
+      root: data_root,
+      vars: { "context" => resource, "resource" => resource,
+              "ucum" => "http://unitsofmeasure.org" }.merge(context || {}),
+      model: model.is_a?(::String) ? Models[model] : model,
+      user_invocation_table: {}
+    }
+
+    visit(Engine.do_eval(ctx, data_root, node["children"][0]))
+  end
+  private_class_method :apply_parsed_path
+
+  # Resolves ResourceNode instances back into plain data, dropping internal
+  # primitive-extension-only placeholders (`{"extension" => [...]}`) along the way.
+  def self.visit(node)
+    data = Engine::Util.get_data(node)
+
+    return visit_array(data) if data.is_a?(::Array)
+    return data.transform_values { |value| visit(value) } if data.is_a?(::Hash)
+
+    data
+  end
+  private_class_method :visit
+
+  def self.visit_array(items)
+    items.each_with_object([]) do |item, acc|
+      visited = visit(item)
+      acc << visited unless visited.is_a?(::Hash) && visited.keys == ["extension"]
+    end
+  end
+  private_class_method :visit_array
+end