ruql 0.1.5 → 1.0.5

data/lib/ruql/json.rb

@@ -0,0 +1,12 @@
+module Ruql
+  class Json
+    attr_reader :output
+    def initialize(quiz, options={})
+      @quiz = quiz
+      @output = ''
+    end
+    def render_quiz
+      @output = JSON.pretty_generate(@quiz.as_json)
+    end
+  end
+end

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,55 +1,52 @@
 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
-    @explanation = nil
+    @question_group = ''
     @question_comment = ''
   end
-  def raw? ; !!@raw ; end
-  
-  def has_explanation? ; @explanation.to_s != '' ; end
 
-  def explanation(text=nil)
-    if text
-      @explanation = text
-    else
-      @explanation
-    end
+  def as_json
+    Hash(
+      :question_text => @question_text,
+      :question_tags => @question_tags.compact,
+      :question_group => @question_group,
+      :answers => @answers.map(&:as_json),
+      :question_type => self.class.to_s,
+      :raw => !!@raw,
+      :name => @name,
+      :points => @points
+      ).compact
   end
 
-  def uid(u) ; @question_uid = u ; end
-  
+  def uid(str); @uid = str; end
+
+  def raw? ; !!@raw ; end
+
   def text(s) ; @question_text = s ; end
 
-  def image(url)
-    @question_image = url
+  def explanation(text)
+    @answers.each { |answer| answer.explanation ||= text }
   end
-  
+
   def answer(text, opts={})
-    @answers << Answer.new(text, correct=true, opts[:explanation], self)
+    @answers << Answer.new(text, correct=true, opts[:explanation])
   end
 
   def distractor(text, opts={})
-    @answers << Answer.new(text, correct=false, opts[:explanation], self)
+    @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
@@ -67,30 +64,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,98 +1,78 @@
 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
-  attr_reader :first_question_number
   attr_reader :options
   attr_reader :output
-  attr_reader :suppress_random
   attr_reader :seed
   attr_reader :logger
-  attr_reader :points_threshold
-  attr_reader :points_string
-  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 get_first_question_number(spec)
-    return 1 if spec.nil?
-    return $1.to_i if spec =~ /^(\d+)$/
-    # file?
-    begin
-      File.readlines(spec).each do |f|
-        return 1 + $1.to_i if f =~ /^last\s+(\d+)/
-      end
-      return 1
-    rescue StandardError => e
-      warn "Warning: starting question numbering at 1, cannot read #{spec}: #{e.message}"
-      return 1
-    end
+    @logger.level = (@options['-V'] || @options['--verbose']) ? Logger::INFO : Logger::WARN
+    #@quiz_yaml = yaml
   end
 
-  def self.get_renderer(renderer)
-    Object.const_get(renderer.to_s + 'Renderer') rescue nil
+  def as_json
+    Hash(:title => @title,
+      :questions => @questions.map(&:as_json),
+      :seed => @seed
+      )
   end
 
   def render_with(renderer,options={})
     srand @seed
-    @first_question_number = get_first_question_number(options.delete('a'))
-    @points_threshold = (options.delete('p') || 0).to_i
-    @points_string = options.delete('P') || "[%d point%s]"
-    @suppress_random = !!options['R']
-    @renderer = Quiz.get_renderer(renderer).send(:new,self,options)
+    @renderer = renderer.send(:new,self,options)
     @renderer.render_quiz
-    if (report = options.delete('r'))
-      File.open(report, "w") do |f|
-        f.puts "questions #{num_questions}"
-        f.puts "first #{first_question_number}"
-        f.puts "last #{first_question_number + num_questions - 1}"
-        f.puts "points #{self.points}"
-      end
-    end
     @output = @renderer.output
   end
 
-  def points ; questions.map(&:points).inject { |sum,points| sum + points } ; end
+  def self.set_options(options)
+    @@options = options
+  end
 
-  def num_questions ; questions.length ; end
+  def ungrouped_questions
+    questions.filter { |q| q.question_group.to_s == '' }
+  end
 
-  def point_string(points)
-    points >= points_threshold ?
-    sprintf(points_string.to_s, points, (points > 1 ? 's' : '')) :
-      ''
+  def grouped_questions
+    questions.filter { |q| q.question_group.to_s != '' }.sort_by(&:question_group)
+  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)
@@ -164,9 +144,10 @@ 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
+
 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') || 'o')[0] + "l"
-    @list_start = quiz.first_question_number
     @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', :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)
@@ -51,10 +95,10 @@ class Html5Renderer
     render_question_text(q, index) do
       answers =
         if q.class == TrueFalse then q.answers.sort.reverse # True always first
-        elsif q.randomize && !@quiz.suppress_random then q.answers.sort_by { rand }
+        elsif q.randomize then q.answers.sort_by { rand }
         else q.answers
         end
-      @h.__send__(@list_type, :class => 'answers') do
+      @h.ol :class => 'answers' do
         answers.each do |answer|
           if @show_solutions
             render_answer_for_solutions(answer, q.raw?, q.class == TrueFalse)
@@ -62,10 +106,6 @@ class Html5Renderer
             if q.raw? then @h.li { |l| l << answer.answer_text } else @h.li answer.answer_text end
           end
         end
-        if @show_solutions && ((exp = q.explanation.to_s) != '')
-          @h.br
-          if q.raw? then @h.span(:class => 'explanation') { |p| p << exp } else @h.span(exp, :class => 'explanation') end
-        end
       end
     end
     self
@@ -104,10 +144,10 @@ class Html5Renderer
         answer.correct? ? "CORRECT: " : "INCORRECT: ")
     end
     @h.li(args) do
-      if raw then @h.span { |p| p << answer.answer_text } else @h.span answer.answer_text  end
+      if raw then @h.p { |p| p << answer.answer_text } else @h.p answer.answer_text  end
       if answer.has_explanation?
-        @h.br
-        if raw then @h.span(:class => 'explanation') { |p| p << answer.explanation } else @h.span(answer.explanation, :class => 'explanation') end
+        if raw then @h.p(:class => 'explanation') { |p| p << answer.explanation }
+        else @h.p(answer.explanation, :class => 'explanation') end
       end
     end
   end
@@ -115,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 = @quiz.point_string(question.points) << ' ' <<
-          ('Select <b>all</b> that apply: ' if question.multiple).to_s <<
+        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