canvas_qti_to_learnosity_converter 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b87553f49f64e8fb54d2334edf92b467322364f3b32d8fa169c6f31cfef2d4be
-  data.tar.gz: 502a402267786ee374ced98d282bc4774b69243bee341e2ed35bd051dd6e7db9
+  metadata.gz: ff0914859bacf0cab5c24c74ca5fbdab49478d9df31714434eaf2ac460e1bc31
+  data.tar.gz: 76403083b18998db6fcf6226bcb081e2f0d3d9e0bf3e5336a13842feca75bfff
 SHA512:
-  metadata.gz: 13688b93f41f22b5bfb9d1ef9a73c50828fa4c43f8a0c8b5e7102f3d5842b9d47d9735beaa5991babfc44374f3cb204d43a3a6d366ba71e6a13cbc8006ea4362
-  data.tar.gz: f74370f50a3e2a9c7052bc0e82a48ec6ed08ebc05151ffdc463768ff122b75cefafba0ee538b756e27f78ce6bf0fd3ce98539816cdefaa475a3aa0687e4c757c
+  metadata.gz: 3eb86fdef2a36743f096f47668a47430b9cdb36bedcb0a3f4493765cdab872b0a7df844efd1e9ce5a38136d73c10807b2058be7c2737cc1314ac3a2f538b8df3
+  data.tar.gz: 39d75a49a6fc9706c6fa443c1cca36b327b84b2260d3b518be6a2522e1438f442906cf32b18f2e876c41e9412e6790572bf12ca18795adfbd8609597cef7ce3f

data/canvas_qti_to_learnosity_converter.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 2.3"
   spec.add_development_dependency "byebug"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 11.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_dependency "nokogiri"
   spec.add_dependency "rubyzip"

data/lib/canvas_qti_to_learnosity_converter/convert.rb

@@ -56,6 +56,11 @@ module CanvasQtiToLearnosityConverter
       "cc.essay.v0p1": EssayQuestion,
     }
 
+    # Canvas lets you create questions that are associated with a stimulus. Authoring
+    # these in Learnosity is terrible if there are too many questions in the same item,
+    # so we limit the number of questions per item to 30.
+    MAX_QUESTIONS_PER_ITEM = 30
+
     attr_accessor :items, :widgets, :item_banks, :assessments, :assets, :errors
 
     def initialize
@@ -114,6 +119,175 @@ module CanvasQtiToLearnosityConverter
           &.first&.next&.text&.to_sym
     end
 
+    def parent_stimulus_ident(item)
+      if item.name == "bankentry_item" || item.name == "section"
+        item.attribute("parent_stimulus_item_ident")&.value
+      else
+        item.css("itemmetadata > qtimetadata > qtimetadatafield > fieldlabel:contains('parent_stimulus_item_ident')").first&.next&.text
+      end
+    end
+
+    def limit_child_questions(child_widgets, parent_ident)
+      if child_widgets.count > MAX_QUESTIONS_PER_ITEM
+        # We only want to include the first MAX_QUESTIONS_PER_ITEM questions
+        child_widgets = child_widgets.first(MAX_QUESTIONS_PER_ITEM)
+        @errors[parent_ident] ||= []
+        @errors[parent_ident].push({
+          error_type: "too_many_questions",
+          message: "Too many questions for item, only the first #{MAX_QUESTIONS_PER_ITEM} will be included",
+        })
+      end
+
+      child_widgets
+    end
+
+    def clone_bank_widget(parent_ident, child_item)
+      # If the item is from a question bank we want to create a new copy of the widget
+      # as Learnosity doesn't really share widgets between items
+      child_item_ref = child_item.attribute("item_ref")&.value
+      converted_widget = @widgets.find { |w| w[:metadata][:original_item_ref] == child_item_ref }
+
+      if converted_widget.blank?
+        raise "Could not find converted widget for item_ref #{child_item_ref}"
+      end
+
+      new_widget = converted_widget.deep_dup
+      new_widget[:reference] = build_reference("#{parent_ident}_#{child_item_ref}")
+      new_widget[:metadata][:original_item_ref] = "#{parent_ident}_#{child_item_ref}"
+      new_widget
+    end
+
+    def convert_child_item(child_item:, path:, parent_ident:, new_references: false)
+      if child_item.name == "section"
+        item_refs = child_item.css("sourcebank_ref").map do |sourcebank_ref|
+          @items.select do |i|
+            (
+              i.dig(:metadata, :original_item_bank_ref) == sourcebank_ref.text &&
+              !(i.dig(:definition, :regions)&.any? { |r| r[:widgets].blank? }) # Exclude empty stimulus items
+            )
+          end.map { |i| i[:metadata][:original_item_ref] }
+        end.flatten
+
+        bank_widgets = item_refs.map { |ref| @widgets.find { |w| w[:metadata][:original_item_ref] == ref } }
+
+        bank_widgets.map do |widget|
+          new_widget = widget.deep_dup
+          new_widget[:reference] = build_reference
+          new_widget
+        end
+      elsif child_item.name == "bankentry_item"
+        new_widget = clone_bank_widget(parent_ident, child_item)
+        if new_references
+          new_widget[:reference] = build_reference
+        end
+        new_widget
+      else
+        child_ident = child_item.attribute("ident")&.value
+        child_learnosity_type, child_quiz_item = convert_item(qti_string: child_item.to_html)
+
+        {
+          type: child_learnosity_type,
+          data: child_quiz_item.convert(@assets, path),
+          reference: build_reference("#{parent_ident}_#{child_ident}"),
+          metadata: { original_item_ref: child_ident },
+        }
+      end
+    end
+
+    # Canvas new quizzes can have a stimulus with associated questions. These have
+    # a material orientation attribute that specifies the orientation of the stimulus.
+    # We create a single Learnosity item with multiple widgets for these items.
+    def build_item_definition(item, learnosity_type, quiz_item, path, child_items)
+      ident = item.attribute("ident")&.value
+
+      item_widgets = [{
+        type: learnosity_type,
+        data: quiz_item.convert(@assets, path),
+        reference: build_reference("#{ident}_widget"),
+        metadata: { original_item_ref: ident },
+      }]
+
+      definition = {}
+
+      if item.css("presentation > material[orientation]").present?
+        child_widgets = child_items.map do |child_item|
+          convert_child_item(child_item:, path:, parent_ident: ident)
+        end.flatten
+
+        child_widgets = limit_child_questions(child_widgets, ident)
+
+        item_widgets += child_widgets
+      end
+
+      if item.css("presentation > material[orientation='left']").present?
+        definition[:regions] = [
+          {
+            widgets: [{ reference: item_widgets.first[:reference] }],
+            width: 50,
+            type: "column"
+          },
+          {
+            widgets: child_widgets.map{ |w| { reference: w[:reference] } },
+            width: 50,
+            type: "column"
+          }
+        ]
+        definition[:scroll] = { enabled: false }
+        definition[:type] = "root"
+      else
+        definition[:widgets] = item_widgets.map{ |w| { reference: w[:reference] } }
+      end
+
+      [item_widgets, definition]
+    end
+
+    # We need to create a new item for stimuluses that are from a question bank, as
+    # the item in the assessment will need to have multiple widgets in it, and the item
+    # from the bank only has the stimulus. We don't want to modify the original item in
+    # the bank as it could be used in multiple assessments and it's convenient to have
+    # the original to clone. We also create new widgets, so that the item can be modified
+    # without affecting any other items that use the same widgets.
+    def clone_bank_item(parent_item, child_items, path)
+      item_ref = parent_item.attribute("item_ref").value
+      bank_item = @items.find { |i| i[:metadata][:original_item_ref] == item_ref }
+      new_item = bank_item.deep_dup
+
+      if new_item[:definition][:regions].blank?
+        raise "Trying to add a child item to a stimulus from a question bank that wasn't converted with regions"
+      end
+
+      # We need new references throughout because we can't consistently generate
+      # references when this stimulus/questions could be used in multiple assessments with
+      # different questions for the same bank stimulus
+      new_item[:reference] = build_reference
+
+      # Use the bank item reference in the metadata so we don't accidentally
+      # find this cloned one if the original is used elsewhere
+      new_item[:metadata][:original_item_ref] = bank_item[:reference]
+
+      cloned_stimulus = @widgets.find { |w| w[:metadata][:original_item_ref] == item_ref }.deep_dup
+      cloned_stimulus[:reference] = build_reference
+      @widgets.push(cloned_stimulus)
+
+      stimulus_region = new_item[:definition][:regions].find { |r| r[:widgets].present? }
+      stimulus_region[:widgets] = [{ reference: cloned_stimulus[:reference] }]
+
+      empty_region = new_item[:definition][:regions].find { |r| r[:widgets].blank? }
+      child_widgets = child_items.map do |child_item|
+        convert_child_item(child_item:, path:, parent_ident: item_ref, new_references: true)
+      end.flatten
+
+      child_widgets = limit_child_questions(child_widgets, item_ref)
+
+      empty_region[:widgets] = child_widgets.map{ |w| { reference: w[:reference] } }
+      new_item[:questions] = child_widgets.select{ |w| w[:type] == "question" }.map{ |w| w[:reference] }
+      new_item[:features] = [{ reference: cloned_stimulus[:reference] }]
+
+      @widgets += child_widgets
+      @items.push(new_item)
+      new_item
+    end
+
     def convert_item(qti_string:)
       xml = Nokogiri.XML(qti_string, &:noblanks)
       type = extract_type(xml)
@@ -194,9 +368,27 @@ module CanvasQtiToLearnosityConverter
 
     def convert_items(qti, path, meta: {}, tags: {})
       converted_item_refs = []
+
+      items_by_parent_stimulus = {}
+      qti.css("item,bankentry_item,section").each do |item|
+        ident = item.attribute("ident")&.value
+        next if ident == "root_section"
+
+        parent_ident = parent_stimulus_ident(item)
+        if parent_ident.present?
+          items_by_parent_stimulus[parent_ident] ||= []
+          items_by_parent_stimulus[parent_ident].push(item)
+        end
+      end
+
       qti.css("item,bankentry_item,section").each.with_index do |item, index|
         begin
+          # Skip items that have a parent, as we'll convert them when we convert the parent
+          next if parent_stimulus_ident(item).present?
+
           ident = item.attribute("ident")&.value
+          item_ref = item.attribute("item_ref")&.value
+
           if item.name == "section"
             next if ident == "root_section"
 
@@ -204,32 +396,31 @@ module CanvasQtiToLearnosityConverter
               item_refs = @items.select { |i| i.dig(:metadata, :original_item_bank_ref) == sourcebank_ref.text }.map { |i| i[:reference] }
               converted_item_refs += item_refs
             end
-          elsif item.name == "bankentry_item"
-            item_ref = item.attribute("item_ref")&.value
-            if item_ref
-              converted_item_refs.push(build_reference(item_ref))
-            end
+          elsif item.name == "bankentry_item" && item_ref.present? && items_by_parent_stimulus[item_ref].present?
+            new_item = clone_bank_item(item, items_by_parent_stimulus[item_ref], path)
+            converted_item_refs.push(new_item[:reference])
+          elsif item.name == "bankentry_item" && item_ref.present?
+            converted_item_refs.push(build_reference(item_ref))
           elsif item.name == "item"
             reference = build_reference(ident)
             item_title = item.attribute("title")&.value || ''
             learnosity_type, quiz_item = convert_item(qti_string: item.to_html)
 
-            item_widgets = [
-              {
-                type: learnosity_type,
-                data: quiz_item.convert(@assets, path),
-                reference: build_reference,
-              }
-            ]
+            item_widgets, definition = build_item_definition(
+              item,
+              learnosity_type,
+              quiz_item,
+              path,
+              items_by_parent_stimulus.fetch(ident, [])
+            )
+
             @widgets += item_widgets
 
             @items << {
               title: item_title,
               reference:,
               metadata: meta.merge({ original_item_ref: ident }),
-              definition: {
-                widgets: item_widgets.map{ |w| { reference: w[:reference] } },
-              },
+              definition:,
               questions: item_widgets.select{ |w| w[:type] == "question" }.map{ |w| w[:reference] },
               features: item_widgets.select{ |w| w[:type] == "feature" }.map{ |w| w[:reference] },
               status: "published",
@@ -250,8 +441,8 @@ module CanvasQtiToLearnosityConverter
             message: e.message,
           })
         rescue StandardError => e
-          @errors[ident] ||= []
-          @errors[ident].push({
+          @errors[ident || item_ref] ||= []
+          @errors[ident || item_ref].push({
             index: index,
             error_type: e.class.to_s,
             message: e.message,

data/lib/canvas_qti_to_learnosity_converter/version.rb

@@ -1,3 +1,3 @@
 module CanvasQtiToLearnosityConverter
-  VERSION = "3.0.0"
+  VERSION = "3.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canvas_qti_to_learnosity_converter
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Atomic Jolt
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-27 00:00:00.000000000 Z
+date: 2025-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -45,14 +45,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement