rename choice path helpers and improve empty value handling in fhir_resource_navigation and metadata_extractor

Author: abhinandan2012

lib/inferno/dsl/fhir_resource_navigation.rb

@@ -42,7 +42,7 @@ def resolve_path(elements, path)
       # @param given_element [FHIR::Model, Array<FHIR::Model>]
       # @param path [String]
       # @param include_dar [Boolean]
-      # @return [Array<FHIR::Model>]
+      # @return [FHIR::Model, Object, false, nil] a single matching value, `false`, or `nil` if not found
       def find_a_value_at(given_element, path, include_dar: false, &block)
         return nil if given_element.nil?
 
@@ -81,8 +81,8 @@ def get_next_value(element, property)
         property = property.to_s
         extension_url = property[/(?<=where\(url=').*(?='\))/]
         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 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)
 
         field_value(element, property)
@@ -96,12 +96,12 @@ def extension_filter_value(element, extension_url)
       end
 
       # @private
-      def explicit_choice_path?(property)
+      def sliced_choice_path?(property)
         property.include?('[x]:')
       end
 
       # @private
-      def implicit_choice_path?(property)
+      def choice_path?(property)
         property.end_with?('[x]')
       end
 
@@ -111,9 +111,9 @@ def slice_path?(property)
       end
 
       # @private
-      def typed_choice_value(element, property)
-        _choice_path, typed_field = property.split(':', 2)
-        field_value(element, typed_field)
+      def sliced_choice_value(element, property)
+        _choice_path, sliced_field = property.split(':', 2)
+        field_value(element, sliced_field)
       end
 
       # @private
@@ -123,7 +123,7 @@ def populated_choice_value(element, property)
           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))
+              field_name.start_with?(choice_prefix) && value_not_empty?(field_value(element, field_name))
             end
 
         return nil if populated_field.blank?
@@ -355,11 +355,11 @@ def current_and_child_values_match?(el_found, value_definitions_for_path)
       # @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)
+        value_not_empty?(value_found)
       end
 
       # @private
-      def value_present?(value)
+      def value_not_empty?(value)
         value.present? || value == false
       end
 

lib/inferno/dsl/must_support_metadata_extractor.rb

@@ -259,7 +259,7 @@ def type_slices
         must_support_type_slice_elements.map do |current_element|
           discriminator = discriminators(sliced_element(current_element)).first
           type_path = discriminator_path(discriminator)
-          type_element, type_path = find_type_slice_target(current_element, type_path)
+          type_element = find_element_by_discriminator_path(current_element, type_path)
 
           type_code = type_element.type.first.code
           discriminator_metadata = {
@@ -280,29 +280,6 @@ def type_slices
         end
       end
 
-      def find_type_slice_target(current_element, type_path)
-        type_element = find_element_by_discriminator_path(current_element, type_path)
-
-        return [type_element, type_path] unless type_slice_requires_resource_path?(type_path, type_element)
-
-        resource_element = type_slice_resource_element(current_element)
-
-        return [type_element, type_path] unless resource_element.present?
-
-        [resource_element, resource_element.path.delete_prefix("#{current_element.path}.")]
-      end
-
-      def type_slice_requires_resource_path?(type_path, type_element)
-        type_path.blank? &&
-          type_element&.type&.all? { |type| type.code == 'BackboneElement' }
-      end
-
-      def type_slice_resource_element(current_element)
-        profile_elements.find do |element|
-          element.id == "#{current_element.id}.resource" && element.type.present?
-        end
-      end
-
       def must_support_value_slice_elements
         must_support_slice_elements.select do |element|
           # discriminator type 'pattern' is deprecated in FHIR R5 and made equivalent to 'value'
@@ -339,7 +316,7 @@ def value_slices # rubocop:disable Metrics/CyclomaticComplexity
                   type: 'unsupported',
                   path: navigation_compatible_discriminator_path(discriminator_path)
                 }
-              elsif !pattern_element.fixed.nil?
+              elsif value_not_empty?(pattern_element.fixed)
                 fixed_values << {
                   path: navigation_compatible_discriminator_path(discriminator_path),
                   value: pattern_element.fixed
@@ -377,8 +354,12 @@ def element_part_of_slice_discrimination?(element)
         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.nil?
+        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

spec/inferno/dsl/fhir_resource_navigation_spec.rb

@@ -121,13 +121,13 @@ def metadata_fixture(filename)
                                                          'value[x]:valueQuantity.code')).to eq('/min')
     end
 
-    it 'can find a populated choice element when the type is not explicit' do
+    it 'can find a populated choice element on an unsliced choice path' do
       supporting_info = FHIR::Claim::SupportingInfo.new(timingDate: '2024-01-01')
 
       expect(must_support_coverage_test.find_a_value_at(supporting_info, 'timing[x]')).to eq('2024-01-01')
     end
 
-    it 'can find a populated choice element when the type is explicit' do
+    it 'can find a populated choice element on a sliced choice path' do
       supporting_info = FHIR::Claim::SupportingInfo.new(
         timingPeriod: FHIR::Period.new(start: '2024-01-01')
       )

spec/inferno/dsl/must_support_metadata_extractor_spec.rb

@@ -111,7 +111,7 @@
     end
 
     it 'extracts the discriminator path when the sliced type is on Bundle.entry.resource' do
-      discriminator = FHIR::ElementDefinition::Slicing::Discriminator.new(type: 'type', path: '$this')
+      discriminator = FHIR::ElementDefinition::Slicing::Discriminator.new(type: 'type', path: 'resource')
       slicing = FHIR::ElementDefinition::Slicing.new(discriminator: [discriminator])
 
       backbone_type = instance_double(FHIR::ElementDefinition::Type, code: 'BackboneElement')