inferno_core 1.4.6 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ed690c6df4e1cfcb7f4ec361fb8326af28107839c20fbb9de6069ccdc3e950b
-  data.tar.gz: 1c35c4afdf97fc1f8e053d213bdc643099c79defd0b09e50fccb34977a2a497d
+  metadata.gz: e77b2567061750720f73082094abe8f2906e060f362842640725481824dea6f3
+  data.tar.gz: 7b7ba8fa843ab58166f725b7939a74311825f959158b5eea06d954dbf1c9fe50
 SHA512:
-  metadata.gz: '048ca08826b17e50cbbd7452d600e996287167ec72d7993ed3a7686849bc6bbcd61221138df2dd5520ee9156deda55c8d577d99f9ade542d17cda31857d82837'
-  data.tar.gz: b1878c6aedf0f99732536a02fad0cbc2cf2913d21e8cae56586764a04c428346303fd9fb95c462538a96a3968fee7cac3cb0e27bd8b28998e293597aa94d7fd9
+  metadata.gz: 19f220a5663640cc07eb0182321aad839126f89e0e85b3c7c9d98971c4cde72b591fc5c86013c3cd8db3fc07f01bd08847b5b98ed82213c4819d75ddcf46a1e5
+  data.tar.gz: c0b1ba31490d081c3e4d351efa9ac182996952366e20b96fa75ec9e7fb816c01dbdba3c7d857746b45455181a098ee2b78fd2b389b65d1b2d0ec7179504d4482

data/lib/inferno/dsl/fhir_resource_navigation.rb

@@ -252,16 +252,18 @@ module Inferno
 
       # @private
       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|
+        codings = resolve_path(slice, discriminator[:path])
+          .flat_map { |codeable_concept| Array.wrap(codeable_concept.coding) }
+        codings.any? do |coding|
           coding.code == discriminator[:code] && coding.system == discriminator[:system]
         end
       end
 
       # @private
       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]
+        resolve_path(slice, discriminator[:path]).any? do |coding|
+          coding.code == discriminator[:code] && coding.system == discriminator[:system]
+        end
       end
 
       # @private
@@ -323,7 +325,10 @@ module Inferno
           when String
             value == coding.code
           when Hash
-            value[:system] == coding.system && value[:code] == coding.code
+            next false unless value[:system] == coding.system
+
+            # A value without a code stands for every code in its system
+            value[:code].nil? ? coding.code.present? : value[:code] == coding.code
           end
         end
       end

data/lib/inferno/dsl/must_support_assessment.rb

@@ -1,3 +1,5 @@
+require_relative 'must_support_strings'
+
 module Inferno
   module DSL
     # The MustSupportAssessment module contains the logic for tests
@@ -23,7 +25,7 @@ module Inferno
       #        test kits can subclass to build these objects, eg from generated YAML, instead of hand-rolling one.
       # @param requirement_extension [String] Extension URL that implies "required" as an alternative to the MS flag
       # @yield [MustSupportMetadataExtractor] Customize the metadata before running the test
-      # @return [Array<String>] List of missing elements
+      # @return [Array<String>] List of missing elements, sorted alphabetically
       def missing_must_support_elements(resources, profile_url, validator_name: :default, metadata: nil,
                                         requirement_extension: nil, &)
         debug_metadata = config.options[:debug_must_support_metadata]
@@ -195,18 +197,17 @@ module Inferno
           end
         end
 
+        # See {MustSupportStrings} for how each missing item is represented. Sorted to match
+        # {ProfileMetadata#must_support_strings}.
         def missing_must_support_strings
-          missing_elements.map { |element_definition| missing_element_string(element_definition) } +
-            missing_slices.map { |slice_definition| slice_definition[:slice_id] } +
-            missing_extensions.map { |extension_definition| extension_definition[:id] }
+          (missing_elements.map { |element_definition| missing_element_string(element_definition) } +
+            missing_slices.map { |slice_definition| MustSupportStrings.slice_string(slice_definition) } +
+            missing_extensions.map { |extension_definition| MustSupportStrings.extension_string(extension_definition) })
+            .sort
         end
 
         def missing_element_string(element_definition)
-          if element_definition[:fixed_value].present?
-            "#{element_definition[:path]}:#{element_definition[:fixed_value]}"
-          else
-            element_definition[:path]
-          end
+          MustSupportStrings.element_string(element_definition)
         end
 
         def must_support_extensions
@@ -452,17 +453,6 @@ module Inferno
         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_strings.rb

@@ -0,0 +1,62 @@
+module Inferno
+  module DSL
+    # Builds the strings used to identify Must Support elements, slices, and extensions from their
+    # metadata, so that lists of what is expected to be supported (eg {ProfileMetadata#must_support_strings})
+    # and lists of what is missing (eg {MustSupportAssessment#missing_must_support_elements}) agree.
+    #
+    # Each item is represented by its ElementDefinition id (which includes the names of any parent
+    # slices) without the leading resource type, eg 'category:us-core' rather than
+    # 'Condition.category:us-core'. Elements with a fixed value have it appended, eg 'name.use = old'.
+    # @private
+    module MustSupportStrings
+      module_function
+
+      # @param element_definition [Hash] Must Support element metadata
+      # @return [String]
+      def element_string(element_definition)
+        path = element_display_path(element_definition)
+
+        fixed_value = element_definition[:fixed_value]
+        if fixed_value.present? || fixed_value == false
+          "#{path} = #{fixed_value}"
+        else
+          path
+        end
+      end
+
+      # @param slice_definition [Hash] Must Support slice metadata
+      # @return [String]
+      def slice_string(slice_definition)
+        id_string(slice_definition, :slice_id)
+      end
+
+      # @param extension_definition [Hash] Must Support extension metadata
+      # @return [String]
+      def extension_string(extension_definition)
+        id_string(extension_definition, :id)
+      end
+
+      # Elements under a choice type slice (eg value[x]:valueQuantity.value) have their navigation
+      # path rewritten so the slice name is mangled (eg valueQuantity:valueQuantity.value), so report
+      # the original path instead. Elements where only some types of a choice are Must Support
+      # (eg original path effective[x], path effectiveDateTime) keep their path since it names the type.
+      def element_display_path(element_definition)
+        original_path = element_definition[:original_path]
+        original_path&.include?('[x]:') ? original_path : element_definition[:path]
+      end
+
+      def id_string(definition, id_key)
+        id = definition[id_key]
+        raise ArgumentError, "Must Support metadata is missing #{id_key.inspect}: #{definition.inspect}" if id.blank?
+
+        without_resource_type(id)
+      end
+
+      # Resource types are PascalCase while element names are camelCase, so a leading
+      # capitalized segment is the resource type prefix of an ElementDefinition id.
+      def without_resource_type(id)
+        id&.sub(/\A[A-Z][A-Za-z0-9]*\./, '')
+      end
+    end
+  end
+end

data/lib/inferno/dsl/profile_metadata.rb

@@ -1,3 +1,5 @@
+require_relative 'must_support_strings'
+
 module Inferno
   module DSL
     # A ProfileMetadata object is a small, inheritable data holder for generated metadata about a
@@ -85,29 +87,18 @@ module Inferno
       # check, this includes everything that's expected to be supported, not just what's absent
       # from a particular set of resources.
       #
-      # Elements are represented as their `path`, with the matched `fixed_value` appended after a
-      # colon where present (eg `"code.coding.code:45473-6"`). Slices and extensions are
-      # represented as their `path`, with their `slice_name` appended after a colon where present
-      # (eg `"category:us-core"`, `"extension:us-core-race"`).
+      # Each item is represented the same way as in the list returned by a missing-elements check:
+      # by its ElementDefinition id (including the names of any parent slices) without the leading
+      # resource type (eg `"category:us-core"`, `"extension:us-core-race"`), with any matched
+      # `fixed_value` appended to elements (eg `"code.coding.code = 45473-6"`). See {MustSupportStrings}.
       # @return [Array<String>]
       def must_support_strings
-        element_strings =
-          Array.wrap(must_supports[:elements]).map do |element|
-            must_support_string(element[:path], element[:fixed_value])
-          end
-        slice_strings =
-          Array.wrap(must_supports[:slices]).map { |slice| must_support_string(slice[:path], slice[:slice_name]) }
-        extension_strings =
-          Array.wrap(must_supports[:extensions]).map { |ext| must_support_string(ext[:path], ext[:slice_name]) }
+        element_strings = Array.wrap(must_supports[:elements]).map { |el| MustSupportStrings.element_string(el) }
+        slice_strings = Array.wrap(must_supports[:slices]).map { |slice| MustSupportStrings.slice_string(slice) }
+        extension_strings = Array.wrap(must_supports[:extensions]).map { |ex| MustSupportStrings.extension_string(ex) }
 
         (element_strings + slice_strings + extension_strings).sort
       end
-
-      private
-
-      def must_support_string(path, suffix)
-        suffix.present? ? "#{path}:#{suffix}" : path
-      end
     end
   end
 end

data/lib/inferno/dsl/value_extractor.rb

@@ -60,9 +60,8 @@ module Inferno
       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 whole_code_system_include?(include_element)
+          whole_code_system(include_element)
         elsif include_element.valueSet.present?
           include_element.valueSet.map do |vs|
             a_value_set = ig_resources.value_set_by_url(vs)
@@ -71,6 +70,18 @@ module Inferno
         end
       end
 
+      def whole_code_system_include?(include_element)
+        include_element.system.present? && include_element.concept.blank? &&
+          include_element.filter&.empty? && include_element.valueSet.blank?
+      end
+
+      # An include of a whole code system lists no codes. Use the code system's concepts when the IG
+      # has them, otherwise keep the include so that any code from its system is accepted.
+      def whole_code_system(include_element)
+        code_system = ig_resources.code_system_by_url(include_element.system)
+        code_system&.concept.present? ? code_system : include_element
+      end
+
       def codes_from_value_set_binding(the_element)
         codes_from_system_code_pair(codings_from_value_set_binding(the_element))
       end
@@ -99,7 +110,7 @@ module Inferno
         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 } }
+            codings_from_include(bound_system)
           when FHIR::CodeSystem
             bound_system.concept.map { |concept| { system: bound_system.url, code: concept.code } }
           else
@@ -108,6 +119,13 @@ module Inferno
         end.uniq
       end
 
+      # A whole code system include becomes a system-only value
+      def codings_from_include(include_element)
+        return [{ system: include_element.system }] if include_element.concept.blank?
+
+        include_element.concept.map { |concept| { system: include_element.system, code: concept.code } }
+      end
+
       def value_set_expansion_contains(element)
         value_set(element)&.expansion&.contains
       end

data/lib/inferno/version.rb

@@ -1,4 +1,4 @@
 module Inferno
   # Standard patterns for gem versions: https://guides.rubygems.org/patterns/
-  VERSION = '1.4.6'.freeze
+  VERSION = '1.5.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inferno_core
 version: !ruby/object:Gem::Version
-  version: 1.4.6
+  version: 1.5.0
 platform: ruby
 authors:
 - Stephen MacVicar
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-13 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -400,14 +400,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.10.1
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.10.1
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -678,6 +678,7 @@ files:
 - lib/inferno/dsl/messages.rb
 - lib/inferno/dsl/must_support_assessment.rb
 - lib/inferno/dsl/must_support_metadata_extractor.rb
+- lib/inferno/dsl/must_support_strings.rb
 - lib/inferno/dsl/oauth_credentials.rb
 - lib/inferno/dsl/primitive_type.rb
 - lib/inferno/dsl/profile_metadata.rb