qti 2.30.0 → 2.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5faafa20e505881d4e305e9346f24060883b8cf86b1861f08021f6def9329ea9
-  data.tar.gz: 69bbc14fecc3909cfc905102433e2ae1631261cf56fcda2c13035a35583a9682
+  metadata.gz: a08fc96f6a77de2160651785437e8ae12448f4b727daddccd06128715c51e5a8
+  data.tar.gz: 8893790e36626b9f29c743d6f48c313b8c77f9294117686dadaec8c085755751
 SHA512:
-  metadata.gz: 43f8a769c16f2a2671219c7f2f3b4e25a3c8321dfed55d17035d1b3eab2238dcbae93f8b669e4393971a31c9607cfb3f2ca78ba454538bcfd279673f2f271eae
-  data.tar.gz: d51c5c66f01164d227c38ebb3098787096ce1b1257737ffe42ae70db5af39c8e09157b87c6469e7b66599803547c3bf92b6c0c9cacb667ef490e15bec86e27df
+  metadata.gz: df3ce562a0617d78c4f34d12d4682743dfb06d409283d6e88a01fb46278d8f815a8820082717da308521c01ba836bf26a98ec7ab73973080ac17ec7fd8ebaa49
+  data.tar.gz: d3fe2fd6a969a72af91ebd5942a3d715075ed9439fefb157a2d791ac7923779fee38a980fdf1624cd3a83efb53cb092b86672c04f4a8b6628931908b217caaa9

data/lib/qti/v1/models/interactions/base_interaction.rb

@@ -76,9 +76,7 @@ module Qti
           end
 
           def answer_feedback
-            path = './/xmlns:respcondition//xmlns:displayfeedback/../' \
-              'xmlns:conditionvar/xmlns:varequal[@respident]/../../' \
-              'xmlns:displayfeedback/..'
+            path = './/xmlns:respcondition[xmlns:displayfeedback][.//xmlns:varequal[@respident]]'
             answers = node.xpath(path).map do |entry|
               answer_feedback_entry(entry)
             end.compact
@@ -88,17 +86,30 @@ module Qti
           private
 
           def answer_feedback_entry(entry)
-            ve = entry.xpath('.//xmlns:varequal').first
+            ve = entry.xpath('.//xmlns:varequal[@respident]').first
+            return nil unless ve
             refid = entry.xpath('./xmlns:displayfeedback[not (@linkrefid="correct_fb" or ' \
               '@linkrefid="general_incorrect_fb" or @linkrefid="general_fb")]').first&.[](:linkrefid)
             feedback = get_feedback(refid)
             return nil unless feedback
-            {
+            answer = {
               response_id: ve[:respident],
               response_value: ve.text,
               texttype: feedback&.[](:texttype),
               feedback: feedback&.text
             }
+            answer[:negated] = true if negated_condition?(ve)
+            answer
+          end
+
+          # Matching is the one Canvas type whose comment is shown when the
+          # student did *not* pick that match, so its `varequal` sits inside a
+          # `not`. Report that, rather than making the consumer infer it from
+          # the question type -- third party QTI may emit either form for any
+          # type. Only set when true, so every other type keeps its old shape.
+          def negated_condition?(varequal)
+            varequal.ancestors.take_while { |a| a.name != 'respcondition' }
+                    .count { |a| a.name == 'not' }.odd?
           end
 
           def get_feedback(ident)

data/lib/qti/version.rb

@@ -1,3 +1,3 @@
 module Qti
-  VERSION = '2.30.0'.freeze
+  VERSION = '2.31.0'.freeze
 end

data/spec/lib/qti/v1/models/interactions/base_interaction_spec.rb

@@ -110,4 +110,266 @@ describe Qti::V1::Models::Interactions::BaseInteraction do
       expect(Qti::V1::Models::Interactions::BaseInteraction.new_quizzes_fib?(assessment_item_refs.first)).to eq false
     end
   end
+
+  # The respcondition lookup in #answer_feedback is shared by every v1
+  # interaction, so relaxing it to reach matching's negated varequal has to
+  # leave the other types untouched. This fixture carries one question of each
+  # Canvas type, all of them fully commented.
+  context 'all_canvas_simple_1.2.xml' do
+    let(:file_path) { File.join('spec', 'fixtures', 'all_canvas_simple_1.2.xml') }
+
+    def answer_feedback_for(index)
+      described_class.new(assessment_item_refs[index], test_object).answer_feedback&.map do |fb|
+        [fb[:response_id], fb[:response_value], fb[:negated], fb[:feedback]]
+      end
+    end
+
+    it 'extracts multiple choice feedback per chosen answer' do
+      expect(answer_feedback_for(0)).to eq(
+        [
+          ['response1', '2799', nil, '<p>Answer feedback for C, correct</p>'],
+          ['response1', '9607', nil, '<p>Answer feedback for A, incorrect</p>'],
+          ['response1', '599', nil, '<p>Answer feedback for B, incorrect</p>'],
+          ['response1', '5711', nil, '<p>Answer feedback for D, incorrect</p>']
+        ]
+      )
+    end
+
+    it 'extracts true/false feedback per chosen answer' do
+      expect(answer_feedback_for(1)).to eq(
+        [
+          ['response1', '919', nil, '<p>Answer Feedback, True, Correct</p>'],
+          ['response1', '2680', nil, '<p>Answer Feedback, False, Incorrect</p>']
+        ]
+      )
+    end
+
+    it 'extracts short answer feedback per chosen answer' do
+      expect(answer_feedback_for(2)).to eq(
+        [
+          ['response1', 'Blank', nil, '<p>Answer Feedback, Correct, Blank</p>'],
+          ['response1', 'blank', nil, '<p>Answer Feedback, Correct, blank</p>']
+        ]
+      )
+    end
+
+    it 'extracts fill in multiple blanks feedback per blank and chosen answer' do
+      expect(answer_feedback_for(3)).to eq(
+        [
+          ['response_Multiple', '832', nil, '<p>Answer Feedback, correct, Multiple</p>'],
+          ['response_Multiple', '2173', nil, '<p>Answer Feedback, correct, multiple</p>'],
+          ['response_Blanks', '9226', nil, '<p>Answer Feedback, correct, Blanks</p>'],
+          ['response_Blanks', '1700', nil, '<p>Answer Feedback, correct, blanks</p>']
+        ]
+      )
+    end
+
+    it 'extracts multiple answers feedback per chosen answer' do
+      expect(answer_feedback_for(4)).to eq(
+        [
+          ['response1', '4094', nil, '<p>Answer Feedback, correct, A</p>'],
+          ['response1', '8128', nil, '<p>Answer Feedback, correct, B</p>'],
+          ['response1', '1582', nil, '<p>Answer Feedback, correct, C</p>'],
+          ['response1', '7498', nil, '<p>Answer Feedback, incorrect, D</p>'],
+          ['response1', '141', nil, '<p>Answer Feedback, incorrect, E</p>'],
+          ['response1', '3202', nil, '<p>Answer Feedback, incorrect, F</p>']
+        ]
+      )
+    end
+
+    it 'extracts multiple dropdowns feedback per chosen answer' do
+      expect(answer_feedback_for(5)).to eq(
+        [
+          ['response_C', '520', nil, '<p>Answer Feedback, correct, C</p>'],
+          ['response_C', '9701', nil, '<p>Answer Feedback, incorrect, D</p>']
+        ]
+      )
+    end
+
+    it 'extracts matching feedback per left hand item, marked as negated' do
+      expect(answer_feedback_for(6)).to eq(
+        [
+          ['response_2030', '6823', true, '<p>Answer Feedback, A:1 Chosen</p>'],
+          ['response_1293', '4469', true, '<p>Answer Feedback, B:2 Chosen</p>']
+        ]
+      )
+    end
+
+    it 'returns nil for the types that carry no answer level feedback' do
+      expect(answer_feedback_for(8)).to be_nil
+      expect(answer_feedback_for(9)).to be_nil
+    end
+
+    # The flag is additive: an entry that is not negated keeps exactly the keys
+    # it had before matching was supported, so a consumer pinned to an older
+    # gem sees no change.
+    it 'only adds the negated key to the negated entries' do
+      keys_by_item = (0..7).map do |index|
+        entries = described_class.new(assessment_item_refs[index], test_object).answer_feedback || []
+        entries.map(&:keys).uniq
+      end
+      expect(keys_by_item).to eq(
+        [
+          [%i[response_id response_value texttype feedback]],
+          [%i[response_id response_value texttype feedback]],
+          [%i[response_id response_value texttype feedback]],
+          [%i[response_id response_value texttype feedback]],
+          [%i[response_id response_value texttype feedback]],
+          [%i[response_id response_value texttype feedback]],
+          [%i[response_id response_value texttype feedback negated]],
+          [%i[response_id response_value texttype feedback]]
+        ]
+      )
+    end
+  end
+
+  # Question 4 has no question_type metadata and more than one response_lid, so
+  # it dispatches to MatchInteraction while actually being fill in multiple
+  # blanks -- and its feedback is on the chosen answer, not a wrong pairing.
+  # Deriving negated per entry rather than per question type is what keeps this
+  # one, and third party packages like it, correct.
+  context 'interaction_checks_1.2.xml' do
+    let(:file_path) { File.join('spec', 'fixtures', 'interaction_checks_1.2.xml') }
+
+    it 'does not mark a non-negated question as negated, whatever it dispatches to' do
+      item = assessment_item_refs[3]
+      expect(Qti::V1::Models::AssessmentItem.new(item).interaction_model)
+        .to be_a(Qti::V1::Models::Interactions::MatchInteraction)
+      expect(described_class.new(item, test_object).answer_feedback.map { |fb| fb[:negated] })
+        .to all(be_nil)
+    end
+
+    it 'still marks the genuine matching question as negated' do
+      expect(described_class.new(assessment_item_refs[6], test_object).answer_feedback.map { |fb| fb[:negated] })
+        .to all(be true)
+    end
+  end
+
+  # NumericInteraction overrides #answer_feedback entirely (it pairs answers by
+  # setvar SCORE, not by varequal), so it never reaches the negated flag. Its
+  # entries are keyed on response_index and carry no negated key at all, which
+  # reads the same as not negated.
+  context 'numeric_answer_feedback.xml' do
+    let(:file_path) { File.join(fixtures_path, 'numeric_answer_feedback.xml') }
+
+    it 'does not report negated for numeric, which pairs answers differently' do
+      entries = Qti::V1::Models::AssessmentItem.new(assessment_item_refs.first).answer_feedback
+      expect(entries.map(&:keys).uniq).to eq([%i[response_index texttype feedback]])
+      expect(entries.map { |fb| fb[:negated] }).to all(be_nil)
+    end
+  end
+
+  # Ordering emits one respcondition holding a varequal per position, with a
+  # single comment for the whole correct sequence. It has always been reported
+  # through the first varequal and no spec covered it, so the relaxed xpath
+  # could have changed it unnoticed.
+  context 'ordering.xml' do
+    let(:file_path) { File.join(fixtures_path, 'ordering.xml') }
+
+    it 'keeps reporting the comment on the correct sequence through its first position' do
+      expect(loaded_class.answer_feedback).to eq(
+        [{ response_id: 'OB01', response_value: 'A',
+           texttype: nil, feedback: 'Yes, the correct order.' }]
+      )
+    end
+  end
+
+  # Codifies the corpus wide check behind the xpath relaxation: matching is the
+  # only shape in the whole fixture corpus that yields a negated entry. Guards
+  # against a future xpath change quietly pulling in another type.
+  context 'the whole fixture corpus' do
+    it 'only ever reports negated entries for matching questions' do
+      negated = Dir.glob(File.join('spec', 'fixtures', '**', '*.xml')).sort.filter_map do |path|
+        assessment = begin
+          Qti::V1::Models::Assessment.from_path!(path)
+        rescue StandardError
+          next
+        end
+        items = assessment.assessment_items
+        next if items.nil?
+
+        found = items.each_with_index.select do |item, _index|
+          entries = begin
+            described_class.new(item, assessment).answer_feedback
+          rescue StandardError
+            nil
+          end
+          entries&.any? { |fb| fb[:negated] }
+        end
+        next if found.empty?
+
+        [path.sub("spec#{File::SEPARATOR}fixtures#{File::SEPARATOR}", ''), found.map(&:last)]
+      end
+
+      expect(negated.to_h).to eq(
+        'all_canvas_simple_1.2.xml' => [6],
+        'interaction_checks_1.2.xml' => [6],
+        "items_1.2#{File::SEPARATOR}matching_feedback.xml" => [0]
+      )
+    end
+  end
+
+  # Shapes the relaxed xpath newly reaches. None occur in a Canvas export, but
+  # third party QTI 1.2 imports through the same code path.
+  context 'unusual respcondition shapes' do
+    let(:assessment) { double(path: 'dummy/blah', package_root: 'dummy') }
+
+    def interaction_for(conditionvar)
+      item = <<~XML
+        <questestinterop xmlns="http://www.imsglobal.org/xsd/ims_qtiasiv1p2">
+          <item ident="i1" title="Question">
+            <resprocessing>
+              <respcondition>
+                <conditionvar>#{conditionvar}</conditionvar>
+                <displayfeedback feedbacktype="Response" linkrefid="99_fb"/>
+              </respcondition>
+            </resprocessing>
+            <itemfeedback ident="99_fb">
+              <flow_mat>
+                <material><mattext texttype="text/html">&lt;p&gt;Comment&lt;/p&gt;</mattext></material>
+              </flow_mat>
+            </itemfeedback>
+          </item>
+        </questestinterop>
+      XML
+      described_class.new(Nokogiri.XML(item, &:noblanks).at_xpath('//xmlns:item'), assessment)
+    end
+
+    # A compound condition is reported through its first answer only. That is
+    # pre-existing behaviour -- ordering questions comment a whole correct
+    # sequence this way -- so it is pinned here rather than changed, and the
+    # negated flag follows the same first varequal.
+    it 'reports a compound condition through its first answer' do
+      interaction = interaction_for(
+        '<and><varequal respident="response1">111</varequal>' \
+        '<not><varequal respident="response1">222</varequal></not></and>'
+      )
+      expect(interaction.answer_feedback).to eq(
+        [{ response_id: 'response1', response_value: '111',
+           texttype: 'text/html', feedback: '<p>Comment</p>' }]
+      )
+    end
+
+    it 'ignores a varequal without a respident when picking the answer' do
+      interaction = interaction_for(
+        '<or><varequal>raw</varequal><varequal respident="response1">111</varequal></or>'
+      )
+      expect(interaction.answer_feedback).to eq(
+        [{ response_id: 'response1', response_value: '111',
+           texttype: 'text/html', feedback: '<p>Comment</p>' }]
+      )
+    end
+
+    it 'treats a doubly negated condition as not negated' do
+      interaction = interaction_for(
+        '<not><not><varequal respident="response1">111</varequal></not></not>'
+      )
+      expect(interaction.answer_feedback.first).not_to have_key(:negated)
+    end
+
+    it 'marks a singly negated condition as negated' do
+      interaction = interaction_for('<not><varequal respident="response1">111</varequal></not>')
+      expect(interaction.answer_feedback.first[:negated]).to be true
+    end
+  end
 end

data/spec/lib/qti/v1/models/interactions/match_interaction_spec.rb

@@ -96,5 +96,45 @@ describe Qti::V1::Models::Interactions::MatchInteraction do
     it 'does not have any scoring algorithm' do
       expect(subject.scoring_algorithm).to eq nil
     end
+
+    describe '#answer_feedback' do
+      it 'returns one entry per commented left hand item, keyed on its response id' do
+        expect(subject.answer_feedback).to eq(
+          [
+            { response_id: 'response_6831', response_value: '6753', negated: true,
+              texttype: 'text/html', feedback: '<p>A:1</p>' },
+            { response_id: 'response_6259', response_value: '7138', negated: true,
+              texttype: 'text/html', feedback: '<p>B:2</p>' }
+          ]
+        )
+      end
+
+      it 'marks the entries as negated, since Classic shows them on a wrong pairing' do
+        expect(subject.answer_feedback.map { |fb| fb[:negated] }).to all(be true)
+      end
+
+      it 'keys every entry on a question that exists' do
+        expect(subject.answer_feedback.map { |fb| fb[:response_id] })
+          .to all(be_in(subject.questions.map { |q| q[:id] }))
+      end
+
+      it 'skips the left hand items without a comment' do
+        expect(subject.answer_feedback.map { |fb| fb[:response_id] })
+          .not_to include('response_743', 'response_1943')
+      end
+
+      it 'ignores the item level feedback' do
+        expect(subject.answer_feedback.map { |fb| fb[:feedback] })
+          .not_to include('<p>Neutral</p>', '<p>Correct</p>', '<p>Incorrect</p>')
+      end
+    end
+  end
+
+  context 'matching.xml without answer feedback' do
+    let(:file) { File.join(path, 'matching.xml') }
+
+    it 'returns nil' do
+      expect(subject.answer_feedback).to be_nil
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qti
 version: !ruby/object:Gem::Version
-  version: 2.30.0
+  version: 2.31.0
 platform: ruby
 authors:
 - Adrian Diaz
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-09-07 00:00:00.000000000 Z
+date: 2026-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionview