RubyGems - ruql - Versions diffs - 0.0.2 - Mend

ruql 0.0.2

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: []