RubyGems - ruqlcqb - Versions diffs - 0.0.0 - Mend

ruqlcqb 0.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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