barker 0.2.2

data/lib/barker/store/memory.rb

@@ -0,0 +1,158 @@
+require 'thread_safe'
+
+module Barker
+  module Store
+    class Memory
+      def initialize(key, options = {})
+        @key        = key
+        @index      = ThreadSafe::Cache.new
+        @build_key  = options[:build_key] || false
+        init_index options[:init]
+      end
+
+      def add(item)
+        key = lookup_key(item)
+
+        raise DuplicateError if exist?(key)
+
+        __add(key, item)
+        item
+      end
+
+      def update(item)
+        key = key(item)
+        raise NotFoundError unless exist?(key)
+        @index[key] = deep_copy(item)
+      end
+
+      def remove(item)
+        key = key(item)
+        raise NotFoundError unless exist?(key)
+        @index.delete(key)
+      end
+
+      def filter(&block)
+        @index.values.select(&block)
+      end
+
+      def exist?(key)
+        @index.key?(key)
+      end
+
+      def get(key)
+        if item = __get(key)
+          deep_copy(item)
+        end
+      end
+
+      def select(group_by, *values)
+        conditions = Hash[Array(group_by).each_with_index.map do |group, i|
+          [group, values[i]]
+        end]
+
+        __all.select do |item|
+          conditions.each.all? do |k, v|
+            item.respond_to?(k) && item.public_send(k) == v
+          end
+        end
+      end
+
+      def all
+        deep_copy(__all)
+      end
+
+      def size
+        @index.size
+      end
+
+      def reload(item)
+        if item
+          get(key(item))
+        else
+          nil
+        end
+      end
+
+      def update_attributes(key, attributes)
+        if item = __get(key)
+          attributes.each do |attribute, value|
+            item.public_send("#{attribute}=", value)
+          end
+        end
+
+        get(key)
+      end
+
+      private
+
+      def key(item)
+        item.send(@key)
+      end
+
+      def deep_copy(object)
+        Marshal.load(Marshal.dump(object))
+      end
+
+      def __get(key)
+        @index[key]
+      end
+
+      def __add(key, item)
+        copy = deep_copy(item)
+        add_to_index key, copy
+      end
+
+      def __all
+        @index.values
+      end
+
+      def each_group(&block)
+        @group_by.each(&block)
+      end
+
+      def add_to_index(key, item)
+        @index[key] = item
+      end
+
+      def build_key?
+        @build_key
+      end
+
+      def lookup_key(item)
+        if build_key?
+          assign_generated_key(item)
+        else
+          key(item)
+        end
+      end
+
+      def assign_generated_key(item)
+        raise KeyPresetError if key(item)
+        key = next_key!
+        item.send("#{@key}=", key)
+        key
+      end
+
+      def next_key!
+        @current_key ||= 0
+        (@current_key += 1).to_s
+      end
+
+      def init_index(items = nil)
+        if items
+          unless build_key?
+            keys = Hash.new {|h,k| h[k] = 0}
+            items.each do |item|
+              keys[key(item)] += 1
+            end
+            raise DuplicateError if keys.values.any?{|v| v > 1}
+          end
+
+          items.each do |item|
+            __add(lookup_key(item), item)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/barker/store.rb

@@ -0,0 +1,6 @@
+require 'barker/store/memory'
+
+module Barker
+  module Store
+  end
+end

data/lib/barker/validations.rb

@@ -0,0 +1,14 @@
+module Barker
+  module Validations
+    module NumericalityOfId
+      def self.included(base)
+        base.validate :numericality_of_id
+      end
+
+      def numericality_of_id
+        self.class.validates :id, :numericality => { :only_integer => true }
+        errors.add(:id, 'is not a number') if id.kind_of? String
+      end
+    end
+  end
+end

data/lib/barker/version.rb

@@ -0,0 +1,3 @@
+module Barker
+  VERSION = "0.2.2"
+end

data/lib/barker.rb

@@ -0,0 +1,45 @@
+module Barker
+  module Errors
+    BarkerError = Class.new(RuntimeError)
+
+    AlreadyAnsweredError = Class.new(BarkerError)
+    AnswerNotFoundError = Class.new(BarkerError)
+    JokerAlreadyUsedError = Class.new(BarkerError)
+    HasToRespondToIdError = Class.new(BarkerError)
+    HasToRespondToLocaleError = Class.new(BarkerError)
+    UnknownJokerError = Class.new(BarkerError)
+    NoCurrentStageError = Class.new(BarkerError)
+    NotStartedError = Class.new(BarkerError)
+    AlreadyStartedError = Class.new(BarkerError)
+    FileNotExistError = Class.new(BarkerError)
+    RecordNotFound = Class.new(BarkerError)
+  end
+end
+
+require 'forwardable'
+require 'active_support/all'
+require 'active_model'
+
+require "barker/version"
+require "barker/validations"
+
+require "barker/store"
+require "barker/repo"
+require "barker/api"
+require "barker/guideline"
+require "barker/import"
+
+require "barker/game_show"
+require "barker/entity"
+require "barker/answer"
+require "barker/question"
+require "barker/quiz"
+require "barker/stage"
+require "barker/round"
+require "barker/joker"
+require "barker/candidate"
+
+require "barker/candidate_answer"
+require "barker/candidate_question"
+require "barker/candidate_round"
+require "barker/candidate_joker"

data/test/factories/answer.rb

@@ -0,0 +1,21 @@
+FactoryGirl.define do
+  factory :answer, :class => Barker::Answer do
+    sequence(:id)       { |i| i }
+    sequence(:label)    {{ "en" => "answer", "de" => "antwort" }}
+    sequence(:correct)  { |i| i.odd? }
+
+    trait :correct do
+      correct true
+    end
+
+    trait :wrong do
+      correct false
+    end
+
+    trait :invalid do
+      id "not_a_number"
+    end
+
+    initialize_with { new(id, label, correct) }
+  end
+end

data/test/factories/candidate.rb

@@ -0,0 +1,23 @@
+require 'test_mocks'
+
+FactoryGirl.define do
+  factory :candidate, :class => Barker::Candidate do
+    sequence(:object) {|i| Mock::ValidUser.new(:id => i)}
+    initialize_with { new(object) }
+  end
+
+  factory :valid_candidate, :class => Barker::Candidate do
+    sequence(:object) {|i| Mock::ValidUser.new(:id => i)}
+    initialize_with { new(object) }
+  end
+
+  factory :candidate_without_id, :class => Barker::Candidate do
+    object          { Mock::UserWithoutId.new }
+    initialize_with { new(object) }
+  end
+
+  factory :candidate_without_locale, :class => Barker::Candidate do
+    object          { Mock::UserWithoutLocale.new }
+    initialize_with { new(object) }
+  end
+end

data/test/factories/candidate_answer.rb

@@ -0,0 +1,12 @@
+FactoryGirl.define do
+  factory :candidate_answer, :class => Barker::CandidateAnswer do
+    candidate { FactoryGirl.build(:candidate) }
+    answer { FactoryGirl.build(:answer) }
+
+    trait :invalid do
+      answer { FactoryGirl.build(:answer, :invalid) }
+    end
+
+    initialize_with { new(candidate, answer) }
+  end
+end

data/test/factories/candidate_joker.rb

@@ -0,0 +1,8 @@
+FactoryGirl.define do
+  factory :candidate_joker, :class => Barker::CandidateJoker do
+    candidate { FactoryGirl.build(:candidate) }
+    joker { FactoryGirl.build(:joker) }
+
+    initialize_with { new(candidate, joker) }
+  end
+end

data/test/factories/candidate_question.rb

@@ -0,0 +1,16 @@
+FactoryGirl.define do
+  factory :candidate_question, :class => Barker::CandidateQuestion do
+    candidate { FactoryGirl.build(:candidate) }
+    question { FactoryGirl.build(:question) }
+
+    trait :valid do
+      asked_at { Time.now }
+      answered_at { Time.now + 1 }
+    end
+
+    trait :invalid do
+    end
+
+    initialize_with { new(candidate, question) }
+  end
+end

data/test/factories/candidate_round.rb

@@ -0,0 +1,8 @@
+FactoryGirl.define do
+  factory :candidate_round, :class => Barker::CandidateRound do
+    round { FactoryGirl.build(:round) }
+    candidate { round.candidates[0] }
+
+    initialize_with { new(candidate, round) }
+  end
+end

data/test/factories/game_show.rb

@@ -0,0 +1,12 @@
+FactoryGirl.define do
+  factory :game_show, :class => Barker::GameShow do
+    candidates { FactoryGirl.build_list(:candidate, 2) }
+    quizzes { FactoryGirl.build_list(:quiz, 2) }
+
+    trait :invalid do
+      candidates { [] }
+    end
+
+    initialize_with { new(quizzes, candidates) }
+  end
+end

data/test/factories/joker.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :joker, :class => Barker::Joker do
+    initialize_with { new("fifty_fifty") }
+  end
+end

data/test/factories/question.rb

@@ -0,0 +1,13 @@
+FactoryGirl.define do
+  factory :question, :class => Barker::Question do
+    sequence(:id) { |i| i }
+    label         {{ "en" => "question", "de" => "frage" }}
+    answers       { FactoryGirl.build_list(:answer, 2) }
+
+    trait :invalid do
+      id "not_a_number"
+    end
+
+    initialize_with { new(id, label, answers) }
+  end
+end

data/test/factories/quiz.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  factory :quiz, :class => Barker::Quiz do
+    questions { FactoryGirl.build_list(:question, 2) }
+
+    trait :invalid do
+      questions { [FactoryGirl.build(:question),FactoryGirl.build(:question, :invalid)] }
+    end
+
+    initialize_with { new(questions) }
+  end
+end

data/test/factories/round.rb

@@ -0,0 +1,12 @@
+FactoryGirl.define do
+  factory :round, :class => Barker::Round do
+    question { FactoryGirl.build(:question) }
+    candidates { FactoryGirl.build_list(:candidate, 2) }
+
+    trait :invalid do
+      question { FactoryGirl.build(:question, :invalid) }
+    end
+
+    initialize_with { new(question, candidates) }
+  end
+end

data/test/factories/stage.rb

@@ -0,0 +1,12 @@
+FactoryGirl.define do
+  factory :stage, :class => Barker::Stage do
+    quiz { FactoryGirl.build(:quiz) }
+    candidates { FactoryGirl.build_list(:candidate, 2) }
+
+    trait :invalid do
+      quiz { FactoryGirl.build(:quiz, :invalid) }
+    end
+
+    initialize_with { new(quiz, candidates) }
+  end
+end

data/test/fixtures/questions.yaml

@@ -0,0 +1,20 @@
+1:
+  label:
+    de: Wann ist der SuperCode nach Kauf einlösbar?
+  answers:
+    1:
+      correct: false
+      label:
+        de: 10 Minuten
+    2:
+      correct: true
+      label:
+        de: 30 Minuten
+    3:
+      correct: false
+      label:
+        de: 5 Minuten
+    4:
+      correct: false
+      label:
+        de: sofort

data/test/test_helper.rb

@@ -0,0 +1,72 @@
+require 'bundler/setup'
+require 'simplecov' if ENV['COVERAGE']
+require 'minitest/autorun'
+require 'barker'
+require 'factory_girl'
+require 'mocha/setup'
+require 'test_mocks'
+
+class Spec < MiniTest::Spec
+  FactoryGirl.find_definitions
+
+  class << self
+    alias :context :describe
+    alias :test :it
+  end
+
+  # time
+  let(:time)                            { Time.parse('20:00') }
+  let(:started_at)                      { time }
+  let(:asked_at)                        { started_at + 2.seconds }
+  let(:finished_at)                     { started_at + 120.seconds }
+  let(:answered_at)                     { asked_at + 20.seconds }
+  let(:delay)                           { answered_at - asked_at }
+
+  # candidate
+  let(:candidates)                      { [FactoryGirl.build(:candidate)] }
+  let(:candidate)                       { candidates.first }
+  let(:candidate_without_id)            { FactoryGirl.build(:candidate_without_id) }
+  let(:candidate_without_locale)        { FactoryGirl.build(:candidate_without_locale) }
+
+  # answer
+  let(:answers)                         { [correct_answer, wrong_answer] }
+  let(:answer)                          { answers.first }
+  let(:correct_answer)                  { FactoryGirl.build(:answer, :correct, :id => 1) }
+  let(:wrong_answer)                    { FactoryGirl.build(:answer, :wrong, :id => 2) }
+  let(:candidate_answer)                { Barker::CandidateAnswer.new(candidate, answer) }
+
+  # question
+  let(:questions)                       { FactoryGirl.build_list(:question, 2, :answers => answers) }
+  let(:question)                        { questions.first }
+  let(:candidate_question)              { Barker::CandidateQuestion.new(candidate, question) }
+
+  # quiz
+  let(:quiz)                            { Barker::Quiz.new(questions) }
+
+  # quizshow
+  let(:quizshow)                        { Barker::Quizshow.create(quiz, candidates) }
+
+  def fake_ctime(file, time)
+    $ctime_fake_hash = {
+        file => time
+    }
+    File.class_eval do
+      class << self
+        alias :old_ctime :ctime
+
+        def ctime(filepath)
+          $ctime_fake_hash[filepath] || old_ctime(filepath)
+        end
+      end
+    end
+
+    yield
+  ensure
+    File.class_eval do
+      class << self
+        alias :ctime :old_ctime
+      end
+    end
+  end
+
+end

data/test/test_mocks.rb

@@ -0,0 +1,21 @@
+module Mock
+  class ValidUser
+    attr_reader :id
+
+    def initialize(options = {})
+      @id = options.delete(:id) || rand(Time.now.to_i)
+    end
+
+    def locale
+      :en
+    end
+  end
+
+  class UserWithoutId < ValidUser
+    undef :id
+  end
+
+  class UserWithoutLocale < ValidUser
+    undef :locale
+  end
+end

data/test/unit/answer_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+module Barker
+  class AnswerTest < Spec
+
+    test "interface" do
+      Barker::Answer.new(1, {"en" => "label"}, true)
+    end
+
+    test "valid factory" do
+      assert FactoryGirl.build(:answer).valid?
+    end
+
+    test "invalid factory" do
+      refute FactoryGirl.build(:answer, :invalid).valid?
+    end
+
+    test "validate numerically of id" do
+      assert FactoryGirl.build(:answer, :id => 1).valid?
+      refute FactoryGirl.build(:answer, :id => 1.5).valid?
+      refute FactoryGirl.build(:answer, :id => "1").valid?
+    end
+
+    test "equality by id" do
+      assert_equal FactoryGirl.build(:answer, :id => 1), FactoryGirl.build(:answer, :id => 1)
+      refute_equal FactoryGirl.build(:answer, :id => 1), FactoryGirl.build(:answer, :id => 2)
+    end
+
+    test "id" do
+      assert_equal 1, FactoryGirl.build(:answer, :id => 1).id
+    end
+
+    test "label" do
+      label = { "en" => "answer", "de" => "antwort" }
+      assert_equal label, FactoryGirl.build(:answer, :label => label).label
+    end
+
+    test "correct?" do
+      assert correct.correct?
+      refute wrong.correct?
+    end
+
+    private
+
+    let(:correct) { FactoryGirl.build(:answer, :correct) }
+    let(:wrong)   { FactoryGirl.build(:answer, :wrong) }
+
+  end
+end