zombie_battleground-api 0.1.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/docker-compose.yml

@@ -0,0 +1,4 @@
+version: '3'
+services:
+  zombie_battleground-api:
+    build: .

data/lib/zombie_battleground/api/client.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+require 'zombie_battleground/api/errors'
+
+require 'zombie_battleground/api/requests/get_decks_request'
+require 'zombie_battleground/api/responses/get_decks_response'
+require 'zombie_battleground/api/requests/get_deck_request'
+require 'zombie_battleground/api/responses/get_deck_response'
+require 'zombie_battleground/api/requests/get_matches_request'
+require 'zombie_battleground/api/responses/get_matches_response'
+require 'zombie_battleground/api/requests/get_match_request'
+require 'zombie_battleground/api/responses/get_match_response'
+require 'zombie_battleground/api/requests/get_cards_request'
+require 'zombie_battleground/api/responses/get_cards_response'
+require 'zombie_battleground/api/requests/get_card_request'
+require 'zombie_battleground/api/responses/get_card_response'
+
+module ZombieBattleground
+  class Api
+    ##
+    # The API Client for Zombie Battleground
+    class Client
+      def initialize
+        @endpoint = 'https://api.loom.games/zb'
+        @api_version = 'v1'
+      end
+
+      def connection(uri:, params:)
+        Faraday.new(
+          url: "#{@endpoint}/#{@api_version}/#{uri}",
+          params: params,
+          headers: {
+            'User-Agent' => "RubyGem-zombie_battleground-api_#{VERSION}",
+            'Content-Type' => 'application/json'
+          }
+        )
+      end
+
+      def decks(**args)
+        request = ZombieBattleground::Api::GetDecksRequest.new
+        args.each { |key, val| request.send("#{key}=", val) }
+        raise ZombieBattleground::Api::Errors::InvalidInput, request.errors.messages unless request.valid?
+
+        response = connection(uri: request.uri, params: request.params).get
+        decks = ZombieBattleground::Api::GetDecksResponse.new(response)
+        raise ZombieBattleground::Api::Errors::InvalidResponse.new(response, decks) unless decks.valid?
+
+        decks
+      end
+
+      def deck(**args)
+        request = ZombieBattleground::Api::GetDeckRequest.new
+        args.each { |key, val| request.send("#{key}=", val) }
+        raise ZombieBattleground::Api::Errors::InvalidInput, request.errors.messages unless request.valid?
+
+        response = connection(uri: request.uri, params: request.params).get
+        deck = ZombieBattleground::Api::GetDeckResponse.new(response)
+        raise ZombieBattleground::Api::Errors::InvalidResponse.new(response, deck) unless deck.valid?
+
+        deck
+      end
+
+      def matches(**args)
+        request = ZombieBattleground::Api::GetMatchesRequest.new
+        args.each { |key, val| request.send("#{key}=", val) }
+        raise ZombieBattleground::Api::Errors::InvalidInput, request.errors.messages unless request.valid?
+
+        response = connection(uri: request.uri, params: request.params).get
+        matches = ZombieBattleground::Api::GetMatchesResponse.new(response)
+        raise ZombieBattleground::Api::Errors::InvalidResponse.new(response, matches) unless matches.valid?
+
+        matches
+      end
+
+      def match(**args)
+        request = ZombieBattleground::Api::GetMatchRequest.new
+        args.each { |key, val| request.send("#{key}=", val) }
+        raise ZombieBattleground::Api::Errors::InvalidInput, request.errors.messages unless request.valid?
+
+        response = connection(uri: request.uri, params: request.params).get
+        match = ZombieBattleground::Api::GetMatchResponse.new(response)
+        raise ZombieBattleground::Api::Errors::InvalidResponse.new(response, match) unless match.valid?
+
+        match
+      end
+
+      def cards(**args)
+        request = ZombieBattleground::Api::GetCardsRequest.new
+        args.each { |key, val| request.send("#{key}=", val) }
+        raise ZombieBattleground::Api::Errors::InvalidInput, request.errors.messages unless request.valid?
+
+        response = connection(uri: request.uri, params: request.params).get
+        cards = ZombieBattleground::Api::GetCardsResponse.new(response)
+        raise ZombieBattleground::Api::Errors::InvalidResponse.new(response, cards) unless cards.valid?
+
+        cards
+      end
+
+      def card(**args)
+        request = ZombieBattleground::Api::GetCardRequest.new
+        args.each { |key, val| request.send("#{key}=", val) }
+        raise ZombieBattleground::Api::Errors::InvalidInput, request.errors.messages unless request.valid?
+
+        response = connection(uri: request.uri, params: request.params).get
+        card = ZombieBattleground::Api::GetCardResponse.new(response)
+        raise ZombieBattleground::Api::Errors::InvalidResponse.new(response, card) unless card.valid?
+
+        card
+      end
+    end
+  end
+end

data/lib/zombie_battleground/api/errors.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ZombieBattleground
+  class Api
+    class Errors
+      class BadRequest < StandardError; end
+      class InternalServerError < StandardError; end
+      class InvalidInput < StandardError; end
+      class NotFound < StandardError; end
+      class ServiceUnavailable < StandardError; end
+      class UnknownResponse < StandardError; end
+
+      ##
+      # Creates an error with the Faraday response and the context for the error
+      class InvalidResponse < StandardError
+        def initialize(response, context)
+          @response = response
+          @context = context
+          super(context.errors.messages.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/zombie_battleground/api/models/card.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+require 'zombie_battleground/api/validation_helper'
+
+module ZombieBattleground
+  class Api
+    ##
+    # Validator for Card
+    class Card
+      include ActiveModel::Validations
+      include ZombieBattleground::Api::ValidationHelper
+
+      attr_reader :id, :mould_id, :version, :kind, :set, :name, :description, :flavor_text,
+                  :picture, :rank, :type, :rarity, :frame, :damage, :health, :cost,
+                  :ability, :block_height, :image_url
+
+      validate :id_is_a_non_negative_integer
+      validate :mould_id_is_a_string_and_not_null
+      validate :version_is_a_string_and_not_null
+      validate :kind_is_a_string_and_not_null
+      validate :set_is_a_string_and_not_null
+      validate :name_is_a_string_and_not_null
+      validate :description_is_a_string_and_not_null
+      validate :rank_is_a_string_and_not_null
+      validate :type_is_a_string_and_not_null
+      validate :rarity_is_a_string_and_not_null
+      validate :frame_is_a_string_and_not_null
+      validate :damage_is_a_non_negative_integer_and_not_null
+      validate :health_is_a_non_negative_integer_and_not_null
+      validate :cost_is_a_non_negative_integer_and_not_null
+      validate :ability_is_a_string_and_not_null
+      validate :block_height_is_a_non_negative_integer_and_not_null
+      validate :image_url_is_a_string_and_not_null
+
+      def initialize(card)
+        card.each do |key, value|
+          next if value.nil? # this is an illegal response, card id 1 is bogus
+
+          instance_variable_set("@#{key}".to_sym, value)
+        end
+      end
+    end
+  end
+end

data/lib/zombie_battleground/api/models/deck.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+require 'zombie_battleground/api/validation_helper'
+require 'zombie_battleground/api/models/simple_card'
+
+module ZombieBattleground
+  class Api
+    ##
+    # Validator for Deck
+    class Deck
+      include ActiveModel::Validations
+      include ZombieBattleground::Api::ValidationHelper
+
+      attr_reader :id, :created_at, :updated_at, :user_id, :deck_id, :name, :hero_id,
+                  :cards, :primary_skill_id, :secondary_skill_id, :version, :sender_address,
+                  :block_height, :is_deleted
+
+      validate :id_is_a_non_negative_integer
+      validate :created_at_is_a_time_and_not_null
+      validate :updated_at_is_a_time_and_not_null
+      validate :user_id_is_a_string_and_not_null
+      validate :deck_id_is_a_non_negative_integer_and_not_null
+      validate :name_is_a_string_and_not_null
+      validate :hero_id_is_a_non_negative_integer_and_not_null
+      validate :cards_is_an_array_of_simple_card
+      validate :primary_skill_id_is_a_non_negative_integer_and_not_null
+      validate :secondary_skill_id_is_a_non_negative_integer_and_not_null
+      validate :version_is_a_string_and_not_null
+      validate :sender_address_is_a_string_and_not_null
+      validate :block_height_is_a_non_negative_integer_and_not_null
+      validates :is_deleted, inclusion: { in: [true, false] }
+
+      def initialize(deck)
+        deck.each do |key, value|
+          next if value.nil? # this is an illegal response, deck id 1 is bogus
+
+          if key == 'cards'
+            instance_variable_set("@#{key}".to_sym, value.map { |card| ZombieBattleground::Api::SimpleCard.new(card) })
+          elsif %w[created_at updated_at].include?(key)
+            instance_variable_set("@#{key}".to_sym, Time.parse(value))
+          else
+            instance_variable_set("@#{key}".to_sym, value)
+          end
+        end
+      end
+
+      def cards_is_an_array_of_simple_card
+        unless @cards.is_a?(Array)
+          errors.add(:cards, 'cards must be an Array')
+          return
+        end
+
+        @cards.each do |card|
+          next if card.is_a?(ZombieBattleground::Api::SimpleCard) &&
+                  card.valid? &&
+                  card.errors.size.zero?
+
+          errors.add(:cards, 'cards must be an array of SimpleCard')
+        end
+      end
+    end
+  end
+end

data/lib/zombie_battleground/api/models/match.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+require 'zombie_battleground/api/validation_helper'
+
+module ZombieBattleground
+  class Api
+    ##
+    # Validator for Match
+    class Match
+      include ActiveModel::Validations
+      include ZombieBattleground::Api::ValidationHelper
+
+      attr_reader :id, :created_at, :updated_at, :player1_id, :player2_id, :player1_accepted,
+                  :player2_accepted, :player1_deck_id, :player2_deck_id, :status, :version,
+                  :random_seed, :winner_id, :block_height
+
+      validate :id_is_a_non_negative_integer
+      validate :created_at_is_a_time_and_not_null
+      validate :updated_at_is_a_time_and_not_null
+      validate :player1_id_is_a_string_and_not_null
+      validate :player2_id_is_a_string_and_not_null
+      validates :player1_accepted, inclusion: { in: [true, false] }
+      validates :player2_accepted, inclusion: { in: [true, false] }
+      validate :player1_deck_id_is_a_non_negative_integer
+      validate :player2_deck_id_is_a_non_negative_integer
+      validate :status_is_a_string_and_not_null
+      validate :version_is_a_string_and_not_null
+      validate :random_seed_is_a_non_negative_integer
+      validate :winner_id_is_a_string_and_not_null
+      validate :block_height_is_a_non_negative_integer_and_not_null
+
+      def initialize(match)
+        match.each do |key, value|
+          next if value.nil? # this is an illegal response, match id 1 is bogus
+
+          if %w[created_at updated_at].include?(key)
+            instance_variable_set("@#{key}".to_sym, Time.parse(value))
+          else
+            instance_variable_set("@#{key}".to_sym, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zombie_battleground/api/models/simple_card.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+require 'zombie_battleground/api/validation_helper'
+
+module ZombieBattleground
+  class Api
+    ##
+    # Validator for SimpleCard (only returned from GetDeck(s))
+    class SimpleCard
+      include ActiveModel::Validations
+      include ZombieBattleground::Api::ValidationHelper
+
+      attr_reader :card_name, :amount
+
+      validate :card_name_is_a_string_and_not_null
+      validate :amount_is_a_non_negative_integer_and_not_null
+
+      def initialize(card)
+        card.each do |key, value|
+          instance_variable_set("@#{key}".to_sym, value)
+        end
+      end
+    end
+  end
+end

data/lib/zombie_battleground/api/requests/get_card_request.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+require 'zombie_battleground/api/validation_helper'
+require 'zombie_battleground/api/requests/request_helper'
+
+module ZombieBattleground
+  class Api
+    ##
+    # Request validator for GetCard
+    class GetCardRequest
+      include ActiveModel::Validations
+      include ZombieBattleground::Api::ValidationHelper
+      include ZombieBattleground::Api::RequestHelper
+
+      attr_accessor :mould_id, :version
+
+      validate :mould_id_is_a_string_and_not_null
+      validate :version_is_a_string_and_not_null
+
+      def uri
+        'card'
+      end
+    end
+  end
+end

data/lib/zombie_battleground/api/requests/get_cards_request.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+require 'zombie_battleground/api/validation_helper'
+require 'zombie_battleground/api/requests/request_helper'
+
+module ZombieBattleground
+  class Api
+    ##
+    # Request validator for GetCards
+    class GetCardsRequest
+      include ActiveModel::Validations
+      include ZombieBattleground::Api::ValidationHelper
+      include ZombieBattleground::Api::RequestHelper
+
+      attr_accessor :id, :mould_id, :version, :kind, :set, :name, :rank, :type, :rarity,
+                    :damage, :health, :cost, :page, :limit
+
+      validate :id_is_a_non_negative_integer
+      validate :mould_id_is_a_string
+      validate :version_is_a_string
+      validate :kind_is_a_string
+      validate :set_is_a_string
+      validate :name_is_a_string
+      validate :rank_is_a_string
+      validate :type_is_a_string
+      validate :rarity_is_a_string
+      validate :damage_is_a_non_negative_integer
+      validate :health_is_a_non_negative_integer
+      validate :cost_is_a_non_negative_integer
+      validate :page_is_a_non_negative_integer
+      validate :limit_is_a_non_negative_integer
+
+      def uri
+        'cards'
+      end
+    end
+  end
+end

data/lib/zombie_battleground/api/requests/get_deck_request.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+require 'zombie_battleground/api/validation_helper'
+require 'zombie_battleground/api/requests/request_helper'
+
+module ZombieBattleground
+  class Api
+    ##
+    # Request validator for GetDeck
+    class GetDeckRequest
+      include ActiveModel::Validations
+      include ZombieBattleground::Api::ValidationHelper
+      include ZombieBattleground::Api::RequestHelper
+
+      attr_accessor :id
+
+      validate :id_is_a_non_negative_integer
+
+      def uri
+        "deck/#{id}"
+      end
+
+      def params
+        {}
+      end
+    end
+  end
+end