RubyGems - ruqlcqb - Versions diffs - 0.0.0 - Mend

ruqlcqb 0.0.0

Files changed (23) hide show

checksums.yaml +7 -0
data/bin/ruqlcqb +95 -0
data/lib/ruql.rb +23 -0
data/lib/ruql/answer.rb +28 -0
data/lib/ruql/fill_in.rb +15 -0
data/lib/ruql/multiple_choice.rb +11 -0
data/lib/ruql/question.rb +73 -0
data/lib/ruql/quiz.rb +105 -0
data/lib/ruql/renderer.rb +20 -0
data/lib/ruql/renderers/auto_qcm_renderer.rb +85 -0
data/lib/ruql/renderers/edxml_renderer.rb +74 -0
data/lib/ruql/renderers/html5_renderer.rb +166 -0
data/lib/ruql/renderers/html_form_renderer.rb +198 -0
data/lib/ruql/renderers/json_renderer.rb +15 -0
data/lib/ruql/renderers/qualtrics_renderer.rb +63 -0
data/lib/ruql/renderers/xml_renderer.rb +148 -0
data/lib/ruql/select_multiple.rb +7 -0
data/lib/ruql/tex_output.rb +27 -0
data/lib/ruql/true_false.rb +17 -0
data/templates/autoqcm.tex.erb +1 -0
data/templates/html5.html.erb +42 -0
data/templates/htmlform.html.erb +44 -0
metadata +94 -0

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d81b97a766f2c8045e559d68b15f609fa8ba1c1
+  data.tar.gz: 243f8d96f129e17672957bdda0895a83f641d046
+SHA512:
+  metadata.gz: 9f62bd2e0b3c1f1cff9e89850ada70ef0e5dff7397ee0c5db2d6f995e5da6b205018807834f51a0aa20e288f14389d1f4877895d960acda559d4a6e99483ebc7
+  data.tar.gz: 0c88b4a37c4aaa43c7f3a0eb7961e1e757f06dd7a83a8958eff8504cef2246f61b268d8ae3119a9301f9476706be28266837ba7647e03209013d5ecc94ed9e60

data/bin/ruqlcqb ADDED Viewed

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+require 'ruql'
+require 'getopt/long'
+def usage
+  name = File.basename $0
+  STDERR.puts <<eos
+Usage: #{name} filename.rb renderer [options]
+filename.rb contains questions expressed in RuQL
+renderer choices are:
+  Html5    - HTML 5 suitable for Web display/printing
+  HtmlForm - HTML forms
+  EdXml    - XML for OpenEdX platform in-course questions
+  AutoQCM  - LaTeX for use with AutoQCM (http://home.gna.org/auto-qcm)
+  Coursera - [obsolete] Coursera HTML/XML format for online auto-grading
+  JSON     - [partially implemented] JSON format
+  Qualtrics -[partially implemented] Qualtrics survey (txt) format
+Global options:
+  -l <loglevel>, --log=<loglevel>
+     In increasing verbosity, they are 'error' (nonfatal), 'warn', 'info',
+     'debug'; default is 'warn'
+  -p <penalty>, --penalty <penalty>
+     The penalty for WRONG answers, as a fraction of the penalty for
+     RIGHT answers.  For a 2-point question, penalty=0.25 means 1/2 point
+     (0.25 * 2) deducted for WRONG answer.  Default is 0.  Not all
+     output formats are able to do something useful with this.
+The EdXML renderer supports these options:
+  -n <name>, --name=<name>
+      Only render the question(s) that have :name => 'name'.
+  NOTE: Some markup that is legal in RuQL questions will break the EdX parser.
+     Manually check your questions as you enter them into EdX.  Code seems to
+     be particularly troublesome.
+  NOTE: The 'points' and 'randomize' attributes of questions are not honored by
+     some systems.
+The HTML5 and HTML Forms renderers supports these options:
+  -c <href>, --css=<href>
+      embed <href> for stylesheet into generated HTML5
+  -j <src>, --js=<src>
+      embed <src> for JavaScrips
+  -t <file.html.erb>, --template=<file.html.erb>
+      Use file.html.erb as HTML template rather than generating our own file.
+      file.html.erb should have <%= yield %> where questions should go.
+      An example is in the templates/ directory of RuQL.
+      The following local variables will be replaced with their values in
+      the template:
+        <%= quiz.title %> - the quiz title
+        <%= quiz.num_questions %> - total number of questions
+        <%= quiz.points %> - total number of points for whole quiz
+  -s, --solutions
+      generate solutions (showing correct answers and explanations)
+  NOTE: If there is more than one quiz (collection of questions) in the file,
+      a complete <html>...</html> block is produced in the output for EACH quiz.
+The AutoQCM renderer supports these options:
+  -t <file.tex.erb>, --template=<file.tex.erb>
+      MANDATORY: Use file.tex.erb as LaTeX/AutoQCM template.
+      The file should have <%= yield %> where questions should go.
+      See the description of template under HTML5 renderer for variable
+      substitutions that can occur in the quiz body.
+The JSON renderer currently supports no options
+The Qualtrics renderer supports these options:
+  -t <file.txt.erb>, --template=<file.txt.erb>
+  The file should have <%= yield %> where questions should go. Since this just creates survey questions, grading information is ignored.Currently supports the same type of questions as the AutoQCM renderer.
+eos
+  exit
+end
+def main
+  filename = ARGV.shift
+  raise "Cannot read #{filename}" unless File.readable? filename
+  renderer = ARGV.shift
+  raise "Unknown renderer '#{renderer}'" unless Quiz.get_renderer(renderer)
+  opts = Getopt::Long.getopts(
+    ['-c', '--css', Getopt::REQUIRED],
+    ['-j', '--js', Getopt::REQUIRED],
+    ['-t', '--template', Getopt::REQUIRED],
+    ['-s', '--solutions', Getopt::BOOLEAN],
+    ['-n', '--name', Getopt::REQUIRED],
+    ['-l', '--log', Getopt::REQUIRED],
+    )
+  Quiz.instance_eval "#{IO.read(filename)}"
+  Quiz.quizzes.each { |quiz| puts quiz.render_with(renderer, opts)  }
+end
+usage if ARGV.length < 2
+main

data/lib/ruql.rb ADDED Viewed

@@ -0,0 +1,23 @@
+# basic gems/libs we rely on
+require 'builder'
+require 'logger'
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__)))
+# renderers
+require 'ruql/renderers/xml_renderer'
+require 'ruql/renderers/html5_renderer'
+require 'ruql/renderers/html_form_renderer'
+require 'ruql/renderers/edxml_renderer'
+require 'ruql/renderers/auto_qcm_renderer'
+require 'ruql/renderers/json_renderer'
+require 'ruql/renderers/qualtrics_renderer'
+# question types
+require 'ruql/quiz'
+require 'ruql/question'
+require 'ruql/answer'
+require 'ruql/multiple_choice'
+require 'ruql/select_multiple'
+require 'ruql/true_false'
+require 'ruql/fill_in'

data/lib/ruql/answer.rb ADDED Viewed

@@ -0,0 +1,28 @@
+class Answer
+  include Comparable
+  attr_accessor :answer_text, :explanation, :correct
+  attr_reader :correct
+  attr_reader :builder
+  attr_reader :question
+  def <=>(other) ; self.answer_text <=> other.answer_text ; end
+  def correct? ; !!correct ; end
+  def has_explanation? ; !!explanation ; end
+  def initialize(answer_text = '', correct = false, explanation=nil)
+    @answer_text = answer_text
+    @correct = !!correct # ensure boolean
+    @explanation = explanation
+  end
+  def to_JSON
+    Hash[instance_variables.collect { |var| [var.to_s.delete('@'), instance_variable_get(var)] }]
+  end
+  def self.from_JSON(hash)
+    answer = Answer.new
+    hash.each do |key, value|
+      answer.send((key + '=').to_sym, value)
+    end
+    answer
+  end
+end

data/lib/ruql/fill_in.rb ADDED Viewed

@@ -0,0 +1,15 @@
+class FillIn < Question
+    attr_accessor :order
+    attr_accessor :case_sensitive
+  def initialize(text='', opts={})
+    super
+    self.question_text = text
+    self.order =  !!opts[:order]
+    self.case_sensitive = !!opts[:case_sensitive]
+  end
+  def multiple ; false ; end
+end

data/lib/ruql/multiple_choice.rb ADDED Viewed

@@ -0,0 +1,11 @@
+class MultipleChoice < Question
+  attr_accessor :multiple
+  def initialize(text='', opts={})
+    super
+    self.question_text = text
+    self.multiple =  !!opts[:multiple]
+    self.randomize = !!opts[:randomize]
+  end
+end

data/lib/ruql/question.rb ADDED Viewed

@@ -0,0 +1,73 @@
+class Question
+  attr_accessor :question_text, :answers, :randomize, :points, :name, :question_tags, :question_comment, :raw
+  def initialize(*args)
+    options = if args[-1].kind_of?(Hash) then args[-1] else {} end
+    @answers = options[:answers] || []
+    @points = [options[:points].to_i, 1].max
+    @raw = options[:raw]
+    @name = options[:name]
+    @question_tags = []
+    @question_comment = ''
+  end
+  def raw? ; !!@raw ; end
+  def text(s) ; @question_text = s ; end
+  def explanation(text)
+    @answers.each { |answer| answer.explanation ||= text }
+  end
+  def answer(text, opts={})
+    @answers << Answer.new(text, correct=true, opts[:explanation])
+  end
+  def distractor(text, opts={})
+    @answers << Answer.new(text, correct=false, opts[:explanation])
+  end
+  # these are ignored but legal for now:
+  def tags(*args) # string or array of strings
+    if args.length > 1
+      @question_tags += args.map(&:to_s)
+    else
+      @question_tags << args.first.to_s
+    end
+  end
+  def comment(str = '')
+    @question_comment = str.to_s
+  end
+  def correct_answer ;  @answers.detect(&:correct?)  ;  end
+  def correct_answers ;  @answers.collect(&:correct?) ; end
+  def answer_helper(obj)
+    if obj.is_a? Array and obj.size and obj[0].is_a? Answer
+      return obj.map {|answer| answer.to_JSON}
+    end
+    obj
+  end
+  #creates a JSON hash of the object with its object name. we should convert this to a mixin for answer and question. aaron
+  def to_JSON
+      h = Hash[instance_variables.collect { |var| [var.to_s.delete('@'), answer_helper(instance_variable_get(var))] }]
+      h['question_type'] = self.class.to_s
+      return h
+  end
+  #factory method to return correct type of question
+  def self.from_JSON(hash_str)
+    hash = JSON.parse(hash_str)
+    #create the appropriate class of the object from the hash's class name
+    question = Object.const_get(hash.fetch('question_type')).new()
+    hash.reject{|key| key == 'answers' or key == 'question_type'}.each do |key, value|
+      question.send((key + '=').to_sym, value)
+    end
+    question.answers = hash['answers'].map{|answer_hash| Answer.from_JSON(answer_hash)}
+    question
+  end
+end

data/lib/ruql/quiz.rb ADDED Viewed

@@ -0,0 +1,105 @@
+class Quiz
+  @@quizzes = []
+  def self.quizzes ; @@quizzes ;  end
+  @@default_options =
+    {
+    :open_time => Time.now,
+    :soft_close_time => Time.now + 24*60*60,
+    :hard_close_time => Time.now + 24*60*60,
+    :maximum_submissions => 1,
+    :duration => 3600,
+    :retry_delay => 600,
+    :parameters =>  {
+      :show_explanations => {
+        :question => 'before_soft_close_time',
+        :option => 'before_soft_close_time',
+        :score => 'before_soft_close_time',
+      }
+    },
+    :maximum_score => 1,
+  }
+  attr_reader :renderer
+  attr_reader :questions
+  attr_reader :options
+  attr_reader :output
+  attr_reader :seed
+  attr_reader :logger
+  attr_accessor :title
+  def initialize(title, options={})
+    @output = ''
+    @questions = options[:questions] || []
+    @title = title
+    @options = @@default_options.merge(options)
+    @seed = srand
+    @logger = Logger.new(STDERR)
+    @logger.level = Logger.const_get (options.delete('l') ||
+      options.delete('log') || 'warn').upcase
+  end
+  def self.get_renderer(renderer)
+    Object.const_get(renderer.to_s + 'Renderer') rescue nil
+  end
+  def render_with(renderer,options={})
+    srand @seed
+    @renderer = Quiz.get_renderer(renderer).send(:new,self,options)
+    @renderer.render_quiz
+    @output = @renderer.output
+  end
+  def points ; questions.map(&:points).inject { |sum,points| sum + points } ; end
+  def num_questions ; questions.length ; end
+  def random_seed(num)
+    @seed = num.to_i
+  end
+  # this should really be done using mixins.
+  def choice_answer(*args, &block)
+    if args.first.is_a?(Hash) # no question text
+      q = MultipleChoice.new('',*args)
+    else
+      text = args.shift
+      q = MultipleChoice.new(text, *args)
+    end
+    q.instance_eval(&block)
+    @questions << q
+  end
+  def select_multiple(*args, &block)
+    if args.first.is_a?(Hash) # no question text
+      q = SelectMultiple.new('',*args)
+    else
+      text = args.shift
+      q = SelectMultiple.new(text, *args)
+    end
+    q.instance_eval(&block)
+    @questions << q
+  end
+  def truefalse(*args)
+    q = TrueFalse.new(*args)
+    @questions << q
+  end
+  def fill_in(*args, &block)
+    if args.first.is_a?(Hash) # no question text
+      q = FillIn.new('', *args)
+    else
+      text = args.shift
+      q = FillIn.new(text, *args)
+    end
+    q.instance_eval(&block)
+    @questions << q
+  end
+  def self.quiz(*args,&block)
+    quiz = Quiz.new(*args)
+    quiz.instance_eval(&block)
+    @@quizzes << quiz
+  end
+end

data/lib/ruql/renderer.rb ADDED Viewed

@@ -0,0 +1,20 @@
+class Renderer
+  attr_reader :quiz
+  def initialize(quiz)
+    @quiz = quiz
+  end
+  @@render_handlers = {}
+  def self.render(thing, &block)
+    @@render_handlers[thing.to_sym] = block
+  end
+  def self.renderer_for(thing)
+    @@render_handlers[thing.to_sym]
+  end
+  def render_quiz!
+    self.instance_eval@@render_handlers[:quiz].call(self.quiz)
+  end
+end

data/lib/ruql/renderers/auto_qcm_renderer.rb ADDED Viewed

@@ -0,0 +1,85 @@
+require 'erb'
+require 'ruql/tex_output'
+class AutoQCMRenderer
+  include TexOutput
+  attr_reader :output
+  def initialize(quiz, options={})
+    @output = ''
+    @quiz = quiz
+    @template = options.delete('t') ||
+      options.delete('template') ||
+      File.join(Gem.loaded_specs['ruql'].full_gem_path, 'templates/autoqcm.tex.erb')
+    @penalty = (options.delete('p') || options.delete('penalty') || '0').to_f
+    @show_solutions = options.delete('s') || options.delete('solutions')
+  end
+  def render_quiz
+    quiz = @quiz                # make quiz object available in template's scope
+    with_erb_template(IO.read(File.expand_path @template)) do
+      output = ''
+      render_random_seed
+      @quiz.questions.each_with_index do |q,i|
+        next_question = render_question q,i
+        output << next_question
+      end
+      output
+    end
+  end
+  def with_erb_template(template)
+    # template will 'yield' back to render_quiz to render the questions
+    @output = ERB.new(template).result(binding)
+  end
+  def render_question(q,index)
+    case q
+    when SelectMultiple,TrueFalse then render(q, index, 'mult') # These are subclasses of MultipleChoice, should go first
+    when MultipleChoice then render(q, index)
+    else
+      @quiz.logger.error "Question #{index} (#{q.question_text[0,15]}...): AutoQCM can only handle multiple_choice, truefalse, or select_multiple questions"
+      ''
+    end
+  end
+  def render_random_seed
+    seed = @quiz.seed
+    @output << "\n%% Random seed: #{seed}\n"
+    @output << "\\AMCrandomseed{#{seed}}\n\n"
+  end
+  def render(question, index, type='')
+    output = ''
+    output << "\\begin{question#{type}}{q#{index}}\n"
+    output << "  \\scoring{b=#{question.points},m=#{@penalty*question.points}}\n"
+    if type == 'mult'
+      question.question_text = "Select ALL that apply. " + question.question_text
+    elsif type == ''
+      question.question_text = "Choose ONE answer. " + question.question_text
+    end
+    output << "  " << to_tex(question.question_text) << "\n"
+    # answers - ignore randomization
+    output << "  \\begin{choices}\n"
+    question.answers.each do |answer|
+      answer_text = to_tex(answer.answer_text)
+      answer_type = if answer.correct? then 'correct' else 'wrong' end
+      output << "    \\#{answer_type}choice{#{answer_text}}\n"
+      if @show_solutions and answer.explanation
+        explanation = to_tex(answer.explanation)
+        if answer_type == 'wrong'
+          output << "{\\color{red}\\tab #{explanation}}"
+        else
+          output << "{\\color[rgb]{0,.5,0}\\tab #{explanation}}"
+        end
+      end
+    end
+    output << "  \\end{choices}\n"
+    output << "\\end{question#{type}}\n\n"
+    output
+  end
+end