inferno_core 1.1.2 → 1.2.0

data/lib/inferno/dsl/fhir_resource_navigation.rb

@@ -24,7 +24,7 @@ module Inferno
         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('.')
 
@@ -42,22 +42,22 @@ module Inferno
       # @param given_element [FHIR::Model, Array<FHIR::Model>]
       # @param path [String]
       # @param include_dar [Boolean]
-      # @return [Array<FHIR::Model>]
+      # @return a single matching value (which can include `false`) or `nil` if not found
       def find_a_value_at(given_element, path, include_dar: false, &block)
         return nil if given_element.nil?
 
         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|
           child = get_next_value(element, segment)
           element_found = find_a_value_at(child, remaining_path, include_dar:, &block)
-          return element_found if element_found.present? || element_found == false
+          return element_found if value_not_empty?(element_found)
         end
 
         nil
@@ -78,25 +78,75 @@ module Inferno
 
       # @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 sliced_choice_value(element, property) if sliced_choice_path?(property)
+        return populated_choice_value(element, property) if 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 sliced_choice_path?(property)
+        property.include?('[x]:')
+      end
+
+      # @private
+      def choice_path?(property)
+        property.end_with?('[x]')
+      end
+
+      # @private
+      def slice_path?(property)
+        property.include?(':') && !property.include?('url')
+      end
+
+      # @private
+      def sliced_choice_value(element, property)
+        _choice_path, sliced_field = property.split(':', 2)
+        field_value(element, sliced_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_not_empty?(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 @@ module Inferno
         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?
@@ -124,6 +215,8 @@ module Inferno
         slice_name = local_field_name(property.to_s.split(':')[1])
 
         slice_by_name = metadata.must_supports[:slices].find { |slice| slice[:slice_name] == slice_name }
+        return nil if slice_by_name.blank?
+
         discriminator = slice_by_name[:discriminator]
         slices = Array.wrap(element.send(element_name))
         slices.find { |slice| matching_slice?(slice, discriminator) }
@@ -168,7 +261,7 @@ module Inferno
 
       # @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
 
@@ -198,15 +291,29 @@ module Inferno
 
       # @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)
+        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
@@ -219,7 +326,7 @@ module Inferno
             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
@@ -243,6 +350,17 @@ module Inferno
         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_not_empty?(value_found)
+      end
+
+      # @private
+      def value_not_empty?(value)
+        value.present? || value == false
+      end
+
       # @private
       def flatten_bundles(resources)
         resources.flat_map do |resource|

data/lib/inferno/dsl/must_support_assessment.rb

@@ -202,14 +202,18 @@ module Inferno
         def missing_extensions(resources = [])
           @missing_extensions ||=
             must_support_extensions.select do |extension_definition|
+              expected_url = normalized_extension_url(extension_definition[:url])
+
               resources.none? do |resource|
                 path = extension_definition[:path]
 
                 if path == 'extension'
-                  resource.extension.any? { |extension| extension.url == extension_definition[:url] }
+                  Array.wrap(resource.extension).any? do |extension|
+                    normalized_extension_url(extension.url) == expected_url
+                  end
                 else
                   extension = find_a_value_at(resource, path) do |el|
-                    el.url == extension_definition[:url]
+                    normalized_extension_url(el.url) == expected_url
                   end
 
                   extension.present?
@@ -233,12 +237,10 @@ module Inferno
         end
 
         def resource_populates_element?(resource, element_definition)
-          path = element_definition[: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:')
+          raw_path = element_definition[:path]
+          path = navigation_compatible_must_support_path(raw_path)
 
-          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] }
 
           value_found = find_a_value_at(resource, path) do |potential_value|
@@ -249,6 +251,47 @@ module Inferno
           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:')
 
@@ -257,8 +300,11 @@ module Inferno
           extension_name = extension_split.first
           extension_path = extension_split.last
 
-          found_extension_url = must_support_extensions.find { |ex| ex[:id].include?(extension_name) }[:url]
-          ms_element_extension = resource.extension.find { |ex| ex.url == found_extension_url }
+          found_extension_url =
+            normalized_extension_url(must_support_extensions.find { |ex| ex[:id].include?(extension_name) }[:url])
+          ms_element_extension = resource.extension.find do |extension|
+            normalized_extension_url(extension.url) == found_extension_url
+          end
 
           if ms_element_extension.present?
             resource = ms_element_extension
@@ -269,17 +315,33 @@ module Inferno
         end
 
         def matching_without_extensions?(value, ms_extension_urls, fixed_value)
-          if value.instance_of?(Inferno::DSL::PrimitiveType)
-            urls = value.extension&.map(&:url)
-            has_ms_extension = (urls & ms_extension_urls).present?
-            value = value.value
-          end
+          has_ms_extension = must_support_extension_present?(value, ms_extension_urls)
+
+          value = value.value if value.instance_of?(Inferno::DSL::PrimitiveType)
 
           return false unless has_ms_extension || value_without_extensions?(value)
 
           matches_fixed_value?(value, fixed_value)
         end
 
+        def must_support_extension_present?(value, ms_extension_urls)
+          return false unless value.respond_to?(:extension)
+
+          (extension_urls(value) & normalized_extension_urls(ms_extension_urls)).present?
+        end
+
+        def extension_urls(value)
+          Array.wrap(value.extension).map { |extension| normalized_extension_url(extension.url) }
+        end
+
+        def normalized_extension_urls(urls)
+          Array.wrap(urls).map { |url| normalized_extension_url(url) }
+        end
+
+        def normalized_extension_url(url)
+          url&.split('|')&.first
+        end
+
         def matches_fixed_value?(value, fixed_value)
           fixed_value.blank? || value == fixed_value
         end
@@ -346,7 +408,7 @@ module Inferno
         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
 
@@ -377,23 +439,31 @@ module Inferno
         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)
+          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

data/lib/inferno/dsl/must_support_metadata_extractor.rb

@@ -46,7 +46,7 @@ module Inferno
       end
 
       def must_support_extension_elements
-        all_must_support_elements.select { |element| element.path.end_with? 'extension' }
+        all_must_support_elements.select { |element| element.path.end_with? 'xtension' }
       end
 
       def must_support_extensions
@@ -54,16 +54,23 @@ module Inferno
           {
             id: element.id,
             path: element.path.gsub("#{resource}.", ''),
-            url: element.type.first.profile.first
+            url: canonical_url_without_version(element.type.first.profile.first),
+            modifier_extension: element.path.end_with?('modifierExtension')
           }.tap do |metadata|
             metadata[:by_requirement_extension_only] = true if by_requirement_extension_only?(element)
           end
         end
       end
 
+      def canonical_url_without_version(url)
+        url&.split('|')&.first
+      end
+
       def must_support_slice_elements
-        all_must_support_elements.select do |element|
-          !element.path.end_with?('extension') && element.sliceName.present?
+        profile_elements.select do |element|
+          next false if element.sliceName.blank? || element.path.end_with?('xtension')
+
+          all_must_support_elements.include?(element) || slice_has_must_support_descendants?(element)
         end
       end
 
@@ -77,47 +84,136 @@ module Inferno
         slice&.slicing&.discriminator
       end
 
+      def slice_has_must_support_descendants?(slice)
+        all_must_support_elements.any? do |element|
+          element.id.start_with?("#{slice.id}.")
+        end
+      end
+
       def find_element_by_discriminator_path(current_element, discriminator_path)
-        if discriminator_path.present?
-          profile_elements.find { |element| element.id == "#{current_element.id}.#{discriminator_path}" } ||
-            profile_elements.find { |element| element.id == "#{current_element.path}.#{discriminator_path}" }
-        else
-          current_element
+        target_element = current_element
+        remaining_path = discriminator_path
+
+        while remaining_path.present?
+          target_element, remaining_path = take_discriminator_step(target_element, remaining_path)
+          return nil if target_element.nil?
+        end
+
+        target_element
+      end
+
+      def take_discriminator_step(current_element, path)
+        return take_extension_discriminator_step(current_element, path) if extension_discriminator_step?(path)
+
+        take_standard_discriminator_step(current_element, path)
+      end
+
+      def extension_discriminator_step?(path)
+        path.start_with?('extension(') || path.start_with?('modifierExtension(')
+      end
+
+      def take_extension_discriminator_step(current_element, path)
+        extension_type = path.start_with?('modifierExtension(') ? 'modifierExtension' : 'extension'
+        ext_url, remaining_path = path.delete_prefix("#{extension_type}('").split("')", 2)
+        next_element = profile_elements.find do |element|
+          element.path == "#{current_element.path}.#{extension_type}" &&
+            element.id.start_with?("#{current_element.id}.#{extension_type}:") &&
+            element.type.any? { |type| extension_profile_matches?(type, ext_url) }
+        end
+
+        [next_element, remaining_path&.delete_prefix('.')]
+      end
+
+      def extension_profile_matches?(type, ext_url)
+        type.code == 'Extension' && type.profile.any? { |profile| profile.start_with?(ext_url) }
+      end
+
+      def take_standard_discriminator_step(current_element, path)
+        step_path, remaining_path = path.split('.', 2)
+        if remaining_path&.start_with?('ofType(')
+          return take_choice_discriminator_step(current_element, step_path, remaining_path)
+        end
+        if legacy_choice_discriminator_step?(step_path)
+          return take_legacy_choice_discriminator_step(current_element, step_path, remaining_path)
+        end
+
+        next_element =
+          profile_elements.find { |element| element.id == "#{current_element.id}.#{step_path}" } ||
+          profile_elements.find { |element| element.id == "#{current_element.path}.#{step_path}" }
+
+        [next_element, remaining_path&.delete_prefix('.')]
+      end
+
+      def legacy_choice_discriminator_step?(path)
+        path.match?(/\A.+\s+as\s+[[:word:]]+\z/)
+      end
+
+      def take_choice_discriminator_step(current_element, step_path, remaining_path)
+        target_element = "#{step_path}[x]"
+        target_type, remaining_path = remaining_path.delete_prefix('ofType(').split(')', 2)
+        next_element = profile_elements.find do |element|
+          element.id == "#{current_element.id}.#{target_element}" &&
+            element.type.any? { |type| type.code.casecmp?(target_type) }
         end
+
+        [next_element, remaining_path&.delete_prefix('.')]
+      end
+
+      def take_legacy_choice_discriminator_step(current_element, step_path, remaining_path)
+        target_element, target_type = step_path.split(/\s+as\s+/, 2)
+        target_element = "#{target_element}[x]" unless target_element.end_with?('[x]')
+        next_element = find_choice_element(current_element, target_element, target_type)
+
+        [next_element, remaining_path&.delete_prefix('.')]
+      end
+
+      def find_choice_element(current_element, target_element, target_type)
+        [current_element.id, current_element.path].filter_map do |base_path|
+          profile_elements.find do |element|
+            element_matches_choice_type?(element, "#{base_path}.#{target_element}", target_type)
+          end
+        end.first
+      end
+
+      def element_matches_choice_type?(element, target_path, target_type)
+        [element.id, element.path].include?(target_path) &&
+          element.type.any? { |type| type.code.casecmp?(target_type) }
       end
 
       def save_pattern_slice(pattern_element, discriminator_path, metadata)
+        runtime_path = navigation_compatible_discriminator_path(discriminator_path)
+
         if pattern_element.patternCodeableConcept
           {
             type: 'patternCodeableConcept',
-            path: discriminator_path,
+            path: runtime_path,
             code: pattern_element.patternCodeableConcept.coding.first.code,
             system: pattern_element.patternCodeableConcept.coding.first.system
           }
         elsif pattern_element.patternCoding
           {
             type: 'patternCoding',
-            path: discriminator_path,
+            path: runtime_path,
             code: pattern_element.patternCoding.code,
             system: pattern_element.patternCoding.system
           }
         elsif pattern_element.patternIdentifier
           {
             type: 'patternIdentifier',
-            path: discriminator_path,
+            path: runtime_path,
             system: pattern_element.patternIdentifier.system
           }
         elsif required_binding_pattern?(pattern_element)
           {
             type: 'requiredBinding',
-            path: discriminator_path,
+            path: runtime_path,
             values: extract_required_binding_values(pattern_element, metadata)
           }
         else
           # prevent errors in case an IG does something different
           {
             type: 'unsupported',
-            path: discriminator_path
+            path: runtime_path
           }
         end
       end
@@ -139,6 +235,16 @@ module Inferno
         end
       end
 
+      def navigation_compatible_discriminator_path(discriminator_path)
+        normalized_path = discriminator_path&.gsub(/(modifierExtension|extension)\('([^']+)'\)/, "\\1.where(url='\\2')")
+        normalized_path = normalized_path&.gsub(/([[:word:]\[\]]+)\.ofType\(([^)]+)\)/) do
+          "#{Regexp.last_match(1).delete_suffix('[x]')}#{Regexp.last_match(2).upcase_first}"
+        end
+        normalized_path&.gsub(/([[:word:]\[\]]+)\s+as\s+([[:word:]]+)/) do
+          "#{Regexp.last_match(1).delete_suffix('[x]')}#{Regexp.last_match(2).upcase_first}"
+        end
+      end
+
       def discriminator_path(discriminator)
         if discriminator.path == '$this'
           ''
@@ -156,15 +262,18 @@ module Inferno
           type_element = find_element_by_discriminator_path(current_element, type_path)
 
           type_code = type_element.type.first.code
+          discriminator_metadata = {
+            type: 'type',
+            code: type_code.upcase_first
+          }
+          runtime_path = navigation_compatible_discriminator_path(type_path)
+          discriminator_metadata[:path] = runtime_path if runtime_path.present?
 
           {
             slice_id: current_element.id,
             slice_name: current_element.sliceName,
             path: current_element.path.gsub("#{resource}.", ''),
-            discriminator: {
-              type: 'type',
-              code: type_code.upcase_first
-            }
+            discriminator: discriminator_metadata
           }.tap do |metadata|
             metadata[:by_requirement_extension_only] = true if by_requirement_extension_only?(current_element)
           end
@@ -202,9 +311,14 @@ module Inferno
               # and in subsequent versions of the profile, the bad discriminator was removed.
               next if pattern_element.nil? && element_discriminators.length > 1
 
-              if pattern_element.fixed.present?
+              if pattern_element.nil?
+                pattern_value = {
+                  type: 'unsupported',
+                  path: navigation_compatible_discriminator_path(discriminator_path)
+                }
+              elsif value_not_empty?(pattern_element.fixed)
                 fixed_values << {
-                  path: discriminator_path,
+                  path: navigation_compatible_discriminator_path(discriminator_path),
                   value: pattern_element.fixed
                 }
               elsif pattern_value.present?
@@ -240,8 +354,12 @@ module Inferno
         must_support_slice_elements.any? { |ms_slice| element.id.include?(ms_slice.id) }
       end
 
+      def value_not_empty?(value)
+        value.present? || value == false
+      end
+
       def handle_fixed_values(metadata, element)
-        if element.fixed.present?
+        if value_not_empty?(element.fixed)
           metadata[:fixed_value] = element.fixed
         elsif element.patternCodeableConcept.present? && !element_part_of_slice_discrimination?(element)
           metadata[:fixed_value] = element.patternCodeableConcept.coding.first.code