atomic_assessments_import 0.2.4 → 0.4.0

data/lib/atomic_assessments_import/exam_soft/extractor/question_type_detector.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module AtomicAssessmentsImport
+  module ExamSoft
+    module Extractor
+      class QuestionTypeDetector
+        TYPE_LABEL_PATTERN = /Type:\s*(.+?)(?=\s*(?:Folder:|Title:|Category:|\d+[.)]|\z))/i
+
+        TYPE_MAP = {
+          /\Amcq?\z/i => "mcq",
+          /\Amultiple\s*choice\z/i => "mcq",
+          /\Ama\z/i => "ma",
+          /\Amultiple\s*(?:select|answer|response)\z/i => "ma",
+          %r{\Atrue[\s/]*false\z}i => "true_false",
+          %r{\At\s*/?\s*f\z}i => "true_false",
+          /\Aessay\z/i => "essay",
+          /\Ae\z/i => "essay",
+          /\Along\s*answer\z/i => "essay",
+          /\Ashort\s*answer\z/i => "short_answer",
+          /\Asa\z/i => "short_answer",
+          /\Afill[\s_-]*in[\s_-]*(?:the[\s_-]*)?blank\z/i => "fill_in_the_blank",
+          /\Afib\z/i => "fill_in_the_blank",
+          /\Af\z/i => "fill_in_the_blank",
+          /\Acloze\z/i => "fill_in_the_blank",
+          /\Amatching\z/i => "matching",
+          /\Aorder(?:ing)?\z/i => "ordering",
+        }.freeze
+
+        def initialize(nodes, has_options:)
+          @nodes = nodes
+          @has_options = has_options
+        end
+
+        def detect
+          full_text = @nodes.map { |n| n.text.strip }.join(" ")
+          match = full_text.match(TYPE_LABEL_PATTERN)
+
+          if match
+            type_text = match[1].strip
+            TYPE_MAP.each do |pattern, type|
+              return type if type_text.match?(pattern)
+            end
+            return type_text.downcase.gsub(/\s+/, "_")
+          end
+
+          @has_options ? "mcq" : "short_answer"
+        end
+      end
+    end
+  end
+end

data/lib/atomic_assessments_import/exam_soft/extractor.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "extractor/question_stem_detector"
+require_relative "extractor/options_detector"
+require_relative "extractor/correct_answer_detector"
+require_relative "extractor/metadata_detector"
+require_relative "extractor/feedback_detector"
+require_relative "extractor/question_type_detector"
+
+module AtomicAssessmentsImport
+  module ExamSoft
+    module Extractor
+      SUPPORTED_TYPES = %w[mcq ma true_false essay short_answer fill_in_the_blank matching ordering].freeze
+      OPTION_TYPES = %w[mcq ma true_false].freeze
+
+      def self.extract(nodes)
+        warnings = []
+
+        # Run detectors
+        options = OptionsDetector.new(nodes).detect
+        has_options = !options.empty?
+
+        metadata = MetadataDetector.new(nodes).detect
+        question_type = QuestionTypeDetector.new(nodes, has_options: has_options).detect
+        stem = QuestionStemDetector.new(nodes).detect
+        feedback = FeedbackDetector.new(nodes).detect
+        correct_answers = has_options ? CorrectAnswerDetector.new(nodes, options).detect : []
+
+        # Determine status
+        status = "published"
+
+        unless SUPPORTED_TYPES.include?(question_type)
+          warnings << "Unsupported question type '#{question_type}'"
+          status = nil
+        end
+
+        if stem.nil?
+          warnings << "No question text found"
+          status = nil
+        end
+
+        if OPTION_TYPES.include?(question_type)
+          if options.empty?
+            warnings << "No options found for #{question_type} question"
+          end
+          if correct_answers.empty?
+            warnings << "No correct answer found"
+            status = nil
+          end
+        end
+
+        # Build row_mock
+        row = {
+          "question id" => nil,
+          "folder" => metadata[:folder],
+          "title" => metadata[:title],
+          "category" => metadata[:categories] || [],
+          "import type" => nil,
+          "description" => nil,
+          "question text" => stem,
+          "question type" => question_type,
+          "stimulus review" => nil,
+          "instructor stimulus" => nil,
+          "correct answer" => correct_answers.join("; "),
+          "scoring type" => nil,
+          "points" => nil,
+          "distractor rationale" => nil,
+          "sample answer" => nil,
+          "acknowledgements" => nil,
+          "general feedback" => feedback,
+          "correct feedback" => nil,
+          "incorrect feedback" => nil,
+          "shuffle options" => nil,
+          "template" => "block layout",
+        }
+
+        # Add option keys
+        options.each_with_index do |opt, index|
+          letter = ("a".ord + index).chr
+          row["option #{letter}"] = opt[:text]
+        end
+
+        # For FITB questions, options ARE the answers (no asterisk marking)
+        if question_type == "fill_in_the_blank" && row["correct answer"].blank? && !options.empty?
+          row["correct answer"] = options.map { |opt| opt[:text] }.join("; ")
+        end
+
+        {
+          row: row,
+          status: status,
+          warnings: warnings,
+        }
+      end
+    end
+  end
+end

data/lib/atomic_assessments_import/exam_soft.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "exam_soft/chunker"
+require_relative "exam_soft/extractor"
+require_relative "exam_soft/converter"
+
+module AtomicAssessmentsImport
+  module ExamSoft
+  end
+end

data/lib/atomic_assessments_import/questions/cloze_dropdown.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "question"
+
+module AtomicAssessmentsImport
+  module Questions
+    class ClozeDropdown < Question
+      CHOICE_OF_PATTERN = /\AChoice of:\s*(.+)/i
+
+      def question_type
+        "clozedropdown"
+      end
+
+      def question_data
+        parsed = parse_dropdown_options
+        super.merge(
+          stimulus: "",
+          template: build_template(parsed.size),
+          possible_responses: parsed.map { |p| p[:choices] },
+          validation: {
+            scoring_type: scoring_type,
+            valid_response: {
+              score: points,
+              value: parsed.map { |p| p[:correct] },
+            },
+          }
+        )
+      end
+
+      private
+
+      def parse_dropdown_options
+        ("a".."o").each_with_object([]) do |letter, acc|
+          option = @row["option #{letter}"]
+          break acc unless option
+
+          m = option.match(CHOICE_OF_PATTERN)
+          next unless m
+
+          parts = m[1].split("|").map(&:strip)
+          correct_index = parts.pop.to_i - 1
+          acc << { choices: parts, correct: parts[correct_index] }
+        end
+      end
+
+      def build_template(blank_count)
+        text = @row["question text"] || ""
+        return text if text.include?("{{response}}")
+
+        if text.match?(/__\d+__/)
+          text.gsub(/__\d+__/, "{{response}}")
+        elsif text.match?(/_____/)
+          text.gsub(/_____/, "{{response}}")
+        elsif text.match?(/\[[A-Za-z0-9]\]/)
+          text.gsub(/\[[A-Za-z0-9]\]/, "{{response}}")
+        else
+          "#{text} #{Array.new(blank_count, "{{response}}").join(" ")}"
+        end
+      end
+    end
+  end
+end

data/lib/atomic_assessments_import/questions/essay.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "question"
+
+module AtomicAssessmentsImport
+  module Questions
+    class Essay < Question
+      def question_type
+        "longtext"
+      end
+
+      def question_data
+        data = super
+        word_limit = @row["word_limit"]&.to_i
+        data[:max_length] = word_limit if word_limit&.positive?
+        data
+      end
+    end
+  end
+end

data/lib/atomic_assessments_import/questions/fill_in_the_blank.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "question"
+
+module AtomicAssessmentsImport
+  module Questions
+    class FillInTheBlank < Question
+      def question_type
+        "clozetext"
+      end
+
+      def question_data
+        answers = (@row["correct answer"] || "").split(";").map(&:strip)
+        super.merge(
+          stimulus: "", # Note: ExamSoft doesn't use a template like Learnosity, so we put the full question text in the template and leave the stimulus blank
+          template: build_stimulus(answers), 
+          validation: {
+            scoring_type: scoring_type,
+            valid_response: {
+              score: points,
+              value: answers
+            },
+          }
+        )
+      end
+
+      private
+
+      def build_stimulus(answers)
+        text = @row["question text"] || ""
+        return text if text.include?("{{response}}")
+
+        # You can indicate the blank(s) in various ways:
+        # Five underscores
+        # Number enclosed by two underscores on each side
+        # Number, uppercase letter, or lowercase letter enclosed by square brackets
+        if text.match?(/__\d+__/)
+          text.gsub(/__\d+__/, "{{response}}")
+        elsif text.match?(/_____/)
+          text.gsub(/_____/, "{{response}}")
+        elsif text.match?(/\[[A-Za-z0-9]\]/)
+          text.gsub(/\[[A-Za-z0-9]\]/, "{{response}}")
+        else
+          "#{text} #{Array.new(answers.size, "{{response}}").join(" ")}"
+        end
+      end
+    end
+  end
+end

data/lib/atomic_assessments_import/questions/matching.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "question"
+
+module AtomicAssessmentsImport
+  module Questions
+    class Matching < Question
+      INDEXES = ("a".."o").to_a.freeze
+
+      def question_type
+        "association"
+      end
+
+      def question_data
+        stimulus_list = []
+        possible_responses = []
+        valid_values = []
+
+        INDEXES.each do |letter|
+          option = @row["option #{letter}"]
+          match_val = @row["match #{letter}"]
+          break unless option
+
+          stimulus_list << option
+          possible_responses << match_val if match_val
+          valid_values << match_val if match_val
+        end
+
+        super.merge(
+          stimulus_list: stimulus_list,
+          possible_responses: possible_responses,
+          validation: {
+            valid_response: {
+              score: points,
+              value: valid_values,
+            },
+          }
+        )
+      end
+    end
+  end
+end

data/lib/atomic_assessments_import/questions/multiple_choice.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "question"
+
+module AtomicAssessmentsImport
+  module Questions
+    class MultipleChoice < Question
+      QUESTION_INDEXES = ("a".."o").to_a.freeze
+
+      def question_type
+        "mcq"
+      end
+
+      def question_data
+        raise "Missing correct answer" if correct_responses.empty?
+        raise "Missing options" if options.empty?
+
+        super.deep_merge(
+          {
+            multiple_responses: multiple_responses,
+            options: options,
+            validation: {
+              scoring_type: scoring_type,
+              valid_response: {
+                score: points,
+                value: correct_responses,
+              },
+              rounding: "none",
+              penalty: 1,
+            },
+            shuffle_options: Utils.parse_boolean(@row["shuffle options"], default: false),
+            ui_style: ui_style,
+          }
+        )
+      end
+
+      def metadata
+        super.merge(
+          {
+            distractor_rationale_response_level: distractor_rationale_response_level,
+          }
+        )
+      end
+
+      def options
+        QUESTION_INDEXES.filter_map.with_index do |value, cnt|
+          key = "option #{value}"
+          if @row[key].present?
+            {
+              label: @row[key],
+              value: cnt.to_s,
+            }
+          end
+        end
+      end
+
+      def correct_responses
+        correct = @row["correct answer"]&.split(";")&.map(&:strip)&.map(&:downcase) || []
+
+        correct.filter_map do |value|
+          QUESTION_INDEXES.find_index(value).to_s
+        end
+      end
+
+      def distractor_rationale_response_level
+        QUESTION_INDEXES.map do |value|
+          key = "option #{value} feedback"
+          @row[key].presence || ""
+        end.reverse.drop_while(&:blank?).reverse
+      end
+
+      def multiple_responses
+        case @row["template"]&.downcase
+        when "multiple response", "block layout multiple response", "choice matrix",
+          "choice matrix inline", "choice matrix labels"
+          true
+        else
+          false
+        end
+      end
+
+      def ui_style
+        case @row["template"]&.downcase
+        when "multiple response"
+          { type: "horizontal" }
+        when "block layout", "block layout multiple response"
+          { choice_label: "upper-alpha", type: "block" }
+        when "choice matrix"
+          { horizontal_lines: false, type: "table" }
+        when "choice matrix inline"
+          { horizontal_lines: false, type: "inline" }
+        when "choice matrix labels"
+          { stem_numeration: "upper-alpha", horizontal_lines: false, type: "table" }
+        when nil, "", "multiple choice", "standard"
+          { type: "horizontal" }
+        else
+          raise "Unknown template: #{@row['template']}"
+        end
+      end
+    end
+  end
+end

data/lib/atomic_assessments_import/questions/ordering.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "question"
+
+module AtomicAssessmentsImport
+  module Questions
+    class Ordering < Question
+      INDEXES = ("a".."o").to_a.freeze
+
+      def question_type
+        "orderlist"
+      end
+
+      ORDER_MARKER = /\s*---\s*(\d+)\s*\z/
+
+      def question_data
+        raw_items = INDEXES.filter_map { |letter| @row["option #{letter}"] }
+
+        if raw_items.any? { |item| item.match?(ORDER_MARKER) }
+          list, valid_values = parse_order_markers(raw_items)
+        else
+          list = raw_items
+          order = (@row["correct answer"] || "").split(";").map(&:strip).map(&:downcase)
+          valid_values = order.filter_map { |letter| INDEXES.find_index(letter) }
+        end
+
+        super.merge(
+          list: list,
+          validation: {
+            scoring_type: scoring_type,
+            valid_response: {
+              score: points,
+              value: valid_values,
+            },
+          }
+        )
+      end
+
+      private
+
+      def parse_order_markers(raw_items)
+        items_with_rank = raw_items.map.with_index do |item, idx|
+          m = item.match(ORDER_MARKER)
+          { text: item.sub(ORDER_MARKER, "").strip, rank: m ? m[1].to_i : idx + 1, original_index: idx }
+        end
+        list = items_with_rank.map { |i| i[:text] }
+        sorted = items_with_rank.sort_by { |i| i[:rank] }
+        valid_values = sorted.map { |i| i[:original_index] }
+        [list, valid_values]
+      end
+    end
+  end
+end

data/lib/atomic_assessments_import/questions/question.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module AtomicAssessmentsImport
+  module Questions
+    class Question
+      def initialize(row)
+        @row = row
+        @reference = SecureRandom.uuid
+      end
+
+      def self.load(row)
+        case row["question type"]
+        when nil, "", /multiple choice/i, /mcq/i, /^ma$/i
+          MultipleChoice.new(row)
+        when /true_false/i, %r{true/false}i
+          MultipleChoice.new(row)
+        when /essay/i, /longanswer/i
+          Essay.new(row)
+        when /short_answer/i, /shorttext/i
+          ShortAnswer.new(row)
+        when /fill_in_the_blank/i, /cloze/i
+          if row["option a"]&.match?(/\AChoice of:/i)
+            ClozeDropdown.new(row)
+          else
+            FillInTheBlank.new(row)
+          end
+        when /matching/i, /association/i
+          Matching.new(row)
+        when /ordering/i, /orderlist/i
+          Ordering.new(row)
+        else
+          raise "Unknown question type #{row['question type']}"
+        end
+      end
+
+      attr_reader :reference
+
+      def question_type
+        raise NotImplementedError
+      end
+
+      def question_data
+        {
+          stimulus: @row["question text"],
+          type: question_type,
+          metadata: metadata,
+          **{
+            stimulus_review: @row["stimulus review"],
+            instructor_stimulus: @row["instructor stimulus"],
+          }.compact,
+        }
+      end
+
+      def metadata
+        {
+          distractor_rationale: @row["distractor rationale"],
+          sample_answer: @row["sample answer"],
+          acknowledgements: @row["acknowledgements"],
+          general_feedback: @row["general feedback"],
+          correct_feedback: @row["correct feedback"],
+          partially_correct_feedback: @row["partially correct feedback"],
+          incorrect_feedback: @row["incorrect feedback"],
+        }.compact
+      end
+
+      def scoring_type
+        case @row["scoring type"]
+        when nil, "", /Partial Match Per Response/i
+          "partialMatchV2"
+        when /Partial Match/i
+          "partialMatch"
+        when /Exact Match/i
+          "exactMatch"
+        else
+          raise "Unknown scoring type #{@row['scoring type']}"
+        end
+      end
+
+      def points
+        if @row["points"].blank?
+          1
+        else
+          Float(@row["points"])
+        end
+      rescue ArgumentError
+        1
+      end
+
+      def to_learnosity
+        {
+          type: question_type,
+          widget_type: "response",
+          reference: @reference,
+          data: question_data,
+        }
+      end
+    end
+  end
+end
+
+require_relative "essay"
+require_relative "short_answer"
+require_relative "fill_in_the_blank"
+require_relative "cloze_dropdown"
+require_relative "matching"
+require_relative "ordering"

data/lib/atomic_assessments_import/questions/short_answer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "question"
+
+module AtomicAssessmentsImport
+  module Questions
+    class ShortAnswer < Question
+      def question_type
+        "shorttext"
+      end
+
+      def question_data
+        super.merge(
+          validation: {
+            valid_response: {
+              score: points,
+              value: @row["correct answer"] || "",
+            },
+          }
+        )
+      end
+    end
+  end
+end

data/lib/atomic_assessments_import/utils.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/digest/uuid"
+
+require_relative "questions/question"
+require_relative "questions/multiple_choice"
+
+module AtomicAssessmentsImport
+  module Utils
+    def self.parse_boolean(value, default:)
+      case value&.downcase
+      when "true", "yes", "y", "1"
+        true
+      when "false", "no", "n", "0"
+        false
+      else
+        default
+      end
+    end
+  end
+end

data/lib/atomic_assessments_import/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AtomicAssessmentsImport
-  VERSION = "0.2.4"
+  VERSION = "0.4.0"
 end

data/lib/atomic_assessments_import/writer.rb

@@ -9,7 +9,7 @@ module AtomicAssessmentsImport
     end
 
     def open
-      @zip = Zip::File.open(@path, Zip::File::CREATE)
+      @zip = Zip::File.open(@path, create: true)
       yield self
     ensure
       @zip.close