triviacrack 0.1.0

data/lib/triviacrack/api/question.rb

@@ -0,0 +1,43 @@
+require "triviacrack/api/common"
+require "triviacrack/parsers/game_parser"
+
+# Public: All methods in this module make requests to the Trivia Crack answers
+# API.
+module TriviaCrack
+  module API
+    module Question
+
+      include TriviaCrack::API::Common
+
+      # Public: Uses the Trivia Crack API to answer the given question.
+      #
+      # game      - The ID of the TriviaCrack::Game.
+      # question  - The TriviaCrack::Question.
+      # answer    - The index of the answer to be submitted.
+      #
+      # Examples
+      #
+      #   answer_question game.id, question, 1
+      #
+      # Returns a boolean indicating whether or not the question was answered
+      # correctly, and the updated TriviaCrack::Game object.
+      # Raises TriviaCrack::Errors::RequestError if the request fails
+      def answer_question(game_id, question, answer)
+        response =
+          post "/api/users/#{@session.user_id}/games/#{game_id}/answers",
+                parameters: { type: question.type.upcase,
+                              answers: [{
+                                id: question.id,
+                                answer: answer,
+                                category: question.category.upcase
+                                }]
+                            }.to_json
+
+        game = TriviaCrack::Parsers::GameParser.parse response.body
+
+        [game, answer == question.correct_answer]
+      end
+
+    end
+  end
+end

data/lib/triviacrack/api/user.rb

@@ -0,0 +1,56 @@
+require "triviacrack/api/common"
+require "triviacrack/parsers/user_parser"
+
+# Public: All methods in this module make requests to the Trivia Crack users
+# API.
+module TriviaCrack
+  module API
+    module User
+
+      include TriviaCrack::API::Common
+
+      # Public: Uses the Trivia Crack Search API to find the numeric user id of
+      # the user identified by the given username.
+      #
+      # username  - Trivia Crack username of a user (e.g. "@example").
+      #
+      # Examples
+      #
+      #   get_user_id "@example"
+      #
+      # Returns the user id of the user.
+      # Raises TriviaCrack:Errors::RequestError if the request fails.
+      def get_user_id(username)
+        # Trim the @ character from the start of the username
+        if username.start_with? "@"
+          username = username[1..-1]
+        end
+
+        response = get "/api/search?username=#{username}"
+
+        body = response.body
+
+        user_id = false
+        body["list"].each do |user|
+          if user["username"] == username
+            user_id = user["id"]
+            break
+          end
+        end
+
+        user_id
+      end
+
+      # Public: Uses the Trivia Crack API to retrieve the user data.
+      #
+      # Returns a TriviaCrack::User representing the current user.
+      # Raises TriviaCrack::Errors::RequestError if the request fails
+      def get_user
+        response = get "/api/users/#{@session.user_id}"
+
+        TriviaCrack::Parsers::UserParser.parse response.body
+      end
+
+    end
+  end
+end

data/lib/triviacrack/category_statistics.rb

@@ -0,0 +1,27 @@
+# Public: An object representing category statistics for a player within a
+# single Trivia Crack game.
+module TriviaCrack
+  class CategoryStatistics
+
+    # Public: The category for these statistics (:arts, :geography, etc).
+    attr_reader :category
+
+    # Public: The number of questions answered correctly for this category.
+    attr_reader :correct
+
+    # Public: The number of questions answered incorrectly for this category.
+    attr_reader :incorrect
+
+    # Public: Boolean indicating whether this is the worst category for the
+    # player.
+    attr_reader :worst
+
+    def initialize(category: nil, correct: nil, incorrect: nil, worst: nil)
+      @category  = category
+      @correct   = correct
+      @incorrect = incorrect
+      @worst     = worst
+    end
+
+  end
+end

data/lib/triviacrack/errors/parse_error.rb

@@ -0,0 +1,7 @@
+# Public: This error is raised when a block of data cannot be correctly parsed.
+module TriviaCrack
+  module Errors
+    class ParseError < StandardError
+    end
+  end
+end

data/lib/triviacrack/errors/request_error.rb

@@ -0,0 +1,18 @@
+# Public: This error is raised when a web request to the Trivia Crack API is
+# unsuccessful.
+module TriviaCrack
+  module Errors
+    class RequestError < StandardError
+
+      # Public: The HTTP status code returned by the Trivia Crack server.
+      attr_reader :code
+
+      # Public: Initializes a RequestError.
+      #
+      # code - The HTTP status code returned by the Trivia Crack server.
+      def initialize(code)
+        @code = code
+      end
+    end
+  end
+end

data/lib/triviacrack/game.rb

@@ -0,0 +1,100 @@
+# Public: An object representing a Trivia Crack Game, including information
+# about the questions to be asked in the game, the state of the game, opponent
+# information, and more.
+module TriviaCrack
+  class Game
+
+    # Public: The unique identifier of the game.
+    attr_reader :id
+
+    # Public: The TriviaCrack::User information for the opponent.
+    attr_reader :opponent
+
+    # Public: The current status of the game (e.g. :active, :ended,
+    # :pending_approval).
+    attr_reader :game_status
+
+    # Public: The language used for the game (e.g. :en).
+    attr_reader :language
+
+    # Public: The datetime on which the game was created.
+    attr_reader :created
+
+    # Public: The datetime on which the last turn was taken.
+    attr_reader :last_turn
+
+    # Public: The type of the game (:normal, :duel)
+    attr_reader :type
+
+    # Public: The datetime on which the game will expire.
+    attr_reader :expiration_date
+
+    # Public: Boolean indicating whether it is the user's turn.
+    attr_reader :my_turn
+
+    # Public: The number of the current round.
+    attr_reader :round_number
+
+    # Public: Boolean indicating whether the game was created with a random
+    # opponent.
+    attr_reader :is_random
+
+    # Public: Number of unread messages.
+    attr_reader :unread_messages
+
+    # Public: The status version.
+    attr_reader :status_version
+
+    # Public: Array of available crowns that can be won by the user.
+    attr_reader :available_crowns
+
+    # Public: Array of questions that can be answered by the user. This array
+    # will be empty if the user is unable to play (i.e. not their turn).
+    attr_reader :questions
+
+    # Public: TriviaCrack::GameStatistics for the user.
+    attr_reader :my_statistics
+
+    # Public: TriviaCrack::GameStatistics for the opponent.
+    attr_reader :opponent_statistics
+
+    def initialize(id:, opponent: nil, game_status: nil, language: nil,
+                   created: nil, last_turn: nil, type: nil,
+                   expiration_date: nil, my_turn: nil, round_number: nil,
+                   is_random: nil, unread_messages: nil, status_version: nil,
+                   available_crowns: nil, questions: nil, my_statistics: nil,
+                   opponent_statistics: nil)
+      @id                   = id
+      @opponent             = opponent
+      @game_status          = game_status
+      @language             = language
+      @created              = created
+      @last_turn            = last_turn
+      @type                 = type
+      @expiration_date      = expiration_date
+      @my_turn              = my_turn
+      @round_number         = round_number
+      @is_random            = is_random
+      @unread_messages      = unread_messages
+      @status_version       = status_version
+      @available_crowns     = available_crowns
+      @questions            = questions
+      @my_statistics        = my_statistics
+      @opponent_statistics  = opponent_statistics
+    end
+
+    # Public: Returns true if the game has not ended and it is the user's turn.
+    #
+    # Examples
+    #
+    #   if game.playable?
+    #     ... do something ...
+    #   end
+    #
+    # Returns a boolean indicating if the game is playable.
+    def playable?
+      @my_turn && @game_status != :ended
+    end
+
+  end
+end

data/lib/triviacrack/game_statistics.rb

@@ -0,0 +1,35 @@
+# Public: An object representing player statistics for a Trivia Crack game.
+module TriviaCrack
+  class GameStatistics
+
+    # Public: The number of questions answered correctly.
+    attr_reader :correct_answers
+
+    # Public: The number of questions answered incorrectly.
+    attr_reader :incorrect_answers
+
+    # Public: The total number of questions answered.
+    attr_reader :questions_answered
+
+    # Public: The total number of challenges won.
+    attr_reader :challenges_won
+
+    # Public: The list of categories for which crowns have been won.
+    attr_reader :crowns
+
+    # Public: A hash of category statistics.
+    attr_reader :categories
+
+    def initialize(correct_answers: nil, incorrect_answers: nil,
+                   questions_answered: nil, challenges_won: nil,
+                   crowns: nil, categories: nil)
+      @correct_answers    = correct_answers
+      @incorrect_answers  = incorrect_answers
+      @questions_answered = questions_answered
+      @challenges_won     = challenges_won
+      @crowns             = crowns
+      @categories         = categories
+    end
+
+  end
+end

data/lib/triviacrack/parsers/category_statistics_parser.rb

@@ -0,0 +1,45 @@
+require "triviacrack/category_statistics"
+
+# Internal: This module is used to parse data returned from the Trivia Crack API
+# into a ruby object that represents category statistics for a Trivia Crack
+# game.
+module TriviaCrack
+  module Parsers
+    module CategoryStatisticsParser
+
+      # Internal: Parses data returned from the Trivia Crack API to create
+      # TriviaCrack::CategoryStatistics objects.
+      #
+      # raw_data - A hash of the raw data returned by the Trivia Crack API.
+      #
+      # Examples
+      #
+      #   raw_data = get_raw_data_from_API
+      #   ...
+      #   stats = TriviaCrack::Parsers::CategoryStatisticsParser.parse raw_data
+      #
+      # Returns a hash of TriviaCrack::CategoryStatistics objects, keyed by
+      # category.
+      def self.parse(raw_data)
+        categories = {}
+
+        if raw_data
+          raw_data.each do |category|
+            category_name = category["category"].downcase.to_sym
+
+            categories[category_name] =
+              TriviaCrack::CategoryStatistics.new(
+                category: category_name,
+                correct: category["correct"],
+                incorrect: category["incorrect"],
+                worst: category["worst"]
+              )
+          end
+        end
+
+        categories
+      end
+
+    end
+  end
+end

data/lib/triviacrack/parsers/game_parser.rb

@@ -0,0 +1,74 @@
+require "triviacrack/game"
+require "triviacrack/parsers/game_statistics_parser"
+require "triviacrack/parsers/question_parser"
+require "triviacrack/parsers/time_parser"
+require "triviacrack/parsers/user_parser"
+
+# Internal: This module is used to parse data returned from the Trivia Crack API
+# into a ruby object that represents a Trivia Crack game.
+module TriviaCrack
+  module Parsers
+    module GameParser
+
+      # Internal: Parses data returned from the Trivia Crack API to create a
+      # TriviaCrack::Game object.
+      #
+      # raw_data - A hash of the raw data returned by the Trivia Crack API.
+      #
+      # Examples
+      #
+      #   raw_data = get_raw_data_from_API
+      #   ...
+      #   game = TriviaCrack::Parsers::GameParser.parse raw_data
+      #
+      # Returns a TriviaCrack::Game.
+      def self.parse(raw_data)
+        questions = []
+        if raw_data["spins_data"]
+          raw_data["spins_data"]["spins"][0]["questions"].each do |q_data|
+            q_data = q_data["question"]
+            q_data["type"] = raw_data["spins_data"]["spins"][0]["type"]
+            question = TriviaCrack::Parsers::QuestionParser.parse q_data
+            questions << question
+          end
+        end
+
+        if raw_data["available_crowns"]
+          crowns = raw_data["available_crowns"].map { |c| c.downcase.to_sym }
+        else
+          crowns = []
+        end
+
+        me = raw_data["my_player_number"] == 1 ? "player_one" : "player_two"
+        them = raw_data["my_player_number"] == 1 ? "player_two" : "player_one"
+
+        my_statistics = raw_data["statistics"]["#{me}_statistics"]
+        my_statistics["crowns"] = raw_data[me]["crowns"]
+
+        opponent_statistics = raw_data["statistics"]["#{them}_statistics"]
+        opponent_statistics["crowns"] = raw_data[them]["crowns"]
+
+        TriviaCrack::Game.new(
+          id: raw_data["id"],
+          opponent: UserParser.parse(raw_data["opponent"]),
+          game_status: raw_data["game_status"].downcase.to_sym,
+          language: raw_data["language"].downcase.to_sym,
+          created: TimeParser.parse(raw_data["created"]),
+          last_turn: TimeParser.parse(raw_data["last_turn"]),
+          type: raw_data["type"].downcase.to_sym,
+          expiration_date: TimeParser.parse(raw_data["expiration_date"]),
+          my_turn: raw_data["my_turn"],
+          round_number: raw_data["round_number"],
+          is_random: raw_data["is_random"],
+          unread_messages: raw_data["unread_messages"],
+          status_version: raw_data["status_version"],
+          available_crowns: crowns,
+          questions: questions,
+          my_statistics: GameStatisticsParser.parse(my_statistics),
+          opponent_statistics: GameStatisticsParser.parse(opponent_statistics)
+        )
+      end
+
+    end
+  end
+end

data/lib/triviacrack/parsers/game_statistics_parser.rb

@@ -0,0 +1,44 @@
+require "triviacrack/game_statistics"
+require "triviacrack/parsers/category_statistics_parser"
+
+# Internal: This module is used to parse data returned from the Trivia Crack API
+# into a ruby object that represents player statistics for a Trivia Crack game.
+module TriviaCrack
+  module Parsers
+    module GameStatisticsParser
+
+      # Internal: Parses data returned from the Trivia Crack API to create a
+      # TriviaCrack::GameStatistics object.
+      #
+      # raw_data - A hash of the raw data returned by the Trivia Crack API.
+      #
+      # Examples
+      #
+      #   raw_data = get_raw_data_from_API
+      #   ...
+      #   stats = TriviaCrack::Parsers::GameStatisticsParser.parse raw_data
+      #
+      # Returns a TriviaCrack::GameStatistics.
+      def self.parse(raw_data)
+        categories =
+          CategoryStatisticsParser.parse raw_data["category_questions"]
+
+        if raw_data["crowns"]
+          crowns = raw_data["crowns"].map { |c| c.downcase.to_sym }
+        else
+          crowns = []
+        end
+
+        TriviaCrack::GameStatistics.new(
+          correct_answers: raw_data["correct_answers"],
+          incorrect_answers: raw_data["incorrect_answers"],
+          questions_answered: raw_data["questions_answered"],
+          challenges_won: raw_data["challenges_won"],
+          crowns: crowns,
+          categories: categories
+        )
+      end
+
+    end
+  end
+end