thegamesdb 1.1.2 → 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,246 +1,146 @@
+# frozen_string_literal: true
+
 require 'thegamesdb/version'
-require 'thegamesdb/config'
+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 = 'https://api.thegamesdb.net/v1/'.freeze
-  IMAGES_BASE_URL = 'https://legacy.thegamesdb.net/banners/'.freeze
-
-  # 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
+  # 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
-  # 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)
-
-    data['data']['platforms'].map do |p|
-      symbolize_keys(p.last)
-    end
-  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.
-  # 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
+    attr_reader :remaining_monthly_allowance, :extra_allowance, :allowance_refresh_timer
 
-  # 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
+    def initialize(api_key)
+      @api_key = api_key
+    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)
+    # 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
 
-    data = json_response(url, params)
-    process_platform_games(data)
-  end
+    private
 
-  # 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 refresh_allowances(response)
+      @remaining_monthly_allowance = response['remaining_monthly_allowance']
+      @extra_allowance = response['extra_allowance']
+      @allowance_refresh_timer = response['allowance_refresh_timer']
+    end
 
-  def self.process_fanart(data, id)
-    fanarts = []
-    fanart = data['images'][id.to_s].select do |a|
-      a['type'] == 'fanart'
+    def process_logo(data, id)
+      logo = data['images'][id.to_s].select { |a| a['type'] == 'clearlogo' }
+      logo.empty? ? '' : logo.first['filename']
     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
-      }
+
+    def process_fanart(data, id)
+      fanart = select_images(data, id, 'fanart')
+      return [] if fanart.empty?
+
+      fanart.map { |art| build_individual_fanart(art) }
     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
+    def process_covers(data, id)
+      covers = {}
+      boxart = select_images(data, id, 'boxart')
+      return [] if boxart.empty?
 
-  def self.process_covers(data, id)
-    covers = {}
-    boxart = data['images'][id.to_s].select do |a|
-      a['type'] == "boxart"
+      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
-    return [] if boxart.empty?
-    boxart.each do |art|
-      width, height = art['resolution'].split("x") unless art['resolution'].nil?
-      covers[art['side'].to_sym] = {
+
+    def build_individual_fanart(art)
+      width, height = art['resolution'].split('x') unless art['resolution'].nil?
+      art_structure(art, width, height)
+    end
+
+    def art_structure(art, width, height)
+      {
         url: art['filename'],
         resolution: art['resolution'],
         width: width,
         height: height
       }
     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
+    def process_screenshots(data, id)
+      select_images(data, id, 'screenshot').map { |b| symbolize_keys(b) }
+    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
-    }
+    def select_images(data, id, image_type)
+      data['images'][id.to_s].select do |a|
+        a['type'] == image_type
+      end
     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
+    # 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
-    hash
   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