canvas_qti_to_learnosity_converter 2.5.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 367e7235a2a58b7fd63af3999e63cb960e34f46fa7f459c08d3608470d55b6c0
-  data.tar.gz: 9e33eabe1f9ddecf970ee13fec9e9dc93e5062f658e5122dc90ea3c0a37a8677
+  metadata.gz: ff0914859bacf0cab5c24c74ca5fbdab49478d9df31714434eaf2ac460e1bc31
+  data.tar.gz: 76403083b18998db6fcf6226bcb081e2f0d3d9e0bf3e5336a13842feca75bfff
 SHA512:
-  metadata.gz: 62c09c119cab2a055a09f89dbfbb961d1a05f8922475940a86b276d77c16252b9ee56ff8f32aba4a52d9e2e87c2c0c7eeeced67bc0b98d59b11c117a4081589e
-  data.tar.gz: 1735c52bf62ae1708e3a1a4eb72af38127eaebd7489e51a206496fa3207e7f350e7bd57e628c4eb8c32f59d4d435246216c61362f683785adfb40b5c67144448
+  metadata.gz: 3eb86fdef2a36743f096f47668a47430b9cdb36bedcb0a3f4493765cdab872b0a7df844efd1e9ce5a38136d73c10807b2058be7c2737cc1314ac3a2f538b8df3
+  data.tar.gz: 39d75a49a6fc9706c6fa443c1cca36b327b84b2260d3b518be6a2522e1438f442906cf32b18f2e876c41e9412e6790572bf12ca18795adfbd8609597cef7ce3f

data/canvas_qti_to_learnosity_converter.gemspec

@@ -20,8 +20,9 @@ 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"
+  spec.add_dependency "activesupport"
 end

data/lib/canvas_qti_to_learnosity_converter/convert.rb

@@ -3,7 +3,12 @@ require "forwardable"
 require "ostruct"
 require "zip"
 require "uri"
+require "active_support"
+require "active_support/core_ext/digest/uuid"
+require "active_support/core_ext/securerandom"
+require "active_support/core_ext/object"
 
+require "canvas_qti_to_learnosity_converter/export_writer"
 require "canvas_qti_to_learnosity_converter/questions/multiple_choice"
 require "canvas_qti_to_learnosity_converter/questions/short_answer"
 require "canvas_qti_to_learnosity_converter/questions/fill_the_blanks"
@@ -16,217 +21,524 @@ require "canvas_qti_to_learnosity_converter/questions/numerical"
 require "canvas_qti_to_learnosity_converter/questions/calculated"
 
 module CanvasQtiToLearnosityConverter
-  FEATURE_TYPES = [ :text_only_question ]
-  QUESTION_TYPES = [
-    :multiple_choice_question,
-    :true_false_question,
-    :multiple_answers_question,
-    :short_answer_question,
-    :fill_in_multiple_blanks_question,
-    :multiple_dropdowns_question,
-    :matching_question,
-    :essay_question,
-    :file_upload_question,
-  ]
-
-  TYPE_MAP = {
-    multiple_choice_question: MultipleChoiceQuestion,
-    true_false_question: MultipleChoiceQuestion,
-    multiple_answers_question: MultipleAnswersQuestion,
-    short_answer_question: ShortAnswerQuestion,
-    fill_in_multiple_blanks_question: FillTheBlanksQuestion,
-    multiple_dropdowns_question: MultipleDropdownsQuestion,
-    matching_question: MatchingQuestion,
-    essay_question: EssayQuestion,
-    file_upload_question: FileUploadQuestion,
-    text_only_question: TextOnlyQuestion,
-    numerical_question: NumericalQuestion,
-    calculated_question: CalculatedQuestion,
-
-    "cc.multiple_choice.v0p1": MultipleChoiceQuestion,
-    "cc.multiple_response.v0p1": MultipleAnswersQuestion,
-    "cc.fib.v0p1": ShortAnswerQuestion,
-    "cc.true_false.v0p1": MultipleChoiceQuestion,
-    "cc.essay.v0p1": EssayQuestion,
-  }
-
-  class CanvasQuestionTypeNotSupportedError < RuntimeError
-    attr_reader :question_type
-    def initialize(question_type)
-      @question_type = question_type.to_s
-      super("Unsupported question type #{@question_type}")
-    end
-  end
+  class Converter
+    FEATURE_TYPES = [ :text_only_question ]
+    QUESTION_TYPES = [
+      :multiple_choice_question,
+      :true_false_question,
+      :multiple_answers_question,
+      :short_answer_question,
+      :fill_in_multiple_blanks_question,
+      :multiple_dropdowns_question,
+      :matching_question,
+      :essay_question,
+      :file_upload_question,
+    ]
+
+    TYPE_MAP = {
+      multiple_choice_question: MultipleChoiceQuestion,
+      true_false_question: MultipleChoiceQuestion,
+      multiple_answers_question: MultipleAnswersQuestion,
+      short_answer_question: ShortAnswerQuestion,
+      fill_in_multiple_blanks_question: FillTheBlanksQuestion,
+      multiple_dropdowns_question: MultipleDropdownsQuestion,
+      matching_question: MatchingQuestion,
+      essay_question: EssayQuestion,
+      file_upload_question: FileUploadQuestion,
+      text_only_question: TextOnlyQuestion,
+      numerical_question: NumericalQuestion,
+      calculated_question: CalculatedQuestion,
+
+      "cc.multiple_choice.v0p1": MultipleChoiceQuestion,
+      "cc.multiple_response.v0p1": MultipleAnswersQuestion,
+      "cc.fib.v0p1": ShortAnswerQuestion,
+      "cc.true_false.v0p1": MultipleChoiceQuestion,
+      "cc.essay.v0p1": EssayQuestion,
+    }
 
-  class CanvasQtiQuiz
-    extend Forwardable
-    def_delegators :@xml, :css
+    # 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
+      @items = []
+      @widgets = []
+      @item_banks = []
+      @assessments = []
+      @assets = {}
+      @errors = {}
+      @namespace = SecureRandom.uuid
+    end
 
-    def initialize(qti_string:)
-      @xml = Nokogiri.XML(qti_string, &:noblanks)
+    class CanvasQuestionTypeNotSupportedError < RuntimeError
+      attr_reader :question_type
+      def initialize(question_type)
+        @question_type = question_type.to_s
+        super("Unsupported question type #{@question_type}")
+      end
     end
-  end
 
+    class CanvasEntryTypeNotSupportedError < RuntimeError
+      attr_reader :question_type
+      def initialize(entry_type)
+        @entry_type = entry_type.to_s
+        super("Unsupported entry type #{@entry_type}")
+      end
+    end
 
-  def self.read_file(path)
-    file = File.new path
-    file.read
-  ensure
-    file.close
-  # Do we need to unlink?
-  end
+    class CanvasQtiQuiz
+      extend Forwardable
+      def_delegators :@xml, :css, :at_css
 
-  def self.build_quiz_from_qti_string(qti_string)
-    CanvasQtiQuiz.new(qti_string: qti_string)
-  end
+      def initialize(qti_string:)
+        @xml = Nokogiri.XML(qti_string, &:noblanks)
+      end
+    end
 
-  def self.build_quiz_from_file(path)
-    qti_file = File.new path
-    qti_string = qti_file.read
-    CanvasQtiQuiz.new(qti_string: qti_string)
-  ensure
-    qti_file.close
-  end
+    def build_quiz_from_qti_string(qti_string)
+      CanvasQtiQuiz.new(qti_string: qti_string)
+    end
 
-  def self.add_files_to_assets(assets, path, text)
-    text.scan(/(%24|\$)IMS-CC-FILEBASE\1\/([^"]+)/) do |_delimiter, asset_path|
-      decoded_path = URI::DEFAULT_PARSER.unescape(asset_path)
-      assets[decoded_path] ||= []
-      assets[decoded_path].push(path)
+    def build_quiz_from_file(path)
+      qti_file = File.new path
+      qti_string = qti_file.read
+      CanvasQtiQuiz.new(qti_string: qti_string)
+    ensure
+      qti_file.close
     end
-  end
 
-  def self.extract_type(xml)
-    xml.css(%{ item > itemmetadata > qtimetadata >
-      qtimetadatafield > fieldlabel:contains("question_type")})
-      &.first&.next&.text&.to_sym ||
+    def extract_type(xml)
       xml.css(%{ item > itemmetadata > qtimetadata >
-        qtimetadatafield > fieldlabel:contains("cc_profile")})
-        &.first&.next&.text&.to_sym
-  end
+        qtimetadatafield > fieldlabel:contains("question_type")})
+        &.first&.next&.text&.to_sym ||
+        xml.css(%{ item > itemmetadata > qtimetadata >
+          qtimetadatafield > fieldlabel:contains("cc_profile")})
+          &.first&.next&.text&.to_sym
+    end
 
-  def self.convert_item(qti_string:)
-    xml = Nokogiri.XML(qti_string, &:noblanks)
-    type = extract_type(xml)
+    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
 
-    if FEATURE_TYPES.include?(type)
-      learnosity_type = "feature"
-    else
-      learnosity_type = "question"
+    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
 
-    question_class = TYPE_MAP[type]
+    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 question_class
-      question = question_class.new(xml)
-    else
-      raise CanvasQuestionTypeNotSupportedError.new(type)
+      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
 
-    [learnosity_type, question]
-  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
 
-  def self.clean_title(title)
-    title.gsub(/["']/, "")
-  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] }]
 
-  def self.convert(qti, assets, errors)
-    quiz = CanvasQtiQuiz.new(qti_string: qti)
-    assessment = quiz.css("assessment")
-    ident = assessment.attribute("ident").value
-    assets[ident] = {}
-    errors[ident] = []
+      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
 
-    items = []
+      child_widgets = limit_child_questions(child_widgets, item_ref)
 
-    quiz.css("item").each.with_index do |item, index|
-      begin
-        next if item.children.length == 0
+      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] }]
 
-        item_title = item.attribute("title")&.value || ''
-        learnosity_type, quiz_item = convert_item(qti_string: item.to_html)
+      @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)
+
+      if FEATURE_TYPES.include?(type)
+        learnosity_type = "feature"
+      else
+        learnosity_type = "question"
+      end
+
+      question_class = TYPE_MAP[type]
+
+      if question_class
+        question = question_class.new(xml)
+      else
+        raise CanvasQuestionTypeNotSupportedError.new(type)
+      end
+
+      [learnosity_type, question]
+    end
 
-        item = {
-          title: item_title,
-          type: learnosity_type,
-          data: quiz_item.to_learnosity,
-          dynamic_content_data: quiz_item.dynamic_content_data()
+    def clean_title(title)
+      title&.gsub(/["']/, "")
+    end
+
+    def convert_assessment(qti, path)
+      quiz = CanvasQtiQuiz.new(qti_string: qti)
+      assessment = quiz.at_css("assessment")
+      return nil unless assessment
+
+      ident = assessment.attribute("ident")&.value
+      reference = build_reference(ident)
+      title = clean_title(assessment.attribute("title").value)
+
+      item_refs = convert_items(quiz, path)
+      @assessments <<
+        {
+          reference:,
+          title:,
+          data: {
+            items: item_refs.uniq.map { |ref| { reference: ref } },
+            config: { title: },
+          },
+          status: "published",
+          tags: {},
         }
+    end
 
-        items.push(item)
-        path = [items.count - 1, :data]
+    def convert_item_bank(qti_string, path)
+      qti = CanvasQtiQuiz.new(qti_string:)
+      item_bank = qti.at_css("objectbank")
+      return nil unless item_bank
 
-        quiz_item.add_learnosity_assets(assets[ident], path)
-      rescue CanvasQuestionTypeNotSupportedError => e
-        errors[ident].push({
-          index: index,
-          error_type: "unsupported_question",
-          question_type: e.question_type.to_s,
-          message: e.message,
-        })
-      rescue StandardError => e
-        errors[ident].push({
-          index: index,
-          error_type: e.class.to_s,
-          message: e.message,
-        })
+      ident = item_bank.attribute("ident")&.value
+      title = clean_title(qti.css(%{ objectbank > qtimetadata >
+        qtimetadatafield > fieldlabel:contains("bank_title")})
+        &.first&.next&.text || '')
+
+      meta = {
+        original_item_bank_ref: ident,
+      }
+      item_refs = convert_items(qti, path, meta:, tags: { "Item Bank" => [title] })
+      @item_banks <<
+        {
+          title: title,
+          ident: ident,
+          item_refs: item_refs,
+        }
+    end
+
+    def build_reference(ident = nil)
+      if ident.present?
+        Digest::UUID.uuid_v5(@namespace, ident)
+      else
+        SecureRandom.uuid
       end
     end
 
-    {
-      title: clean_title(assessment.attribute("title").value),
-      ident: ident,
-      items: items,
-    }
-  end
+    def convert_items(qti, path, meta: {}, tags: {})
+      converted_item_refs = []
 
-  def self.convert_qti_file(path)
-    file = File.new(path)
-    qti_string = file.read
-    convert(qti_string)
-  ensure
-    file.close
-    file.unlink
-  end
+      items_by_parent_stimulus = {}
+      qti.css("item,bankentry_item,section").each do |item|
+        ident = item.attribute("ident")&.value
+        next if ident == "root_section"
 
-  def self.imscc_quiz_paths(parsed_manifest)
-    resources = parsed_manifest.css("resources > resource[type^='imsqti_xmlv1p2']")
-    resources.map do |entry|
-      resource_path(parsed_manifest, entry)
+        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"
+
+            item.css("sourcebank_ref").each do |sourcebank_ref|
+              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.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, 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:,
+              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",
+              tags: tags,
+              type: learnosity_type,
+              dynamic_content_data: quiz_item.dynamic_content_data()
+            }
+
+            converted_item_refs.push(reference)
+          end
+
+        rescue CanvasQuestionTypeNotSupportedError => e
+          @errors[ident] ||= []
+          @errors[ident].push({
+            index: index,
+            error_type: "unsupported_question",
+            question_type: e.question_type.to_s,
+            message: e.message,
+          })
+        rescue StandardError => e
+          @errors[ident || item_ref] ||= []
+          @errors[ident || item_ref].push({
+            index: index,
+            error_type: e.class.to_s,
+            message: e.message,
+          })
+        end
+      end
+      converted_item_refs
     end
-  end
 
-  def self.resource_path(parsed_manifest, entry)
-    # Use the Canvas non_cc_assignment qti path when possible.  This works for both classic and new quizzes
-    entry.css("dependency").each do |dependency|
-      ref = dependency.attribute("identifierref").value
-      parsed_manifest.css(%{resources > resource[identifier="#{ref}"] > file}).each do |file|
-        path = file.attribute("href").value
-        return path if path.match?(/^non_cc_assessments/)
+    def convert_qti_file(path)
+      file = File.new(path)
+      qti_string = file.read
+      convert(qti_string)
+    ensure
+      file.close
+      file.unlink
+    end
+
+    def imscc_quiz_paths(parsed_manifest)
+      resources = parsed_manifest.css("resources > resource[type^='imsqti_xmlv1p2']")
+      resources.map do |entry|
+        resource_path(parsed_manifest, entry)
       end
     end
-    entry.css("file").first&.attribute("href")&.value
-  end
 
-  def self.convert_imscc_export(path)
-    Zip::File.open(path) do |zip_file|
-      entry = zip_file.find_entry("imsmanifest.xml")
-      manifest = entry.get_input_stream.read
-      parsed_manifest = Nokogiri.XML(manifest, &:noblanks)
-      paths = imscc_quiz_paths(parsed_manifest)
+    def imscc_item_bank_paths(parsed_manifest)
+      resources = parsed_manifest.css("resources > resource[type='associatedcontent/imscc_xmlv1p1/learning-application-resource']")
+      resources.map do |entry|
+        resource_path(parsed_manifest, entry)
+      end
+    end
 
-      assets = {}
-      errors = {}
-      converted_assesments = paths.map do |qti_path|
-        qti = zip_file.find_entry(qti_path).get_input_stream.read
-        convert(qti, assets, errors)
+    def resource_path(parsed_manifest, entry)
+      # Use the Canvas non_cc_assignment qti path when possible.  This works for both classic and new quizzes
+      entry.css("dependency").each do |dependency|
+        ref = dependency.attribute("identifierref").value
+        parsed_manifest.css(%{resources > resource[identifier="#{ref}"] > file}).each do |file|
+          path = file.attribute("href").value
+          return path if path.match?(/^non_cc_assessments/)
+        end
       end
+      entry.css("file").first&.attribute("href")&.value
+    end
 
-      {
-        assessments: converted_assesments,
-        assets: assets,
-        errors: errors,
-      }
+    def convert_imscc_export(path)
+      Zip::File.open(path) do |zip_file|
+        entry = zip_file.find_entry("imsmanifest.xml")
+        manifest = entry.get_input_stream.read
+        parsed_manifest = Nokogiri.XML(manifest, &:noblanks)
+
+        item_bank_paths = imscc_item_bank_paths(parsed_manifest)
+        item_bank_paths.each do |item_bank_path|
+          qti = zip_file.find_entry(item_bank_path).get_input_stream.read
+          convert_item_bank(qti, File.dirname(item_bank_path))
+        end
+
+        assessment_paths = imscc_quiz_paths(parsed_manifest)
+        assessment_paths.each do |qti_path|
+          qti = zip_file.find_entry(qti_path).get_input_stream.read
+          convert_assessment(qti, File.dirname(qti_path))
+        end
+
+        {
+          errors: @errors,
+        }
+      end
+    end
+
+    def generate_learnosity_export(input_path, output_path)
+      result = convert_imscc_export(input_path)
+
+      export_writer = ExportWriter.new(output_path)
+      export_writer.write_to_zip("export.json", { version: 2.0 })
+
+      @assessments.each do |activity|
+        export_writer.write_to_zip("activities/#{activity[:reference]}.json", activity)
+      end
+      @items.each do |item|
+        export_writer.write_to_zip("items/#{item[:reference]}.json", item)
+      end
+      @widgets.each do |widget|
+        export_writer.write_to_zip("#{widget[:type]}s/#{widget[:reference]}.json", widget)
+      end
+
+      Zip::File.open(input_path) do |input|
+        @assets.each do |source, destination|
+          source = source.gsub(/^\//, '')
+          asset = input.find_entry(source) || input.find_entry("web_resources/#{source}")
+          if asset
+            export_writer.write_asset_to_zip("assets/#{destination}", input.read(asset))
+          end
+        end
+      end
+      export_writer.close
+
+      result
     end
   end
 end

data/lib/canvas_qti_to_learnosity_converter/export_writer.rb

@@ -0,0 +1,21 @@
+class ExportWriter
+  def initialize(temp_file)
+    @zip = Zip::File.open(temp_file.path, Zip::File::CREATE)
+  end
+
+  def close
+    @zip.close
+  end
+
+  def write_to_zip(filename, content)
+    @zip.get_output_stream(filename) do |file|
+      file << content.to_json
+    end
+  end
+
+  def write_asset_to_zip(filename, content)
+    @zip.get_output_stream(filename) do |file|
+      file << content
+    end
+  end
+end

data/lib/canvas_qti_to_learnosity_converter/questions/calculated.rb

@@ -37,13 +37,13 @@ module CanvasQtiToLearnosityConverter
       }
     end
 
-    def add_learnosity_assets(assets, path)
-      learnosity = to_learnosity
-      CanvasQtiToLearnosityConverter.add_files_to_assets(
+    def add_learnosity_assets(assets, path, learnosity)
+      process_assets!(
         assets,
-        path + [:stimulus],
+        path,
         learnosity[:stimulus]
       )
+      learnosity
     end
 
     def dynamic_content_data()

data/lib/canvas_qti_to_learnosity_converter/questions/essay.rb

@@ -12,13 +12,13 @@ module CanvasQtiToLearnosityConverter
       }
     end
 
-    def add_learnosity_assets(assets, path)
-      learnosity = to_learnosity
-      CanvasQtiToLearnosityConverter.add_files_to_assets(
+    def add_learnosity_assets(assets, path, learnosity)
+      process_assets!(
         assets,
-        path + [:stimulus],
+        path,
         learnosity[:stimulus]
       )
+      learnosity
     end
   end
 end

data/lib/canvas_qti_to_learnosity_converter/questions/file_upload.rb

@@ -25,13 +25,13 @@ module CanvasQtiToLearnosityConverter
       }
     end
 
-    def add_learnosity_assets(assets, path)
-      learnosity = to_learnosity
-      CanvasQtiToLearnosityConverter.add_files_to_assets(
+    def add_learnosity_assets(assets, path, learnosity)
+      process_assets!(
         assets,
-        path + [:stimulus],
+        path,
         learnosity[:stimulus]
       )
+      learnosity
     end
   end
 end

data/lib/canvas_qti_to_learnosity_converter/questions/fill_the_blanks.rb

@@ -11,14 +11,13 @@ module CanvasQtiToLearnosityConverter
       }
     end
 
-    def add_learnosity_assets(assets, path)
-      learnosity = to_learnosity
-
-      CanvasQtiToLearnosityConverter.add_files_to_assets(
+    def add_learnosity_assets(assets, path, learnosity)
+      process_assets!(
         assets,
-        path + [:template],
+        path,
         learnosity[:template]
       )
+      learnosity
     end
 
     def extract_validation()

data/lib/canvas_qti_to_learnosity_converter/questions/matching.rb

@@ -66,13 +66,13 @@ module CanvasQtiToLearnosityConverter
       end
     end
 
-    def add_learnosity_assets(assets, path)
-      learnosity = to_learnosity
-      CanvasQtiToLearnosityConverter.add_files_to_assets(
+    def add_learnosity_assets(assets, path, learnosity)
+      process_assets!(
         assets,
-        path + [:stimulus],
+        path,
         learnosity[:stimulus]
       )
+      learnosity
     end
   end
 end

data/lib/canvas_qti_to_learnosity_converter/questions/multiple_choice.rb

@@ -46,21 +46,21 @@ module CanvasQtiToLearnosityConverter
       }
     end
 
-    def add_learnosity_assets(assets, path)
-      learnosity = to_learnosity
-      CanvasQtiToLearnosityConverter.add_files_to_assets(
+    def add_learnosity_assets(assets, path, learnosity)
+      process_assets!(
         assets,
-        path + [:stimulus],
+        path,
         learnosity[:stimulus]
       )
 
       learnosity[:options].each.with_index do |option, index|
-        CanvasQtiToLearnosityConverter.add_files_to_assets(
+        process_assets!(
           assets,
-          path + [:options, index, "label"],
+          path,
           option["label"]
         )
       end
+      learnosity
     end
   end
 

data/lib/canvas_qti_to_learnosity_converter/questions/numerical.rb

@@ -53,13 +53,13 @@ module CanvasQtiToLearnosityConverter
       }
     end
 
-    def add_learnosity_assets(assets, path)
-      learnosity = to_learnosity
-      CanvasQtiToLearnosityConverter.add_files_to_assets(
+    def add_learnosity_assets(assets, path, learnosity)
+      process_assets!(
         assets,
-        path + [:stimulus],
+        path,
         learnosity[:stimulus]
       )
+      learnosity
     end
   end
 end

data/lib/canvas_qti_to_learnosity_converter/questions/question.rb

@@ -31,5 +31,34 @@ module CanvasQtiToLearnosityConverter
     def dynamic_content_data()
       {}
     end
+
+    def process_assets!(assets, path, text)
+      doc = Nokogiri::XML.fragment(text)
+      changed = false
+      doc.css("img").each do |node|
+        source = node["src"]
+        next if !source
+
+        source = URI::DEFAULT_PARSER.unescape(source)
+        if /^\$IMS-CC-FILEBASE\$(.*)/.match(source) || /^((?!https?:).*)/.match(source)
+          if source.start_with?("$IMS-CC-FILEBASE$")
+            path = ''
+          end
+          asset_path = $1
+          asset_path = asset_path.split("?").first.gsub(/^\//, '')
+          asset_path = File.join(path, asset_path)
+          clean_ext = File.extname(asset_path).gsub(/[^a-z0-9_.-]/i, '')
+          assets[asset_path] ||= "#{SecureRandom.uuid}#{clean_ext}"
+          node["src"] = "___EXPORT_ROOT___/assets/#{assets[asset_path]}"
+          changed = true
+        end
+      end
+      text.replace(doc.to_xml) if changed
+    end
+
+    def convert(assets, path)
+      object = to_learnosity
+      add_learnosity_assets(assets, path, object)
+    end
   end
 end

data/lib/canvas_qti_to_learnosity_converter/questions/short_answer.rb

@@ -28,13 +28,13 @@ module CanvasQtiToLearnosityConverter
       }
     end
 
-    def add_learnosity_assets(assets, path)
-      learnosity = to_learnosity
-      CanvasQtiToLearnosityConverter.add_files_to_assets(
+    def add_learnosity_assets(assets, path, learnosity)
+      process_assets!(
         assets,
-        path + [:stimulus],
+        path,
         learnosity[:stimulus]
       )
+      learnosity
     end
   end
 end

data/lib/canvas_qti_to_learnosity_converter/questions/template_question.rb

@@ -26,14 +26,13 @@ module CanvasQtiToLearnosityConverter
       extract_mattext(template_node_list.first)
     end
 
-    def add_learnosity_assets(assets, path)
-      learnosity = to_learnosity
-
-      CanvasQtiToLearnosityConverter.add_files_to_assets(
+    def add_learnosity_assets(assets, path, learnosity)
+      process_assets!(
         assets,
-        path + [:template],
+        path,
         learnosity[:template]
       )
+      learnosity
     end
   end
 end

data/lib/canvas_qti_to_learnosity_converter/questions/text_only.rb

@@ -10,13 +10,13 @@ module CanvasQtiToLearnosityConverter
       }
     end
 
-    def add_learnosity_assets(assets, path)
-      learnosity = to_learnosity
-      CanvasQtiToLearnosityConverter.add_files_to_assets(
+    def add_learnosity_assets(assets, path, learnosity)
+      process_assets!(
         assets,
-        path + [:content],
+        path,
         learnosity[:content]
       )
+      learnosity
     end
   end
 end

data/lib/canvas_qti_to_learnosity_converter/version.rb

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

data/lib/canvas_qti_to_learnosity_converter.rb

@@ -2,5 +2,4 @@ require 'canvas_qti_to_learnosity_converter/version'
 require 'canvas_qti_to_learnosity_converter/convert'
 
 module CanvasQtiToLearnosityConverter
-  # Your code goes here...
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canvas_qti_to_learnosity_converter
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Atomic Jolt
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-30 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
@@ -95,6 +95,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description:
 email:
 - support@atomicjolt.com
@@ -115,6 +129,7 @@ files:
 - canvas_qti_to_learnosity_converter.gemspec
 - lib/canvas_qti_to_learnosity_converter.rb
 - lib/canvas_qti_to_learnosity_converter/convert.rb
+- lib/canvas_qti_to_learnosity_converter/export_writer.rb
 - lib/canvas_qti_to_learnosity_converter/questions/calculated.rb
 - lib/canvas_qti_to_learnosity_converter/questions/essay.rb
 - lib/canvas_qti_to_learnosity_converter/questions/file_upload.rb