fhirpath 0.2.0.pre1

data/lib/fhirpath/vector_runner.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'errors'
+require_relative 'conformance/importer'
+
+module FHIRPath
+  # Small, optional JSONL differential-vector runner. It is deliberately kept
+  # outside the evaluator's runtime path and does not require Python.
+  module VectorRunner
+    CLASSIFICATIONS = %w[pass defect unsupported host-dependent not-run].freeze
+
+    module_function
+
+    def run(path, evaluator: nil)
+      cases = File.foreach(path).with_index(1).each_with_object([]) do |(line, line_number), results|
+        next if line.strip.empty?
+
+        vector = JSON.parse(line)
+        results << execute(vector, line_number, evaluator: evaluator)
+      end
+      counts = CLASSIFICATIONS.each_with_object({}) { |name, result| result[name] = 0 }
+      cases.each { |result| counts[result['classification']] += 1 }
+      {
+        total: cases.length,
+        counts: counts,
+        capability_totals: capability_totals(cases),
+        cases: cases
+      }
+    end
+
+    def execute(vector, line_number, evaluator: nil)
+      return result_for(vector, line_number, 'not-run').merge('actual' => nil) if vector['classification'] == 'not-run'
+
+      values = evaluate(vector, evaluator).to_a
+      classification = if values == vector.fetch('expected', []) && !vector['error']
+                         'pass'
+                       else
+                         'defect'
+                       end
+      result_for(vector, line_number, classification).merge('actual' => values)
+    rescue UnsupportedFeatureError => e
+      error_result(vector, line_number, classify_error(vector, e, 'unsupported'), e)
+    rescue HostError => e
+      error_result(vector, line_number, classify_error(vector, e, 'host-dependent'), e)
+    rescue Error => e
+      error_result(vector, line_number, classify_error(vector, e, 'defect'), e)
+    rescue StandardError => e
+      error_result(vector, line_number, 'defect', e)
+    end
+
+    def evaluate(vector, evaluator = nil)
+      return evaluator.call(vector) if evaluator
+
+      # Conformance records spell the default out as `plain`; the public API
+      # treats `nil` as the PlainModel default and rejects unknown release
+      # strings, so map the explicit plain marker to nil before dispatch.
+      model = vector['model']
+      model = nil if model.to_s == 'plain'
+      FHIRPath.evaluate(vector['resource'] || {}, vector.fetch('expression'),
+                        variables: vector['variables'] || {}, model: model)
+    end
+
+    def error_result(vector, line_number, classification, error)
+      result_for(vector, line_number, classification).merge(
+        'actual' => nil,
+        'actual_error' => serialize_error(error)
+      )
+    end
+
+    def expected_error_matches?(expected, error)
+      return error.is_a?(Error) if expected == true
+      return false unless expected
+
+      class_matches = !expected['class'] || expected['class'] == error.class.name
+      actual_code = error.respond_to?(:code) ? error.code.to_s : nil
+      code_matches = !expected['code'] || expected['code'].to_s == actual_code
+      class_matches && code_matches
+    end
+
+    def classify_error(vector, error, fallback)
+      return 'pass' if expected_error_matches?(vector['error'], error)
+      return 'defect' if vector['error']
+
+      fallback
+    end
+
+    def result_for(vector, line_number, classification)
+      vector.merge(result_fields(vector, line_number, classification))
+    end
+
+    def result_fields(vector, line_number, classification)
+      origin = vector['origin'] || {}
+      {
+        'line' => line_number,
+        'suite' => result_value(vector, 'suite', origin['suite']),
+        'suite_commit' => result_value(vector, 'suite_commit', origin['suite_commit'] || origin['commit']),
+        'input_fixture' => vector.fetch('input_fixture', nil),
+        'model' => result_value(vector, 'model', 'plain'),
+        'host_features' => result_value(vector, 'host_features', Capability.current.host_features),
+        'target' => result_value(vector, 'target', Capability.current.fhirpath),
+        'expected' => vector.fetch('expected', []),
+        'classification' => classification
+      }
+    end
+
+    def result_value(vector, key, fallback)
+      vector[key] || fallback
+    end
+
+    def serialize_error(error)
+      serialized = if error.respond_to?(:to_h)
+                     { 'class' => error.class.name }.merge(error.to_h.transform_keys(&:to_s))
+                   else
+                     { 'class' => error.class.name, 'message' => error.message }
+                   end
+      serialized['code'] = error.code.to_s if error.respond_to?(:code)
+      serialized
+    end
+
+    def capability_totals(cases)
+      cases.group_by { |result| result['capability'] || 'unspecified' }
+           .transform_values do |capability_cases|
+             counts = CLASSIFICATIONS.each_with_object({}) { |name, result| result[name] = 0 }
+             capability_cases.each { |result| counts[result['classification']] += 1 }
+             { total: capability_cases.length, counts: counts }
+           end
+    end
+  end
+end

data/lib/fhirpath/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module FHIRPath
+  VERSION = '0.2.0.pre1'
+  # A stable release requires the complete release gate to be deliberately
+  # promoted. Keep pre-release status explicit while the shared-suite and
+  # model-adapter work remains incomplete.
+  RELEASE_CHANNEL = 'pre-release'
+end

data/lib/fhirpath.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'fhirpath/version'
+require_relative 'fhirpath/source_span'
+require_relative 'fhirpath/errors'
+require_relative 'fhirpath/capability'
+require_relative 'fhirpath/collection'
+require_relative 'fhirpath/types'
+require_relative 'fhirpath/ast'
+require_relative 'fhirpath/model'
+require_relative 'fhirpath/models_r4'
+require_relative 'fhirpath/model_registry'
+require_relative 'fhirpath/host_services'
+require_relative 'fhirpath/functions'
+require_relative 'fhirpath/evaluation_context'
+require_relative 'fhirpath/parser'
+require_relative 'fhirpath/evaluator'
+require_relative 'fhirpath/compiled_expression'
+
+# Public entry point for the Ruby FHIRPath implementation.
+module FHIRPath
+  class << self
+    def version
+      VERSION
+    end
+
+    def parse(expression, capability: Capability.current)
+      Parser.parse(expression, capability: capability)
+    end
+
+    def model(release)
+      ModelRegistry.fetch(release)
+    end
+
+    def available_models
+      ['R4'].freeze
+    end
+
+    def compile(expression, model: nil, capability: Capability.current,
+                functions: FunctionRegistry.standard)
+      parsed = expression.is_a?(ParsedExpression) ? expression : parse(expression, capability: capability)
+      CompiledExpression.new(parsed: parsed, model: resolve_model(model, capability),
+                             functions: functions, capability: capability)
+    end
+
+    def evaluate(resource, expression, variables: {}, model: nil,
+                 capability: Capability.current, functions: FunctionRegistry.standard,
+                 options: {}, host: nil)
+      compile(expression, model: model, capability: capability, functions: functions)
+        .evaluate(resource, variables: variables, host: host, options: options)
+    end
+
+    def evaluate_first(resource, expression, variables: {}, model: nil,
+                       capability: Capability.current, functions: FunctionRegistry.standard,
+                       options: {}, host: nil)
+      evaluate(resource, expression, variables: variables, model: model,
+                                     capability: capability, functions: functions, options: options, host: host)
+        .first_item
+    end
+
+    private
+
+    def resolve_model(model, capability)
+      return PlainModel.new if model.nil?
+      return model unless model.is_a?(Symbol) || model.is_a?(String)
+
+      provider = ModelRegistry.fetch(model)
+      unless capability.supports_model?(provider.class::RELEASE)
+        raise UnsupportedFeatureError.new(
+          "FHIR model release is not enabled: #{provider.class::RELEASE}",
+          code: :unsupported_model_release
+        )
+      end
+      provider
+    end
+  end
+end

data/script/import_vectors.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'json'
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'fhirpath/vector_runner'
+
+source_root = ARGV.fetch(0) do
+  abort "usage: #{File.basename($PROGRAM_NAME)} FHIR_TEST_CASES_CHECKOUT [MANIFEST]"
+end
+manifest = ARGV[1] || File.expand_path('../conformance/official-r4-core.json', __dir__)
+
+records = FHIRPath::Conformance::Importer.from_manifest(manifest, source_root: source_root).import
+records.each { |record| puts JSON.generate(record) }

data/script/run_vectors.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'json'
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'fhirpath'
+require 'fhirpath/vector_runner'
+
+path = ARGV.fetch(0) do
+  abort "usage: #{File.basename($PROGRAM_NAME)} PATH_TO_JSONL"
+end
+
+report = FHIRPath::VectorRunner.run(path)
+puts JSON.pretty_generate(report)
+
+# A release may document unsupported or host-dependent cases, but it must not
+# ship known defects or silently skipped cases as conformance evidence.
+blocked = report[:counts].slice('defect', 'not-run')
+exit 1 if blocked.values.any?(&:positive?)

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: fhirpath
+version: !ruby/object:Gem::Version
+  version: 0.2.0.pre1
+platform: ruby
+authors:
+- Nicco Reyes
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-09-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: A prototype Ruby-native scaffold for the HL7 FHIRPath expression language,
+  with a deliberately limited supported surface.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- SECURITY.md
+- conformance/core.jsonl
+- conformance/official-r4-core.json
+- conformance/r4.jsonl
+- docs/api.md
+- docs/architecture.md
+- docs/conformance.md
+- docs/feature-matrix.md
+- docs/first-slice.md
+- docs/release-checklist.md
+- docs/releasing.md
+- docs/support-matrix.md
+- lib/fhirpath.rb
+- lib/fhirpath/ast.rb
+- lib/fhirpath/capability.rb
+- lib/fhirpath/collection.rb
+- lib/fhirpath/compiled_expression.rb
+- lib/fhirpath/conformance/importer.rb
+- lib/fhirpath/errors.rb
+- lib/fhirpath/evaluation_context.rb
+- lib/fhirpath/evaluator.rb
+- lib/fhirpath/functions.rb
+- lib/fhirpath/host_services.rb
+- lib/fhirpath/model.rb
+- lib/fhirpath/model_registry.rb
+- lib/fhirpath/models_r4.rb
+- lib/fhirpath/parser.rb
+- lib/fhirpath/source_span.rb
+- lib/fhirpath/types.rb
+- lib/fhirpath/vector_runner.rb
+- lib/fhirpath/version.rb
+- script/import_vectors.rb
+- script/run_vectors.rb
+homepage: https://github.com/niccoreyes/fhirpath-ruby
+licenses:
+- MIT
+metadata:
+  release_status: pre-release
+  fhirpath_target: 2.0.0
+  capability_set: parser,immutable-ast,collection-evaluation,plain-model-navigation,primitive-values,arithmetic,comparison-and-equivalence,boolean-logic,union-membership-and-type-operators,collection-functions,focus-variables,external-constants,custom-functions,compiled-expression-reuse,fhir-r4-model,structured-errors
+  source_code_uri: https://github.com/niccoreyes/fhirpath-ruby
+  bug_tracker_uri: https://github.com/niccoreyes/fhirpath-ruby/issues
+  documentation_uri: https://github.com/niccoreyes/fhirpath-ruby/blob/main/docs/api.md
+  changelog_uri: https://github.com/niccoreyes/fhirpath-ruby/blob/main/CHANGELOG.md
+  support_matrix_uri: https://github.com/niccoreyes/fhirpath-ruby/blob/main/docs/support-matrix.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A Ruby foundation for FHIRPath
+test_files: []