thegamesdb 1.1.2 → 2.1.0

data/lib/thegamesdb.rb

@@ -1,246 +1,98 @@
+# frozen_string_literal: true
+
 require 'thegamesdb/version'
-require 'thegamesdb/config'
+require 'thegamesdb/developers'
+require 'thegamesdb/error'
+require 'thegamesdb/games'
+require 'thegamesdb/genres'
+require 'thegamesdb/platforms'
+require 'thegamesdb/publishers'
+require 'thegamesdb/utils'
 require 'net/http'
 require 'json'
 
-# Client for TheGamesDB API (thegamesdb.net)
 module Gamesdb
-  BASE_URL = 'https://api.thegamesdb.net/v1/'.freeze
-  IMAGES_BASE_URL = 'https://legacy.thegamesdb.net/banners/'.freeze
+  # Client for TheGamesDB API (thegamesdb.net)
+  class Client
+    include Gamesdb::Developers
+    include Gamesdb::Games
+    include Gamesdb::Genres
+    include Gamesdb::Platforms
+    include Gamesdb::Publishers
 
-  # Method for listing platform's games
-  #
-  # See: https://api.thegamesdb.net/#/operations/Games/GamesByPlatformID
-  #
-  # Parameters: platform id (int), page (int)
-  #
-  # = Returns:
-  # Array of Hashes with games info
-  #
-  def self.games_by_platform_id(platform_id, page = 1)
-    url = 'Games/ByPlatformID'
-    params = {id: platform_id, page: page, include: 'boxart'}
-    data = json_response(url, params)
-    process_platform_games(data)
-  end
+    BASE_URL = 'https://api.thegamesdb.net/v1/'
+    IMAGES_BASE_URL = 'https://legacy.thegamesdb.net/banners/'
 
-  # Method for listing platforms
-  # https://api.thegamesdb.net/#/operations/Platforms/Platforms
-  #
-  # Parameters: none
-  #
-  # == Returns:
-  # Array of Hashes with platforms info
-  #
-  def self.platforms
-    url = 'Platforms'
-    params = { fields: 'icon,console,controller,developer,manufacturer,media,cpu,memory,graphics,sound,maxcontrollers,display,overview,youtube' }
-    data = json_response(url, params)
+    attr_reader :remaining_monthly_allowance, :extra_allowance, :allowance_refresh_timer
 
-    data['data']['platforms'].map do |p|
-      symbolize_keys(p.last)
+    def initialize(api_key)
+      @api_key = api_key
     end
-  end
-
-  # This API feature returns a set of metadata and artwork data for a
-  # specified Platform ID.
-  # https://api.thegamesdb.net/#/operations/Platforms/PlatformsByPlatformID
-  #
-  # Parameters:
-  #  - id - (int) The numeric ID of the platform in the GamesDB database
-  #
-  # == Returns:
-  # Hash with platform info
-  #
-  def self.platform_by_id(id)
-    url = 'Platforms/ByPlatformID'
-    params = {
-      id: id,
-      fields: 'icon,console,controller,developer,manufacturer,media,cpu,memory,graphics,sound,maxcontrollers,display,overview,youtube'
-    }
-    data = json_response(url, params)
-
-    response = data['data']['platforms'].values.first
-    symbolize_keys(response)
-  end
-
-  # Method for getting game info
-  # TODO: check (and test) that we support ',' delimited list
-  # https://api.thegamesdb.net/#/operations/Games/GamesByGameID
-  #
-  # Parameters:
-  #  - id - (int) Game id
-  #
-  # == Returns:
-  # Hash with game info
-  #
-  def self.game_by_id(id)
-    url = 'Games/ByGameID'
-    params = {
-      id: id,
-      fields: 'players,publishers,genres,overview,last_updated,rating,platform,coop,youtube,os,processor,ram,hdd,video,sound,alternates',
-      include: 'boxart,platform'
-    }
-    data = json_response(url, params)
-    return [] if data['data']['count'] == 0
-    symbolize_keys(data['data']['games'].first)
-  end
-
-  # The GetGamesList API search returns a listing of games matched up
-  # with loose search terms.
-  # https://api.thegamesdb.net/#/operations/Games/GamesByGameName
-  #
-  # Parameters:
-  # - name (required)
-  # - platform (optional - platform id)
-  # - page (optional)
-  #
-  # == Returns:
-  # Hash with game info:  id, name (not-unique), release_date,
-  # platform, etc.
-  #
-  def self.games_by_name(name, platform: nil, page: 1)
-    url = 'Games/ByGameName'
-    params = {
-      fields: 'players,publishers,genres,overview,last_updated,rating,platform,coop,youtube,os,processor,ram,hdd,video,sound,alternates',
-      include: 'boxart',
-      name: name,
-      page: page
-    }
-    unless platform.nil?
-      params.merge!("filter[platform]" => platform)
-    end
-
-    data = json_response(url, params)
-    process_platform_games(data)
-  end
-
-  # This API feature returns a list of available artwork types and
-  # locations specific to the requested game id in the database. It
-  # also lists the resolution of any images available. Scrapers can be
-  # set to use a minimum or maximum resolution for specific images
-  # https://api.thegamesdb.net/#/operations/Games/GamesImages
-  #
-  # Parameters
-  # - id - (integer) The numeric ID of the game in Gamesdb that you
-  # like to fetch artwork details for
-  #
-  # == Returns:
-  # Hash with game art info: fanart (array), boxart (Hash, :front,
-  # :back),  screenshots (array), fanart (array)
-  #
-  def self.game_images(id)
-    url = 'Games/Images'
-    data = json_response(url, games_id: id)
-    return [] if data.dig('data', 'count') == (0 || nil)
-
-    response = {}
-    response[:base_url] = data['data']['base_url']['original']
-    response[:logo] = process_logo(data['data'], id)
-    response[:boxart] = process_covers(data['data'], id)
-    response[:screenshot] = process_screenshots(data['data'], id)
-    response[:fanart] = process_fanart(data['data'], id)
-    response
-  end
 
-  def self.process_logo(data, id)
-    logo = data['images'][id.to_s].select { |a| a['type'] == "clearlogo" }
-    logo.empty? ? '' : logo.first['filename']
-  end
-
-  def self.process_fanart(data, id)
-    fanarts = []
-    fanart = data['images'][id.to_s].select do |a|
-      a['type'] == 'fanart'
+    # Perform request
+    #
+    # Used by every API endpoint, but can also be used manually.
+    #
+    # @param url [String] Required
+    # @param params [Hash] optional
+    #
+    # @return [Hash] Parsed JSON response
+    def perform_request(url, params = {})
+      raise ArgumentError, 'You need to set the API KEY to use the GamesDB API' unless @api_key
+
+      params = params.merge({ apikey: @api_key })
+      uri = URI(BASE_URL + url)
+      uri.query = URI.encode_www_form(params)
+      response = JSON.parse(Net::HTTP.get_response(uri).body)
+      http_error(response) if response['code'] >= 300
+
+      refresh_allowances(response)
+      response
+    rescue StandardError => e
+      raise e
     end
-    return [] if fanart.empty?
-    fanart.each do |art|
-      width, height = art['resolution'].split("x") unless art['resolution'].nil?
-      fanarts << {
-        url: art['filename'],
-        resolution: art['resolution'],
-        width: width,
-        height: height
-      }
-    end
-    fanarts
-  end
 
-  def self.process_screenshots(data, id)
-    data['images'][id.to_s].select do |a|
-      a['type'] == 'screenshot'
-    end.map { |b| symbolize_keys(b) }
-  end
+    private
 
-  def self.process_covers(data, id)
-    covers = {}
-    boxart = data['images'][id.to_s].select do |a|
-      a['type'] == "boxart"
-    end
-    return [] if boxart.empty?
-    boxart.each do |art|
-      width, height = art['resolution'].split("x") unless art['resolution'].nil?
-      covers[art['side'].to_sym] = {
-        url: art['filename'],
-        resolution: art['resolution'],
-        width: width,
-        height: height
-      }
+    def refresh_allowances(response)
+      @remaining_monthly_allowance = response['remaining_monthly_allowance']
+      @extra_allowance = response['extra_allowance']
+      @allowance_refresh_timer = response['allowance_refresh_timer']
     end
-    covers
-  end
-
-  private
 
-  def self.configuration
-    @configuration ||= Config.new
-  end
-
-  # Api call and xml parsing
-  def self.json_response(url, params = {})
-    params = params.merge({apikey: configuration.api_key})
-
-    uri = URI(BASE_URL + url)
-    uri.query = URI.encode_www_form(params)
-    request = Net::HTTP.get_response(uri)
-    response = JSON.parse(request.body)
-    response
-  end
-
-  # Process games for platform_games
-  def self.process_platform_games(data)
-    games = []
-
-    data['data']['games'].each do |elem|
-      id = elem['id']
-      games << {
-        name: elem['game_title'],
-        id: id,
-        release_date: elem['release_date'],
-        platform: elem['platform'],
-        developers: elem['developers'],
-        players: elem['players'],
-        publishers: elem['publishers'],
-        genres: elem['genres'],
-        overview: elem['overview'],
-        last_updated: elem['last_updated'],
-        rating: elem['rating'],
-        coop: elem['coop'],
-        youtube: elem['youtube'],
-        alternates: elem['alternates'],
-        image: if boxart = data.dig('include', 'boxart', 'data', id.to_s)
-                 data['include']['boxart']['base_url']['original'] +
-                   boxart.select { |a| a['side'] == 'front' }.first['filename'] || ''
-               end
-    }
+    # TODO: More granular errors
+    def http_error(response)
+      raise Gamesdb::Error.new(response['code'], response['status'])
     end
-    games
-  end
 
-  def self.symbolize_keys(hash)
-    hash.keys.each do |key|
-      hash[key.to_sym] = hash.delete(key)
+    # Process games for platform_games
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def process_platform_games(data)
+      data['data']['games'].map do |elem|
+        {
+          name: elem['game_title'],
+          id: elem['id'],
+          release_date: elem['release_date'],
+          platform: elem['platform'],
+          developers: elem['developers'],
+          players: elem['players'],
+          publishers: elem['publishers'],
+          genres: elem['genres'],
+          overview: elem['overview'],
+          last_updated: elem['last_updated'],
+          rating: elem['rating'],
+          coop: elem['coop'],
+          youtube: elem['youtube'],
+          alternates: elem['alternates'],
+          image: if (boxart = data.dig('include', 'boxart', 'data', elem['id'].to_s))
+                   data['include']['boxart']['base_url']['original'] +
+                     boxart.select { |a| a['side'] == 'front' }.first['filename'] || ''
+                 end
+        }
+      end
     end
-    hash
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/test/client_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative './test_helper'
+
+describe 'Gamesdb - client', :vcr do
+  let(:client) { Gamesdb::Client.new(ENV['GAMESDB_API_KEY']) }
+
+  describe 'client' do
+    it 'should update allowances' do
+      client.games_by_id(1904)
+      monthly = client.remaining_monthly_allowance
+      client.games_by_id(1527)
+      expect(client.remaining_monthly_allowance).must_equal(monthly - 1)
+    end
+
+    describe 'errors' do
+      let(:client) { Gamesdb::Client.new('invalid_api_key') }
+
+      it 'should raise http error' do
+        assert_raises Gamesdb::Error do
+          client.games_by_id(1904)
+        end
+      end
+    end
+  end
+end

data/test/developers_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative './test_helper'
+
+describe 'Gamesdb - developers', :vcr do
+  let(:client) { Gamesdb::Client.new(ENV['GAMESDB_API_KEY']) }
+
+  describe 'developers' do
+    it 'should return the developers' do
+      @developers = client.developers
+
+      expect(@developers.count.positive?)
+      expect(@developers.first.keys).must_equal(['id', 'name'])
+    end
+  end
+end

data/test/games_test.rb

@@ -1,75 +1,89 @@
-require_relative './test_helper.rb'
+# frozen_string_literal: true
+
+require_relative './test_helper'
 
 describe 'Gamesdb - games', :vcr do
+  let(:client) { Gamesdb::Client.new(ENV['GAMESDB_API_KEY']) }
+
   describe 'game' do
     before do
-      @game = Gamesdb.game_by_id(109)
+      @game = client.games_by_id(109)
     end
 
     it 'should have a valid id' do
-      @game[:id].must_be_kind_of Integer
-      @game[:id].must_equal 109
+      expect(@game[:id]).must_be_kind_of Integer
+      expect(@game[:id]).must_equal 109
     end
 
     it 'should have valid fields' do
-      @game[:game_title].must_be_kind_of String
-      @game[:game_title].length.wont_be :<, 0
+      expect(@game[:game_title]).must_be_kind_of String
+      expect(@game[:game_title].length).wont_be :<, 0
+    end
+  end
+
+  describe 'game by several ids' do
+    it 'should return games for a String of ids' do
+      @games = client.games_by_id('109,108').sort_by { |g| g[:id] }
+
+      expect(@games.count).must_equal 2
+      expect(@games.first[:id]).must_equal 108
+      expect(@games.last[:id]).must_equal 109
     end
   end
 
   describe 'empty game' do
     before do
-      @game = Gamesdb.game_by_id(3)
+      @game = client.games_by_id(3)
     end
 
     it 'should return an empty array' do
-      @game.must_equal []
+      expect(@game).must_equal []
     end
   end
 
   describe 'games by name' do
     before do
-      @games_list = Gamesdb.games_by_name('turrican')
+      @games_list = client.games_by_name('turrican')
     end
 
     it 'should return a list' do
       game = @games_list.first
-      game[:id].must_be_kind_of Integer
-      game[:name].must_be_kind_of String
-      game[:platform].must_be_kind_of Integer
-      game[:release_date].must_be_kind_of String
+      expect(game[:id]).must_be_kind_of Integer
+      expect(game[:name]).must_be_kind_of String
+      expect(game[:platform]).must_be_kind_of Integer
+      expect(game[:release_date]).must_be_kind_of String
     end
   end
 
   describe 'games by name pages' do
     before do
-      @first_page = Gamesdb.games_by_name('mario', page: 1)
-      @second_page = Gamesdb.games_by_name('mario', page: 2)
+      @first_page = client.games_by_name('mario', page: 1)
+      @second_page = client.games_by_name('mario', page: 2)
     end
 
     it 'should return games in platform by id' do
-      @first_page.count.wont_be :<, 0
-      @first_page.count.must_equal 20
+      expect(@first_page.count).wont_be :<, 0
+      expect(@first_page.count).must_equal 20
     end
 
     it 'should return games in the platform for the second page' do
-      @second_page.count.wont_be :<, 0
-      @second_page.count.must_equal 20
-      (@first_page & @second_page).must_equal []
+      expect(@second_page.count).wont_be :<, 0
+      expect(@second_page.count).must_equal 20
+      expect(@first_page & @second_page).must_equal []
     end
   end
 
   describe 'games by name and platform' do
     before do
-      @games_list = Gamesdb.games_by_name('mario', platform: 7)
+      @games_list = client.games_by_name('mario', platform: 7)
     end
 
     it 'should return a list' do
       @games_list.each do |game|
-        game[:id].must_be_kind_of Integer
-        game[:id].must_be_kind_of Integer
-        game[:name].must_be_kind_of String
-        game[:platform].must_equal 7
+        expect(game[:id]).must_be_kind_of Integer
+        expect(game[:id]).must_be_kind_of Integer
+        expect(game[:name]).must_be_kind_of String
+        expect(game[:platform]).must_equal 7
       end
     end
   end
@@ -77,40 +91,76 @@ describe 'Gamesdb - games', :vcr do
   describe 'games art', :vcr do
     describe 'when most of the art is available' do
       before do
-        @images = Gamesdb.game_images('216')
+        @images = client.games_images('218')
       end
 
       it 'should return logo and boxart' do
-        @images[:boxart].count.wont_be :<, 0
-        @images[:logo].must_be_kind_of String
-        @images[:boxart][:front][:url].must_be_kind_of String
-        @images[:boxart][:front][:width].must_be_kind_of String
-        @images[:boxart][:front][:height].must_be_kind_of String
-        @images[:boxart][:front][:resolution].must_be_kind_of String
+        expect(@images[:boxart].count).wont_be :<, 0
+        expect(@images[:logo]).must_be_kind_of String
+        expect(@images[:boxart][:front][:url]).must_be_kind_of String
+        expect(@images[:boxart][:front][:width]).must_be_kind_of String
+        expect(@images[:boxart][:front][:height]).must_be_kind_of String
+        expect(@images[:boxart][:front][:resolution]).must_be_kind_of String
       end
 
       it 'should return screenshots' do
-        @images[:screenshot].count.wont_be :<, 0
-        @images[:screenshot].first.must_be_kind_of Hash
-        @images[:screenshot].first[:filename].must_be_kind_of String
+        expect(@images[:screenshot].count).wont_be :<, 0
+        expect(@images[:screenshot].first).must_be_kind_of Hash
+        expect(@images[:screenshot].first[:filename]).must_be_kind_of String
       end
 
       it 'should return fanart' do
-        @images[:fanart].count.wont_be :<, 0
-        @images[:fanart].first[:url].must_be_kind_of String
-        @images[:fanart].first[:width].must_be_kind_of String
-        @images[:fanart].first[:height].must_be_kind_of String
-        @images[:fanart].first[:resolution].must_be_kind_of String
+        expect(@images[:fanart].count).wont_be :<, 0
+        expect(@images[:fanart].first[:url]).must_be_kind_of String
+        expect(@images[:fanart].first[:width]).must_be_kind_of String
+        expect(@images[:fanart].first[:height]).must_be_kind_of String
+        expect(@images[:fanart].first[:resolution]).must_be_kind_of String
       end
     end
 
     describe 'when some art is missing' do
       before do
-        @images = Gamesdb.game_images(65238)
+        @images = client.games_images(65_238)
       end
 
       it 'should return an empty array' do
-        @images.must_be_kind_of Hash
+        expect(@images).must_be_kind_of Hash
+      end
+    end
+
+    describe 'update games' do
+      it 'should return updates' do
+        updates = client.games_update(1)
+
+        expect(updates[:updates].count).must_equal 100
+        expect(updates[:updates].first).must_equal(
+          {
+            'edit_id' => 2,
+            'game_id' => 38_113,
+            'timestamp' => '2018-06-28 15:20:54',
+            'type' => 'boxart',
+            'value' => 'boxart/front/38113-1.jpg'
+          }
+        )
+        expect(updates[:updates].last).must_equal(
+          {
+            'edit_id' => 101,
+            'game_id' => 22_208,
+            'timestamp' => '2018-06-29 01:36:38',
+            'type' => 'rating',
+            'value' => 'E - Everyone'
+          }
+        )
+        expect(updates[:previous_page]).must_be_nil
+        expect(updates[:next_page]).must_equal 2
+      end
+
+      it 'should return updates when using a page parameter' do
+        updates = client.games_update(1, { page: 1_000 })
+
+        expect(updates[:updates].count).must_equal 100
+        expect(updates[:previous_page]).must_equal 999
+        expect(updates[:next_page]).must_equal 1001
       end
     end
   end

data/test/genres_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative './test_helper'
+
+describe 'Gamesdb - genres', :vcr do
+  let(:client) { Gamesdb::Client.new(ENV['GAMESDB_API_KEY']) }
+
+  describe 'genres' do
+    it 'should return the genres' do
+      @genres = client.genres
+
+      expect(@genres.count).must_equal 29
+      expect(@genres.min_by { |g| g['id'] }).must_equal({ 'id' => 1, 'name' => 'Action' })
+    end
+  end
+end