robut-quiz 0.1.0

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gem 'robut'
+
+group :test do
+  gem 'rspec'
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'growl_notify'
+end

data/Guardfile

@@ -0,0 +1,8 @@
+
+
+guard 'rspec', :version => 2, :cli => '--color --format d' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.1.0 / 2011-10-23
+
+* Initial Release
+* User is able to ask polar question

data/README.md

@@ -0,0 +1,30 @@
+# Robut-Quiz
+
+A Plugin for [Robut](https://github.com/justinweiss/robut) that allows you to ask questions and collect the results from all participants within the chatroom.
+
+## Usage
+
+### Polar Question (Yes/No)
+
+```
+   user_a  > @robut ask 'Do you want to go to the bar at 4:30?' for 5 minutes.
+   robut   > @user I have enqueued your question
+   robut   > @all Question: 'Do you want to go to the bar at 4:30?'
+   user_a  > @robut answer YES
+   user_b  > @robut answer yes
+   user_c  > @robut answer n
+   robut   > @all The results are in for 'Do you want to go to the bar at 4:30?:'
+             2 YES votes and 1 NO vote
+```
+
+## Installation
+
+Install the gem
+
+    gem install robut-quiz
+    
+Add the plugin to your [Chatfile](https://github.com/justinweiss/robut/blob/master/examples/Chatfile)
+
+    require 'robut_quiz'
+    
+    Robut::Plugin.plugins << Robut::Plugin::Quiz

data/lib/polar.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+
+class Robut::Plugin::Quiz::Polar
+  include Robut::Plugin::Quiz::Question
+  
+  YES_ANSWER = /y|yes/i
+  NO_ANSWER = /n|no/i
+  
+  def handle_response(sender_nick,response)
+    
+    if response =~ YES_ANSWER
+      store_positive_response_for sender_nick
+      true
+    elsif response =~ NO_ANSWER
+      store_negative_response_for sender_nick
+      true
+    else
+      nil
+    end
+    
+  end
+  
+  def results
+    
+    yes_votes = no_votes = 0
+    
+    captured_results.each_pair do |key,value|
+      yes_votes = yes_votes + 1 if value
+      no_votes = no_votes + 1 unless value
+    end
+    
+    "#{yes_votes} YES vote#{yes_votes != 1 ? 's' : ''} and #{no_votes} NO vote#{no_votes != 1 ? 's' : ''}"
+  end
+  
+  def captured_results
+    @captured_results ||= {}
+  end
+  
+  def store_positive_response_for sender_nick
+    captured_results[sender_nick] = true
+  end
+  
+  def store_negative_response_for sender_nick
+    captured_results[sender_nick] = false
+  end
+  
+end

data/lib/question.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+module Robut::Plugin::Quiz::Question
+  
+  # @see ask%20%3F(choice%7Cpolar%7Cscale)%3F%20(%3F%3Aquestion%20)%3F'(%5B%5E'%5D%2B)'%5B%5Cs%2C%5D*((%3F%3A'%5B%5E'%5D%2B'%5B%5Cs%2C%5D*)*)%2B(%3F%3A(%3F%3Afor%20)%3F(%5Cd%2B)%20minutes%3F)%3F
+  # 
+  # 1st: question type - choice, polar, scale
+  # 2nd: question
+  # 3rd: choices
+  #
+  QUESTION_REGEX = /^ask ?(choice|polar|scale)? (?:question )?['"]([^'"]+)['"][\s,]*((?:['"][^'"]+['"][\s,]*)*)*(?:(?:for )?(\d+) minutes?)?$/
+  
+  # This regex will find all the questions and parameters specified with the question 
+  GROUP_REGEX = /['"]([^'"]+)['"]/ 
+  
+  def initialize(sender,request)
+    @sender = sender
+    process_question(request)
+  end
+  
+  def process_question(request)
+    
+    request =~ QUESTION_REGEX
+    @question = Regexp.last_match(2)
+    # After the target, question type, question, and answer length has been determined
+    # look at all the single quoted items to find the list of parameters if there are any
+    @parameters = request.scan(GROUP_REGEX)[1..-1].flatten
+    
+  end
+  
+  def to_s
+    @question
+  end
+  
+  def ask
+    "@all Question '#{@question}'"
+  end
+  
+end

data/lib/quiz.rb

@@ -0,0 +1,120 @@
+# encoding: UTF-8
+require 'robut'
+
+class Robut::Plugin::Quiz
+  include Robut::Plugin
+  
+  def usage
+    [ 
+      "#{at_nick} ask polar 'Should I continue the presentation?' for 3 minutes",
+    ]
+  end
+  
+  def handle(time, sender_nick, message)
+    
+    # check to see if the user is asking the bot a question
+    request = words(message).join(" ")
+    
+    if sent_to_me? message and is_a_valid_question? request
+      
+      enqueue_the_question sender_nick, request
+      reply "@#{sender_nick}, I have added your question to the list."
+      quizmaster
+      
+    end
+    
+    if sent_to_me? message and currently_asking_a_question? and is_a_valid_response? request
+      process_response_for_active_question sender_nick, request
+    end
+    
+  end
+  
+  QUESTION_REGEX = /^ask ?(choice|polar|scale)? (?:question )?.+(?:(?:for )?(\d+) minutes?)$/
+  
+  def is_a_valid_question? message
+    QUESTION_REGEX =~ message
+  end
+  
+  ANSWER_REGEX = /^answer .+$/
+  
+  def is_a_valid_response? message
+    ANSWER_REGEX =~ message
+  end
+  
+  def enqueue_the_question(sender,question)
+    (store["quiz::question::queue"] ||= []) << [sender,question]
+  end
+  
+  def quizmaster
+    @@quizmaster ||= Thread.new { pop_the_question until there_are_no_more_questions_to_pop }
+  end
+  
+  def pop_the_question
+    if popped_question = (store["quiz::question::queue"] ||= []).pop
+      process_the_question *popped_question
+    end
+  end
+  
+  def there_are_no_more_questions_to_pop
+    (store["quiz::question::queue"] ||= []).empty?
+  end
+  
+  def currently_asking_a_question?
+    defined? @@current_question and @@current_question
+  end
+  
+  def process_the_question(sender,request)
+    
+    request =~ QUESTION_REGEX
+    type = Regexp.last_match(1) || 'polar'
+    question_length = Regexp.last_match(2) || '2' 
+    
+    set_current_question create_the_question_based_on_type(type,sender,request), question_length
+  end
+  
+  #
+  # @param [String] question_type the name of the question type which will be
+  #   converted from a String to the Class name within the current namespace.
+  # @param [String] sender the sender of the question
+  # @param [String] request the entire message that initiated the question 
+  #
+  def create_the_question_based_on_type(question_type,sender,request)
+    self.class.const_get(question_type.capitalize).new sender, request
+  end
+  
+  def set_current_question(question,length_of_time)
+    
+    start_accepting_responses_for_this_question question
+    
+    reply question.ask
+
+    sleep length_of_time.to_i * 60
+    
+    stop_accepting_responses_for_this_question question
+    
+    reply "The results are in for '#{question}':"
+    reply question.results
+    
+  end
+  
+  def start_accepting_responses_for_this_question(question)
+    @@current_question = question
+  end
+  
+  def stop_accepting_responses_for_this_question(question)
+    @@current_question = nil
+  end
+  
+  def process_response_for_active_question(sender_nick, request)
+    if @@current_question.handle_response sender_nick, request
+      reply "Thank you, @#{sender_nick}, I have recorded your response."
+    else
+      reply "Sorry, @#{sender_nick}, I was unable to record that answer"
+    end
+  end
+  
+end
+
+
+require_relative 'question'
+require_relative 'polar'

data/lib/robut_quiz.rb

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+
+require 'robut'
+
+class Robut::Plugin::Quiz
+  VERSION = "0.1.0"
+end
+
+require_relative 'quiz'
+

data/robut-quiz.gemspec

@@ -0,0 +1,59 @@
+require './lib/robut_quiz'
+
+class Robut::Plugin::Quiz
+  def self.show_version_changes(version)
+    date = ""
+    changes = []  
+    grab_changes = false
+
+    File.open("#{File.dirname(__FILE__)}/History.txt",'r') do |file|
+      while (line = file.gets) do
+
+        if line =~ /^===\s*#{version.gsub('.','\.')}\s*\/\s*(.+)\s*$/
+          grab_changes = true
+          date = $1.strip
+        elsif line =~ /^===\s*.+$/
+          grab_changes = false
+        elsif grab_changes
+          changes = changes << line
+        end
+
+      end
+    end
+
+    { :date => date, :changes => changes }
+  end
+end
+
+Gem::Specification.new do |s|
+  s.name        = 'robut-quiz'
+  s.version     = ::Robut::Plugin::Quiz::VERSION
+  s.authors     = ["Franklin Webber"]
+  s.description = %{ Robut plugin that provides quiz asking functionality. }
+  s.summary     = "Quiz asking Robut"
+  s.email       = 'franklin.webber@gmail.com'
+  s.homepage    = "http://github.com/burtlo/robut-quiz"
+
+  s.platform    = Gem::Platform::RUBY
+  
+  changes = Robut::Plugin::Quiz.show_version_changes(::Robut::Plugin::Quiz::VERSION)
+  
+  s.post_install_message = "
+--------------------------------------------------------------------------------
+    ___
+  !(O-0)! ~ Thank you for installing robut-quiz #{::Robut::Plugin::Quiz::VERSION} / #{changes[:date]}
+ >==[ ]==<
+    @ @
+
+  Changes:
+  #{changes[:changes].collect{|change| "  #{change}"}.join("")}
+--------------------------------------------------------------------------------"
+
+  s.add_dependency 'robut', '~> 0.3'
+  
+  s.rubygems_version   = "1.3.7"
+  s.files            = `git ls-files`.split("\n")
+  s.extra_rdoc_files = ["README.md", "History.txt"]
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.require_path     = "lib"
+end

data/spec/polar_spec.rb

@@ -0,0 +1,117 @@
+require_relative 'spec_helper'
+
+describe Robut::Plugin::Quiz::Polar do
+  
+  subject do
+    Robut::Plugin::Quiz::Polar.new 'person',"ask polar 'Should I continue the presentation?' for 3 minutes"
+  end
+  
+  let(:time) { Time.now }
+  
+  describe "#handle_response" do
+    
+    context "when the response is a 'yes'" do
+      
+      it "should store positive response for the user" do
+        
+        subject.should_receive(:store_positive_response_for).with('person')
+        subject.handle_response('person','yes')
+        
+      end
+      
+    end
+
+    context "when the response is a 'y'" do
+      
+      it "should store a positive response for the user" do
+        
+        subject.should_receive(:store_positive_response_for).with('person')
+        subject.handle_response('person','y')
+
+      end
+    end
+    
+    context "when the response is a 'no'" do
+      
+      it "should store negative response for the user" do
+        
+        subject.should_receive(:store_negative_response_for).with('person')
+        subject.handle_response('person','no')
+        
+      end
+      
+    end
+    
+    context "when the response is a 'n'" do
+      
+      it "should store negative response for the user" do
+      
+        subject.should_receive(:store_negative_response_for).with('person')
+        subject.handle_response('person','n')
+        
+      end
+      
+    end
+    
+  end
+  
+  describe "#declare_results" do
+    
+    context "when there have been no votes" do
+      
+      it "should reply that there are zero YES votes and zero NO votes" do
+        
+        subject.results.should eq "0 YES votes and 0 NO votes"
+        
+      end
+      
+    end
+    
+    context "when there has been a yes vote" do
+      
+      it "should reply that there is 1 YES vote" do
+        
+        subject.handle_response('person','yes')
+        subject.results.should eq "1 YES vote and 0 NO votes"
+        
+      end
+      
+    end
+    
+    context "when there has been a no vote" do
+      
+      it "should reply that there is 1 NO vote" do
+        
+        subject.handle_response('person','no')
+        subject.results.should eq "0 YES votes and 1 NO vote"
+        
+      end
+      
+    end
+    
+    context "when there has been multiple votes by the same user" do
+      
+      it "should count as one vote" do
+        
+        subject.handle_response('person','no')
+        subject.handle_response('person','no')
+        subject.handle_response('person','no')
+        subject.results.should eq "0 YES votes and 1 NO vote"
+        
+      end
+
+      it "should only count the last vote" do
+        
+        subject.handle_response('person','yes')
+        subject.handle_response('person','yes``')
+        subject.handle_response('person','no')
+        subject.results.should eq "0 YES votes and 1 NO vote"
+        
+      end
+      
+    end
+    
+  end
+  
+  
+end

data/spec/quiz_spec.rb

@@ -0,0 +1,156 @@
+require_relative 'spec_helper'
+
+describe Robut::Plugin::Quiz do
+  
+  subject { 
+    connection = double("connection")
+    connection.stub_chain(:config, :nick) { "quizmaster" }
+    connection.stub(:store).and_return(store)
+    connection.stub(:reply).and_return(nil)
+    Robut::Plugin::Quiz.new connection 
+  }
+  
+  let!(:store) { {} }
+  
+  let(:time) { Time.now }
+  
+  [ 
+    "ask choice 'What do you want for lunch?', 'pizza', 'sandwich', 'salad' for 1 minute",
+    "ask polar 'Should I continue the presentation?' for 3 minutes",
+    "ask scale question 'how much did you like the presentation?', '1..5' for 10 minutes",
+    "ask 'Should I continue the presentation?', 'y|yes', 'n|no' for 1 minutes",
+    "ask polar 'Should I continue the presentation?' for 3 minutes"
+    
+  ].each do |question|
+  
+    it "should match the question: '#{question}'" do
+      
+      subject.is_a_valid_question?(question).should be_true
+      
+    end
+    
+  end
+    
+  describe "#handle" do
+    
+    context "when a question is asked" do
+      
+      it "should be enqueued to be asked" do
+        
+        subject.should_receive(:enqueue_the_question).with('person',"ask polar 'Should I continue the presentation?' for 3 minutes")
+        subject.handle time,'person',"@quizmaster ask polar 'Should I continue the presentation?' for 3 minutes"
+        
+      end
+      
+    end
+    
+    context "when currently asking a question" do
+      
+      context "when the response is not an answer to the question" do
+        
+        it "should not process response for the question" do
+          
+          subject.stub(:currently_asking_a_question?).and_return(true)
+          subject.stub(:is_a_valid_response?).and_return(false)
+
+          subject.should_not_receive(:process_response_for_active_question)
+          
+          subject.handle time,'person',"@quizmaster ask polar 'Should I continue the presentation?' for 3 minutes"
+          
+        end
+        
+      end
+      
+      context "when the response is an answer to the question" do
+        
+        it "should process response for the question" do
+          subject.stub(:sent_to_me?).and_return(true)
+          subject.stub(:currently_asking_a_question?).and_return(true)
+          subject.stub(:is_a_valid_response?).and_return(true)
+
+          subject.should_receive(:process_response_for_active_question)
+          
+          subject.handle time,'person',"@quizmaster ask polar 'Should I continue the presentation?' for 3 minutes"
+          
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+  
+  
+  describe "#process_the_question" do
+    
+    context "when a polar question is asked" do
+      
+      it "should find all the components of the question" do
+        
+        expected_question = Robut::Plugin::Quiz::Polar.new 'person',"ask polar 'Should I continue the presentation?' for 3 minutes"
+        
+        subject.should_receive(:create_the_question_based_on_type).and_return(expected_question)
+        
+        subject.should_receive(:set_current_question).with(expected_question,'3')
+        subject.process_the_question 'person',"ask polar 'Should I continue the presentation?' for 3 minutes"
+        
+      end
+      
+    end
+    
+  end
+
+
+  describe "#set_current_question" do
+    
+    before :each do
+      subject.stub(:sleep)
+    end
+    
+    let(:question) do
+      Robut::Plugin::Quiz::Polar.new 'person',"ask polar 'Should I continue the presentation?' for 3 minutes"
+    end
+    
+    it "should place robut in the mode where it is asking a question" do
+      
+      subject.should_receive(:start_accepting_responses_for_this_question)
+      subject.set_current_question(question,'3')
+      
+    end
+    
+    it "should ask the question" do
+      
+      question.should_receive(:ask)
+      subject.set_current_question(question,'3')
+      
+    end
+    
+    it "should wait until the question time is done" do
+      
+      subject.should_receive(:sleep).with(180)
+      subject.set_current_question(question,'3')
+      
+    end
+    
+    context "when it is done waiting" do
+      
+      it "should take robut out of the mdoe where it is asking a question" do
+        
+        subject.should_receive(:stop_accepting_responses_for_this_question)
+        subject.set_current_question(question,'3')
+        
+      end
+      
+      it "should process the results for the question" do
+        
+        question.should_receive(:results)
+        subject.set_current_question(question,'3')
+        
+      end
+      
+    end
+    
+  end
+    
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/robut_quiz'

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: robut-quiz
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Franklin Webber
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-23 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: robut
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.3"
+  type: :runtime
+  version_requirements: *id001
+description: " Robut plugin that provides quiz asking functionality. "
+email: franklin.webber@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- History.txt
+files: 
+- Gemfile
+- Guardfile
+- History.txt
+- README.md
+- lib/polar.rb
+- lib/question.rb
+- lib/quiz.rb
+- lib/robut_quiz.rb
+- robut-quiz.gemspec
+- spec/polar_spec.rb
+- spec/quiz_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/burtlo/robut-quiz
+licenses: []
+
+post_install_message: "\n\
+  --------------------------------------------------------------------------------\n    ___\n  !(O-0)! ~ Thank you for installing robut-quiz 0.1.0 / 2011-10-23\n >==[ ]==<\n    @ @\n\n  Changes:\n    \n  * Initial Release\n  * User is able to ask polar question\n\n\
+  --------------------------------------------------------------------------------"
+rdoc_options: 
+- --charset=UTF-8
+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.10
+signing_key: 
+specification_version: 3
+summary: Quiz asking Robut
+test_files: []
+