RubyGems - ruql - Versions diffs - 0.0.2 - Mend

ruql 0.0.2

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 (19) hide show

data/bin/ruql +86 -0
data/lib/ruql/answer.rb +16 -0
data/lib/ruql/fill_in.rb +15 -0
data/lib/ruql/multiple_choice.rb +12 -0
data/lib/ruql/question.rb +47 -0
data/lib/ruql/quiz.rb +105 -0
data/lib/ruql/renderer.rb +20 -0
data/lib/ruql/renderers/auto_qcm_renderer.rb +70 -0
data/lib/ruql/renderers/edxml_renderer.rb +74 -0
data/lib/ruql/renderers/html5_renderer.rb +162 -0
data/lib/ruql/renderers/json_renderer.rb +49 -0
data/lib/ruql/renderers/xml_renderer.rb +148 -0
data/lib/ruql/select_multiple.rb +8 -0
data/lib/ruql/tex_output.rb +18 -0
data/lib/ruql/true_false.rb +17 -0
data/lib/ruql.rb +21 -0
data/templates/autoqcm.tex.erb +1 -0
data/templates/html5.html.erb +44 -0
metadata +96 -0

data/bin/ruql ADDED Viewed

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+require 'ruql'
+require 'getopt/long'
+def usage
+  name = $0.gsub( Regexp.new '^[^/]+/', '')
+  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
+  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
+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 renderer supports these options:
+  -c <href>, --css=<href>
+      embed <href> for stylesheet into generated HTML5
+  -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
+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],
+    ['-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/answer.rb ADDED Viewed

@@ -0,0 +1,16 @@
+class Answer
+  include Comparable
+  attr_accessor :answer_text, :explanation
+  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, explanation=nil)
+    @answer_text = answer_text
+    @correct = !!correct # ensure boolean
+    @explanation = explanation
+  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,12 @@
+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,47 @@
+class Question
+  attr_accessor :question_text, :answers, :randomize, :points, :name, :question_tags, :question_comment
+  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
+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,70 @@
+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
+  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 MultipleChoice then render(q, index)
+    when SelectMultiple,TrueFalse then render(q, index, 'mult')
+    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"
+    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"
+    end
+    output << "  \\end{choices}\n"
+    output << "\\end{question}\n\n"
+    output
+  end
+end

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

@@ -0,0 +1,74 @@
+class EdXmlRenderer
+  require 'builder'
+  attr_reader :output
+  def initialize(quiz,options={})
+    @only_question = options.delete('n') || options.delete('name')
+    @output = ''
+    @b = Builder::XmlMarkup.new(:target => @output, :indent => 2)
+    @quiz = quiz
+  end
+  def render(thing)
+    case thing
+    when MultipleChoice,SelectMultiple,TrueFalse then render_multiple_choice(thing)
+    when FillIn then render_fill_in(thing)
+    else
+      raise "Unknown question type: #{thing}"
+    end
+  end
+  def render_quiz
+    # entire quiz can be in one question group, as long as we specify
+    # that ALL question from the group must be used to make the quiz.
+    question_list = if @only_question
+                    then @quiz.questions.select { |q| q.name == @only_question }
+                    else @quiz.questions
+                    end
+    question_list.each { |question| render(question) }
+    @output
+  end
+  def render_fill_in(question)
+    raise "Not yet implemented for edXML"
+  end
+  def render_multiple_choice(question)
+    @b.problem do
+      # if question text has explicit newlines, use them to separate <p>'s
+      if question.raw?
+        @b.p { |p| p << question.question_text }
+      else
+        question.question_text.lines.map(&:chomp).each do |line|
+          if question.raw? then @b.p { |p| p << line } else @b.p(line) end
+        end
+      end
+      @b.multiplechoiceresponse do
+        @b.choicegroup :type => 'MultipleChoice' do
+          question.answers.each do |answer|
+            if question.raw?
+              @b.choice(:correct => answer.correct?) do |choice|
+                choice << answer.answer_text
+                choice << "\n"
+              end
+            else
+              @b.choice answer.answer_text, :correct => answer.correct?
+            end
+          end
+        end
+      end
+      @b.solution do
+        @b.div :class => 'detailed_solution' do
+          @b.p 'Explanation'
+          if question.raw?
+            @b.p { |p| p << question.correct_answer.explanation }
+          else
+            @b.p question.correct_answer.explanation
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+class Html5Renderer
+  require 'builder'
+  require 'erb'
+  attr_reader :output
+  def initialize(quiz,options={})
+    @css = options.delete('c') || options.delete('css')
+    @show_solutions = options.delete('s') || options.delete('solutions')
+    @template = options.delete('t') ||
+      options.delete('template') ||
+      File.join(Gem.loaded_specs['ruql'].full_gem_path, 'templates/html5.html.erb')
+    @output = ''
+    @quiz = quiz
+    @h = Builder::XmlMarkup.new(:target => @output, :indent => 2)
+  end
+  def render_quiz
+    if @template
+      render_with_template do
+        render_questions
+        @output
+      end
+    else
+      @h.html do
+        @h.head do
+          @h.title @quiz.title
+          @h.link(:rel => 'stylesheet', :type =>'text/css', :href=>@css) if @css
+        end
+        @h.body do
+          render_questions
+        end
+      end
+    end
+    self
+  end
+  def render_with_template
+    # local variables that should be in scope in the template
+    quiz = @quiz
+    # the ERB template includes 'yield' where questions should go:
+    output = ERB.new(IO.read(File.expand_path @template)).result(binding)
+    @output = output
+  end
+  def render_questions
+    render_random_seed
+    @h.ol :class => 'questions' do
+      @quiz.questions.each_with_index do |q,i|
+        case q
+        when MultipleChoice, SelectMultiple, TrueFalse then render_multiple_choice(q,i)
+        when FillIn then render_fill_in(q, i)
+        else
+          raise "Unknown question type: #{q}"
+        end
+      end
+    end
+  end
+  def render_multiple_choice(q,index)
+    render_question_text(q, index) do
+      answers =
+        if q.class == TrueFalse then q.answers.sort.reverse # True always first
+        elsif q.randomize then q.answers.sort_by { rand }
+        else q.answers
+        end
+      @h.ol :class => 'answers' do
+        answers.each do |answer|
+          if @show_solutions
+            render_answer_for_solutions(answer, q.raw?)
+          else
+            if q.raw? then @h.li { |l| l << answer.answer_text } else @h.li answer.answer_text end
+          end
+        end
+      end
+    end
+    self
+  end
+  def render_fill_in(q, idx)
+    render_question_text(q, idx) do
+      if @show_solutions
+        answer = q.answers[0]
+        if answer.has_explanation?
+          if q.raw? then @h.p(:class => 'explanation') { |p| p << answer.explanation }
+          else @h.p(answer.explanation, :class => 'explanation') end
+        end
+        answers = (answer.answer_text.kind_of?(Array) ? answer.answer_text : [answer.answer_text])
+        @h.ol :class => 'answers' do
+          answers.each do |answer|
+            if answer.kind_of?(Regexp)
+              answer = answer.inspect
+              if !q.case_sensitive
+                answer += 'i'
+              end
+            end
+            @h.li do
+              if q.raw? then @h.p { |p| p << answer } else @h.p answer end
+            end
+          end
+        end
+      end
+    end
+  end
+  def render_answer_for_solutions(answer,raw)
+    args = {:class => (answer.correct? ? 'correct' : 'incorrect')}
+    @h.li(args) do
+      if raw then @h.p { |p| p << answer.answer_text } else @h.p answer.answer_text  end
+      if answer.has_explanation?
+        if raw then @h.p(:class => 'explanation') { |p| p << answer.explanation }
+        else @h.p(answer.explanation, :class => 'explanation') end
+      end
+    end
+  end
+  def render_question_text(question,index)
+    html_args = {
+      :id => "question-#{index}",
+      :class => ['question', question.class.to_s.downcase, (question.multiple ? 'multiple' : '')]
+        .join(' ')
+    }
+    @h.li html_args  do
+      @h.div :class => 'text' do
+        qtext = "[#{question.points} point#{'s' if question.points>1}] " <<
+          ('Select ALL that apply: ' if question.multiple).to_s <<
+          if question.class == FillIn then question.question_text.gsub(/\-+/, '_____________________________')
+          else question.question_text
+          end
+        if question.raw?
+          @h.p { |p| p << qtext }
+        else
+          qtext.each_line do |p|
+            @h.p do |par|
+              par << p # preserves HTML markup
+            end
+          end
+        end
+      end
+      yield # render answers
+    end
+    self
+  end
+  def quiz_header
+    @h.div(:id => 'student-name') do
+      @h.p 'Name:'
+      @h.p 'Student ID:'
+    end
+    if @quiz.options[:instructions]
+      @h.div :id => 'instructions' do
+        @quiz.options[:instructions].each_line { |p| @h.p p }
+      end
+    end
+    self
+  end
+  def render_random_seed
+    @h.comment! "Seed: #{@quiz.seed}"
+  end
+end

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

@@ -0,0 +1,49 @@
+class JSONRenderer
+  require 'json'
+  attr_reader :output
+  def initialize(quiz,options={})
+    @output = ''
+    @json_array = []
+    @quiz = quiz
+  end
+  def render_quiz
+    @quiz.questions.each do |question|
+      case question
+      when MultipleChoice, SelectMultiple, TrueFalse then render_multiple_choice(question)
+      when FillIn then render_fill_in(question) # not currently supported
+      else
+        raise "Unknown question type: #{question}"
+      end
+    end
+    @output = JSON.pretty_generate(@json_array)
+  end
+  def render_multiple_choice(question)
+    question_hash = {
+      "text" => question.question_text,
+      "answers" => answers_to_json_array(question.answers)
+    }
+    @json_array.push(question_hash)
+  end
+  def answers_to_json_array(answers)
+    answers_array = []
+    answers.each do |answer|
+      answer_json = {
+        "text" => answer.answer_text,
+        "explanation" => answer.explanation,
+        "correct" => answer.correct
+      }
+      answers_array.push(answer_json)
+    end
+    answers_array
+  end
+  def render_fill_in(q)
+    # fill-in-the-blank questions not currently supported
+  end
+end

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

@@ -0,0 +1,148 @@
+class XMLRenderer
+  require 'builder'
+  attr_reader :output
+  def initialize(quiz,options={})
+    @output = ''
+    @b = Builder::XmlMarkup.new(:target => @output, :indent => 2)
+    @quiz = quiz
+  end
+  def render(thing)
+    case thing
+    when MultipleChoice,SelectMultiple,TrueFalse then render_multiple_choice(thing)
+    when FillIn then render_fill_in(thing)
+    else
+      raise "Unknown question type: #{thing}"
+    end
+  end
+  def render_quiz
+    # entire quiz can be in one question group, as long as we specify
+    # that ALL question from the group must be used to make the quiz.
+    xml_quiz do
+      # after preamble...
+      @b.question_groups do
+        @b.question_group(:select => @quiz.questions.length) do
+          @quiz.questions.each do |question|
+            self.render(question)
+          end
+        end
+      end
+    end
+    @output
+  end
+  def render_fill_in(question)
+    @b.question :type => 'GS_Short_Answer_Question_Simple', :id => question.object_id.to_s(16) do
+      @b.metadata {
+        @b.parameters {
+          @b.rescale_score question.points
+          @b.type 'regexp'
+        }
+      }
+      # since we want all the options to appear, we create N option
+      # groups each containig 1 option, and specify that option to
+      # always be selected for inclusion in the quiz.  If the original
+      # question specified 'random', use the 'randomize' attribute on
+      # option_groups to scramble the order in which displayed;
+      # otherwise, display in same order as answers appear in source.
+      @b.data {
+        @b.text { @b.cdata!(question.question_text) }
+        @b.option_groups(:randomize => !!question.randomize) {
+          @b.option_group(:select => 'all') {
+            question.answers.each do |answer|
+              option_args = {}
+              option_args['selected_score'] = answer.correct? ? 1 : 0
+              option_args['unselected_score'] =
+                question.multiple ? 1 - option_args['selected_score'] : 0
+              option_args['id'] = answer.object_id.to_s(16)
+              @b.option(option_args) do
+                answer_text = answer.answer_text
+                if answer_text.kind_of?(Regexp)
+                  answer_text = answer_text.inspect
+                  if !question.case_sensitive
+                    answer_text += 'i'
+                  end
+                end
+                @b.text { @b.cdata!(answer_text) }
+                @b.explanation { @b.cdata!(answer.explanation) } if answer.has_explanation?
+              end
+            end
+          }
+        }
+      }
+    end
+  end
+  def render_multiple_choice(question)
+    @b.question :type => 'GS_Choice_Answer_Question', :id => question.object_id.to_s(16) do
+      @b.metadata {
+        @b.parameters {
+          @b.rescale_score question.points
+          @b.choice_type (question.multiple ? 'checkbox' : 'radio')
+        }
+      }
+      # since we want all the options to appear, we create N option
+      # groups each containig 1 option, and specify that option to
+      # always be selected for inclusion in the quiz.  If the original
+      # question specified 'random', use the 'randomize' attribute on
+      # option_groups to scramble the order in which displayed;
+      # otherwise, display in same order as answers appear in source.
+      @b.data {
+        @b.text { @b.cdata!(question.question_text) }
+        @b.option_groups(:randomize => !!question.randomize) {
+          question.answers.each do |a|
+            @b.option_group(:select => 'all') {
+              self.render_multiple_choice_answer a, question.multiple
+            }
+          end
+        }
+      }
+    end
+  end
+  alias :render_true_false :render_multiple_choice
+  def render_multiple_choice_answer(answer, multiple_allowed)
+    option_args = {}
+    option_args['selected_score'] = answer.correct? ? 1 : 0
+    option_args['unselected_score'] =
+      multiple_allowed ? 1 - option_args['selected_score'] : 0
+    option_args['id'] = answer.object_id.to_s(16)
+    @b.option(option_args) do
+      @b.text { @b.cdata!(answer.answer_text) }
+      @b.explanation { @b.cdata!(answer.explanation) } if answer.has_explanation?
+    end
+  end
+  private
+  def options_to_xml(h)
+    h.each_pair do |k,v|
+      if v.is_a?(Hash)
+        @b.__send__(k.to_sym) do
+          options_to_xml v
+        end
+      else
+        @b.__send__(k.to_sym, v)
+      end
+    end
+  end
+  def xml_quiz
+    @b.quiz do
+      @b.metadata do
+        @b.type 'quiz'
+        @b.title @quiz.title
+        options_to_xml @quiz.options
+      end
+      @b.preamble
+      @b.data do
+        yield
+      end
+    end
+  end
+end

data/lib/ruql/select_multiple.rb ADDED Viewed

@@ -0,0 +1,8 @@
+class SelectMultiple < MultipleChoice
+  def initialize(text='', opts={})
+    super
+    self.multiple = true
+  end
+end

data/lib/ruql/tex_output.rb ADDED Viewed

@@ -0,0 +1,18 @@
+module TexOutput
+  @@tex_replace = {
+    /_/ => '\textunderscore{}',
+    Regexp.new('<tt>([^<]+)</tt>', Regexp::IGNORECASE) => "\\texttt{\\1}",
+    Regexp.new('<pre>(.*?)</pre>', Regexp::MULTILINE | Regexp::IGNORECASE) => "\\begin{Verbatim}\\1\\end{Verbatim}",
+  }
+  @@tex_escape = Regexp.new '\$|&|%|#|\{|\}'
+  def to_tex(str)
+    str = str.gsub(@@tex_escape) { |match| "\\#{match}" }
+    @@tex_replace.each_pair do |match, replace|
+      str = str.gsub(match, replace)
+    end
+    str
+  end
+end

data/lib/ruql/true_false.rb ADDED Viewed

@@ -0,0 +1,17 @@
+class TrueFalse < Question
+  def initialize(text, correct_answer, opts=nil)
+    super
+    opts ||= {}
+    opts[:explanation] ||= ''
+    correct_answer = !!correct_answer # ensure 'true' or 'false' only
+    self.question_text = "True or False: #{text}"
+    self.answer correct_answer.to_s.capitalize
+    self.distractor (!correct_answer).to_s.capitalize, :explanation => opts[:explanation]
+  end
+  def multiple ; false ; end
+  def incorrect_answer ; self.answers.reject(&:correct).first ; end
+  def explanation ; incorrect_answer.explanation ; end
+end

data/lib/ruql.rb ADDED Viewed

@@ -0,0 +1,21 @@
+# 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/edxml_renderer'
+require 'ruql/renderers/auto_qcm_renderer'
+require 'ruql/renderers/json_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/templates/autoqcm.tex.erb ADDED Viewed

	@@ -0,0 +1 @@
1	+ <%= yield %>

data/templates/html5.html.erb ADDED Viewed

@@ -0,0 +1,44 @@
+<html>
+  <head>
+    <title><%= quiz.title %></title>
+    <style type="text/css" media="all">
+    body { font-family: Times, serif; }
+    .header { text-align: right; font-weight: bold; padding-right: 30%; line-height: 300%; }
+    h1 { text-align: center; }
+    ol.questions { list-style-type: number; }
+    li.question { page-break-inside: avoid; border-bottom: 1px solid grey; padding-bottom: 2ex; }
+    li.multiplechoice  ol.answers { list-style-type: lower-alpha; }
+    li.multiplechoice  ol.answers li { padding-bottom: 0.5ex; }
+    li.selectmultiple  ol.answers { vertical-align: center; list-style-type: none; list-style-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUAQMAAAC3R49OAAAABlBMVEUAAAD///+l2Z/dAAAAEklEQVQImWNgAIL6/w+ogoEAAKI4Kp2NVIeDAAAAAElFTkSuQmCC');  }
+    li.truefalse ol.answers { list-style-type: none; }
+    li.truefalse ol.answers li { width: 15%; display: inline-block; }
+    .correct { color: green }
+    .incorrect { color: red }
+    .explanation { font-style: italic }
+    .instructions { clear: both; border: 1px solid black; align: center; padding: 2ex; margin: 2ex; }
+    </style>
+  </head>
+  <body>
+    <div class="header">
+      <div id="name">Name:</div>
+      <div id="sid">SID:</div>
+    </div>
+    <h1><%= quiz.title %></h1>
+    <div class="instructions">
+      <ul>
+        <li>No books, notes, or electronic devices allowed.  </li>
+        <li>Time limit is 30 minutes.</li>
+        <li><%= quiz.num_questions %> multiple-choice questions, points indicated per question,
+          <%= quiz.points %> points total.  Points per question are intended
+          to reflect approximate times they should take, at about 1 point per minute.</li>
+        <li>For 'select all that apply' questions worth N points,
+          you get 1/N of the points for each RIGHT answer that you check, plus
+          1/N of the points for each WRONG answer that you correctly
+          leave unchecked.  That is, equal weight is given to deciding
+          whether each choice is part of the right answer or not.</li>
+      </ul>
+      <b>Good skill!</b>
+    </div>
+    <%= yield %>
+  </body>
+</html>

metadata ADDED Viewed

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: ruql
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease:
+platform: ruby
+authors:
+- Armando Fox
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-12-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: getopt
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby-embedded DSL for creating short-answer quiz questions
+email: fox@cs.berkeley.edu
+executables:
+- ruql
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ruql.rb
+- lib/ruql/quiz.rb
+- lib/ruql/answer.rb
+- lib/ruql/question.rb
+- lib/ruql/renderer.rb
+- lib/ruql/select_multiple.rb
+- lib/ruql/fill_in.rb
+- lib/ruql/multiple_choice.rb
+- lib/ruql/true_false.rb
+- lib/ruql/tex_output.rb
+- lib/ruql/renderers/auto_qcm_renderer.rb
+- lib/ruql/renderers/edxml_renderer.rb
+- lib/ruql/renderers/html5_renderer.rb
+- lib/ruql/renderers/json_renderer.rb
+- lib/ruql/renderers/xml_renderer.rb
+- templates/autoqcm.tex.erb
+- templates/html5.html.erb
+- bin/ruql
+homepage: http://github.com/saasbook/ruql
+licenses:
+- CC By-SA
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.25
+signing_key:
+specification_version: 3
+summary: Ruby question language
+test_files: []