thegamesdb 0.2.0 → 2.0.0

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rake/testtask'
 require 'bundler/gem_tasks'
 
@@ -5,6 +7,7 @@ Rake::TestTask.new('test') do |t|
   t.pattern = 'test/**/*_test.rb'
 end
 
+desc 'Run a Ruby console with gamesdb already loaded'
 task :console do
   require 'irb'
   require 'irb/completion'

data/lib/thegamesdb.rb

@@ -1,180 +1,146 @@
+# frozen_string_literal: true
+
 require 'thegamesdb/version'
-require 'ox'
+require 'thegamesdb/developers'
+require 'thegamesdb/games'
+require 'thegamesdb/genres'
+require 'thegamesdb/platforms'
+require 'thegamesdb/publishers'
 require 'net/http'
+require 'json'
 
-# Client for TheGamesDB API (thegamesdb.net)
 module Gamesdb
-  BASE_URL = 'http://legacy.thegamesdb.net/api/'
-  IMAGES_BASE_URL = 'http://legacy.thegamesdb.net/banners/'
-
-  # Method for listing platform's games
-  # http://wiki.thegamesdb.net/index.php?title=GetPlatformGames
-  #
-  # Parameters: platform id (int) || platform slug (string)
-  # For information on how to attain a valid platform slug see `platform`
-  #
-  # == Returns:
-  # Array of Hashes with games info
-  def self.platform_games(platform)
-    url = platform.is_a?(Numeric) ? 'GetPlatformGames.php' : 'PlatformGames.php'
-    data = xml_response(url, platform: platform)
-    process_platform_games(data)
-  end
+  # 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 platforms
-  # http://wiki.thegamesdb.net/index.php?title=GetPlatformsList
-  #
-  # Parameters: none
-  #
-  # == Returns:
-  # Array of Hashes with platforms info
-  #
-  def self.platforms
-    url = 'GetPlatformsList.php'
-    data = xml_response(url)
-    platforms = []
-
-    data[:Platforms].first.last.each do |platform|
-      platforms << { name: platform[:name], id: platform[:id].to_i, slug: platform[:alias] }
-    end
-    platforms
-  end
+    BASE_URL = 'https://api.thegamesdb.net/v1/'
+    IMAGES_BASE_URL = 'https://legacy.thegamesdb.net/banners/'
 
-  # This API feature returns a set of metadata and artwork data for a
-  # specified Platform ID.
-  # http://wiki.thegamesdb.net/index.php/GetPlatform
-  #
-  # Parameters:
-  #  - id - (int) The numeric ID of the platform in the GamesDB database
-  #
-  # == Returns:
-  # Hash with platform info
-  #
-  def self.platform(id)
-    url = 'GetPlatform.php'
-    data = xml_response(url, id: id)[:Platform]
-    data[:name] = data.delete(:Platform)
-    data
-  end
+    attr_reader :remaining_monthly_allowance, :extra_allowance, :allowance_refresh_timer
 
-  # Method for getting game info
-  # TODO: name and platform parameters (for search)
-  # http://wiki.thegamesdb.net/index.php?title=GetGame
-  #
-  # Parameters:
-  #  - id - (int) Game id
-  #
-  # == Returns:
-  # Hash with game info
-  #
-  def self.game(id)
-    url = 'GetGame.php'
-    data = xml_response(url, id: id)
-    game = process_game(data[:Game])
-    game
-  end
+    def initialize(api_key)
+      @api_key = api_key
+    end
 
-  # The GetGamesList API search returns a listing of games matched up
-  # with loose search terms.
-  # http://wiki.thegamesdb.net/index.php/GetGamesList
-  #
-  # Parameters:
-  # - name (required)
-  # - TODO: platform (optional): filters results by platform (not implemented)
-  # - TODO: genre (optional): filters results by genre (not
-  # implemented)
-  #
-  # == Returns:
-  # Hash with game info:  id, name (not-unique), release_date,
-  # platform
-  #
-  def self.games_list(name)
-    url = 'GetGamesList.php'
-    data = xml_response(url, name: name)
-    data[:Game].map { |game| process_game(game) }
-  end
+    # 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)
+      refresh_allowances(response)
+      response
+    rescue StandardError => e
+      # TODO: Handle errors
+      raise e
+    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
-  # http://wiki.thegamesdb.net/index.php/GetArt
-  #
-  # 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.art(id)
-    url = 'GetArt.php'
-    data = xml_response(url, id: id)[:Images]
-    data[:logo] = data[:clearlogo].last
-    data[:boxart] = process_covers(data[:boxart])
-    data
-  end
+    private
 
-  def self.process_covers(boxart)
-    boxart = boxart.flatten
-
-    covers = {}
-    boxart.each do |art|
-      next unless art.is_a?(Hash)
-      covers[art[:side].to_sym] = {
-        url: art[:thumb].gsub('thumb/',''),
-        width: art[:width],
-        height: art[:height],
-        thumb: art[:thumb]
-      }
+    def refresh_allowances(response)
+      @remaining_monthly_allowance = response['remaining_monthly_allowance']
+      @extra_allowance = response['extra_allowance']
+      @allowance_refresh_timer = response['allowance_refresh_timer']
+    end
+
+    def process_logo(data, id)
+      logo = data['images'][id.to_s].select { |a| a['type'] == 'clearlogo' }
+      logo.empty? ? '' : logo.first['filename']
     end
-    covers
-  end
 
-  private
+    def process_fanart(data, id)
+      fanart = select_images(data, id, 'fanart')
+      return [] if fanart.empty?
 
-  # Api call and xml parsing
-  def self.xml_response(url, params = {})
-    uri = URI(BASE_URL + url)
-    uri.query = URI.encode_www_form(params)
-    request = Net::HTTP.get_response(uri)
-    Ox.load(request.body, mode: :hash)[:Data]
-  end
+      fanart.map { |art| build_individual_fanart(art) }
+    end
 
-  # Process games for platform_games
-  def self.process_platform_games(data)
-    games = []
+    def process_covers(data, id)
+      covers = {}
+      boxart = select_images(data, id, 'boxart')
+      return [] if boxart.empty?
 
-    data.first.last.each do |elem|
-      name = elem[:GameTitle]
-      id = elem[:id].to_i
-      date = elem.dig(:ReleaseDate)
-      games << { name: name, id: id, release_date: date }
+      boxart.each do |art|
+        width, height = art['resolution'].split('x') unless art['resolution'].nil?
+        covers[art['side'].to_sym] = art_structure(art, width, height)
+      end
+      covers
     end
-    games
-  end
 
-  def self.process_game(game)
-    game[:id] = game[:id].to_i
-    game[:name] = game.delete(:GameTitle)
-    game[:title] = game[:name]
-    game[:platform] = game.delete(:Platform)
-    game
-  end
+    def build_individual_fanart(art)
+      width, height = art['resolution'].split('x') unless art['resolution'].nil?
+      art_structure(art, width, height)
+    end
 
-  # Method for processing the fan art and screenshots into a uniform
-  # collection with url, width, height and thumb url
-  def self.images_from_nodes(data)
-    images = []
-    data.each do |art|
-      images << {
-        url: art.original.nodes[0],
-        width: art.nodes.first.attributes[:width],
-        height: art.nodes.first.attributes[:height],
-        thumb: art.thumb.text
+    def art_structure(art, width, height)
+      {
+        url: art['filename'],
+        resolution: art['resolution'],
+        width: width,
+        height: height
       }
     end
-    images
+
+    def process_screenshots(data, id)
+      select_images(data, id, 'screenshot').map { |b| symbolize_keys(b) }
+    end
+
+    def select_images(data, id, image_type)
+      data['images'][id.to_s].select do |a|
+        a['type'] == image_type
+      end
+    end
+
+    # 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
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+
+    def symbolize_keys(hash)
+      new_hash = {}
+      hash.each_key do |key|
+        new_hash[key.to_sym] = hash.delete(key)
+      end
+      new_hash
+    end
   end
 end

data/lib/thegamesdb/developers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Gamesdb
+  # Developers related API Endpoints
+  module Developers
+    # Fetches Developers list
+    #
+    # @see https://api.thegamesdb.net/#/Developers/Developers
+    #
+    # @return Array of Hashes with id and name as keys
+    def developers
+      url = 'Developers'
+      data = perform_request(url)
+      data['data']['developers'].map { |_id, developer| developer }
+    end
+  end
+end

data/lib/thegamesdb/games.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Gamesdb
+  # Games related API Endpoints
+  module Games
+    # Method for listing platform's games
+    #
+    # @see https://api.thegamesdb.net/#/Games/GamesByPlatformID
+    #
+    # @param id [Integer]
+    # @param page [Integer]
+    #
+    # @return [Array] Array of Hashes with games info
+    #
+    def games_by_platform_id(platform_id, page = 1)
+      url = 'Games/ByPlatformID'
+      params = { id: platform_id, page: page, include: 'boxart' }
+      data = perform_request(url, params)
+      process_platform_games(data)
+    end
+
+    # Method for getting game info
+    #
+    # @see https://api.thegamesdb.net/#/Games/GamesByGameID
+    #
+    # @param id [Integer|String] Game id or string of ',' delimited list
+    #
+    # @return [Array|Hash] Hash with game info
+    #
+    # rubocop:disable Metrics/MethodLength
+    def games_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 = perform_request(url, params)
+      return [] if (data['data']['count']).zero?
+
+      games = data['data']['games']
+      return symbolize_keys(games.first) if games.count == 1
+
+      games.map { |game| symbolize_keys(game) }
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # The GetGamesList API search returns a listing of games matched up with loose search terms.
+    #
+    # @see https://api.thegamesdb.net/#/Games/GamesByGameName
+    #
+    # @param name [String] game name (required)
+    # @param platform [Integer] (optional - platform id)
+    # @param page [Integer] (optional)
+    #
+    # @return [Hash] Hash with game info:  id, name (not-unique), release_date, platform, etc.
+    #
+    # rubocop:disable Metrics/MethodLength
+    def 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
+      }
+      params.merge!('filter[platform]' => platform) unless platform.nil?
+
+      data = perform_request(url, params)
+      process_platform_games(data)
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # 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
+    #
+    # @see https://api.thegamesdb.net/#/Games/GamesImages
+    #
+    # @param id [Integer] The numeric ID of the game in Gamesdb that you like to fetch artwork details for
+    #
+    # @return [Hash] Hash with game art info: fanart (array), boxart (Hash,
+    #   :front, :back),  screenshots (array), fanart (array)
+    #
+    # rubocop:disable Metrics/AbcSize
+    def games_images(id)
+      url = 'Games/Images'
+      data = perform_request(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
+
+    # Fetch games update
+    #
+    # @see https://api.thegamesdb.net/#/Games/GamesUpdates
+    #
+    # @param last_edit_id [Integer] Required
+    # @param time [Integer] (optional)
+    # @param page [Integer] results page offset to return (optional)
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def games_update(last_edit_id, arguments = {})
+      url = 'Games/Updates'
+      params = arguments.merge({ last_edit_id: last_edit_id })
+      data = perform_request(url, params)
+
+      regexp = /page=([0-9]+)/
+      response = {}
+      response[:updates] = data['data']['updates']
+      response[:previous_page] = data.dig('pages', 'previous')&.match(regexp)&.captures&.first&.to_i
+      response[:next_page] = data.dig('pages', 'next')&.match(regexp)&.captures&.first&.to_i
+      response
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+  end
+end