inferno_core 1.4.3 → 1.4.5

data/lib/inferno/dsl/must_support_metadata_extractor.rb

@@ -75,7 +75,20 @@ module Inferno
       end
 
       def all_must_support_elements
-        profile_elements.select { |element| element.mustSupport || by_requirement_extension_only?(element) }
+        profile_elements.select do |element|
+          (element.mustSupport || by_requirement_extension_only?(element)) && !prohibited_by_cardinality?(element)
+        end
+      end
+
+      # A profile can inherit mustSupport flags from a base profile while constraining the element to a max
+      # cardinality of 0. Such an element, and its descendants, cannot appear in a conformant resource.
+      def prohibited_by_cardinality?(element)
+        profile_elements.any? do |profile_element|
+          profile_element.max == '0' &&
+            (element.id == profile_element.id ||
+              element.id.start_with?("#{profile_element.id}.") ||
+              element.id.start_with?("#{profile_element.id}:"))
+        end
       end
 
       def must_support_extension_elements
@@ -364,6 +377,11 @@ module Inferno
                   path: navigation_compatible_discriminator_path(discriminator_path),
                   value: pattern_element.fixed
                 }
+              elsif pattern_element.patternString
+                fixed_values << {
+                  path: navigation_compatible_discriminator_path(discriminator_path),
+                  value: pattern_element.patternString
+                }
               elsif pattern_value.present?
                 raise StandardError, "Found more than one pattern slices for the same element #{pattern_element}."
               else

data/lib/inferno/entities/input.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 require_relative 'attributes'
 require_relative '../exceptions'
 
@@ -91,6 +93,30 @@ module Inferno
         type_is_hash && input_name_string_exists && value_string_exists
       end
 
+      # @private
+      # Whether this input is enabled for a map of submitted input values.
+      # An input without an enable_when condition is always enabled. An input
+      # whose controlling input is itself conditionally disabled (i.e. has its
+      # own enable_when condition that is not met) is never enabled, regardless
+      # of the controlling input's current value.
+      # @param visited [Array<Symbol>] names of inputs already visited in this
+      #   evaluation chain, used to guard against circular enable_when references.
+      def enabled?(input_values, available_inputs, visited = [])
+        return true if enable_when.blank?
+        return false if visited.include?(name)
+        return false unless input_values.key?(enable_when[:input_name])
+
+        controlling_input = available_inputs[enable_when[:input_name].to_sym]
+        if controlling_input && !controlling_input.enabled?(input_values, available_inputs, visited + [name])
+          return false
+        end
+
+        return checkbox_group_enabled?(input_values[enable_when[:input_name]]) if checkbox_group?(controlling_input)
+
+        normalize_enable_when_value(input_values[enable_when[:input_name]]) ==
+          normalize_enable_when_value(enable_when[:value])
+      end
+
       # @private
       # Merge this input with an input belonging to a child. Fields defined on
       # this input take precedence over those defined on the child input.
@@ -211,6 +237,37 @@ module Inferno
 
         ATTRIBUTES.all? { |attribute| send(attribute) == other.send(attribute) }
       end
+
+      private
+
+      def checkbox_group?(input)
+        input&.type.to_s == 'checkbox' && input.options&.dig(:list_options)&.any?
+      end
+
+      def checkbox_group_enabled?(value)
+        actual_values = normalize_checkbox_values(value)
+        expected_values = normalize_checkbox_values(enable_when[:value])
+        !actual_values.nil? && actual_values == expected_values
+      end
+
+      def normalize_checkbox_values(value)
+        value = JSON.parse(value) if value.is_a?(String)
+        return unless value.is_a?(Array) && value.all? { |item| item.is_a?(String) }
+
+        value.sort
+      rescue JSON::ParserError
+        nil
+      end
+
+      # Normalize values using the same rules as the client-side enable_when
+      # comparison for non-checkbox-group inputs.
+      def normalize_enable_when_value(value)
+        return '' if value.nil?
+        return JSON.generate(value.sort_by(&:to_s)) if value.is_a?(Array)
+        return JSON.generate(value) if value.is_a?(Hash)
+
+        value.to_s
+      end
     end
   end
 end