fhirpath-rb 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9eefe06c5824eee637149d60af147480e36b717e5c6f15d3ad498529b9a2c52c
+  data.tar.gz: 1a2692a532e82590b309277b0f8a75ea7dff0d95565bda303dcb386303634274
+SHA512:
+  metadata.gz: 70c7b85868c2ec1cc185674a314d5923fcaeb31d950c4143fb4f439746aa7b9862d28e6f49914689d421af1c6888bf1ee0f8899cea6ced726b8113db89d23410
+  data.tar.gz: 05cf47e784e7560b02a77914cd1a64a9801296898ad94a46281a5960ca1b8574cddd2dd70d7b576e4a983059d13b0c684d786eb475f41cac1152d51987808296

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,25 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+# extconf.rb's $CFLAGS/$srcs/etc are mkmf's own API, not avoidable globals.
+Style/GlobalVars:
+  Exclude:
+    - "ext/**/extconf.rb"
+
+Style/FrozenStringLiteralComment:
+  Exclude:
+    - "ext/**/extconf.rb"
+
+# Both files are inherently long: one assembles generated C++ source via heredocs, the other
+# lists fhirpath-py's ported test expressions.
+Metrics/BlockLength:
+  Exclude:
+    - "rakelib/**/*.rake"
+    - "spec/**/*_spec.rb"
+    - "*.gemspec"

data/CLAUDE.md

@@ -0,0 +1,59 @@
+# fhirpath-rb
+
+Ruby implementation of [FHIRPath](https://hl7.org/fhirpath/), the expression language used to
+navigate and extract data from FHIR resources. This is a **port of
+[fhirpath-py](https://github.com/beda-software/fhirpath-py)** — when in doubt about behavior,
+naming, or edge cases, treat fhirpath-py as the reference implementation rather than
+re-deriving from the spec alone. fhirpath-py is itself a port of
+[fhirpath.js](https://github.com/HL7/fhirpath.js) (the canonical HL7 reference implementation),
+so fhirpath.js is the next place to check if fhirpath-py is ambiguous.
+
+## Status
+
+Repo scaffolding only — no evaluator code has been ported yet. `lib/fhirpath.rb` just defines
+the `Fhirpath` module and `Fhirpath::Error`. Everything in "Planned architecture" below
+describes the target design, not current code.
+
+## Planned architecture
+
+Mirror fhirpath-py's module boundaries; they map cleanly to a Ruby gem's `lib/` layout:
+
+| fhirpath-py | Planned Ruby equivalent | Purpose |
+|---|---|---|
+| `fhirpathpy/__init__.py` (`evaluate`, `compile`) | `lib/fhirpath.rb` (`Fhirpath.evaluate`, `Fhirpath.compile`) | Public API |
+| `fhirpathpy/parser/FHIRPath.g4` + antlr-generated parser | `lib/fhirpath/parser/` | Grammar + parser producing an AST. No Ruby ANTLR runtime is planned by default — evaluate whether to generate a parser from the same `.g4` grammar (via a build step, not committed generated code) or hand-write a recursive-descent/Parslet/Racc parser that accepts the same grammar. |
+| `fhirpathpy/engine/nodes.py` (`FP_Type`, `FP_Quantity`, `FP_DateTime`, `ResourceNode`, ...) | `lib/fhirpath/engine/nodes.rb` (or one file per type under `lib/fhirpath/engine/nodes/`) | FHIRPath value types (quantities, date/time with partial precision, resource wrapper) and their `equals`/`equivalent_to`/`compare` semantics |
+| `fhirpathpy/engine/__init__.py` (`do_eval`) + `evaluators/` | `lib/fhirpath/engine/evaluator.rb` | AST node dispatch — walks the parsed tree and evaluates each node kind against the current context |
+| `fhirpathpy/engine/invocations/*.py` (aggregate, collections, combining, constants, datetime, equality, existence, filtering, logic, math, misc, navigation, strings, subsetting, types) | `lib/fhirpath/engine/invocations/*.rb`, one file per category | Built-in function library (`where`, `select`, `first`, `substring`, `today()`, ...); each category stays its own file to match fhirpath-py |
+| `fhirpathpy/engine/util.py` (`get_data`, `parse_value`, `set_paths`, `arraify`, `process_user_invocation_table`) | `lib/fhirpath/engine/util.rb` | Shared helpers used across the engine |
+| `fhirpathpy/models/{dstu2,stu3,r4,r5}` | `lib/fhirpath/models/{dstu2,stu3,r4,r5}.rb` | Per-FHIR-version model data (choice-type expansion, primitive extension handling) used to disambiguate polymorphic fields like `Patient.deceased[x]` |
+
+Public API surface to match fhirpath-py's `evaluate`/`compile` (see its README):
+
+```ruby
+Fhirpath.evaluate(resource, path, context = {}, model = nil, options = {})
+Fhirpath.compile(path, model = nil, options = {}) # => callable, parses once, reusable across resources
+```
+
+`options[:user_invocation_table]` should let callers override or add functions, mirroring
+fhirpath-py's `userInvocationTable` (see its README's "User-defined functions" section).
+
+## Test strategy
+
+fhirpath-py's `tests/cases/*.yaml` are FHIRPath-spec-section-organized YAML test cases (e.g.
+`5.1_existence.yaml`, `6.5_boolean_logic.yaml`) plus FHIR-specific cases (`fhir-r4.yaml`,
+`fhir-quantity.yaml`). When porting the evaluator, port these fixtures (or write a shared
+YAML-driven RSpec runner that reads an equivalent fixture format) rather than inventing a
+parallel set of hand-written examples — they encode a lot of spec edge cases that are easy to
+miss otherwise.
+
+## Conventions
+
+- Ruby >= 3.0, `frozen_string_literal: true` in every file.
+- Gem name is `fhirpath-rb` (matching the `fhirpath-py` naming pattern) but the module is flat
+  `Fhirpath`, not `Fhirpath::Rb` — `rb`/`py` are naming suffixes on the repo/gem, not part of
+  the API, so callers write `Fhirpath.evaluate(...)`, not `Fhirpath::Rb.evaluate(...)`.
+- RSpec for tests (`spec/`), RuboCop for linting (`.rubocop.yml`). `bundle exec rake` runs both
+  (the default Rake task) and must stay clean.
+- No implementation code should be added speculatively — this file describes the target shape
+  so future work has a map, not a request to build it all now.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 beda.software
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# fhirpath-rb
+
+[FHIRPath](https://hl7.org/fhirpath/) implementation in Ruby.
+
+This is a Ruby port of [fhirpath-py](https://github.com/beda-software/fhirpath-py), which is
+itself a Python port of [fhirpath.js](https://github.com/HL7/fhirpath.js). The goal is to bring
+the same evaluator (parser, engine, built-in function library, and FHIR data models) to the
+Ruby ecosystem.
+
+## Installation
+
+Not yet released to RubyGems. Once published:
+
+```bash
+bundle add fhirpath-rb
+```
+
+## Planned usage
+
+```ruby
+require "fhirpath"
+
+patient = {
+  "resourceType" => "Patient",
+  "name" => [
+    { "use" => "official", "given" => ["Peter", "James"], "family" => "Chalmers" },
+    { "use" => "usual", "given" => ["Jim"] }
+  ]
+}
+
+Fhirpath.evaluate(patient, "Patient.name.where(use = 'usual').given.first()")
+# => ["Jim"]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then run `rake spec` to
+run the tests, and `bundle exec rake` to run the full default task (specs + rubocop). You can
+also run `bin/console` for an interactive prompt.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/ext/fhir_path_parser/extconf.rb

@@ -0,0 +1,40 @@
+require "mkmf-rice"
+
+extension_name = "fhir_path_parser"
+dir_config(extension_name)
+
+have_library("stdc++")
+
+$CFLAGS << " -std=c++14"
+
+# The antlr4 runtime sources below are compiled directly into this extension, never built as
+# a separate DLL, so ANTLR4CPP_PUBLIC must never expand to __declspec(dllimport) (its default
+# on Windows) — that would reject definitions like static data members as belonging to an
+# imported class. Define it unconditionally rather than gating on --enable-static.
+$defs.push("-DANTLR4CPP_STATIC") unless $defs.include?("-DANTLR4CPP_STATIC")
+
+include_paths = [
+  ".",
+  "antlrgen",
+  "antlr4-upstream/runtime/Cpp/runtime/src",
+  "antlr4-upstream/runtime/Cpp/runtime/src/atn",
+  "antlr4-upstream/runtime/Cpp/runtime/src/dfa",
+  "antlr4-upstream/runtime/Cpp/runtime/src/misc",
+  "antlr4-upstream/runtime/Cpp/runtime/src/support",
+  "antlr4-upstream/runtime/Cpp/runtime/src/tree",
+  "antlr4-upstream/runtime/Cpp/runtime/src/tree/pattern",
+  "antlr4-upstream/runtime/Cpp/runtime/src/tree/xpath"
+]
+
+$srcs = []
+
+include_paths.each do |include_path|
+  $INCFLAGS << " -I#{include_path}"
+  $VPATH << include_path
+
+  Dir.glob("#{include_path}/*.cpp").each do |path|
+    $srcs << path
+  end
+end
+
+create_makefile(extension_name)

data/lib/fhirpath/engine/evaluators/expressions.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    # Unary/prefix and infix-operator expression evaluators; see evaluators.rb for
+    # member/index/function invocation, chaining, and the node-type dispatch table.
+    module Evaluators
+      class << self
+        def polarity_expression(ctx, parent_data, node)
+          sign = node["terminalNodeText"].first
+          result = Engine.do_eval(ctx, parent_data, node["children"][0])
+          raise Fhirpath::Error, "Unary #{sign} can only be applied to an individual number." if result.length != 1
+
+          value = Util.get_data(result.first)
+          raise Fhirpath::Error, "Unary #{sign} can only be applied to a number." unless value.is_a?(::Numeric)
+
+          [sign == "-" ? -value : value]
+        end
+
+        # Ports fhirpath-py's op_expression: reads the infix operator's symbol off the node and
+        # dispatches to the matching invocation (e.g. EqualityExpression's "=").
+        def op_expression(ctx, parent_data, node)
+          op = node["terminalNodeText"].first
+          Engine.infix_invoke(ctx, op, parent_data, node["children"])
+        end
+
+        # Unlike op_expression, "|" is fixed rather than read off the node.
+        def union_expression(ctx, parent_data, node)
+          Engine.infix_invoke(ctx, "|", parent_data, node["children"])
+        end
+
+        # Ports fhirpath-py's alias_op_expression({"is": "isOp", "as": "asOp"}): "is"/"as" used
+        # as infix operators (e.g. "x is Boolean") dispatch to the "...Op" invocation names.
+        TYPE_EXPRESSION_ALIASES = { "is" => "isOp", "as" => "asOp" }.freeze
+
+        def type_expression(ctx, parent_data, node)
+          aliased_op_expression(ctx, parent_data, node, TYPE_EXPRESSION_ALIASES)
+        end
+
+        # Ports fhirpath-py's alias_op_expression({"contains": "containsOp", "in": "inOp"}).
+        MEMBERSHIP_EXPRESSION_ALIASES = { "contains" => "containsOp", "in" => "inOp" }.freeze
+
+        def membership_expression(ctx, parent_data, node)
+          aliased_op_expression(ctx, parent_data, node, MEMBERSHIP_EXPRESSION_ALIASES)
+        end
+
+        private
+
+        def aliased_op_expression(ctx, parent_data, node, aliases)
+          op = node["terminalNodeText"].first
+          alias_name = aliases[op]
+          raise Fhirpath::Error, "Do not know how to alias #{op} by #{aliases}" unless alias_name
+
+          Engine.infix_invoke(ctx, alias_name, parent_data, node["children"])
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/evaluators/literals.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Fhirpath
+  module Engine
+    # Literal-term evaluators (number/string/boolean/null/quantity/date-time), ported from
+    # fhirpath-py's fhirpathpy/engine/evaluators/__init__.py. Split out of evaluators.rb to keep
+    # that file's module body short; reopens the same Evaluators module.
+    module Evaluators
+      class << self
+        def number_literal(_ctx, _parent_data, node)
+          value = BigDecimal(node["text"])
+          int_value = value.to_i
+          [value == int_value ? int_value : value]
+        end
+
+        def string_literal(_ctx, _parent_data, node)
+          text = node["text"].sub(/\A['"]/, "").sub(/['"]\z/, "")
+          text = text.gsub("\\'", "'")
+                     .gsub("\\`", "`")
+                     .gsub('\\"', '"')
+                     .gsub("\\r", "\r")
+                     .gsub("\\n", "\n")
+                     .gsub("\\t", "\t")
+                     .gsub("\\f", "\f")
+                     .gsub("\\\\", "\\")
+          [text.gsub(/\\u(\h{4})/) { [::Regexp.last_match(1).to_i(16)].pack("U") }]
+        end
+
+        def boolean_literal(_ctx, _parent_data, node)
+          [node["text"] == "true"]
+        end
+
+        def null_literal(_ctx, _parent_data, _node)
+          []
+        end
+
+        def quantity_literal(_ctx, _parent_data, node)
+          value_node = node["children"][0]
+          value = BigDecimal(value_node["terminalNodeText"][0])
+          unit_node = value_node["children"][0]
+          unit = quantity_unit(unit_node)
+
+          [Nodes::FPQuantity.new(value, unit)]
+        end
+
+        def date_time_literal(_ctx, _parent_data, node)
+          [Nodes::FPDateTime.new(node["text"][1..])]
+        end
+
+        def time_literal(_ctx, _parent_data, node)
+          [Nodes::FPTime.new(node["text"][2..])]
+        end
+
+        private
+
+        # A Unit node's terminalNodeText holds a quoted UCUM unit (e.g. "'mo'") directly; for a
+        # calendar duration unit (e.g. "years") it instead has a PluralDateTimePrecision child
+        # whose terminalNodeText holds the word.
+        def quantity_unit(unit_node)
+          return unit_node["terminalNodeText"].first if unit_node["terminalNodeText"]&.any?
+          return unit_node["children"].first["terminalNodeText"].first if unit_node["children"]&.any?
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/evaluators/member_invocation.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    # MemberInvocation evaluator (e.g. the ".value" in "Observation.value") and its reducer,
+    # ported from fhirpath-py's member_invocation/create_reduce_member_invocation
+    # (fhirpathpy/engine/evaluators/__init__.py). Split out of evaluators.rb to keep that file's
+    # module body short; reopens the same Evaluators module.
+    module Evaluators
+      class << self
+        def member_invocation(ctx, parent_data, node)
+          key = Engine.do_eval(ctx, parent_data, node["children"][0])[0].delete("`")
+          return [] unless parent_data.is_a?(::Array)
+
+          matches = resource_type_matches(parent_data, key)
+          return matches if matches
+
+          model = ctx[:model]
+          parent_data.reduce([]) { |acc, res| reduce_member(acc, res, model, key) }
+        end
+
+        private
+
+        # The special case where a capitalized path segment (e.g. the leading "Observation" in
+        # "Observation.value") filters a collection of raw resource hashes by resourceType,
+        # rather than looking up an ordinary property.
+        def resource_type_matches(parent_data, key)
+          return nil unless Util.capitalized?(key)
+
+          filtered = parent_data.select { |item| item["resourceType"] == key }
+          filtered.map { |item| Nodes::ResourceNode.create_node(item, key) }
+        rescue ::NoMethodError, ::TypeError
+          # parent_data holds nodes that don't support `[]` (e.g. already ResourceNodes) — fall
+          # through to the ordinary member lookup below, matching fhirpath-py's TypeError catch.
+          nil
+        end
+
+        def reduce_member(acc, res, model, key)
+          res = Nodes::ResourceNode.create_node(res)
+          child_path, full_path, actual_types = member_lookup_paths(res, key, model)
+          to_add, to_add_ext, child_path = member_lookup_value(res, key, actual_types, child_path)
+          child_path = remap(model, "path2Type", child_path)
+
+          acc = append_member_value(acc, to_add, child_path, full_path)
+          append_member_value(acc, to_add_ext, child_path, full_path)
+        end
+
+        def member_lookup_paths(res, key, model)
+          child_path = res.path ? "#{res.path}.#{key}" : "_.#{key}"
+          full_path = (res.prop_name ? "#{res.prop_name}.#{key}" : child_path).delete("_")
+          child_path = remap(model, "pathsDefinedElsewhere", child_path)
+          actual_types = model.is_a?(::Hash) ? model.dig("choiceTypePaths", child_path) : nil
+
+          [child_path, full_path, actual_types]
+        end
+
+        def member_lookup_value(res, key, actual_types, child_path)
+          return [res.data.value, nil, child_path] if res.data.is_a?(Nodes::FPQuantity)
+          return choice_type_value(res, key, actual_types, child_path) if choice_type?(res, actual_types)
+          return hash_value(res, key, child_path) if res.data.is_a?(::Hash)
+          return [res.data.length, nil, child_path] if key == "length" && res.data.respond_to?(:length)
+
+          [nil, nil, child_path]
+        end
+
+        def choice_type?(res, actual_types)
+          actual_types && !actual_types.empty? && res.data.is_a?(::Hash)
+        end
+
+        def hash_value(res, key, child_path)
+          child_path = "Extension" if key == "extension"
+          [res.data[key], res.data["_#{key}"], child_path]
+        end
+
+        def choice_type_value(res, key, actual_types, child_path)
+          actual_types.each do |actual_type|
+            field = "#{key}#{actual_type}"
+            to_add = res.data[field]
+            to_add_ext = res.data["_#{field}"]
+            next if to_add.nil? && to_add_ext.nil?
+
+            return [to_add, to_add_ext, child_path + actual_type]
+          end
+
+          [nil, nil, child_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
+
+        def append_member_value(acc, value, child_path, full_path)
+          return acc unless Util.some?(value)
+
+          if value.is_a?(::Array)
+            mapped = value.each_with_index.map do |item, i|
+              Nodes::ResourceNode.create_node(item, child_path, prop_name: "#{full_path}[#{i}]", index: i)
+            end
+            acc + mapped
+          else
+            acc + [Nodes::ResourceNode.create_node(value, child_path, prop_name: full_path)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/evaluators.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "evaluators/expressions"
+require_relative "evaluators/member_invocation"
+require_relative "evaluators/literals"
+
+module Fhirpath
+  module Engine
+    # Ruby port of fhirpath-py's fhirpathpy/engine/evaluators/__init__.py: dispatch table from
+    # AST node "type" to the function that evaluates it, plus the term/identifier/invocation
+    # evaluators. Unary/binary *Expression evaluators live in evaluators/expressions.rb, literal
+    # evaluators live in evaluators/literals.rb; this file is reopened by both.
+    module Evaluators
+      class << self
+        def identifier(_ctx, _parent_data, node)
+          [node["text"].sub(/\A"/, "").sub(/"\z/, "")]
+        end
+
+        def this_invocation(ctx, _parent_data, _node)
+          Util.arraify(ctx[:this])
+        end
+
+        def index_invocation(ctx, _parent_data, _node)
+          Util.arraify(ctx[:index])
+        end
+
+        def total_invocation(ctx, _parent_data, _node)
+          Util.arraify(ctx[:total])
+        end
+
+        # Ports fhirpath-py's external_constant_term ("%name"/"%`escaped name`" environment
+        # variables, https://hl7.org/fhirpath/#environment-variables).
+        def external_constant_term(ctx, _parent_data, node)
+          var_name = node["children"][0]["children"][0]["text"].delete("`")
+          unless ctx[:vars].key?(var_name)
+            raise Fhirpath::Error, "Attempting to access an undefined environment variable: #{var_name}"
+          end
+
+          Util.arraify(ctx[:vars][var_name])
+        end
+
+        def literal_term(ctx, parent_data, node)
+          term = node["children"]&.first
+          term ? Engine.do_eval(ctx, parent_data, term) : [node["text"]]
+        end
+
+        def parenthesized_term(ctx, parent_data, node)
+          Engine.do_eval(ctx, parent_data, node["children"][0])
+        end
+
+        def invocation_term(ctx, parent_data, node)
+          Engine.do_eval(ctx, parent_data, node["children"][0])
+        end
+
+        def term_expression(ctx, parent_data, node)
+          Engine.do_eval(ctx, parent_data, node["children"][0])
+        end
+
+        def invocation_expression(ctx, parent_data, node)
+          node["children"].reduce(parent_data) { |acc, child| Engine.do_eval(ctx, acc, child) }
+        end
+
+        def indexer_expression(ctx, parent_data, node)
+          coll = Engine.do_eval(ctx, parent_data, node["children"][0])
+          idx = Engine.do_eval(ctx, parent_data, node["children"][1])
+          return [] if Util.empty?(idx)
+
+          idx_num = idx[0].to_i
+          coll && idx_num >= 0 && coll.length > idx_num ? [coll[idx_num]] : []
+        end
+
+        def functn(ctx, parent_data, node)
+          node["children"].map { |child| Engine.do_eval(ctx, parent_data, child) }
+        end
+
+        def param_list(_ctx, _parent_data, node)
+          node
+        end
+
+        def function_invocation(ctx, parent_data, node)
+          args = Engine.do_eval(ctx, parent_data, node["children"][0])
+          fn_name = args[0]
+          args = args[1..] || []
+
+          raw_params = nil
+          raw_params = args[0]["children"] if args[0].is_a?(::Hash) && args[0].key?("children")
+
+          Engine.do_invoke(ctx, fn_name, parent_data, raw_params)
+        end
+      end
+
+      DISPATCH = {
+        "Functn" => method(:functn),
+        "ParamList" => method(:param_list),
+        "Identifier" => method(:identifier),
+        "LiteralTerm" => method(:literal_term),
+        "NullLiteral" => method(:null_literal),
+        "NumberLiteral" => method(:number_literal),
+        "StringLiteral" => method(:string_literal),
+        "BooleanLiteral" => method(:boolean_literal),
+        "QuantityLiteral" => method(:quantity_literal),
+        "DateTimeLiteral" => method(:date_time_literal),
+        "TimeLiteral" => method(:time_literal),
+        "InvocationTerm" => method(:invocation_term),
+        "ParenthesizedTerm" => method(:parenthesized_term),
+        "ThisInvocation" => method(:this_invocation),
+        "IndexInvocation" => method(:index_invocation),
+        "TotalInvocation" => method(:total_invocation),
+        "ExternalConstantTerm" => method(:external_constant_term),
+        "MemberInvocation" => method(:member_invocation),
+        "FunctionInvocation" => method(:function_invocation),
+        "PolarityExpression" => method(:polarity_expression),
+        "IndexerExpression" => method(:indexer_expression),
+        "TermExpression" => method(:term_expression),
+        "InvocationExpression" => method(:invocation_expression),
+        "UnionExpression" => method(:union_expression),
+        "EqualityExpression" => method(:op_expression),
+        "InequalityExpression" => method(:op_expression),
+        "TypeExpression" => method(:type_expression),
+        "MembershipExpression" => method(:membership_expression),
+        "OrExpression" => method(:op_expression),
+        "ImpliesExpression" => method(:op_expression),
+        "AndExpression" => method(:op_expression),
+        "XorExpression" => method(:op_expression),
+        "AdditiveExpression" => method(:op_expression),
+        "MultiplicativeExpression" => method(:op_expression)
+      }.freeze
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "math"
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of fhirpath-py's fhirpathpy/engine/invocations/aggregate.py (FHIRPath spec
+      # section 7).
+      module Aggregate
+        class << self
+          # `$total`/`$index` (see Evaluators.total_invocation/index_invocation) read
+          # ctx[:total]/ctx[:index], which this loop maintains for `expr` to see.
+          def aggregate(ctx, data, expr, initial_value = [])
+            ctx[:total] = initial_value
+            Util.arraify(data).each_with_index do |item, index|
+              ctx[:index] = index
+              ctx[:total] = expr.call(item)
+            end
+            ctx[:total]
+          end
+
+          def sum(_ctx, coll)
+            coll.sum
+          end
+
+          def avg(ctx, coll)
+            return [] if coll.empty?
+
+            Math.div(ctx, sum(ctx, coll), coll.length)
+          end
+
+          def min(_ctx, coll)
+            return [] if coll.empty?
+
+            coll.min
+          end
+
+          def max(_ctx, coll)
+            return [] if coll.empty?
+
+            coll.max
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    module Invocations
+      # Ruby port of `contains`/`in` from fhirpath-py's
+      # fhirpathpy/engine/invocations/collections.py (FHIRPath spec 6.4.2/6.4.3).
+      module Collections
+        class << self
+          def contains(_ctx, coll, item)
+            return [] if item.empty?
+            return false if coll.empty?
+            if item.length > 1
+              raise Fhirpath::Error,
+                    "Expected singleton on right side of contains, got #{item.inspect}"
+            end
+
+            coll.include?(item.first)
+          end
+
+          def in(_ctx, coll, other)
+            return [] if coll.empty?
+            return false if other.empty?
+            raise Fhirpath::Error, "Expected singleton on right side of in, got #{coll.inspect}" if coll.length > 1
+
+            other.include?(coll.first)
+          end
+        end
+      end
+    end
+  end
+end