ruql 0.1.3 → 1.0.3

data/lib/ruql/multiple_choice.rb

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

data/lib/ruql/open_assessment/open_assessment.rb

@@ -115,7 +115,7 @@ class OpenAssessment
   # Adds fields for a simple_open_assessment question
   def add_simple_question
     criterion = Criterion.new
-    criterion.name("How'd you do?") # "
+    criterion.name("How'd you do?")
     criterion.label("Scoring Rubric")
 
     raise "Must have answer for question" if @question_answer.nil?

data/lib/ruql/question.rb

@@ -1,40 +1,27 @@
 class Question
-  attr_accessor :question_text, 
-                :answers, 
-                :question_image,
-                :randomize, 
-                :points, 
-                :name, 
-                :question_tags, 
-                :question_uid, 
-                :question_comment, 
-                :raw
-  
+  attr_accessor :question_text, :answers, :randomize, :points, :name, :question_tags, :question_group, :question_comment, :uid
+
   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_image = options[:image]
     @question_tags = []
-    @question_uid = (options.delete(:uid) || SecureRandom.uuid).to_s
+    @question_group = ''
     @question_comment = ''
   end
+
+  def uid(str); @uid = str; end
+
   def raw? ; !!@raw ; end
-  
-  def uid(u) ; @question_uid = u ; end
-  
+
   def text(s) ; @question_text = s ; end
 
   def explanation(text)
     @answers.each { |answer| answer.explanation ||= text }
   end
 
-  def image(url)
-    @question_image = url
-  end
-  
   def answer(text, opts={})
     @answers << Answer.new(text, correct=true, opts[:explanation])
   end
@@ -43,6 +30,10 @@ class Question
     @answers << Answer.new(text, correct=false, opts[:explanation])
   end
 
+  def group(str)
+    @question_group = str
+  end
+  
   # these are ignored but legal for now:
   def tags(*args) # string or array of strings
     if args.length > 1
@@ -60,30 +51,4 @@ class Question
 
   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

@@ -1,24 +1,6 @@
 class Quiz
   @@quizzes = []
-  @quiz_yaml = {}
-  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,
-  }
+  @@options = {}
 
   attr_reader :renderer
   attr_reader :questions
@@ -26,36 +8,65 @@ class Quiz
   attr_reader :output
   attr_reader :seed
   attr_reader :logger
-  attr_accessor :title, :quizzes
+  attr_accessor :title
+
+  def self.reset
+    @@quizzes = []
+    @@options = {}
+  end
+  def self.quizzes ; @@quizzes ; end
+  def self.options ; @@options ; end
 
   def initialize(title, options={})
     @output = ''
-    @questions = options.delete(:questions) || []
+    @questions = options[:questions] || []
     @title = title
-    @options = @@default_options.merge(options)
+    @options = @@options.merge(options)
     @seed = srand
     @logger = Logger.new(STDERR)
-    @logger.level = Logger.const_get (options.delete('l') ||
-                                      options.delete('log') || 'warn').upcase
-    if (yaml = options.delete(:yaml))
-      @quiz_yaml = YAML::load(IO.read yaml)
-    end
-  end
-
-  def self.get_renderer(renderer)
-    Object.const_get(renderer.to_s + 'Renderer') rescue nil
+    @logger.level = (@options['-V'] || @options['--verbose']) ? Logger::INFO : Logger::WARN
+    #@quiz_yaml = yaml
   end
 
   def render_with(renderer,options={})
     srand @seed
-    @renderer = Quiz.get_renderer(renderer).send(:new,self,options)
+    @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 self.set_options(options)
+    @@options = options
+  end
+
+  def ungrouped_questions
+    questions.filter { |q| q.question_group.to_s == '' }
+  end
+
+  def grouped_questions
+    questions.filter { |q| q.question_group.to_s != '' }.sort_by(&:question_group)
+  end
 
-  def num_questions ; questions.length ; end
+  def groups ; questions.map(&:question_group).uniq.reject { |g| g.to_s == '' } ; end
+
+  def ungrouped_points
+    ungrouped_questions.map(&:points).sum
+  end
+
+  def grouped_points
+    gq = grouped_questions
+    groups.sum do |g|
+      gq.detect { |q| q.question_group == g }.points
+    end
+  end
+
+  def points
+    ungrouped_points + grouped_points
+  end
+  
+  def num_questions
+    groups.length + ungrouped_questions.length
+  end
 
   def random_seed(num)
     @seed = num.to_i
@@ -126,8 +137,8 @@ class Quiz
     @questions << q
   end
 
-  def self.quiz(*args, &block)
-    quiz = Quiz.new(*args)
+  def self.quiz(title, args={}, &block)
+    quiz = Quiz.new(title, args)
     quiz.instance_eval(&block)
     @@quizzes << quiz
   end

data/lib/ruql/renderers/edxml_renderer.rb

@@ -4,7 +4,7 @@ require 'yaml'
 class EdXmlRenderer
 
   attr_reader :output
-  attr_accessor :file
+  attr_accessor :file, :yaml_file
   def initialize(quiz,options={})
     @only_question = options.delete('n') || options.delete('name')
     @output = ''

data/lib/ruql/renderers/html5_renderer.rb

@@ -5,21 +5,65 @@ class Html5Renderer
   attr_reader :output
 
   def initialize(quiz,options={})
+    @css = options.delete('c') || options.delete('css')
     @show_solutions = options.delete('s') || options.delete('solutions')
+    @show_tags = options.delete('T') || options.delete('show-tags')
     @template = options.delete('t') ||
       options.delete('template') ||
-      File.join(File.dirname(__FILE__), '../../../templates/html5.html.erb')
+      File.join((Gem.loaded_specs['ruql'].full_gem_path rescue '.'), 'templates/html5.html.erb')
     @output = ''
-    @list_type = options.delete('o') || options.delete('list-type') || '1'
-    @list_start = options.delete('a') || options.delete('list-start') || '1'
     @quiz = quiz
     @h = Builder::XmlMarkup.new(:target => @output, :indent => 2)
   end
 
+  def allowed_options
+    opts = [
+      ['-c', '--css', Getopt::REQUIRED],
+      ['-t', '--template', Getopt::REQUIRED],
+      ['-s', '--solutions', Getopt::BOOLEAN],
+      ['-T', '--show-tags', Getopt::BOOLEAN]
+    ]
+    help = <<eos
+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
+  -T, --show-tags
+      Show the tag(s) associated with a question within an element <div class="tags">.
+  -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.
+eos
+    return(
+
+
   def render_quiz
-    render_with_template do
-      render_questions
-      @output
+    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
@@ -34,7 +78,7 @@ class Html5Renderer
     
   def render_questions
     render_random_seed
-    @h.ol :class => 'questions', :type => @list_type, :start => @list_start do
+    @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)
@@ -111,23 +155,21 @@ class Html5Renderer
   def render_question_text(question,index)
     html_args = {
       :id => "question-#{index}",
-      :'data-uid' => question.question_uid,
-      :class => ['question', question.class.to_s.downcase, (question.multiple ? 'multiple' : '')].join(' ')
+      :class => ['question', question.class.to_s.downcase, (question.multiple ? 'multiple' : '')]
+        .join(' ')
     }
-    if question.question_image           # add CSS class to both <li> and <img>
-      html_args[:class] << 'question-with-image'
-    end
     @h.li html_args  do
-      # if there's an image, render it first
-      if question.question_image
-        @h.img :src => question.question_image, :class => 'question-image'
-      end
       @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 @show_tags
+          @h.div(:class => 'text') do
+            question.tags.join(',')
+          end
+        end
         if question.raw?
           @h.p { |p| p << qtext }
         else

data/lib/ruql/renderers/json_renderer.rb

@@ -10,6 +10,40 @@ class JSONRenderer
   end
 
   def render_quiz
-    @output = @quiz.questions.map {|question| JSON.pretty_generate(question.to_JSON)}
+    @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

@@ -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
+