enhance FHIR resource navigation and discriminator path resolution for complex slice types

Author: abhinandan2012

lib/inferno/dsl/fhir_resource_navigation.rb

@@ -24,7 +24,7 @@ def resolve_path(elements, path)
         elements = Array.wrap(elements)
         return elements if path.blank?
 
-        paths = path.split(/(?<!hl7)\./)
+        paths = path_segments(path)
         segment = paths.first
         remaining_path = paths.drop(1).join('.')
 
@@ -49,9 +49,9 @@ def find_a_value_at(given_element, path, include_dar: false, &block)
         elements = Array.wrap(given_element)
         return find_in_elements(elements, include_dar:, &block) if path.empty?
 
-        path_segments = path.split(/(?<!hl7)\./)
+        path_segments = path_segments(path)
 
-        segment = path_segments.shift.delete_suffix('[x]').gsub(/^class$/, 'local_class').gsub('[x]:', ':').to_sym
+        segment = path_segments.shift
 
         remaining_path = path_segments.join('.')
         elements.each do |element|
@@ -78,25 +78,75 @@ def find_in_elements(elements, include_dar: false, &)
 
       # @private
       def get_next_value(element, property)
+        property = property.to_s
         extension_url = property[/(?<=where\(url=').*(?='\))/]
-        if extension_url.present?
-          element.url == extension_url ? element : nil
-        elsif property.to_s.include?(':') && !property.to_s.include?('url')
-          find_slice_via_discriminator(element, property)
+        return extension_filter_value(element, extension_url) if extension_url.present?
+        return typed_choice_value(element, property) if explicit_choice_path?(property)
+        return populated_choice_value(element, property) if implicit_choice_path?(property)
+        return find_slice_via_discriminator(element, property) if slice_path?(property)
 
-        else
-          local_name = local_field_name(property)
-          value = element.send(local_name)
-          primitive_value = get_primitive_type_value(element, property, value)
-          primitive_value.present? ? primitive_value : value
-        end
+        field_value(element, property)
       rescue NoMethodError
         nil
       end
 
+      # @private
+      def extension_filter_value(element, extension_url)
+        element.url == extension_url ? element : nil
+      end
+
+      # @private
+      def explicit_choice_path?(property)
+        property.include?('[x]:')
+      end
+
+      # @private
+      def implicit_choice_path?(property)
+        property.end_with?('[x]')
+      end
+
+      # @private
+      def slice_path?(property)
+        property.include?(':') && !property.include?('url')
+      end
+
+      # @private
+      def typed_choice_value(element, property)
+        _choice_path, typed_field = property.split(':', 2)
+        field_value(element, typed_field)
+      end
+
+      # @private
+      def populated_choice_value(element, property)
+        choice_prefix = property.delete_suffix('[x]')
+        populated_field =
+          Array.wrap(element.to_hash&.keys)
+            .map(&:to_s)
+            .find do |field_name|
+              field_name.start_with?(choice_prefix) && value_present?(field_value(element, field_name))
+            end
+
+        return nil if populated_field.blank?
+
+        field_value(element, populated_field)
+      end
+
+      # @private
+      def field_value(element, field_name)
+        local_name = local_field_name(field_name)
+        value = element.send(local_name)
+        primitive_value = get_primitive_type_value(element, field_name, value)
+        primitive_value.present? ? primitive_value : value
+      end
+
       # @private
       def get_primitive_type_value(element, property, value)
-        source_value = element.source_hash["_#{property}"]
+        return nil unless element.respond_to?(:source_hash)
+
+        source_hash = element.source_hash
+        return nil unless source_hash.present?
+
+        source_value = source_hash["_#{property}"]
 
         return nil unless source_value.present?
 
@@ -116,6 +166,47 @@ def local_field_name(field_name)
         end
       end
 
+      # @private
+      def path_segments(path)
+        state = { current_segment: +'', segments: [], parentheses_depth: 0, in_quotes: false }
+        path.each_char { |char| update_path_segment_state(state, char) }
+        state[:segments] << state[:current_segment] unless state[:current_segment].empty?
+        state[:segments]
+      end
+
+      # @private
+      def update_path_segment_state(state, char)
+        case char
+        when "'"
+          state[:current_segment] << char
+          state[:in_quotes] = !state[:in_quotes]
+        when '('
+          append_path_character(state, char, depth_change: 1)
+        when ')'
+          append_path_character(state, char, depth_change: -1)
+        when '.'
+          split_path_segment_or_append(state, char)
+        else
+          state[:current_segment] << char
+        end
+      end
+
+      # @private
+      def append_path_character(state, char, depth_change:)
+        state[:current_segment] << char
+        state[:parentheses_depth] += depth_change unless state[:in_quotes]
+      end
+
+      # @private
+      def split_path_segment_or_append(state, char)
+        if state[:parentheses_depth].zero? && !state[:in_quotes]
+          state[:segments] << state[:current_segment].dup
+          state[:current_segment].clear
+        else
+          state[:current_segment] << char
+        end
+      end
+
       # @private
       def find_slice_via_discriminator(element, property)
         return unless metadata.present?
@@ -170,7 +261,7 @@ def matching_pattern_identifier_slice?(slice, discriminator)
 
       # @private
       def matching_value_slice?(slice, discriminator)
-        values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
+        values = discriminator[:values].map { |value| value.merge(path: path_segments(value[:path])) }
         verify_slice_by_values(slice, values)
       end
 
@@ -200,15 +291,31 @@ def matching_type_slice?(slice, discriminator)
 
       # @private
       def matching_required_binding_slice?(slice, discriminator)
-        slice_coding = discriminator[:path].present? ? slice.send((discriminator[:path]).to_s).coding : slice.coding
-        slice_coding.any? do |coding|
-          discriminator[:values].any? do |value|
-            case value
-            when String
-              value == coding.code
-            when Hash
-              value[:system] == coding.system && value[:code] == coding.code
-            end
+        slice_coding = required_binding_codings(slice, discriminator)
+        return slice_coding.present? if discriminator[:values].blank?
+
+        slice_coding.any? { |coding| required_binding_value_match?(coding, discriminator[:values]) }
+      end
+
+      # @private
+      def required_binding_codings(slice, discriminator)
+        if discriminator[:path].present?
+          Array.wrap(resolve_path(slice, discriminator[:path])).flat_map { |value| Array.wrap(value&.coding) }
+        elsif slice.is_a?(FHIR::Coding)
+          [slice]
+        else
+          Array.wrap(slice.coding)
+        end
+      end
+
+      # @private
+      def required_binding_value_match?(coding, values)
+        values.any? do |value|
+          case value
+          when String
+            value == coding.code
+          when Hash
+            value[:system] == coding.system && value[:code] == coding.code
           end
         end
       end
@@ -221,7 +328,7 @@ def verify_slice_by_values(element, value_definitions)
             value_definitions
               .select { |value_definition| value_definition[:path].first == path_prefix }
               .each { |value_definition| value_definition[:path].shift }
-          find_a_value_at(element, path_prefix) do |el_found|
+          value_at_path_matches?(element, path_prefix) do |el_found|
             current_and_child_values_match?(el_found, value_definitions_for_path)
           end
         end
@@ -245,6 +352,17 @@ def current_and_child_values_match?(el_found, value_definitions_for_path)
         current_element_values_match && child_element_values_match
       end
 
+      # @private
+      def value_at_path_matches?(element, path, include_dar: false, &)
+        value_found = find_a_value_at(element, path, include_dar:, &)
+        value_present?(value_found)
+      end
+
+      # @private
+      def value_present?(value)
+        value.present? || value == false
+      end
+
       # @private
       def flatten_bundles(resources)
         resources.flat_map do |resource|

lib/inferno/dsl/must_support_assessment.rb

@@ -237,12 +237,10 @@ def find_missing_elements(resources, must_support_elements)
         end
 
         def resource_populates_element?(resource, element_definition)
-          path = element_definition[:path]
+          raw_path = element_definition[:path]
+          path = navigation_compatible_must_support_path(raw_path)
 
-          # handle MustSupport element under extension: Ex: extension:supporting-info.value[x]
-          resource, path = process_must_support_element_in_extension(resource, path) if path.start_with?('extension:')
-
-          ms_extension_urls = must_support_extensions.select { |ex| ex[:path] == "#{path}.extension" }
+          ms_extension_urls = must_support_extensions.select { |ex| ex[:path] == "#{raw_path}.extension" }
             .map { |ex| ex[:url] }
           include_dar = normalized_extension_urls(ms_extension_urls).include?(FHIRResourceNavigation::DAR_EXTENSION_URL)
 
@@ -254,6 +252,47 @@ def resource_populates_element?(resource, element_definition)
           value_found.present? || value_found == false
         end
 
+        def navigation_compatible_must_support_path(path)
+          logical_segments = []
+
+          path_segments(path).map do |segment|
+            normalized_segment = normalized_must_support_path_segment(segment, logical_segments)
+            logical_segments << segment.split(':').first
+            normalized_segment
+          end.join('.')
+        end
+
+        def normalized_must_support_path_segment(segment, logical_segments)
+          extension_type, extension_name = segment.match(/\A(modifierExtension|extension):(.+)\z/)&.captures
+          return segment if extension_type.blank?
+
+          extension_path = [logical_segments.join('.'), extension_type].reject(&:blank?).join('.')
+          extension_definition = must_support_extension_definition(extension_path, extension_type, extension_name)
+          return segment if extension_definition.blank?
+
+          "#{extension_type}.where(url='#{normalized_extension_url(extension_definition[:url])}')"
+        end
+
+        def must_support_extension_definition(extension_path, extension_type, extension_name)
+          suffix = "#{extension_type}:#{extension_name}"
+          path_matching_extensions = must_support_extensions.select { |definition| definition[:path] == extension_path }
+
+          extension_definition_candidates(path_matching_extensions).each do |definitions, matcher|
+            match = definitions.find { |definition| definition[:id].public_send(matcher, suffix) }
+            return match if match.present?
+          end
+
+          nil
+        end
+
+        def extension_definition_candidates(path_matching_extensions)
+          [
+            [path_matching_extensions, :end_with?],
+            [path_matching_extensions, :include?],
+            [must_support_extensions, :end_with?]
+          ]
+        end
+
         def process_must_support_element_in_extension(resource, path)
           return [resource, path] unless path.start_with?('extension:')
 
@@ -370,7 +409,7 @@ def find_pattern_identifier_slice(element, discriminator)
         end
 
         def find_value_slice(element, discriminator)
-          values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
+          values = discriminator[:values].map { |value| value.merge(path: path_segments(value[:path])) }
           find_slice_by_values(element, values)
         end
 
@@ -401,23 +440,33 @@ def find_type_slice(element, discriminator)
         end
 
         def find_required_binding_slice(element, discriminator)
+          if element.is_a?(FHIR::Coding) && required_binding_value_match?(element, discriminator[:values])
+            return element
+          end
+
           coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
 
           find_a_value_at(element, coding_path) do |coding|
-            discriminator[:values].any? do |value|
-              case value
-              when String
-                value == coding.code
-              when Hash
-                value[:system] == coding.system && value[:code] == coding.code
-              end
-            end
+            required_binding_value_match?(coding, discriminator[:values])
           end
         end
 
         def find_slice_by_values(element, value_definitions)
           Array.wrap(element).find { |el| verify_slice_by_values(el, value_definitions) }
         end
+
+        def required_binding_value_match?(coding, values)
+          return true if values.blank?
+
+          values.any? do |value|
+            case value
+            when String
+              value == coding.code
+            when Hash
+              value[:system] == coding.system && value[:code] == coding.code
+            end
+          end
+        end
       end
     end
   end