gipper 0.0.1

data/lib/answers.rb

@@ -0,0 +1,99 @@
+require 'answer'
+
+module Gipper
+  # == Gipper::Answers
+  #
+  # This class acts like an Array that contains each Answer.
+  #
+  # To popuate the object use the parse method.
+  #
+  #   answers = Gipper::Answers.new
+  #   answers.parse "~ wrong = correct # you are right!"
+  #
+  #   answers.length
+  #   >> 2
+  #
+  #   answers[0].correct
+  #   >> false
+  #
+  #   answers.find_style
+  #   >> :multiple_choice
+
+
+  class Answers < Array
+    include Oniguruma
+
+    # parses the answers an array of answer objects.
+    def parse answer
+      @answer_text = set_numerical_indicator answer
+      parts = split_apart @answer_text
+
+      parts.each do |clause|
+        answer = Answer.new
+        answer.parse(clause, @style_hint)
+        self << answer
+      end
+    end
+
+    # find_style does it's best to determine the questions style.  It cannot determine
+    # the missing word questions since the necessary information is in the question object.
+    # use question.find_style for that purpose.
+    def find_style
+      return @style_hint if @style_hint
+
+      if self.length == 1 && self[0].text.nil? && boolean?(self[0].correct.class)
+        return :true_false
+      end
+
+      if self[0].text && self[0].correct.class == String
+        return :matching
+      end
+
+      if (count_true < 2) && (self.length > 1)
+        return :multiple_choice
+      else
+        return :short_answer
+      end
+    end
+
+    private
+      def boolean? klass
+        klass == TrueClass || klass == FalseClass
+      end
+
+      def count_true
+        true_count = 0
+        self.each do |hash|
+          if (hash.correct == true)
+            true_count = true_count + 1
+          end
+        end
+        true_count
+      end
+
+      def set_numerical_indicator answer
+        if is_numerical? answer
+          @style_hint = :numerical
+          answer[1..-1]
+        else
+          answer
+        end
+      end
+
+      def is_numerical? answer
+        answer[0] == 35
+      end
+
+      # Iterates through the answer clauses
+      def split_apart clauses
+        reg = ORegexp.new('(?<!\\\\)(?:[~=])(.(?!(?<!\\\\)[~=]))*', :options => OPTION_MULTILINE)
+
+        matches =  reg.scan(clauses)
+
+        # if we didn't find any ~ or = then there is only a single answer
+        matches = [clauses] unless matches
+
+        matches.map { |m| m.to_s.strip}
+      end
+  end
+end

data/lib/gipper.rb

@@ -0,0 +1,15 @@
+begin
+  require 'oniguruma'
+rescue LoadError
+  require 'rubygems'
+  require 'oniguruma'
+end
+
+require 'answer'
+require 'answers'
+require 'question'
+require 'quiz'
+
+module Gipper
+
+end

data/lib/question.rb

@@ -0,0 +1,53 @@
+require 'special_charater_handler'
+
+module Gipper
+  class Question
+    include Oniguruma
+    include Gipper::SpecialCharacterHandler
+    
+    attr_accessor :text_post, :answer, :title, :text, :style, :format
+    
+    # instance method to parse the question
+    def parse text
+      reg = ORegexp.new('(.+)(?<!\\\\)\{(?<!\\\\)(.+)\}(.*)', :options => OPTION_MULTILINE)
+      matches = reg.match(text.strip).captures.map { |s| s.strip }
+
+      @text_post = unescape(matches[2]) unless matches[2].empty?
+      
+      answer = matches[1]
+
+      @answer = Gipper::Answers.new
+      @answer.parse(answer)
+
+      @format, @title, @text = to_parts(matches[0]).map { |s| unescape s}
+
+      @style = find_style @answer
+    end
+
+    def find_style answers
+      if @text_post
+        return :missing_word
+      end
+
+      answers.find_style
+    end
+
+    private
+      def to_parts question
+        format_part = '(\[(?<format>(.*))\])'
+        title_part = '(:{2}(?<title>(.*)):{2})'
+        question_part = '(?<question>(.*))'
+        whole_regex = "^#{format_part}?\\s*#{title_part}?\\s*#{question_part}$"
+
+        reg = ORegexp.new(whole_regex, :options => OPTION_MULTILINE)
+        parts = reg.match(question.strip)
+
+        format = parts[:format].strip if parts[:format]
+        title = parts[:title].strip if parts[:title]
+        question = parts[:question].strip
+
+        return [format, title, question]
+      end
+  end
+end
+

data/lib/quiz.rb

@@ -0,0 +1,31 @@
+require 'answers'
+require 'question'
+
+module Gipper
+  class Quiz
+    def self.parse gift_file
+      quiz = Quiz.new()
+      gift = []
+      gift_file.strip!
+      
+      quiz.iterate_through gift_file do |question|
+        q = Gipper::Question.new
+        q.parse(question)
+        gift << q
+      end
+      
+      gift
+    end
+    
+    def iterate_through questions
+      questions.gsub!(/^\s*\/\/.*$/, "")  # strip out comment lines
+      
+      list = questions.split(/[\r\n][\r\n\t\s]*[\r\n]/)
+      list.each do |item|
+        if item != ''
+          yield item 
+        end
+      end
+    end
+  end
+end

data/lib/special_charater_handler.rb

@@ -0,0 +1,8 @@
+module Gipper
+  module SpecialCharacterHandler
+    protected
+      def unescape text
+        text.gsub(/\\(~|=|#|\{|\})/, '\1') if !text.nil?
+      end
+  end
+end

data/script/txt2html

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+load File.dirname(__FILE__) + "/../Rakefile"
+require 'rubyforge'
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+
+download = "http://rubyforge.org/projects/#{$hoe.rubyforge_name}"
+version  = $hoe.version
+
+def rubyforge_project_id
+  RubyForge.new.configure.autoconfig["group_ids"][$hoe.rubyforge_name]
+end
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1 then return 'st'
+    when 2 then return 'nd'
+    when 3 then return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text_template = fsrc.read
+  body_text = ERB.new(body_text_template).result(binding)
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)

data/script/txt2html.cmd

@@ -0,0 +1 @@
+@ruby script/txt2html %*

data/tasks/rspec.rake

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

data/test/answer_test.rb

@@ -0,0 +1,152 @@
+require 'test_helper'
+
+class AnswerTest < Test::Unit::TestCase
+  def setup
+    @answer = Gipper::Answer.new
+  end
+
+  should "accept a single answer without equals as the correct and only answer" do
+    @answer.parse("5")
+    assert_equal true, @answer.correct
+    assert_equal "5", @answer.text
+  end
+
+  context "determining weight" do
+    should "have a default weight of nil" do
+      @answer.parse("foo" )
+      assert_nil @answer.weight
+    end
+
+    should "parse weight from numerical and non-numerical answers" do
+      @answer.parse("%50%yadda yadda" )
+      assert_equal 50, @answer.weight
+    end
+  end
+
+  should "use decimals for numerical answers" do
+    assert_answer_parsing "5.6765", :correct => 5.6765, :weight => nil, :range => 0, :numerical => true
+  end
+
+  should "handle alternate range format for numerical answers" do
+    assert_answer_parsing "5.1..5.9", :correct => 5.5, :weight => nil, :range => 0.4, :numerical => true
+  end
+
+  should "handle alternate range format for numerical answers with multiple decimal places" do
+    assert_answer_parsing "5.6765..5.6766", :correct => 5.67655, :weight => nil, :range => 0.00005, :numerical => true
+  end
+
+  context "parsing true false questions" do
+    should "recognize feedback" do
+      assert_answer_parsing " T#foo", :correct => true, :text => nil, :comment => "foo"
+    end
+
+    should "be tolerant of input variance" do
+      assert_answer_parsing " T", :correct => true
+      assert_answer_parsing "TrUE ", :correct => true
+      assert_answer_parsing " true", :correct => true
+      assert_answer_parsing " t ", :correct => true
+      assert_answer_parsing "F ", :correct => false
+      assert_answer_parsing "  false ", :correct => false
+      assert_answer_parsing " faLse", :correct => false
+      assert_answer_parsing " f ", :correct => false
+    end
+  end
+
+  should "identify matching questions and place the match into correct" do
+    assert_answer_parsing "=waffle -> cone", :correct => "cone", :text => "waffle"
+  end
+
+  should "be tolerant of input variance" do
+    assert_answer_parsing "~ %%%%%%%", :correct => false, :text => "%%%%%%%"
+    assert_answer_parsing "~UUUUUUUUU", :correct => false, :text => "UUUUUUUUU"
+  end
+
+  should "get answer conmments" do
+    assert_answer_parsing "~ %%%%%%%#foo", :correct => false, :text => "%%%%%%%", :comment => "foo"
+  end
+
+  should "get answer conmments when preceeded by a new line" do
+    assert_answer_parsing "~ Oompa\r\n#kun", :correct => false, :text => "Oompa", :comment => "kun"
+  end
+
+  # If you want to use curly braces, { or }, or equal sign, =,
+  # or # or ~ in a GIFT file (for example in a math question including
+  # TeX expressions) you must "escape" them by preceding them with a \
+  # directly in front of each { or } or =.
+  should "ignore all escaped characters" do
+    assert_answer_parsing "~ \\{\\}\\~\\=\\#foo", :correct => false, :text => "{}~=#foo", :comment => nil
+  end
+
+  context "numerical answers" do
+    should "understand numerical answer format" do
+      assert_answer_parsing "2000:3", :correct => 2000, :range => 3, :text => nil, :comment => nil, :weight => nil, :numerical => true
+    end
+
+    should "simple numerical answer format" do
+      assert_answer_parsing "=2000:0 #Whoopdee do!", :correct => 2000, :range => 0, :text => nil, :comment => "Whoopdee do!", :weight => nil, :numerical => true
+    end
+
+    should "percent based numerical answer format" do
+      assert_answer_parsing "=%50%2000:3 #Yippers", :correct => 2000, :range => 3, :text => nil, :comment => "Yippers", :weight => 50, :numerical => true
+    end
+  end
+
+
+  context "feedback comment splitting" do
+    should "return nils when passed empty string" do
+      text, comment = @answer.send :split_comment, ""
+      assert_nil comment
+      assert_nil text
+    end
+
+    should "return nils when passed nil" do
+      text, comment = @answer.send :split_comment, nil
+      assert_nil comment
+      assert_nil text
+    end
+
+    should "return nil comment and full text when no comment" do
+      text, comment = @answer.send :split_comment, "foo"
+      assert_nil comment
+      assert_equal "foo", text
+    end
+
+    should "return comment and text when feedback comment" do
+      text, comment = @answer.send :split_comment, "foo #bar"
+      assert_equal "foo", text
+      assert_equal "bar", comment
+    end
+
+    should "return full text when feedback comment is escaped" do
+      text, comment = @answer.send :split_comment, 'foo \\#bar'
+      assert_nil comment
+      assert_equal 'foo \\#bar', text
+    end
+  end
+
+  context "escape stripping" do
+    should "not remove escaped feedback comments" do
+      result = @answer.send :unescape, "foo \\#comment"
+      assert_equal "foo #comment", result
+    end
+
+    should "remove escapes from read string" do
+      @answer.parse('~ \\{\\}\\~\\=\\#foo', nil)
+      assert_equal "{}~=#foo", @answer.text
+    end
+  end
+
+  context "evaluating correctness" do
+    should "view equals as correct" do
+      result = @answer.send :split_correct, "= foo"
+      assert result[0]
+      assert_equal "foo", result[1]
+    end
+
+    should "view twiddle as incorrect" do
+      result = @answer.send :split_correct, "~ foo"
+      assert !result[0]
+      assert_equal "foo", result[1]
+    end
+  end
+end