quiz_master 0.0.2 → 0.0.3

data/lib/quiz_master/quiz_variant.rb

@@ -0,0 +1,36 @@
+module QuizMaster
+  # This class allows us to build a QuizVariant which is a Quiz whose Questions
+  # and thier Answers have been re-ordered in the way specified by the orderings
+  # supplied to new.
+  #
+  # Once a QuizVariant has been made it is not intended to be mutated, it is an
+  # "end result" which can be used to generate output.
+  class QuizVariant
+    # Get the questions for this QuizVariant.
+    attr_reader :questions
+    # Get the header for this QuizVariant.
+    attr_reader :header
+    # Get the footer for this QuizVariant.
+    attr_reader :footer
+
+    # Public: Initialize this QuizVariant.  The Answers are reordered before the
+    # Questions.
+    #
+    # source            - A Quiz to be "shuffled" according to the reorderings.
+    # answer_orderings  - An Array of ReorderingVectors which specify how each
+    #                     Question's Answers are to be reordered.
+    # question_ordering - A ReorderingVector which specifies how the Questions
+    #                     are to be reordered.
+    #
+    # Returns a QuizVariant.
+    def initialize(source, answer_orderings, question_ordering)
+      @header = source.header.dup
+      @footer = source.footer.dup
+      @questions = source
+        .reorder_answers(answer_orderings)
+        .reorder_questions(question_ordering)
+        .questions
+        .map(&:render_answers)
+    end
+  end
+end

data/lib/quiz_master/rendered_question.rb

@@ -1,5 +1,5 @@
-require_relative 'question'
-require_relative 'answers_renderer'
+require_relative "question"
+require_relative "answers_renderer"
 
 module QuizMaster
   # This class is a question which has its answers rendered.

data/lib/quiz_master/reorderer.rb

@@ -0,0 +1,68 @@
+module QuizMaster
+  # This is responsible for reordering an Array.  It is a place to put any
+  # logic and error checking.
+  #
+  # Examples
+  #
+  #     r = Reorderer.new(0, 2, 1, 3)
+  #     r.reorder(%w(a b c d)) # => %w(a c b d)
+  class Reorderer
+    # Public: Initialize a Reorderer.
+    #
+    # args - Specify an Array of indices which must not be empty and must
+    #        contain the values 0 ... size of array.
+    #
+    # Examples
+    #
+    #     r = Reorderer.new(2, 0, 1)
+    #
+    # Raises ArgumentError if the args can't be validated.
+    def initialize(*args)
+      @indices = args.to_a
+      indices_invalid? &&
+        fail(ArgumentError, "#{args.inspect} is a bad set of indices")
+    end
+
+    # Public: Reorder the passed array based on the indices we were initialized
+    # with.
+    #
+    # array - An Array containing elements you're interested in reordering.
+    #
+    # Examples
+    #
+    #     r.reorder([1, 3, 5])
+    #
+    # Raises an ArgumentError if the size of the Array isn't the same as the
+    #   size of the indices specified in new.
+    #
+    # Returns a new Array containing the reordered elements of array.
+    def reorder(array)
+      fail(ArgumentError, "array should have #{@indices.size} elements") if
+        array.size != @indices.size
+      array.values_at(*@indices)
+    end
+
+    # Determines which elements of a list will be moved when the list is
+    # reordered.
+    #
+    # Examples
+    #
+    #     r = Reorderer.new(3,0,2,1)
+    #     r.moving_indices # => [0, 1, 3]
+    #     # ... so element 2 of an Array will be element 2 of the result
+    #     # of the re-order, and elements 0, 1, and 3 will be moved in the
+    #     # result:
+    #     r.reorder(%w(zero one two three)) # => ["three", "zero", "two", "one"]
+    #
+    # Retruns an Array of source indices.
+    def moving_indices
+      @indices.each_with_index
+        .select { |destination, source| source != destination }
+        .map { |_, source| source }
+    end
+
+    private def indices_invalid?
+      @indices.empty? || @indices.sort != (0 ... @indices.size).to_a
+    end
+  end
+end

data/lib/quiz_master/reordering_vector.rb

@@ -0,0 +1,95 @@
+require "forwardable"
+
+module QuizMaster
+  # A ReorderingVector is a way of specifying how an array should be reordered.
+  # It contains a mapping of source indices so you can say:
+  #
+  #     reordered = original.values_at(*reordering_vector)
+  #
+  # The reordering is constructed "randomly" at initialization, and has the idea
+  # of "anchored" indices which are guaranteed to remain in their original
+  # place.
+  class ReorderingVector
+    extend Forwardable
+    include Comparable
+
+    # Public: Initialize a ReorderingVector.
+    #
+    # anchored      - An Array of "truthy" values which indicate the size of the
+    #                 Array to reorder and which elements should be "anchored"
+    #                 at their current position in the reordering (indicated by
+    #                 a +true+ value).
+    # shuffle_block - A block used to shuffle the "un-anchored" indices.  It is
+    #                 called with an Array as an argument and should return an
+    #                 Array containing the same elements.  Optional
+    def initialize(anchored, &shuffle_block)
+      shuffle_block ||= ->(a) { a.shuffle }
+      @indices = create_indices(anchored, &shuffle_block)
+    end
+
+    ##
+    # :method: []
+    # :args: index
+    #
+    # Public: Get the element at the specified index.
+    #
+    # Returns the element at the specified index.
+    def_delegator :@indices, :[]
+
+    ##
+    # :method: size
+    #
+    # Public: Get the size of the ReorderingVector.
+    #
+    # Returns an Integer representing the size of the ReorderingVector.
+    def_delegator :@indices, :size
+
+    ##
+    # :method: each
+    #
+    # Public: Allows us to enumerate the elements of the ReorderingVector.
+    #
+    # Yields each element of the Reordering Vector.
+    #
+    # Returns an Enumerator if no block given.
+    def_delegator :@indices, :each
+
+    # Public: Convert a ReorderingVector to an Array
+    #
+    # Examples
+    #
+    #     r = ReorderingVector.new([true, false, false, true])
+    #     r.to_a  # => [0, 2, 1, 3]
+    #
+    # Returns an Array representation of this object.
+    def to_a
+      @indices.dup
+    end
+
+    alias_method :to_ary, :to_a
+
+    # Public: Compare two ReorderingVectors.  We include the Comparable module
+    # so this gives us all of the comparisons.  We compare ReorderingVectors as
+    # Arrays.
+    #
+    # other - An other objecy which can be compared to an Array.
+    #
+    # Returns +1 / 0 / -1 for successful comparisons, and nil for incomparable
+    # values.
+    def <=>(other)
+      to_a <=> other.to_a
+    end
+
+    private def create_indices(anchored, &shuffle_block)
+      anchored_indices, floating_indices =
+        anchored.each_index.partition { |i| anchored[i] }
+
+      result = anchored_indices.each_with_object([]) { |i,  a| a[i] = i }
+
+      shuffled = shuffle_block.call(floating_indices)
+      floating_indices.zip(shuffled).each_with_object(result) do |(to, from), a|
+        a[to] = from
+      end
+    end
+  end
+end

data/lib/quiz_master/text_answer_sheet_formatter.rb

@@ -13,7 +13,7 @@ module QuizMaster
       # This generates an infinite range which we can use for numbering the
       # questions.
       numbers = (1 .. Float::INFINITY)
-      quiz.questions.zip(numbers).each_with_object('') do |(q, number), result|
+      quiz.questions.zip(numbers).each_with_object("") do |(q, number), result|
         result << "#{number}) #{q.correct_answer.tag}\n"
       end
     end

data/lib/quiz_master/text_assembler.rb

@@ -21,7 +21,7 @@ module QuizMaster
     # Public: Create a TextAssembler object
     def initialize
       @tags = []
-      @format_string = ''
+      @format_string = ""
     end
 
     # Public: Add a tag reference to the text we are assembling.
@@ -35,7 +35,7 @@ module QuizMaster
     # Returns nothing.
     def add_tag_reference(tag)
       @tags << tag
-      @format_string << '(%s)'
+      @format_string << "(%s)"
     end
 
     # Public: Add some literal text to the text we are assembling.
@@ -48,7 +48,7 @@ module QuizMaster
     #
     # Returns nothing.
     def add_text(text)
-      @format_string << text.gsub('%', '%%')
+      @format_string << text.gsub("%", "%%")
     end
 
     # Public: Get the String representation of the TextAssembler.

data/lib/quiz_master/text_question_formatter.rb

@@ -36,7 +36,7 @@ module QuizMaster
     #
     # Returns a String containing the formatted Question.
     def format(question, number)
-      answers = AnswersRenderer.new(answers: question.answers, first_tag: 'a')
+      answers = AnswersRenderer.new(answers: question.answers, first_tag: "a")
 
       answers.each_with_object("#{number}) #{question.prompt}\n\n") do |a, text|
         text << "  #{a.tag}) #{a.text}\n"

data/lib/quiz_master/text_question_sheet_formatter.rb

@@ -1,8 +1,9 @@
-require_relative 'text_question_formatter'
+require_relative "text_question_formatter"
 
 module QuizMaster
   # This is responsible for generating a text version of Quizes.
   class TextQuestionSheetFormatter
+    # Initialiize a TextQuestionSheetFormatter.
     def initialize
       @question_formatter = TextQuestionFormatter.new
     end

data/lib/quiz_master/version.rb

@@ -1,5 +1,5 @@
 #
 module QuizMaster
   # The Gem version. We will use semantic versioning: http://semver.org
-  VERSION = '0.0.2'
+  VERSION = "0.0.3"
 end

data/quiz_master.gemspec

@@ -1,17 +1,19 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'quiz_master/version'
+require "quiz_master/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = 'quiz_master'
+  spec.name          = "quiz_master"
   spec.version       = QuizMaster::VERSION
-  spec.authors       = ['Mike Stok']
-  spec.email         = ['mike@stok.ca']
-  spec.summary       = 'Simple manager for multiple choice quizzes'
+  spec.authors       = ["Mike Stok"]
+  spec.email         = ["mike@stok.ca"]
+  spec.summary       = "Simple manager for multiple choice quizzes"
   # spec.description   = %q{TODO: Write a longer description. Optional.}
-  spec.homepage      = 'https://github.com/mikestok/quiz_master'
-  spec.license       = 'MIT'
+  spec.homepage      = "https://github.com/mikestok/quiz_master"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = "~> 2.1"
 
   # Because there are likely to be / characters in the regular expressions
   # we relax the rubocop checks for a bit...
@@ -19,13 +21,13 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
+  spec.require_paths = ["lib"]
   # rubocop:enable Style/RegexpLiteral
 
-  spec.add_development_dependency 'bundler', '~> 1.6'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rubocop'
-  spec.add_development_dependency 'rdoc'
-  spec.add_development_dependency 'inch'
-  spec.add_development_dependency 'sparkr' # inch should have included this...
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "rdoc"
+  spec.add_development_dependency "inch"
+  spec.add_development_dependency "sparkr" # inch should have included this...
 end

data/test/question_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe Question do
+  describe "reorder_answers" do
+    it "can reorder its answers" do
+      q = example_questions.first
+      reordered = q.reorder_answers(Reorderer.new(2, 0, 1, 3))
+      reordered.answers.map(&:text).must_equal(
+        [
+          "This is the third answer",
+          "This is the first answer",
+          "This is the second answer",
+          "{{3}} and {{5}}"
+        ]
+      )
+    end
+
+    it 'raises an error if asked to move "anchored" answers' do
+      q = example_questions[2]
+      lambda do
+        q.reorder_answers(Reorderer.new(0, 7, 2, 3, 4, 5, 6, 1))
+      end.must_raise(MovingAnchoredAnswerError)
+    end
+  end
+
+  describe "reordering_vector" do
+    q = example_questions[2]
+    rv = q.reordering_vector { |a| a.reverse }
+
+    it "must be a ReorderingVector" do
+      rv.must_be_kind_of(ReorderingVector)
+    end
+
+    it "must have the expected order" do
+      rv.to_a.must_equal([5, 4, 3, 2, 1, 0, 6, 7])
+    end
+  end
+
+  describe "render_answers" do
+    first_tag = "a"
+    q = example_questions.first.render_answers(first_tag: first_tag)
+
+    it "must have the correct first answer and tag" do
+      af = q.answers.first
+      af.tag.must_equal first_tag
+      af.text.must_equal "This is the first answer"
+    end
+
+    it "must have the correct last answer and tag" do
+      al = q.answers.last
+      al.tag.must_equal "d"
+      al.text.must_equal "(a) and (c)"
+    end
+  end
+end

data/test/quiz_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe Quiz do
+  describe "answer_reordering_vectors" do
+    it "should generate expected answer reordering vectors" do
+      quiz_source = Quiz.new(example_questions)
+      vectors = quiz_source.answer_reordering_vectors { |a| a.reverse }
+
+      vectors.must_equal([
+        ReorderingVector([3, 2, 1, 0]),
+        ReorderingVector([3, 2, 1, 0]),
+        ReorderingVector([5, 4, 3, 2, 1, 0, 6, 7])
+      ])
+    end
+  end
+
+  describe "question_reordering_vector" do
+    it "should generate expected reordering vector" do
+      quiz_source = Quiz.new(example_questions)
+      v = quiz_source.question_reordering_vector { |a| a.reverse }
+
+      v.must_equal(ReorderingVector([2, 1, 0]))
+    end
+  end
+
+  describe "reorder_answers" do
+    quiz_source = Quiz.new(example_questions)
+    vectors = quiz_source.answer_reordering_vectors { |a| a.reverse }
+    quiz = quiz_source.reorder_answers(vectors)
+
+    it "should *not* have shuffled the questions" do
+      quiz.questions.first.prompt.must_equal(
+        EXAMPLE_QUESTION_PARAMS.first[:prompt]
+      )
+    end
+
+    it "should have shuffled the answers within the question" do
+      quiz.questions.first.answers.first.text.must_equal(
+        EXAMPLE_QUESTION_PARAMS.first[:answers].last.text
+      )
+    end
+  end
+
+  describe "reorder_questions" do
+    it "should return a quiz with questions re-ordered" do
+      quiz_source = Quiz.new(example_questions)
+      vector = quiz_source.question_reordering_vector { |a| a.reverse }
+      quiz = quiz_source.reorder_questions(vector)
+
+      quiz.questions.first.prompt.must_equal(
+        EXAMPLE_QUESTION_PARAMS.last[:prompt]
+      )
+    end
+  end
+end

data/test/quiz_variant_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe QuizVariant do
+  describe "initialize" do
+    quiz_source = Quiz.new(example_questions)
+
+    answer_orderings = [
+      ReorderingVector([3, 1, 0, 2]),
+      ReorderingVector([1, 0, 2, 3]),
+      ReorderingVector([4, 0, 1, 3, 5, 2, 6, 7])
+    ]
+    question_ordering = ReorderingVector([0, 2, 1])
+
+    variant = QuizVariant.new(quiz_source, answer_orderings, question_ordering)
+
+    it "has questions in the right order" do
+      variant.questions[0].prompt.must_equal "Example 1 prompt"
+      variant.questions[1].prompt.must_equal "What is the colour of a Banana?"
+      variant.questions[2].prompt.must_equal "Example 2 prompt"
+    end
+
+    it "has answers in the right order" do
+      banana_question = variant.questions[1]
+      banana_question.answers[0].text.must_equal "Brown"
+      banana_question.answers[1].text.must_equal "Green"
+      banana_question.answers[6].text.must_equal "All of the colours above"
+    end
+
+    it "has the tags assigned" do
+      banana_question = variant.questions[1]
+      banana_question.answers[0].tag.must_equal "a"
+    end
+  end
+end