barker 0.2.2

data/lib/barker/api/response/candidate_question.rb

@@ -0,0 +1,51 @@
+module Barker
+  module Api
+    module Response
+      class CandidateQuestion < Base
+
+        extend Forwardable
+        def_delegators :candidate_question, :id, :question_id, :candidate_id, :label, :state, :asked_at, :answered_at, :asked?, :answered?, :open?, :time_left, :timeout?, :correct?, :wrong?
+
+        def answers
+          candidate_question.answers.map { |candidate_answer| build_candidate_answer(candidate_answer) }
+        end
+
+        def given_answer
+          build_candidate_answer(candidate_question.given_answer)
+        end
+
+        def to_hash
+          {
+            'id'            => id,
+            'question_id'   => question_id,
+            'candidate_id'  => candidate_id,
+            'label'         => label,
+            'state'         => state,
+            'asked_at'      => to_i(asked_at),
+            'answered_at'   => to_i(answered_at),
+            'asked?'        => asked?, 
+            'answered?'     => answered?,
+            'open?'         => open?,
+            'time_left'     => time_left,
+            'timeout?'      => timeout?,
+            'correct?'      => correct?,
+            'wrong?'        => wrong?,
+            'answers'       => answers.map(&:to_hash),
+            'given_answer'  => given_answer? && given_answer.to_hash
+          }
+        end
+
+        private
+
+        def build_candidate_answer(candidate_answer)
+          Response::CandidateAnswer.new(:candidate_answer => candidate_answer)
+        end
+
+        def given_answer?
+          given_answer.candidate_answer
+        end
+
+      end
+    end
+  end
+end

data/lib/barker/api/response/error.rb

@@ -0,0 +1,17 @@
+module Barker
+  module Api
+    module Response
+      class Error < Base
+
+        extend Forwardable
+
+        def to_hash
+          {
+            'error' => error
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/barker/api/response/game_show.rb

@@ -0,0 +1,43 @@
+module Barker
+  module Api
+    module Response
+      class GameShow < Base
+
+        extend Forwardable
+        def_delegators :game_show, :id, :game_show_id, :joker_ids, :jokers, :started_at, :finished_at, :aborted_at, :started?, :finished?, :aborted?, :running?, :stage, :round, :next_stage?, :next_round?
+
+        def candidates
+          game_show.candidates.map {|candidate| Response::Candidate.new(:candidate => candidate)}
+        end
+
+        def rounds
+          game_show.rounds.map {|round| Response::Round.new(:round => round)}
+        end
+
+        def to_hash
+          {
+            'id'           => id,
+            'game_show_id' => game_show_id,
+            'joker_ids'    => joker_ids,
+            'jokers'       => jokers.map(&:to_hash),
+            'started_at'   => to_i(started_at),
+            'finished_at'  => to_i(finished_at),
+            'aborted_at'   => to_i(aborted_at),
+            'started?'     => started?,
+            'finished?'    => finished?,
+            'aborted?'     => aborted?,
+            'running?'     => running?,
+            'stage'        => stage,
+            'round'        => round,
+            'next_stage?'  => next_stage?,
+            'next_round?'  => next_round?,
+            'candidates'   => candidates.map(&:to_hash),
+            'rounds'       => rounds.map(&:to_hash),
+            'round_time'   => round_time
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/barker/api/response/round.rb

@@ -0,0 +1,21 @@
+module Barker
+  module Api
+    module Response
+      class Round < Base
+
+        extend Forwardable
+
+        def questions
+          round.candidate_questions.map{|candidate_question| Response::CandidateQuestion.new(:candidate_question => candidate_question) }
+        end
+
+        def to_hash
+          {
+            'questions' => questions.map(&:to_hash)
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/barker/api/response.rb

@@ -0,0 +1,15 @@
+require 'barker/api/response/base'
+require 'barker/api/response/error'
+require 'barker/api/response/game_show'
+require 'barker/api/response/round'
+require 'barker/api/response/candidate'
+require 'barker/api/response/candidate_question'
+require 'barker/api/response/candidate_answer'
+require 'barker/api/response/candidate_joker'
+
+module Barker
+  module Api
+    module Response
+    end
+  end
+end

data/lib/barker/api.rb

@@ -0,0 +1,7 @@
+require 'barker/api/base'
+require 'barker/api/response'
+
+module Barker
+  module Api
+  end
+end

data/lib/barker/candidate.rb

@@ -0,0 +1,52 @@
+module Barker
+  class Candidate
+
+    include Errors
+
+    attr_accessor :id, :locale, :joined_at, :leaved_at, :aborted_at
+
+    def initialize(object)
+      raise HasToRespondToIdError     unless object.respond_to?(:id)
+      raise HasToRespondToLocaleError unless object.respond_to?(:locale)
+
+      @id         = object.id
+      @locale     = object.locale.to_s
+      @joined_at  = nil
+      @leaved_at  = nil
+      @aborted_at = nil
+    end
+
+    def join
+      @joined_at = Time.now
+    end
+
+    def leave
+      @leaved_at = Time.now
+    end
+
+    def abort
+      @aborted_at = Time.now
+    end
+
+    def joined?
+      !!joined_at
+    end
+
+    def leaved?
+      !!leaved_at
+    end
+
+    def aborted?
+      !!aborted_at
+    end
+
+    def jokers
+      @jokers ||= []
+    end
+
+    def candidate_id
+      id
+    end
+
+  end
+end

data/lib/barker/candidate_answer.rb

@@ -0,0 +1,42 @@
+module Barker
+  class CandidateAnswer
+
+    attr_accessor :candidate, :answer, :reveal_answer
+  
+    def initialize(candidate, answer)
+      @candidate = candidate
+      @answer    = answer
+      @revealed  = false
+    end
+
+    def valid?
+      answer.valid?
+    end
+
+    def label
+      answer.label[candidate.locale] || answer.label["en"]
+    end
+
+    def revealed?
+      @revealed
+    end
+
+    def reveal
+      @revealed = true
+    end
+
+    def correct?
+      answer.correct?
+    end
+
+    def answer_id
+      answer.id
+    end
+    alias :id :answer_id
+
+    def candidate_id
+      candidate.id
+    end
+
+  end
+end

data/lib/barker/candidate_joker.rb

@@ -0,0 +1,30 @@
+module Barker
+  class CandidateJoker
+
+    include Errors
+
+    attr_reader :used_at, :used_in
+
+    def initialize(candidate_question, joker)
+      @candidate_question = candidate_question
+      @joker   = joker
+    end
+
+    def joker_id
+      @joker.id
+    end
+    alias :id :joker_id
+
+    def candidate_id
+      @candidate_question.candidate_id
+    end
+
+    def call
+      raise UnknownJokerError unless @joker
+      @used_at = Time.now
+      @used_in = @candidate_question
+      @joker.call(@used_in)
+    end
+  end
+end
+

data/lib/barker/candidate_question.rb

@@ -0,0 +1,116 @@
+module Barker
+  class CandidateQuestion
+
+    include Errors
+
+    attr_reader :candidate, :question, :answers, :given_answer
+    attr_accessor :answered_at, :asked_at, :timer
+
+    def initialize(candidate, question, options = {})
+      @candidate    = candidate
+      @question     = question
+      @answers      = question.answers.map { |answer| CandidateAnswer.new(candidate, answer) }
+
+      @given_answer = nil
+      @asked_at     = nil
+      @answered_at  = nil
+      @timer        = options[:timer] || nil
+    end
+
+    def ask(options = {})
+      if !asked? || options[:reset_timer]
+        @asked_at = Time.now
+      end
+      self
+    end
+
+    def answer(answer_id)
+      raise AlreadyAnsweredError  if answered?
+      raise AnswerNotFoundError   unless @given_answer = answers.find {|answer| answer.id == answer_id }
+      @answered_at = Time.now
+      given_answer
+    end
+
+    def joker(joker)
+      raise JokerAlreadyUsedError if joker_played?(joker) 
+      CandidateJoker.new(self, joker).tap do |candidate_joker|
+        candidate_joker.call
+        candidate.jokers << candidate_joker
+      end
+    end
+
+    def valid?
+      question.valid? && timestamps? && asked_before_answered?
+    end
+
+    def open?
+      !asked? && !answered?
+    end
+
+    def asked?
+      !!asked_at
+    end
+
+    def answered?
+      !!answered_at
+    end
+
+    def correct?
+      !!given_answer.try(:correct?)
+    end
+
+    def wrong?
+      !correct?
+    end
+
+    def state
+      if open?
+        :open
+      elsif answered?
+        correct?? :correct : :wrong
+      elsif asked?
+        :asked
+      end
+    end
+
+    def question_id
+      question.id
+    end
+    alias :id :question_id
+
+    def candidate_id
+      candidate.id
+    end
+
+    def label
+      question.label[candidate.locale] || question.label["en"]
+    end
+
+    def timeout?
+      timer.nil?? false : !(time_left.try(:>, 0))
+    end
+
+    def time_left
+      left = timer.try(:-, delay)
+      (left.try(:>=, 0))? left : 0
+    end
+
+    private
+
+    def delay
+      (asked_at.try(:-, answered_at || Time.now) || 0).abs
+    end
+
+    def timestamps?
+      asked_at && answered_at
+    end
+
+    def asked_before_answered?
+      answered_at >= asked_at
+    end
+
+    def joker_played?(joker)
+      candidate.jokers.any? {|candidate_joker| candidate_joker.id == joker.id}
+    end
+  end
+end

data/lib/barker/candidate_round.rb

@@ -0,0 +1,32 @@
+module Barker
+  class CandidateRound
+    attr_reader :candidate, :round, :guideline, :timer
+
+    def initialize(candidate, round, options = {})
+      @candidate = candidate
+      @round = round
+      @guideline = options[:guideline]
+      @timer = guideline.try(:round_time)
+    end
+
+    def question
+      @question ||= CandidateQuestion.new(candidate, round.question, :timer => timer)
+    end
+
+    def ask(options = {})
+      question.ask(options)
+    end
+
+    def answer(answer_id)
+      question.answer(answer_id)
+    end
+
+    def given_answer
+      question.given_answer
+    end
+
+    def joker(joker)
+      question.joker(joker)
+    end
+  end
+end

data/lib/barker/entity.rb

@@ -0,0 +1,15 @@
+module Barker
+  class Entity < Struct
+
+    include ActiveModel::Validations
+
+    def self.model_name
+      ActiveModel::Name.new(self, nil, self.to_s)
+    end
+
+    def ==(other)
+      id == other.id
+    end
+
+  end
+end

data/lib/barker/game_show.rb

@@ -0,0 +1,176 @@
+module Barker
+  class GameShow
+
+    include Errors
+
+    attr_accessor :id
+    attr_reader :quizzes, :candidates, :guideline, :jokers, :guideline, :created_at, :started_at, :finished_at, :aborted_at
+
+    def initialize(quizzes, candidates, options = {})
+      @started_at     = nil
+      @finished_at    = nil
+      @aborted_at     = nil
+      @created_at     = Time.now
+      @stage          = -1
+      @guideline      = build_guideline(options[:guideline] || :base)
+      @quizzes        = build_quizzes(quizzes)
+      @candidates     = build_candidates(candidates) 
+      @jokers         = build_jokers
+      @stages         = []
+    end
+
+    def ==(other)
+      created_at == other.created_at
+    end
+
+    def valid?
+      started? && stages.any? && candidates.any?
+    end
+
+    def game_show_id
+      id
+    end
+
+    # state
+    def start
+      @stages += quizzes.map { |quiz| Stage.new(quiz, candidates, :guideline => guideline) }
+      @started_at = Time.now unless started_at
+    end
+
+    def finish
+      @finished_at = Time.now unless finished_at
+    end
+
+    def abort
+      @aborted_at = Time.now unless aborted_at
+    end
+
+    def started?
+      !!started_at
+    end
+
+    def finished?
+      !!finished_at
+    end
+
+    def aborted?
+      !!aborted_at
+    end
+
+    def running?
+      started? && !finished? && !aborted?
+    end
+
+    # stage
+    def stages
+      raise NotStartedError unless started?
+      @stages
+    end
+
+    def current_stage
+      stage != -1 && @stages[stage]
+    end
+
+    def next_stage
+      @stage += 1
+    end
+
+    def next_stage?
+      !!@stages[stage + 1]
+    end
+
+    # round
+    def current_round
+      current_stage && current_stage.current_round || nil
+    end
+
+    def next_round
+      current_stage && current_stage.next_round || nil
+    end
+
+    def next_round?
+      current_stage && current_stage.next_round?
+    end
+
+    def join(candidate)
+      raise AlreadyStartedError if started?
+      candidate.join
+      @candidates ||= []
+      @candidates << candidate
+      candidate
+    end
+
+    def leave(candidate_id)
+      candidate = candidates.find {|candidate| candidate.id == candidate_id }
+      candidate.leave
+      candidate
+    end
+
+    def ask(candidate_id, options = {})
+      current_round.ask(candidate_id, options)
+    end
+
+    def answer(candidate_id, answer_id)
+      guideline.answer(current_round.candidate_round(candidate_id), candidate_id, answer_id)
+      current_round.answer(candidate_id, answer_id)
+    end
+
+    def given_answer(candidate_id)
+      current_round.given_answer(candidate_id)
+    end
+
+    def joker(candidate_id, joker_id)
+      joker = jokers.find{|joker| joker.id == joker_id }
+      candidate = candidates.find{|candidate| candidate.id == candidate.id }
+      current_round.joker(candidate, joker)
+    end
+
+    def joker_ids
+      jokers.map(&:id)
+    end
+
+    # NOTE: ignore stages for the moment - merge rounds from all stages together
+    def rounds
+      @stages.map{|stage| stage.rounds }.flatten
+    end
+
+    def self.load(serialized)
+      Marshal::load(Base64.decode64(serialized))
+    end
+
+    def serialize
+      Base64.encode64(Marshal::dump(self))
+    end
+
+    def stage
+      @stage
+    end
+
+    def round
+      current_stage && current_stage.try(:round_counter) || -1
+    end
+
+    def round_time
+      @guideline.round_time
+    end
+
+    private
+
+    def build_guideline(key)
+      "Barker::Guideline::#{key.to_s.classify}".constantize.new
+    end
+
+    def build_quizzes(quizzes)
+      (quizzes && quizzes.any?)? quizzes : guideline.quizzes
+    end
+
+    def build_candidates(candidates)
+      ((candidates && candidates.any?)? candidates : guideline.candidates).map {|candidate| self.join(candidate) }
+    end
+
+    def build_jokers
+      guideline.jokers.map {|joker_key| Joker.new(joker_key) }
+    end
+
+  end
+end

data/lib/barker/guideline/base.rb

@@ -0,0 +1,33 @@
+module Barker
+  module Guideline
+    class Base
+
+      include Errors
+
+      def initialize(options = {})
+      end
+
+      def quizzes
+        []
+      end
+
+      def candidates
+        []
+      end
+
+      def jokers
+        []
+      end
+
+      def round_time
+        nil
+      end
+
+      def answer(current_round, candidate_id, answer_id)
+        nil
+      end
+
+    end
+
+  end
+end