inferno_core 0.6.1 → 0.6.3

data/lib/inferno/dsl/value_extractor.rb

@@ -0,0 +1,136 @@
+module Inferno
+  module DSL
+    class ValueExtractor
+      attr_accessor :ig_resources, :resource, :profile_elements
+
+      def initialize(ig_resources, resource, profile_elements)
+        self.ig_resources = ig_resources
+        self.resource = resource
+        self.profile_elements = profile_elements
+      end
+
+      def values_from_fixed_codes(profile_element, type)
+        return [] unless type == 'CodeableConcept'
+
+        elements = profile_elements.select do |element|
+          element.path == "#{profile_element.path}.coding.code" && element.fixedCode.present?
+        end
+
+        elements.map(&:fixedCode)
+      end
+
+      def values_from_pattern_coding(profile_element, type)
+        return [] unless type == 'CodeableConcept'
+
+        elements = profile_elements.select do |element|
+          element.path == "#{profile_element.path}.coding" && element.patternCoding.present?
+        end
+
+        elements.map { |element| element.patternCoding.code }
+      end
+
+      def values_from_pattern_codeable_concept(profile_element, type)
+        return [] unless type == 'CodeableConcept'
+
+        elements = profile_elements.select do |element|
+          element.path == profile_element.path && element.patternCodeableConcept.present? && element.min.positive?
+        end
+
+        elements.map { |element| element.patternCodeableConcept.coding.first.code }
+      end
+
+      def value_set_binding(the_element)
+        the_element&.binding
+      end
+
+      def value_set(the_element)
+        ig_resources.value_set_by_url(value_set_binding(the_element)&.valueSet)
+      end
+
+      def bound_systems(the_element)
+        bound_systems_from_valueset(value_set(the_element))
+      end
+
+      def bound_systems_from_valueset(value_set)
+        value_set&.compose&.include&.map do |include_element|
+          bound_systems_from_valueset_include_element(include_element)
+        end&.flatten&.compact
+      end
+
+      def bound_systems_from_valueset_include_element(include_element)
+        if include_element.concept.present?
+          include_element
+        elsif include_element.system.present? && include_element.filter&.empty?
+          # Cannot process intensional value set with filters
+          ig_resources.code_system_by_url(include_element.system)
+        elsif include_element.valueSet.present?
+          include_element.valueSet.map do |vs|
+            a_value_set = ig_resources.value_set_by_url(vs)
+            bound_systems_from_valueset(a_value_set)
+          end
+        end
+      end
+
+      def codes_from_value_set_binding(the_element)
+        codes_from_system_code_pair(codings_from_value_set_binding(the_element))
+      end
+
+      def codes_from_system_code_pair(codings)
+        codings.present? ? codings.map { |coding| coding[:code] }.compact.uniq : []
+      end
+
+      def codings_from_value_set_binding(the_element)
+        return [] if the_element.nil?
+
+        bound_systems = bound_systems(the_element)
+
+        return codings_from_bound_systems(bound_systems) if bound_systems.present?
+
+        expansion_contains = value_set_expansion_contains(the_element)
+
+        return [] if expansion_contains.blank?
+
+        expansion_contains.map { |contains| { system: contains.system, code: contains.code } }.compact.uniq
+      end
+
+      def codings_from_bound_systems(bound_systems)
+        return [] unless bound_systems.present?
+
+        bound_systems.flat_map do |bound_system|
+          case bound_system
+          when FHIR::ValueSet::Compose::Include
+            bound_system.concept.map { |concept| { system: bound_system.system, code: concept.code } }
+          when FHIR::CodeSystem
+            bound_system.concept.map { |concept| { system: bound_system.url, code: concept.code } }
+          else
+            []
+          end
+        end.uniq
+      end
+
+      def value_set_expansion_contains(element)
+        value_set(element)&.expansion&.contains
+      end
+
+      def fhir_metadata(current_path)
+        FHIR.const_get(resource)::METADATA[current_path]
+      end
+
+      def values_from_resource_metadata(paths)
+        values = []
+
+        paths.each do |current_path|
+          current_metadata = fhir_metadata(current_path)
+
+          next unless current_metadata&.dig('valid_codes').present?
+
+          values += current_metadata['valid_codes'].flat_map do |system, codes|
+            codes.map { |code| { system:, code: } }
+          end
+        end
+
+        values
+      end
+    end
+  end
+end

data/lib/inferno/dsl.rb

@@ -1,4 +1,5 @@
 require_relative 'dsl/assertions'
+require_relative 'dsl/auth_info'
 require_relative 'dsl/fhir_client'
 require_relative 'dsl/fhir_validation'
 require_relative 'dsl/fhir_evaluation/evaluator'

data/lib/inferno/entities/ig.rb

@@ -14,10 +14,7 @@ module Inferno
     class IG < Entity
       ATTRIBUTES = [
         :id,
-        :profiles,
-        :extensions,
-        :value_sets,
-        :search_params,
+        :resources_by_type,
         :examples
       ].freeze
 
@@ -25,12 +22,8 @@ module Inferno
 
       def initialize(**params)
         super(params, ATTRIBUTES)
-
-        @profiles = []
-        @extensions = []
-        @value_sets = []
+        @resources_by_type ||= Hash.new { |hash, key| hash[key] = [] }
         @examples = []
-        @search_params = []
       end
 
       def self.from_file(ig_path)
@@ -71,6 +64,9 @@ module Inferno
             next
           end
         end
+
+        ig.id = extract_package_id(ig.ig_resource)
+
         ig
       end
 
@@ -91,6 +87,9 @@ module Inferno
             next
           end
         end
+
+        ig.id = extract_package_id(ig.ig_resource)
+
         ig
       end
 
@@ -113,28 +112,51 @@ module Inferno
       end
 
       def handle_resource(resource, relative_path)
-        case resource.resourceType
-        when 'StructureDefinition'
-          if resource.type == 'Extension'
-            extensions.push resource
-          else
-            profiles.push resource
-          end
-        when 'ValueSet'
-          value_sets.push resource
-        when 'SearchParameter'
-          search_params.push resource
-        when 'ImplementationGuide'
-          @id = extract_package_id(resource)
+        if relative_path.start_with? 'package/example'
+          examples << resource
         else
-          examples.push(resource) if relative_path.start_with? 'package/example'
+          resources_by_type[resource.resourceType] << resource
         end
       end
 
-      def extract_package_id(ig_resource)
+      def self.extract_package_id(ig_resource)
         "#{ig_resource.id}##{ig_resource.version || 'current'}"
       end
 
+      def profiles
+        resources_by_type['StructureDefinition'].filter { |sd| sd.type != 'Extension' }
+      end
+
+      def extensions
+        resources_by_type['StructureDefinition'].filter { |sd| sd.type == 'Extension' }
+      end
+
+      def capability_statement(mode = 'server')
+        resources_by_type['CapabilityStatement'].find do |capability_statement_resource|
+          capability_statement_resource.rest.any? { |r| r.mode == mode }
+        end
+      end
+
+      def ig_resource
+        resources_by_type['ImplementationGuide'].first
+      end
+
+      def profile_by_url(url)
+        profiles.find { |profile| profile.url == url }
+      end
+
+      def resource_for_profile(url)
+        profiles.find { |profile| profile.url == url }.type
+      end
+
+      def value_set_by_url(url)
+        resources_by_type['ValueSet'].find { |profile| profile.url == url }
+      end
+
+      def code_system_by_url(url)
+        resources_by_type['CodeSystem'].find { |system| system.url == url }
+      end
+
       # @private
       def add_self_to_repository
         repository.insert(self)

data/lib/inferno/entities/input.rb

@@ -43,7 +43,7 @@ module Inferno
 
       # These are the attributes that can be directly copied when merging a
       # runnable's input with an input configuration.
-      MERGEABLE_ATTRIBUTES = (ATTRIBUTES - [:type]).freeze
+      MERGEABLE_ATTRIBUTES = (ATTRIBUTES - [:type, :options]).freeze
 
       def initialize(**params)
         bad_params = params.keys - ATTRIBUTES
@@ -69,21 +69,27 @@ module Inferno
 
         self.type = child_input.type if child_input.present? && child_input.type != 'text'
 
+        merge_options(primary_source: self, secondary_source: child_input)
+
         self
       end
 
       # @private
       # Merge this input with an input from a configuration. Fields defined in
       # the configuration take precedence over those defined on this input.
-      def merge(other_input)
+      def merge(other_input, merge_all: false)
         return self if other_input.nil?
 
-        MERGEABLE_ATTRIBUTES.each do |attribute|
+        attributes_to_merge = merge_all ? ATTRIBUTES : MERGEABLE_ATTRIBUTES
+
+        attributes_to_merge.each do |attribute|
           merge_attribute(attribute, primary_source: other_input, secondary_source: self)
         end
 
         self.type = other_input.type if other_input.type.present? && other_input.type != 'text'
 
+        merge_options(primary_source: other_input, secondary_source: self)
+
         self
       end
 
@@ -103,6 +109,60 @@ module Inferno
         send("#{attribute}=", value)
       end
 
+      # @private
+      # Merge input options. This performs a normal merge for all options except
+      # for the "components" field, the members of which are individually merged
+      # by `merge_components`
+      # @param primary_source [Input]
+      # @param secondary_source [Input]
+      def merge_options(primary_source:, secondary_source:)
+        primary_options = primary_source.options.dup || {}
+        secondary_options = secondary_source.options.dup || {}
+
+        return if primary_options.blank? && secondary_options.blank?
+
+        primary_components = primary_options.delete(:components) || []
+        secondary_components = secondary_options.delete(:components) || []
+
+        send('options=', secondary_options.merge(primary_options))
+
+        merge_components(primary_components:, secondary_components:)
+      end
+
+      # @private
+      # Merge component hashes.
+      # @param primary_source [Input]
+      # @param secondary_source [Input]
+      def merge_components(primary_components:, secondary_components:) # rubocop:disable Metrics/CyclomaticComplexity
+        primary_components
+          .each { |component| component[:name] = component[:name].to_sym }
+        secondary_components
+          .each { |component| component[:name] = component[:name].to_sym }
+
+        return if primary_components.blank? && secondary_components.blank?
+
+        component_keys =
+          (primary_components + secondary_components)
+            .map { |component| component[:name] }
+            .uniq
+
+        merged_components = component_keys.map do |key|
+          primary_component = primary_components.find { |component| component[:name] == key }
+          secondary_component = secondary_components.find { |component| component[:name] == key }
+
+          next secondary_component if primary_component.blank?
+
+          next primary_component if secondary_component.blank?
+
+          Input.new(**secondary_component).merge(Input.new(**primary_component), merge_all: true).to_hash
+        end
+
+        merged_components.each { |component| component[:name] = component[:name].to_sym }
+
+        self.options ||= {}
+        self.options[:components] = merged_components
+      end
+
       def to_hash
         ATTRIBUTES.each_with_object({}) do |attribute, hash|
           value = send(attribute)