inferno_core 0.6.1 → 0.6.2

data/lib/inferno/dsl/fhir_resource_navigation.rb

@@ -0,0 +1,226 @@
+require_relative 'primitive_type'
+
+module Inferno
+  module DSL
+    # The FHIRResourceNavigation module is used to pick values from a FHIR resource, based on a profile.
+    # Originally intended for use for verifying the presence of Must Support elements on a resource.
+    # This module expects pre-processed metadata defining the elements of the profile
+    #  to be present in the attribute `metadata` in the including class.
+    # @see Inferno::DSL::MustSupportMetadataExtractor
+    module FHIRResourceNavigation
+      DAR_EXTENSION_URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason'.freeze
+      PRIMITIVE_DATA_TYPES = FHIR::PRIMITIVES.keys
+
+      # Get a value from the given FHIR element(s) by walking the given path through the element.
+      # @param elements [FHIR::Model, Array<FHIR::Model>]
+      # @param path [String]
+      # @return [Array<FHIR::Model>]
+      def resolve_path(elements, path)
+        elements = Array.wrap(elements)
+        return elements if path.blank?
+
+        paths = path.split(/(?<!hl7)\./)
+        segment = paths.first
+        remaining_path = paths.drop(1).join('.')
+
+        elements.flat_map do |element|
+          child = get_next_value(element, segment)
+          resolve_path(child, remaining_path)
+        end.compact
+      end
+
+      # Get a value from the given FHIR element(s), by navigating through the resource to the given path.
+      # Fields with a DataAbsentReason extension present may be selected if include_dar is true.
+      # To filter the resulting elements, a block may be passed in.
+      # @param given_element [FHIR::Model, Array<FHIR::Model>]
+      # @param path [String]
+      # @param include_dar [Boolean]
+      # @return [Array<FHIR::Model>]
+      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)\./)
+
+        segment = path_segments.shift.delete_suffix('[x]').gsub(/^class$/, 'local_class').gsub('[x]:', ':').to_sym
+
+        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
+        end
+
+        nil
+      end
+
+      def find_in_elements(elements, include_dar: false, &)
+        unless include_dar
+          elements = elements.reject do |el|
+            el.respond_to?(:extension) && el.extension.any? { |ext| ext.url == DAR_EXTENSION_URL }
+          end
+        end
+
+        return elements.find(&) if block_given?
+
+        elements.first
+      end
+
+      def get_next_value(element, property)
+        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)
+
+        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
+      rescue NoMethodError
+        nil
+      end
+
+      def get_primitive_type_value(element, property, value)
+        source_value = element.source_hash["_#{property}"]
+
+        return nil unless source_value.present?
+
+        primitive_value = PrimitiveType.new(source_value)
+        primitive_value.value = value
+        primitive_value
+      end
+
+      def local_field_name(field_name)
+        # fhir_models prepends fields whose names are reserved in ruby with "local_"
+        # This should be used before `x.send(field_name)`
+        if ['method', 'class'].include?(field_name.to_s)
+          "local_#{field_name}"
+        else
+          field_name
+        end
+      end
+
+      def find_slice_via_discriminator(element, property)
+        return unless metadata.present?
+
+        element_name = local_field_name(property.to_s.split(':')[0])
+        slice_name = local_field_name(property.to_s.split(':')[1])
+
+        slice_by_name = metadata.must_supports[:slices].find { |slice| slice[:slice_name] == slice_name }
+        discriminator = slice_by_name[:discriminator]
+        slices = Array.wrap(element.send(element_name))
+        slices.find { |slice| matching_slice?(slice, discriminator) }
+      end
+
+      def matching_slice?(slice, discriminator)
+        case discriminator[:type]
+        when 'patternCodeableConcept'
+          matching_pattern_codeable_concept_slice?(slice, discriminator)
+        when 'patternCoding'
+          matching_pattern_coding_slice?(slice, discriminator)
+        when 'patternIdentifier'
+          matching_pattern_identifier_slice?(slice, discriminator)
+        when 'value'
+          matching_value_slice?(slice, discriminator)
+        when 'type'
+          matching_type_slice?(slice, discriminator)
+        when 'requiredBinding'
+          matching_required_binding_slice?(slice, discriminator)
+        end
+      end
+
+      def matching_pattern_codeable_concept_slice?(slice, discriminator)
+        slice_value = discriminator[:path].present? ? slice.send((discriminator[:path]).to_s)&.coding : slice.coding
+        slice_value&.any? do |coding|
+          coding.code == discriminator[:code] && coding.system == discriminator[:system]
+        end
+      end
+
+      def matching_pattern_coding_slice?(slice, discriminator)
+        slice_value = discriminator[:path].present? ? slice.send(discriminator[:path]) : slice
+        slice_value&.code == discriminator[:code] && slice_value&.system == discriminator[:system]
+      end
+
+      def matching_pattern_identifier_slice?(slice, discriminator)
+        slice.identifier.system == discriminator[:system]
+      end
+
+      def matching_value_slice?(slice, discriminator)
+        values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
+        verify_slice_by_values(slice, values)
+      end
+
+      def matching_type_slice?(slice, discriminator)
+        case discriminator[:code]
+        when 'Date'
+          begin
+            Date.parse(slice)
+          rescue ArgumentError
+            false
+          end
+        when 'DateTime'
+          begin
+            DateTime.parse(slice)
+          rescue ArgumentError
+            false
+          end
+        when 'String'
+          slice.is_a? String
+        else
+          slice.is_a? FHIR.const_get(discriminator[:code])
+        end
+      end
+
+      def matching_required_binding_slice?(slice, discriminator)
+        discriminator[:path].present? ? slice.send((discriminator[:path]).to_s).coding : slice.coding
+        slice_value { |coding| discriminator[:values].include?(coding.code) }
+      end
+
+      def verify_slice_by_values(element, value_definitions)
+        path_prefixes = value_definitions.map { |value_definition| value_definition[:path].first }.uniq
+        path_prefixes.all? do |path_prefix|
+          value_definitions_for_path =
+            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|
+            current_and_child_values_match?(el_found, value_definitions_for_path)
+          end
+        end
+      end
+
+      def current_and_child_values_match?(el_found, value_definitions_for_path)
+        child_element_value_definitions, current_element_value_definitions =
+          value_definitions_for_path.partition { |value_definition| value_definition[:path].present? }
+
+        current_element_values_match =
+          current_element_value_definitions
+            .all? { |value_definition| value_definition[:value] == el_found }
+
+        child_element_values_match =
+          if child_element_value_definitions.present?
+            verify_slice_by_values(el_found, child_element_value_definitions)
+          else
+            true
+          end
+        current_element_values_match && child_element_values_match
+      end
+
+      def flatten_bundles(resources)
+        resources.flat_map do |resource|
+          if resource&.resourceType == 'Bundle'
+            # Recursive to consider that Bundles may contain Bundles
+            flatten_bundles(resource.entry.map(&:resource))
+          else
+            resource
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/must_support_metadata_extractor.rb

@@ -0,0 +1,366 @@
+require_relative 'value_extractor'
+
+module Inferno
+  module DSL
+    # The MustSupportMetadataExtractor takes a StructureDefinition and parses it into a hash-based metadata
+    #  that simplifies checking for MustSupport elements.
+    # MustSupport elements may be either plain elements, extensions, or slices.
+    # This logic was originally developed for the US Core Test Kit and has been migrated into Inferno core.
+    class MustSupportMetadataExtractor
+      attr_accessor :profile_elements, :profile, :resource, :ig_resources, :requirement_extension_url
+
+      # Construct a new extractor
+      # @param profile_elements [Array<FHIR::ElementDefinition>] the elements of the profile to consider,
+      #   ie, profile.snapshot.element
+      # @param profile [FHIR::StructureDefinition] the profile to parse
+      # @param resource [String] the resourceType that the profile applies to, ie, profile.type
+      # @param ig_resources [Inferno::Entities::IG]
+      # @param requirement_extension_url [String] the URL of an extension to flag elements as required even if not MS
+      def initialize(profile_elements, profile, resource, ig_resources, requirement_extension_url = nil)
+        self.profile_elements = profile_elements
+        self.profile = profile
+        self.resource = resource
+        self.ig_resources = ig_resources
+        self.requirement_extension_url = requirement_extension_url
+      end
+
+      # Retrieval method for the must support metadata
+      # @return [Hash]
+      def must_supports
+        @must_supports ||= {
+          extensions: must_support_extensions,
+          slices: must_support_slices,
+          elements: must_support_elements
+        }
+      end
+
+      def by_requirement_extension_only?(element)
+        requirement_extension_url && !element.mustSupport &&
+          element.extension.any? do |extension|
+            extension.url == requirement_extension_url && extension.valueBoolean
+          end
+      end
+
+      def all_must_support_elements
+        profile_elements.select { |element| element.mustSupport || by_requirement_extension_only?(element) }
+      end
+
+      def must_support_extension_elements
+        all_must_support_elements.select { |element| element.path.end_with? 'extension' }
+      end
+
+      def must_support_extensions
+        must_support_extension_elements.map do |element|
+          {
+            id: element.id,
+            path: element.path.gsub("#{resource}.", ''),
+            url: element.type.first.profile.first
+          }.tap do |metadata|
+            metadata[:by_requirement_extension_only] = true if by_requirement_extension_only?(element)
+          end
+        end
+      end
+
+      def must_support_slice_elements
+        all_must_support_elements.select do |element|
+          !element.path.end_with?('extension') && element.sliceName.present?
+        end
+      end
+
+      def sliced_element(slice)
+        profile_elements.find do |element|
+          element.id == slice.path || element.id == slice.id.sub(":#{slice.sliceName}", '')
+        end
+      end
+
+      def discriminators(slice)
+        slice&.slicing&.discriminator
+      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
+        end
+      end
+
+      def save_pattern_slice(pattern_element, discriminator_path, metadata)
+        if pattern_element.patternCodeableConcept
+          {
+            type: 'patternCodeableConcept',
+            path: discriminator_path,
+            code: pattern_element.patternCodeableConcept.coding.first.code,
+            system: pattern_element.patternCodeableConcept.coding.first.system
+          }
+        elsif pattern_element.patternCoding
+          {
+            type: 'patternCoding',
+            path: discriminator_path,
+            code: pattern_element.patternCoding.code,
+            system: pattern_element.patternCoding.system
+          }
+        elsif pattern_element.patternIdentifier
+          {
+            type: 'patternIdentifier',
+            path: discriminator_path,
+            system: pattern_element.patternIdentifier.system
+          }
+        elsif required_binding_pattern?(pattern_element)
+          {
+            type: 'requiredBinding',
+            path: discriminator_path,
+            values: extract_required_binding_values(pattern_element, metadata)
+          }
+        else
+          # prevent errors in case an IG does something different
+          {
+            type: 'unsupported',
+            path: discriminator_path
+          }
+        end
+      end
+
+      def required_binding_pattern?(pattern_element)
+        pattern_element.binding&.strength == 'required' && pattern_element.binding&.valueSet
+      end
+
+      def extract_required_binding_values(pattern_element, metadata)
+        value_extractor = ValueExtractor.new(ig_resources, resource, profile_elements)
+
+        value_extractor.codings_from_value_set_binding(pattern_element).presence ||
+          value_extractor.values_from_resource_metadata([metadata[:path]]).presence || []
+      end
+
+      def must_support_type_slice_elements
+        must_support_slice_elements.select do |element|
+          discriminators(sliced_element(element))&.first&.type == 'type'
+        end
+      end
+
+      def discriminator_path(discriminator)
+        if discriminator.path == '$this'
+          ''
+        elsif discriminator.path.start_with?('$this.')
+          discriminator.path[6..]
+        else
+          discriminator.path
+        end
+      end
+
+      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 = find_element_by_discriminator_path(current_element, type_path)
+
+          type_code = type_element.type.first.code
+
+          {
+            slice_id: current_element.id,
+            slice_name: current_element.sliceName,
+            path: current_element.path.gsub("#{resource}.", ''),
+            discriminator: {
+              type: 'type',
+              code: type_code.upcase_first
+            }
+          }.tap do |metadata|
+            metadata[:by_requirement_extension_only] = true if by_requirement_extension_only?(current_element)
+          end
+        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'
+          ['value', 'pattern'].include?(discriminators(sliced_element(element))&.first&.type)
+        end
+      end
+
+      def value_slices # rubocop:disable Metrics/CyclomaticComplexity
+        must_support_value_slice_elements.map do |current_element|
+          {
+            slice_id: current_element.id,
+            slice_name: current_element.sliceName,
+            path: current_element.path.gsub("#{resource}.", '')
+          }.tap do |metadata|
+            fixed_values = []
+            pattern_value = {}
+
+            element_discriminators = discriminators(sliced_element(current_element))
+
+            element_discriminators.each do |discriminator|
+              discriminator_path = discriminator_path(discriminator)
+              pattern_element = find_element_by_discriminator_path(current_element, discriminator_path)
+
+              # This is a workaround for a known version of a profile that has a bad discriminator:
+              # the discriminator refers to a nested field within a CodeableConcept,
+              # but the profile doesn't contain an element definition for it, so there's no way to
+              # define a fixed value on the element to define the slice.
+              # In this instance the element has a second (good) discriminator on the CodeableConcept field itself,
+              # 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?
+                fixed_values << {
+                  path: discriminator_path,
+                  value: pattern_element.fixed
+                }
+              elsif pattern_value.present?
+                raise StandardError, "Found more than one pattern slices for the same element #{pattern_element}."
+              else
+                pattern_value = save_pattern_slice(pattern_element, discriminator_path, metadata)
+              end
+            end
+
+            if fixed_values.present?
+              metadata[:discriminator] = {
+                type: 'value',
+                values: fixed_values
+              }
+            elsif pattern_value.present?
+              metadata[:discriminator] = pattern_value
+            end
+
+            metadata[:by_requirement_extension_only] = true if by_requirement_extension_only?(current_element)
+          end
+        end
+      end
+
+      def must_support_slices
+        type_slices + value_slices
+      end
+
+      def plain_must_support_elements
+        all_must_support_elements - must_support_extension_elements - must_support_slice_elements
+      end
+
+      def element_part_of_slice_discrimination?(element)
+        must_support_slice_elements.any? { |ms_slice| element.id.include?(ms_slice.id) }
+      end
+
+      def handle_fixed_values(metadata, element)
+        if element.fixed.present?
+          metadata[:fixed_value] = element.fixed
+        elsif element.patternCodeableConcept.present? && !element_part_of_slice_discrimination?(element)
+          metadata[:fixed_value] = element.patternCodeableConcept.coding.first.code
+          metadata[:path] += '.coding.code'
+        elsif element.fixedCode.present?
+          metadata[:fixed_value] = element.fixedCode
+        elsif element.patternIdentifier.present? && !element_part_of_slice_discrimination?(element)
+          metadata[:fixed_value] = element.patternIdentifier.system
+          metadata[:path] += '.system'
+        end
+      end
+
+      def type_must_support_extension?(extensions)
+        extensions&.any? do |extension|
+          extension.url == 'http://hl7.org/fhir/StructureDefinition/elementdefinition-type-must-support' &&
+            extension.valueBoolean
+        end
+      end
+
+      def save_type_code?(type)
+        type.code == 'Reference'
+      end
+
+      def get_type_must_support_metadata(current_metadata, current_element)
+        current_element.type.map do |type|
+          next unless type_must_support_extension?(type.extension)
+
+          metadata =
+            {
+              path: "#{current_metadata[:path].delete_suffix('[x]')}#{type.code.upcase_first}",
+              original_path: current_metadata[:path]
+            }
+          metadata[:types] = [type.code] if save_type_code?(type)
+          handle_type_must_support_target_profiles(type, metadata) if type.code == 'Reference'
+
+          metadata
+        end.compact
+      end
+
+      def handle_type_must_support_target_profiles(type, metadata)
+        target_profiles = extract_target_profiles(type)
+
+        # remove target_profile for FHIR Base resource type.
+        target_profiles.delete_if { |reference| reference.start_with?('http://hl7.org/fhir/StructureDefinition') }
+        metadata[:target_profiles] = target_profiles if target_profiles.present?
+      end
+
+      def extract_target_profiles(type)
+        target_profiles = []
+
+        if type.targetProfile&.length == 1
+          target_profiles << type.targetProfile.first
+        else
+          type.source_hash['_targetProfile']&.each_with_index do |hash, index|
+            if hash.present?
+              element = FHIR::Element.new(hash)
+              target_profiles << type.targetProfile[index] if type_must_support_extension?(element.extension)
+            end
+          end
+        end
+
+        target_profiles
+      end
+
+      def handle_choice_type_in_sliced_element(current_metadata, must_support_elements_metadata)
+        choice_element_metadata = must_support_elements_metadata.find do |metadata|
+          metadata[:original_path].present? &&
+            current_metadata[:path].include?(metadata[:original_path])
+        end
+
+        return unless choice_element_metadata.present?
+
+        current_metadata[:original_path] = current_metadata[:path]
+        current_metadata[:path] =
+          current_metadata[:path].sub(choice_element_metadata[:original_path], choice_element_metadata[:path])
+      end
+
+      def must_support_elements
+        must_support_elements_metadata = []
+        plain_must_support_elements.each do |current_element|
+          current_metadata = {
+            path: current_element.id.gsub("#{resource}.", '')
+          }
+          current_metadata[:by_requirement_extension_only] = true if by_requirement_extension_only?(current_element)
+
+          type_must_support_metadata = get_type_must_support_metadata(current_metadata, current_element)
+
+          if type_must_support_metadata.any?
+            must_support_elements_metadata.concat(type_must_support_metadata)
+          else
+            handle_choice_type_in_sliced_element(current_metadata, must_support_elements_metadata)
+
+            supported_types = extract_supported_types(current_element)
+            current_metadata[:types] = supported_types if supported_types.present?
+
+            if current_element.type.first&.code == 'Reference'
+              handle_type_must_support_target_profiles(current_element.type.first,
+                                                       current_metadata)
+            end
+
+            handle_fixed_values(current_metadata, current_element)
+
+            remove_conflicting_metadata_without_fixed_value(must_support_elements_metadata, current_metadata)
+
+            must_support_elements_metadata << current_metadata
+          end
+        end
+        must_support_elements_metadata.uniq
+      end
+
+      def extract_supported_types(current_element)
+        current_element.type.select { |type| save_type_code?(type) }.map(&:code)
+      end
+
+      def remove_conflicting_metadata_without_fixed_value(must_support_elements_metadata, current_metadata)
+        must_support_elements_metadata.delete_if do |metadata|
+          metadata[:path] == current_metadata[:path] && metadata[:fixed_value].blank?
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/primitive_type.rb

@@ -0,0 +1,9 @@
+require 'fhir_models'
+
+module Inferno
+  module DSL
+    class PrimitiveType < FHIR::Element
+      attr_accessor :value
+    end
+  end
+end