word_2_quiz 1.0.0

data/.ruby-gemset

@@ -0,0 +1 @@
+word2quiz

data/.ruby-version

@@ -0,0 +1 @@
+2.1.9

data/.travis.yml

@@ -0,0 +1,20 @@
+---
+language: ruby
+cache: bundler
+
+rvm:
+  - 2.1.9
+  - 2.2.2
+  - 2.3.3
+
+before_install:
+  - gem update bundler
+
+install:
+  - bundle install --path vendor/bundle
+
+branches:
+  only:
+  - master
+
+script: bundle exec rake

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in word_2_quiz.gemspec
+gemspec

data/README.md

@@ -0,0 +1,49 @@
+# Word2Quiz
+
+Converts word document quizzes to a Word2Quiz::Quiz, which can be converted to a hash or to an Instructure canvas hash format.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'word_2_quiz'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install word_2_quiz
+
+## Usage
+
+Expects a docx quiz where every question is on a new line started with a number
+followed by a period, and every answer is below each question. Every answer is
+on a new line, and begins with a letter followed by a period. The title is
+assumed to be on lines 3 & 4, and the description is generated from lines 0-5 of
+the quiz.
+
+The answer key should be in a doc file, where each solution consists of a
+number and an answer - e.g `1. C  2.B`
+
+To get the parse the quiz, run
+  `quiz = Word2Quiz.parse_quiz("path/to/quiz.docx", "path/to/solutions.doc")`
+
+To get the quiz as a hash, run `quiz.to_h`
+
+To get the quiz for creating on canvas run `quiz.to_canvas`
+
+To get the quiz questions for creating on canvas run `quiz.questions_as_canvas`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/word_2_quiz.

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/setup"
+require "rspec"
+
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+end
+
+Bundler::GemHelper.install_tasks
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "word_2_quiz"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/convert_quiz

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+LIB_DIR = File.join(__dir__, "..", "lib")
+$LOAD_PATH << LIB_DIR
+require "bundler/setup"
+require "word_2_quiz/quiz_parser"
+require "word_2_quiz/quiz_solutions_parser"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+#Switch this out with parse solutions
+#Word2Quiz.parse_quiz(ARGV[0])
+Word2Quiz.parse_quiz(ARGV[0], ARGV[1])

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/word_2_quiz.rb

@@ -0,0 +1,5 @@
+require "word_2_quiz/version"
+require "word_2_quiz/quiz_parser"
+
+module Word2Quiz
+end

data/lib/word_2_quiz/answer.rb

@@ -0,0 +1,52 @@
+require "word_2_quiz/helpers"
+
+module Word2Quiz
+  ##
+  # Answer contains all data for a single answer. An answer has text and whether
+  # it is correct.
+  ##
+  class Answer
+    attr_accessor :text, :correct
+
+    # index of the very first answer paragraph
+    ANSWER_START = 0
+
+    # Canvas expects a weight greather than zero for correct, 0 for incorrect.
+    CORRECT_WEIGHT = 100
+    INCORRECT_WEIGHT = 0
+
+    def initialize(text = "", correct = false)
+      @text = text
+      @correct = correct
+    end
+
+    ##
+    # Expects an array of paragraphs that are a single answer, and
+    # The correct answer for that question, e.g. answer="a"
+    ##
+    def self.from_paragraphs(paragraphs, solution)
+      non_empty_paragraphs = Helpers.strip_blanks(paragraphs)
+      text = non_empty_paragraphs.map(&:to_html).join("\n")
+      start_paragraph = non_empty_paragraphs[ANSWER_START]
+      is_correct = start_paragraph.text.downcase.start_with?(solution.downcase)
+
+      Answer.new(text, is_correct)
+    end
+
+    def to_h
+      {
+        text: @text,
+        correct: @correct,
+      }
+    end
+
+    # Canvas has an undocumented answer_html field for answers that we have to
+    # use because we are sending html, not plain text.
+    def to_canvas
+      {
+        answer_html: @text,
+        answer_weight: @correct ? CORRECT_WEIGHT : INCORRECT_WEIGHT,
+      }
+    end
+  end
+end

data/lib/word_2_quiz/helpers.rb

@@ -0,0 +1,104 @@
+require "numbers_in_words"
+module Word2Quiz
+  module Helpers
+    TIME_TO_MINUTES_MAP = {
+      "hours" => 60,
+      "minutes" => 1,
+    }.freeze
+
+    # indexes of paragraphs where title and description start and end
+    TITLE_START = 3
+    TITLE_END = 4
+    DESCRIPTION_START = 0
+    DESCRIPTION_END = 5
+    QUESTION_START = 0
+
+    ##
+    # Takes in an array of indexes, and returns out an array of arrays of
+    # paragraphs bounded by the indexes, e.g. if indexes is [2, 5] then it
+    # returns:
+    # [paragraphs[0...2], paragraphs[2...5], paragraphs[5...paragraphs.count]]
+    ##
+    def self.map_to_boundaries(indexes:, paragraphs:)
+      indexes.map.with_index do |start_index, i|
+        first_index = start_index
+        last_index = indexes[i + 1] || paragraphs.count
+
+        paragraphs[first_index...last_index]
+      end
+    end
+
+    def self.get_quiz_duration(paragraphs)
+      time_paragraph = paragraphs.find do |p|
+        p.text.include?("one session not to exceed ")
+      end
+
+      time = time_paragraph.text.sub(
+        "This examination consists of one session not to exceed ",
+        "",
+      ).chomp(".")
+
+      time_number = time.split(" ").first
+      time_unit = time.split(" ").last
+      unit_conversion = TIME_TO_MINUTES_MAP[time_unit]
+
+      NumbersInWords.in_numbers(time_number) * unit_conversion
+    end
+
+    ##
+    # Returns the quiz title. The 3rd and 4th lines contain the best title for
+    # the quiz.
+    ##
+    def self.get_quiz_title(paragraphs)
+      paragraphs[TITLE_START..TITLE_END].map(&:text).join(" ")
+    end
+
+    ##
+    # Returns the quiz description. Lines 0-5 are the best description for the
+    # quiz.
+    ##
+    def self.get_quiz_description(paragraphs)
+      paragraphs[DESCRIPTION_START..DESCRIPTION_END].map(&:to_html).join("\n")
+    end
+
+    ##
+    # Returns the question number
+    #
+    ##
+    def self.get_question_number(paragraphs)
+      match = paragraphs[QUESTION_START].text.match(/^(\d+)\./)
+      match ? match.captures.first : nil
+    end
+
+    ##
+    # Finds the index of the paragraph where the questions start
+    ##
+    def self.get_question_start_index(paragraphs)
+      paragraphs.find_index { |p| p.text.include?("Multiple Choice") }
+    end
+
+    ##
+    # Finds the index of the paragraph where the questions end
+    ##
+    def self.get_question_end_index(paragraphs)
+      paragraphs.find_index { |p| p.text.include?("End of examination") }
+    end
+
+    ##
+    # Returns the indexes of the start of each question.
+    ##
+    def self.get_question_indexes(paragraphs)
+      paragraphs.each_index.select { |i| paragraphs[i].text.match(/^\d*\./) }
+    end
+
+    ##
+    # Returns an array of paragraphs with leading and trailing blank paragraphs
+    # removed.
+    ##
+    def self.strip_blanks(paragraphs)
+      t = paragraphs.drop_while { |p| p.text.chomp.empty? }
+      t.pop while t.last.text.chomp.empty?
+      t
+    end
+  end
+end

data/lib/word_2_quiz/question.rb

@@ -0,0 +1,65 @@
+require "word_2_quiz/helpers"
+
+module Word2Quiz
+  ##
+  # Question contains all data for a single question. A question has text, and
+  # answers.
+  ##
+  class Question
+    attr_accessor :text, :answers
+
+    POINTS_POSSIBLE = 5
+
+    def initialize(text = "", answers = [])
+      @answers = answers
+      @text = text
+    end
+
+    ##
+    # Creates a question from an array of strings
+    # paragraphs: an array of nokogiri nodes containing each line for the
+    # question text and answers
+    # solution: a string containing which answer(a,b,c,d) is correct
+    ##
+    def self.from_paragraphs(paragraphs, solution)
+      answers = []
+
+      answer_start_indexes = paragraphs.each_index.select do |i|
+        # an answer starts with a letter then a dot
+        paragraphs[i].text.match(/^[a-z]\./)
+      end
+
+      all_answer_paragraphs = Helpers.map_to_boundaries(
+        indexes: answer_start_indexes,
+        paragraphs: paragraphs,
+      )
+
+      question_paragraphs = paragraphs.take(answer_start_indexes.first)
+      question_paragraphs = Helpers.strip_blanks(question_paragraphs)
+      question_text = question_paragraphs.map(&:to_html).join("\n")
+
+      all_answer_paragraphs.each do |answer_paragraphs|
+        answer = Answer.from_paragraphs(answer_paragraphs, solution)
+        answers.push(answer)
+      end
+
+      Question.new(question_text, answers)
+    end
+
+    def to_h
+      {
+        text: @text,
+        answers: @answers.map(&:to_h),
+      }
+    end
+
+    def to_canvas
+      {
+        question_type: "multiple_choice_question",
+        question_text: @text,
+        points_possible: POINTS_POSSIBLE,
+        answers: @answers.map(&:to_canvas),
+      }
+    end
+  end
+end

data/lib/word_2_quiz/quiz.rb

@@ -0,0 +1,86 @@
+require "word_2_quiz/question"
+require "word_2_quiz/answer"
+require "word_2_quiz/helpers"
+
+module Word2Quiz
+  ##
+  # Quiz contains all quiz data. A quiz has a description,
+  # a title, a time limit, and questions.
+  ##
+  class Quiz
+    attr_accessor :questions, :description, :title, :time_limit
+
+    ALLOWED_ATTEMPTS = 1
+
+    def initialize(title:, time_limit:, description: "")
+      @questions = []
+      @description = description
+      @title = title
+      @time_limit = time_limit
+    end
+
+    def self.from_paragraphs(paragraphs, answers)
+      all_question_paragraphs = Quiz.get_question_paragraphs(paragraphs)
+
+      quiz_title = Helpers.get_quiz_title(paragraphs)
+      quiz_description = Helpers.get_quiz_description(paragraphs)
+
+      quiz_duration = Helpers.get_quiz_duration(paragraphs)
+
+      quiz = Quiz.new(
+        title: quiz_title,
+        time_limit: quiz_duration,
+        description: quiz_description,
+      )
+
+      all_question_paragraphs.each do |question_paragraphs|
+        question_number = Helpers.get_question_number(question_paragraphs)
+        question = Question.from_paragraphs(
+          question_paragraphs,
+          answers[question_number],
+        )
+
+        quiz.questions.push(question)
+      end
+      quiz
+    end
+
+    def self.get_question_paragraphs(paragraphs)
+      question_start_index = Helpers.get_question_start_index(paragraphs)
+      question_end_index = Helpers.get_question_end_index(paragraphs)
+
+      question_range = paragraphs[question_start_index...question_end_index]
+
+      question_indexes = Helpers.get_question_indexes(question_range)
+
+      Helpers.map_to_boundaries(
+        indexes: question_indexes,
+        paragraphs: question_range,
+      )
+    end
+
+    def to_h
+      {
+        title: @title,
+        questions: @questions.map(&:to_h),
+        description: @description,
+        time_limit: @time_limit,
+      }
+    end
+
+    def to_canvas
+      {
+        title: @title,
+        question_count: @questions.count,
+        quiz_type: "assignment",
+        description: @description,
+        allowed_attempts: ALLOWED_ATTEMPTS,
+        time_limit: @time_limit,
+      }
+    end
+
+    def questions_as_canvas
+      @questions.map(&:to_canvas)
+    end
+  end
+end