inferno_core 0.6.0 → 0.6.2

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/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)