inferno_core 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 173f64337d9dc56eff789e35b65fa26656ef256316e42fd68ab0c84765175bbc
-  data.tar.gz: b6bd2746f865f1f40c3771ef90b01d97ecf3fcd5a40f44dc8ddee6bf46ee616a
+  metadata.gz: e3ab1df7a5983dabeaaac0fdfa75d5235815b48841dc94db70c55438f91c438d
+  data.tar.gz: 30da5ad7c4c0b379b91c49197b9d458fdfa912dbd5058b75793d46ebf87be46a
 SHA512:
-  metadata.gz: b20f45985bd53be776773bc5bfe75c693891abee583469768348472f33b1f6afa4ee88da47130624a8cae5a23617ffffb061f2f7ea08a68f3699aa7a0c1c4d96
-  data.tar.gz: b709e8ffdf296b5aea82febeb6e1164843f402bb7e8b090ca09ac04e80956732d6df2a796f63e16cce00f1688cf70b8ab83bd0bfbb43ae8cb9d257231a3ba858
+  metadata.gz: 4397d0025d25280991e60ffe4c2ff1b660b64ebcb067f5988b1edbafd4b51d06c07639508bf1c9590718ae597ae6f9e4e1586348a83a84e6baff86de18e0fba9
+  data.tar.gz: c2c18fef0b14842503aba9367c7faec52f5c68bbda66694ddf22a99fd927eabcd53503d1b724430534f3f2ab06d662be3dcd1496822c14b49463a440a23d3516

data/lib/inferno/apps/cli/execute_script.rb

@@ -909,6 +909,7 @@ module Inferno
           expected_results_file: expected_file,
           compare_messages: options[:compare_messages],
           compare_result_message: options[:compare_result_message],
+          only_different_messages: options[:only_different_messages],
           inferno_base_url: options[:inferno_base_url],
           normalized_strings: Array(comparison_config['normalized_strings'])
         }

data/lib/inferno/apps/cli/main.rb

@@ -104,6 +104,11 @@ module Inferno
              type: :numeric,
              default: 120,
              desc: 'Default seconds to wait for a matching step before timing out.'
+      option :only_different_messages,
+             aliases: ['-d'],
+             type: :boolean,
+             default: true,
+             desc: 'Only show messages that differ when comparing results.'
       option :allow_commands,
              type: :boolean,
              default: false,

data/lib/inferno/apps/cli/session/session_compare.rb

@@ -40,6 +40,13 @@ module Inferno
             type: :array,
             desc: 'Literal strings or regexes to normalize away before comparing ' \
                   '(URL-encoded form of literal strings will also be normalized).'
+          },
+          only_different_messages: {
+            aliases: ['-d'],
+            type: :boolean,
+            default: false,
+            desc: 'When displaying messages in CSV output, only show mismatched messages ' \
+                  '(hide matching ones).'
           }
         }.freeze
         def run
@@ -270,10 +277,66 @@ module Inferno
           UNKNOWN_MESSAGE_TYPE_ORDER = 99
 
           def build_message_comparisons
-            expected_msgs = sorted_messages(expected_result)
-            actual_msgs = sorted_messages(actual_result)
-            max_length = [expected_msgs.size, actual_msgs.size].max
-            (0...max_length).map { |i| messages_match?(expected_msgs[i], actual_msgs[i]) }
+            lcs_align(sorted_messages(expected_result), sorted_messages(actual_result))
+          end
+
+          def lcs_align(expected, actual)
+            lcs_backtrack(lcs_matrix(expected, actual), expected, actual)
+          end
+
+          def lcs_matrix(expected, actual)
+            matrix = Array.new(expected.size + 1) { Array.new(actual.size + 1, 0) }
+            (1..expected.size).each do |expected_index|
+              (1..actual.size).each do |actual_index|
+                matrix[expected_index][actual_index] =
+                  if same_message?(expected[expected_index - 1], actual[actual_index - 1])
+                    matrix[expected_index - 1][actual_index - 1] + 1
+                  else
+                    [matrix[expected_index - 1][actual_index],
+                     matrix[expected_index][actual_index - 1]].max
+                  end
+              end
+            end
+            matrix
+          end
+
+          def lcs_backtrack(matrix, expected, actual)
+            alignment = []
+            expected_index = expected.size
+            actual_index = actual.size
+
+            while expected_index.positive? || actual_index.positive?
+              step = lcs_backtrack_step(matrix, expected, actual, expected_index, actual_index)
+              alignment.unshift(step[:entry])
+              expected_index = step[:next_expected_index]
+              actual_index = step[:next_actual_index]
+            end
+            alignment
+          end
+
+          # Each step returns { entry:, next_expected_index:, next_actual_index: }.
+          # entry is { expected: msg_or_nil, actual: msg_or_nil, match: bool }.
+          def lcs_backtrack_step(matrix, expected, actual, expected_index, actual_index)
+            if expected_index.positive? &&
+               actual_index.positive? &&
+               same_message?(expected[expected_index - 1], actual[actual_index - 1])
+
+              # Items match: consume both
+              entry = { expected: expected[expected_index - 1], actual: actual[actual_index - 1], match: true }
+              { entry:, next_expected_index: expected_index - 1, next_actual_index: actual_index - 1 }
+            elsif actual_index.positive? &&
+                  (expected_index.zero? ||
+                   matrix[expected_index][actual_index - 1] >= matrix[expected_index - 1][actual_index])
+              # Item in actual is "Additional": consume only actual
+              { entry: { expected: nil, actual: actual[actual_index - 1], match: false },
+                next_expected_index: expected_index,
+                next_actual_index: actual_index - 1 }
+            else
+              # Item in expected is "Missing": consume only expected
+              { entry: { expected: expected[expected_index - 1], actual: nil, match: false },
+                next_expected_index: expected_index - 1,
+                next_actual_index: actual_index }
+            end
           end
 
           def sorted_messages(result)
@@ -283,15 +346,8 @@ module Inferno
             end
           end
 
-          def messages_match?(expected_message, actual_message)
-            expected_message.present? && actual_message.present? && same_message?(expected_message, actual_message)
-          end
-
           def same_messages?
-            return false unless expected_result['messages']&.size == actual_result['messages']&.size
-            return true unless expected_result['messages'].present?
-
-            message_comparisons.all?
+            message_comparisons.all? { |entry| entry[:match] }
           end
 
           def same_message?(expected_message, actual_message)
@@ -370,13 +426,28 @@ module Inferno
           def format_messages_for_csv(results)
             return '' unless results&.dig('messages').present?
 
-            sorted_messages(results).each_with_index.map do |message, index|
-              message_text_for_csv(message, index)
-            end.join("\n")
+            is_expected = results == expected_result
+            lines = message_comparisons.filter_map { |entry| message_line_for_csv(entry, is_expected) }
+            collapse_message_lines(lines).join("\n")
+          end
+
+          def message_line_for_csv(entry, is_expected)
+            return if options[:only_different_messages] && entry[:match]
+
+            msg = is_expected ? entry[:expected] : entry[:actual]
+            return if msg.nil?
+
+            message_text_for_csv(msg, entry[:match])
+          end
+
+          def collapse_message_lines(lines)
+            lines.chunk_while { |a, b| a == b }.map do |group|
+              group.size > 1 ? "(#{group.size}) #{group.first}" : group.first
+            end
           end
 
-          def message_text_for_csv(message, index)
-            prefix = message_comparisons[index] ? '- ' : '! '
+          def message_text_for_csv(message, matches)
+            prefix = matches ? '- ' : '! '
             text = normalize_string(message['message'].to_s)
               .gsub("\r\n", '\n')
               .gsub("\n", '\n')

data/lib/inferno/apps/web/serializers/input.rb

@@ -16,6 +16,7 @@ module Inferno
         field :locked, if: :field_present?
         field :hidden, if: :field_present?
         field :value, if: :field_present?
+        field :enable_when, if: :field_present?
       end
     end
   end

data/lib/inferno/config/application.rb

@@ -1,3 +1,4 @@
+require 'logger'
 require 'active_support/all'
 require 'dotenv'
 require 'dry/system'

data/lib/inferno/dsl/input_output_handling.rb

@@ -16,6 +16,10 @@ module Inferno
       # @option input_params [Hash] :options Possible input option formats based on input type
       # @option options [Array] :list_options Array of options for input formats
       #   that require a list of possible values (radio and checkbox)
+      # @option input_params [Hash] :enable_when Conditions for showing the input. Must be a Hash
+      #   with String :input_name (the name of the controlling input) and String :value (the value
+      #   that triggers visibility). For checkbox inputs the value must be a JSON-encoded sorted
+      #   array, e.g. '["a","b"]'.
       # @return [void]
       # @example
       #   input :patient_id, title: 'Patient ID', description: 'The ID of the patient being searched for',

data/lib/inferno/entities/input.rb

@@ -15,22 +15,25 @@ module Inferno
         :options,
         :locked,
         :hidden,
-        :value
+        :value,
+        :enable_when
       ].freeze
       include Entities::Attributes
 
       # These attributes require special handling when merging input
       # definitions.
       UNINHERITABLE_ATTRIBUTES = [
-        # Locking or hiding an input only has meaning at the level it is applied.
-        # Consider:
+        # Locking, hiding, or conditional display only have meaning at the level
+        # they are applied. Consider:
         # - ParentGroup
         #   - Group 1, input :a
-        #   - Group 2, input :a, locked: true, hidden: true, optional: true
-        # The input 'a' should only be locked or hidden when running Group 2 in isolation.
-        # It should not be locked or hidden when running Group 1 or the ParentGroup.
+        #   - Group 2, input :a, locked: true, hidden: true, enable_when: {...}, optional: true
+        # The input 'a' should only be locked, hidden, or conditionally shown when
+        # running Group 2 in isolation. It should not inherit those when running
+        # Group 1 or the ParentGroup.
         :locked,
         :hidden,
+        :enable_when,
         # Input type is sometimes only a UI concern (e.g. text vs. textarea), so
         # it is common to not redeclare the type everywhere it's used and needs
         # special handling to avoid clobbering the type with the default (text)
@@ -59,6 +62,8 @@ module Inferno
           )
         end
 
+        assert_enable_when_shape!(params)
+
         params
           .compact
           .each { |key, value| send("#{key}=", value) }
@@ -66,6 +71,26 @@ module Inferno
         self.name = name.to_s if params[:name].present?
       end
 
+      def assert_enable_when_shape!(params)
+        enable_when = params[:enable_when]
+        return if enable_when.blank?
+        return if enable_when_valid?(enable_when)
+
+        raise Exceptions::InvalidAttributeException.new(
+          :enable_when,
+          self.class,
+          'must be a Hash with a non-empty String :input_name and a String :value'
+        )
+      end
+
+      def enable_when_valid?(enable_when)
+        type_is_hash = enable_when.is_a?(Hash)
+        input_name_string_exists = enable_when[:input_name].is_a?(String) && enable_when[:input_name].present?
+        value_string_exists = enable_when.key?(:value) && enable_when[:value].is_a?(String)
+
+        type_is_hash && input_name_string_exists && value_string_exists
+      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.