canvas_qti_to_learnosity_converter 1.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b08edcaa5b1202695605345f102ecd6999daf9da1e93afe4be7f3fac421e1607
-  data.tar.gz: dac787cd08b5d12ba9f2612db7b7b05d5d8421d1ac49775790f3469af8fca511
+  metadata.gz: '052911e6b4ed78bd22f6f6f99af67f56e5aa42bb84f327cfe9da5090900ff3f8'
+  data.tar.gz: 8927eb57c5e1b4a75dd00b49775e9479573295c7b7ce1bb48565bf0763852ea7
 SHA512:
-  metadata.gz: f6628bda0a17f0686f773cbf651fe1b19dd427d466440e43ba2ec3759e60d9f03d8f8b67544716f13239d776d6cfda201c1b427562d9e2aedf116e244b3ef239
-  data.tar.gz: 278c0aed069d6b31d91088c764010c288ebefe4a818e4049d87b489ed0f1e38d796192bedb05afae538028165643a09dda55003eeab523737fceb23a5f66576b
+  metadata.gz: 9e435bae6d96255228cd1ccc74b1b98e96208f5962b860db9629d07d3de668539065cc5795a13f09bff7ace2b6b84f938ae449b5d0268788a0cf17b1a4a08646
+  data.tar.gz: ece35a13ae4485a6eb0518e472530426c121215720759058ebcda7ce0c2283ac9d94e72944dc392ee78987caaab85035d8b5f8173a10ee5453605ced1fda1e21

data/lib/canvas_qti_to_learnosity_converter/convert.rb

@@ -4,7 +4,30 @@ require "ostruct"
 require "zip"
 require "uri"
 
+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"
+require "canvas_qti_to_learnosity_converter/questions/multiple_dropdowns"
+require "canvas_qti_to_learnosity_converter/questions/matching"
+require "canvas_qti_to_learnosity_converter/questions/essay"
+require "canvas_qti_to_learnosity_converter/questions/file_upload"
+require "canvas_qti_to_learnosity_converter/questions/text_only"
+require "canvas_qti_to_learnosity_converter/questions/numerical"
+
 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,
+  ]
+
   class CanvasQuestionTypeNotSupportedError < RuntimeError
   end
 
@@ -17,33 +40,6 @@ module CanvasQtiToLearnosityConverter
     end
   end
 
-  class CanvasQtiQuizQuestion
-    extend Forwardable
-    def_delegators :@xml, :css
-
-    def initialize(qti_string:)
-      @xml = Nokogiri.XML(qti_string, &:noblanks)
-    end
-  end
-
-  class LearnosityQuestion < OpenStruct
-  end
-
-  class MultipleChoiceLearnosityQuestion < LearnosityQuestion
-  end
-
-  class MultipleAnswersLearnosityQuestion < LearnosityQuestion
-  end
-
-  class Learnosityitem
-  end
-
-  class LearnosityActivity
-  end
-
-  LEARNOSITY_TYPE_MAP = {
-    "mcq" => MultipleChoiceLearnosityQuestion
-  }
 
   def self.read_file(path)
     file = File.new path
@@ -65,94 +61,6 @@ module CanvasQtiToLearnosityConverter
     qti_file.close
   end
 
-  def self.build_item_from_file(path, item_type = nil)
-    file = File.new path
-    file_val = JSON.parse(file.read)
-    type = item_type || LEARNOSITY_TYPE_MAP[file_val["type"]]
-    type.new(file_val)
-  ensure
-    file.close
-  end
-
-  def self.extract_type(item)
-    item.css(%{ item > itemmetadata > qtimetadata >
-      qtimetadatafield > fieldlabel:contains("question_type")})
-      &.first&.next&.text&.to_sym
-  end
-
-  def self.extract_mattext(mattext_node)
-    mattext_node.content
-  end
-
-  def self.extract_stimulus(item)
-    mattext = item.css("item > presentation > material > mattext").first
-    extract_mattext(mattext)
-  end
-
-  def self.extract_multiple_choice_options(item)
-    choices = item.css("item > presentation > response_lid > render_choice > response_label")
-    choices.map do |choice|
-      ident = choice.attribute("ident").value
-      {
-        "value" => ident,
-        "label" => extract_mattext(choice.css("material > mattext").first),
-      }
-    end
-  end
-
-  def self.extract_response_id(item)
-    item.css("item > presentation > response_lid").attribute("ident").value
-  end
-
-  def self.extract_multiple_choice_validation(item)
-    resp_conditions = item.css("item > resprocessing > respcondition")
-    correct_condition = resp_conditions.select do |condition|
-      setvar = condition.css("setvar")
-      setvar.length === 1 && setvar.text === "100"
-    end.first
-
-
-    # TODO check for more than 1 element
-    correct_value = correct_condition.css("varequal").text
-    {
-      "scoring_type" => "exactMatch",
-      "valid_response" => {
-        "value" => [correct_value],
-      },
-    }
-  end
-
-  def self.extract_multiple_answers_validation(item)
-    correct_condition = item.css('item > resprocessing > respcondition[continue="No"] > conditionvar > and > varequal')
-    alt_responses = correct_condition.map(&:text)
-    {
-      "scoring_type" => "partialMatch",
-      "alt_responses" => alt_responses,
-    }
-  end
-
-  def self.convert_multiple_choice(item)
-    MultipleChoiceLearnosityQuestion.new({
-      stimulus: extract_stimulus(item),
-      options: extract_multiple_choice_options(item),
-      multiple_responses: false,
-      response_id: extract_response_id(item),
-      type: "mcq",
-      validation: extract_multiple_choice_validation(item),
-    })
-  end
-
-  def self.convert_multiple_answers(item)
-    MultipleAnswersLearnosityQuestion.new({
-      stimulus: extract_stimulus(item),
-      options: extract_multiple_choice_options(item),
-      multiple_responses: true,
-      response_id: extract_response_id(item),
-      type: "mcq",
-      validation: extract_multiple_answers_validation(item),
-    })
-  end
-
   def self.add_files_to_assets(assets, path, text)
     text.scan(/%24IMS-CC-FILEBASE%24\/([^"]+)/).flatten.each do |asset_path|
       decoded_path = URI.unescape(asset_path)
@@ -161,35 +69,54 @@ module CanvasQtiToLearnosityConverter
     end
   end
 
-  def self.convert_item(qti_quiz, assets, item_index)
-    type = extract_type(qti_quiz)
+  def self.extract_type(xml)
+    xml.css(%{ item > itemmetadata > qtimetadata >
+      qtimetadatafield > fieldlabel:contains("question_type")})
+      &.first&.next&.text&.to_sym
+  end
+
+  def self.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 = case type
     when :multiple_choice_question
-      convert_multiple_choice(qti_quiz)
+      MultipleChoiceQuestion.new(xml)
     when :true_false_question
-      convert_multiple_choice(qti_quiz)
+      MultipleChoiceQuestion.new(xml)
     when :multiple_answers_question
-      convert_multiple_answers(qti_quiz)
+      MultipleAnswersQuestion.new(xml)
+    when :short_answer_question
+      ShortAnswerQuestion.new(xml)
+    when :fill_in_multiple_blanks_question
+      FillTheBlanksQuestion.new(xml)
+    when :multiple_dropdowns_question
+      MultipleDropdownsQuestion.new(xml)
+    when :matching_question
+      MatchingQuestion.new(xml)
+    when :essay_question
+      EssayQuestion.new(xml)
+    when :file_upload_question
+      FileUploadQuestion.new(xml)
+    when :text_only_question
+      TextOnlyQuestion.new(xml)
+    when :numerical_question
+      NumericalQuestion.new(xml)
     else
       raise CanvasQuestionTypeNotSupportedError
     end
 
-    add_files_to_assets(
-      assets,
-      [item_index, :stimulus],
-      question.stimulus
-    )
-
-    question.options.each.with_index do |option, index|
-      add_files_to_assets(
-        assets,
-        [item_index, :options, index, "label"],
-        option["label"]
-      )
-    end
+    [learnosity_type, question]
+  end
 
-    question
+  def self.clean_title(title)
+    title.gsub(/["']/, "")
   end
 
   def self.convert(qti, assets)
@@ -198,17 +125,23 @@ module CanvasQtiToLearnosityConverter
     ident = assessment.attribute("ident").value
     assets[ident] = {}
 
-    items = quiz.css("item").map.with_index do |item, index|
+    items = []
+
+    quiz.css("item").each.with_index do |item, index|
       begin
-        quiz_item = CanvasQtiQuizQuestion.new(qti_string: item.to_html)
-        convert_item(quiz_item, assets[ident], index)
+        learnosity_type, quiz_item = convert_item(qti_string: item.to_html)
+
+        items.push({type: learnosity_type, data: quiz_item.to_learnosity})
+        path = [items.count - 1, :data]
+
+        quiz_item.add_learnosity_assets(assets[ident], path)
       rescue CanvasQuestionTypeNotSupportedError
         nil
       end
-    end.compact
+    end
 
     {
-      title: assessment.attribute("title").value,
+      title: clean_title(assessment.attribute("title").value),
       ident: ident,
       items: items,
     }
@@ -228,12 +161,6 @@ module CanvasQtiToLearnosityConverter
       map { |entry| entry.attribute("href").value }
   end
 
-  def self.to_native_types(activity)
-    clone = activity.clone
-    clone[:items] = activity[:items].map(&:to_h)
-    clone
-  end
-
   def self.convert_imscc_export(path)
     Zip::File.open(path) do |zip_file|
       entry = zip_file.find_entry("imsmanifest.xml")
@@ -244,7 +171,7 @@ module CanvasQtiToLearnosityConverter
       assets = {}
       converted_assesments = paths.map do |qti_path|
         qti = zip_file.find_entry(qti_path).get_input_stream.read
-        to_native_types(convert(qti, assets))
+        convert(qti, assets)
       end
 
       {

data/lib/canvas_qti_to_learnosity_converter/questions/essay.rb

@@ -0,0 +1,21 @@
+require "canvas_qti_to_learnosity_converter/questions/question"
+
+module CanvasQtiToLearnosityConverter
+  class EssayQuestion < QuizQuestion
+    def to_learnosity
+      {
+        type: "longtextV2",
+        stimulus: extract_stimulus(),
+      }
+    end
+
+    def add_learnosity_assets(assets, path)
+      learnosity = to_learnosity
+      CanvasQtiToLearnosityConverter.add_files_to_assets(
+        assets,
+        path + [:stimulus],
+        learnosity[:stimulus]
+      )
+    end
+  end
+end

data/lib/canvas_qti_to_learnosity_converter/questions/file_upload.rb

@@ -0,0 +1,34 @@
+require "canvas_qti_to_learnosity_converter/questions/question"
+
+module CanvasQtiToLearnosityConverter
+  class FileUploadQuestion < QuizQuestion
+    def to_learnosity
+      {
+        type: "fileupload",
+        stimulus: extract_stimulus(),
+        allow_pdf: true,
+        allow_jpg: true,
+        allow_gif: true,
+        allow_png: true,
+        allow_csv: true,
+        allow_rtf: true,
+        allow_txt: true,
+        allow_xps: true,
+        allow_ms_word: true,
+        allow_ms_excel: true,
+        allow_ms_powerpoint: true,
+        allow_ms_publisher: true,
+        allow_open_office: true
+      }
+    end
+
+    def add_learnosity_assets(assets, path)
+      learnosity = to_learnosity
+      CanvasQtiToLearnosityConverter.add_files_to_assets(
+        assets,
+        path + [:stimulus],
+        learnosity[:stimulus]
+      )
+    end
+  end
+end

data/lib/canvas_qti_to_learnosity_converter/questions/fill_the_blanks.rb

@@ -0,0 +1,62 @@
+require "canvas_qti_to_learnosity_converter/questions/template_question"
+
+module CanvasQtiToLearnosityConverter
+  class FillTheBlanksQuestion < TemplateQuestion
+    def to_learnosity
+      {
+        type: "clozetext",
+        stimulus: "",
+        template: extract_template(),
+        validation: extract_validation(),
+      }
+    end
+
+    def add_learnosity_assets(assets, path)
+      learnosity = to_learnosity
+
+      CanvasQtiToLearnosityConverter.add_files_to_assets(
+        assets,
+        path + [:template],
+        learnosity[:template]
+      )
+    end
+
+    def extract_validation()
+      template = get_template()
+
+      responses = extract_template_values(template).map do |name|
+        result = @xml.css(%{item > presentation >
+          response_lid[ident="response_#{name}"] > render_choice material >
+          mattext}).map do |node|
+          extract_mattext(node)
+        end
+
+        if result.empty?
+          nil
+        else
+          result
+        end
+      end.compact
+
+      all_responses = []
+      create_responses(responses, 0, all_responses, [])
+
+      {
+        "scoring_type" => "partialMatch",
+        "valid_response" => all_responses.shift,
+        "alt_responses" => all_responses
+      }
+    end
+
+    def create_responses(blank_responses, depth, result, current_response)
+      if depth == blank_responses.count
+        result.push({ "value" => current_response })
+        return
+      end
+
+      blank_responses[depth].each do |possible_response|
+        create_responses(blank_responses, depth + 1, result, current_response + [possible_response])
+      end
+    end
+  end
+end

data/lib/canvas_qti_to_learnosity_converter/questions/matching.rb

@@ -0,0 +1,75 @@
+require "canvas_qti_to_learnosity_converter/questions/question"
+
+module CanvasQtiToLearnosityConverter
+  class MatchingQuestion < QuizQuestion
+    def to_learnosity
+      {
+        type: "association",
+        stimulus: extract_stimulus(),
+        stimulus_list: extract_stimulus_list(),
+        validation: extract_validation(),
+        possible_responses: extract_responses(),
+        duplicate_responses: true,
+      }
+    end
+
+    def extract_stimulus_list()
+      @xml.css("item > presentation > response_lid > material > mattext").map do |node|
+        extract_mattext(node)
+      end
+    end
+
+    def extract_response_idents()
+      @xml.css("item > presentation > response_lid").map do |node|
+        node.attribute("ident").text
+      end
+    end
+
+    def extract_valid_label_idents(valid_response_idents)
+      valid_response_idents.map do |ident|
+        @xml.css(%{item > resprocessing > respcondition varequal[respident="#{ident}"]}).map do |node|
+          node.content
+        end
+      end.flatten
+    end
+
+    def extract_validation()
+      valid_response_idents = extract_response_idents()
+      valid_label_idents = extract_valid_label_idents(valid_response_idents)
+
+      valid_idents = Hash[valid_response_idents.zip(valid_label_idents)]
+
+      valid_responses = valid_idents.map do |response_ident, label_ident|
+        @xml.css(%{item > presentation >
+          response_lid[ident="#{response_ident}"]
+          response_label[ident="#{label_ident}"] > material > mattext}).map do |node|
+          extract_mattext(node)
+        end
+      end.flatten
+
+      {
+        "scoring_type" => "partialMatch",
+        "valid_response" => {
+          "value" => valid_responses
+        }
+      }
+    end
+
+    def extract_responses()
+      response_node = @xml.css("item > presentation > response_lid").first
+
+      response_node.css("response_label mattext").map do |node|
+        extract_mattext(node)
+      end
+    end
+
+    def add_learnosity_assets(assets, path)
+      learnosity = to_learnosity
+      CanvasQtiToLearnosityConverter.add_files_to_assets(
+        assets,
+        path + [:stimulus],
+        learnosity[:stimulus]
+      )
+    end
+  end
+end

data/lib/canvas_qti_to_learnosity_converter/questions/multiple_choice.rb

@@ -0,0 +1,89 @@
+require "canvas_qti_to_learnosity_converter/questions/question"
+
+module CanvasQtiToLearnosityConverter
+  class MultipleChoiceQuestion < QuizQuestion
+    def extract_options()
+      choices = @xml.css("item > presentation > response_lid > render_choice > response_label")
+      choices.map do |choice|
+        ident = choice.attribute("ident").value
+        {
+          "value" => ident,
+          "label" => extract_mattext(choice.css("material > mattext").first),
+        }
+      end
+    end
+
+    def extract_response_id()
+      @xml.css("item > presentation > response_lid").attribute("ident").value
+    end
+
+    def extract_validation()
+      resp_conditions = @xml.css("item > resprocessing > respcondition")
+      correct_condition = resp_conditions.select do |condition|
+        setvar = condition.css("setvar")
+        setvar.length === 1 && setvar.text === "100"
+      end.first
+
+      # TODO check for more than 1 element
+      correct_value = correct_condition.css("varequal").text
+      {
+        "scoring_type" => "exactMatch",
+        "valid_response" => {
+          "value" => [correct_value],
+        },
+      }
+    end
+
+    def to_learnosity
+      {
+        stimulus: extract_stimulus(),
+        options: extract_options(),
+        multiple_responses: false,
+        response_id: extract_response_id(),
+        type: "mcq",
+        validation: extract_validation(),
+      }
+    end
+
+    def add_learnosity_assets(assets, path)
+      learnosity = to_learnosity
+      CanvasQtiToLearnosityConverter.add_files_to_assets(
+        assets,
+        path + [:stimulus],
+        learnosity[:stimulus]
+      )
+
+      learnosity[:options].each.with_index do |option, index|
+        CanvasQtiToLearnosityConverter.add_files_to_assets(
+          assets,
+          path + [:options, index, "label"],
+          option["label"]
+        )
+      end
+    end
+  end
+
+  class MultipleAnswersQuestion < MultipleChoiceQuestion
+    def to_learnosity
+      {
+        stimulus: extract_stimulus(),
+        options: extract_options(),
+        multiple_responses: true,
+        response_id: extract_response_id(),
+        type: "mcq",
+        validation: extract_validation()
+      }
+    end
+
+    def extract_validation()
+      correct_condition = @xml.css('item > resprocessing >
+                                   respcondition[continue="No"] > conditionvar >
+                                   and > varequal')
+      alt_responses = correct_condition.map(&:text)
+      {
+        "scoring_type" => "partialMatch",
+        "alt_responses" => alt_responses,
+      }
+    end
+  end
+end

data/lib/canvas_qti_to_learnosity_converter/questions/multiple_dropdowns.rb

@@ -0,0 +1,55 @@
+require "canvas_qti_to_learnosity_converter/questions/template_question"
+
+module CanvasQtiToLearnosityConverter
+  class MultipleDropdownsQuestion < TemplateQuestion
+    def to_learnosity
+      {
+        type: "clozedropdown",
+        stimulus: "",
+        template: extract_template(),
+        validation: extract_validation(),
+        possible_responses: extract_responses(),
+      }
+    end
+
+    def extract_validation()
+      template = get_template()
+
+      valid_responses = extract_template_values(template).map do |name|
+        correct_ident = @xml.css(%{item > resprocessing > respcondition >
+          conditionvar > varequal[respident="response_#{name}"]}).first&.content
+
+        @xml.css(%{item > presentation >
+          response_lid[ident="response_#{name}"] response_label}).map do |node|
+          text = extract_mattext(node.css("mattext").first)
+          ident = node.attribute("ident").text
+          ident == correct_ident ? text : nil
+        end.compact
+      end.flatten
+
+      {
+        "scoring_type" => "partialMatch",
+        "valid_response" => {
+          "value" => valid_responses,
+        }
+      }
+    end
+
+    def extract_responses()
+      template = get_template()
+
+      extract_template_values(template).map do |name|
+        result = @xml.css(%{item > presentation >
+          response_lid[ident="response_#{name}"] > render_choice mattext}).map do |node|
+          extract_mattext(node)
+        end
+
+        if result.empty?
+          nil
+        else
+          result
+        end
+      end.compact
+    end
+  end
+end

data/lib/canvas_qti_to_learnosity_converter/questions/numerical.rb

@@ -0,0 +1,65 @@
+require "canvas_qti_to_learnosity_converter/questions/question"
+
+module CanvasQtiToLearnosityConverter
+  class NumericalQuestion < QuizQuestion
+    def to_learnosity
+      {
+        is_math: true,
+        type: "formulaV2",
+        stimulus: extract_stimulus(),
+        template: "{{response}}",
+        validation: extract_validation(),
+      }
+    end
+
+    def extract_validation()
+      response_mins = @xml.css('item > resprocessing >
+        respcondition[continue="No"] > conditionvar vargte').map do |node|
+        node.content
+      end
+
+      response_maxs = @xml.css('item > resprocessing >
+        respcondition[continue="No"] > conditionvar varlte').map do |node|
+        node.content
+      end
+
+      answer_bounds = response_mins.zip(response_maxs).map do |bounds|
+        puts bounds.inspect
+        # Get the precision by counting the number of places after the decimal
+        precision = [
+          bounds.first.split(".").last.length,
+          bounds.last.split(".").last.length
+        ].max
+
+        {
+          center: ((bounds.first.to_f + bounds.last.to_f) / 2.0).round(precision),
+          pm: ((bounds.first.to_f - bounds.last.to_f) / 2.0).round(precision).abs,
+        }
+      end
+
+      valid_answers = answer_bounds.map do |bounds|
+        {
+          "value" => [{
+            "method" => "equivValue",
+            "value" => "#{bounds[:center]}\\pm#{bounds[:pm]}",
+          }]
+        }
+      end
+
+      {
+        "scoring_type" => "exactMatch",
+        "valid_response" => valid_answers.shift,
+        "alt_responses" => valid_answers,
+      }
+    end
+
+    def add_learnosity_assets(assets, path)
+      learnosity = to_learnosity
+      CanvasQtiToLearnosityConverter.add_files_to_assets(
+        assets,
+        path + [:stimulus],
+        learnosity[:stimulus]
+      )
+    end
+  end
+end

data/lib/canvas_qti_to_learnosity_converter/questions/question.rb

@@ -0,0 +1,19 @@
+module CanvasQtiToLearnosityConverter
+  class QuizQuestion
+    extend Forwardable
+    def_delegators :@xml, :css
+
+    def initialize(xml)
+      @xml = xml
+    end
+
+    def extract_stimulus()
+      mattext = @xml.css("item > presentation > material > mattext").first
+      extract_mattext(mattext)
+    end
+
+    def extract_mattext(mattext_node)
+      mattext_node.content
+    end
+  end
+end

data/lib/canvas_qti_to_learnosity_converter/questions/short_answer.rb

@@ -0,0 +1,40 @@
+require "canvas_qti_to_learnosity_converter/questions/question"
+
+module CanvasQtiToLearnosityConverter
+  # This is fill in the blank in the Canvas UI, but it is actually a short
+  # answer type.
+  class ShortAnswerQuestion < QuizQuestion
+    def extract_response_id()
+      @xml.css("item > presentation > response_str").attribute("ident").value
+    end
+
+    def to_learnosity
+      {
+        type: "shorttext",
+        stimulus: extract_stimulus(),
+        validation: extract_validation(),
+        response_id: extract_response_id(),
+      }
+    end
+
+    def extract_validation()
+      correct_responses = @xml.css('item > resprocessing >
+        respcondition[continue="No"] > conditionvar > varequal')
+      correct_response = { "value" => correct_responses.shift.text }
+      {
+        "scoring_type" => "exactMatch",
+        "valid_response" => correct_response,
+        "alt_responses" => correct_responses.map { |res| { "value" => res.text } }
+      }
+    end
+
+    def add_learnosity_assets(assets, path)
+      learnosity = to_learnosity
+      CanvasQtiToLearnosityConverter.add_files_to_assets(
+        assets,
+        path + [:stimulus],
+        learnosity[:stimulus]
+      )
+    end
+  end
+end

data/lib/canvas_qti_to_learnosity_converter/questions/template_question.rb

@@ -0,0 +1,39 @@
+require "canvas_qti_to_learnosity_converter/questions/question"
+
+module CanvasQtiToLearnosityConverter
+  class TemplateQuestion < QuizQuestion
+    def extract_template()
+      placeholders = @xml.css("item > presentation > response_lid > material >
+        mattext").map { |text| extract_mattext(text) }
+
+      template = get_template()
+
+      placeholders.each do |placeholder|
+        template.sub!("[#{placeholder}]", "{{response}}")
+      end
+
+      template
+    end
+
+    def extract_template_values(template)
+      template.scan(/\[([^\]]+)\]/).map do |capture_list|
+        capture_list.first
+      end
+    end
+
+    def get_template()
+      template_node_list = @xml.css("item > presentation > material > mattext")
+      extract_mattext(template_node_list.first)
+    end
+
+    def add_learnosity_assets(assets, path)
+      learnosity = to_learnosity
+
+      CanvasQtiToLearnosityConverter.add_files_to_assets(
+        assets,
+        path + [:template],
+        learnosity[:template]
+      )
+    end
+  end
+end

data/lib/canvas_qti_to_learnosity_converter/questions/text_only.rb

@@ -0,0 +1,22 @@
+require "canvas_qti_to_learnosity_converter/questions/question"
+
+module CanvasQtiToLearnosityConverter
+  class TextOnlyQuestion < QuizQuestion
+    def to_learnosity
+      {
+        type: "sharedpassage",
+        heading: "",
+        content: extract_stimulus(),
+      }
+    end
+
+    def add_learnosity_assets(assets, path)
+      learnosity = to_learnosity
+      CanvasQtiToLearnosityConverter.add_files_to_assets(
+        assets,
+        path + [:content],
+        learnosity[:content]
+      )
+    end
+  end
+end

data/lib/canvas_qti_to_learnosity_converter/version.rb

@@ -1,3 +1,3 @@
 module CanvasQtiToLearnosityConverter
-  VERSION = "1.0.0"
+  VERSION = "2.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canvas_qti_to_learnosity_converter
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Atomic Jolt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-31 00:00:00.000000000 Z
+date: 2018-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -115,6 +115,17 @@ 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/questions/essay.rb
+- lib/canvas_qti_to_learnosity_converter/questions/file_upload.rb
+- lib/canvas_qti_to_learnosity_converter/questions/fill_the_blanks.rb
+- lib/canvas_qti_to_learnosity_converter/questions/matching.rb
+- lib/canvas_qti_to_learnosity_converter/questions/multiple_choice.rb
+- lib/canvas_qti_to_learnosity_converter/questions/multiple_dropdowns.rb
+- lib/canvas_qti_to_learnosity_converter/questions/numerical.rb
+- lib/canvas_qti_to_learnosity_converter/questions/question.rb
+- lib/canvas_qti_to_learnosity_converter/questions/short_answer.rb
+- lib/canvas_qti_to_learnosity_converter/questions/template_question.rb
+- lib/canvas_qti_to_learnosity_converter/questions/text_only.rb
 - lib/canvas_qti_to_learnosity_converter/version.rb
 homepage: https://github.com/atomicjolt/qti_to_learnosity_converter
 licenses: