thegamesdb 1.1.2 → 2.1.0

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/error.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Gamesdb
+  # Gamesdb errors
+  class Error < StandardError
+    def initialize(code, status)
+      @code = code
+      @status = status
+      super("Gamesdb: #{code} - #{status}")
+    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 Gamesdb::Utils.symbolize_keys(games.first) if games.count == 1
+
+      games.map { |game| Gamesdb::Utils.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] = Gamesdb::Utils.process_logo(data['data'], id)
+      response[:boxart] = Gamesdb::Utils.process_covers(data['data'], id)
+      response[:screenshot] = Gamesdb::Utils.process_screenshots(data['data'], id)
+      response[:fanart] = Gamesdb::Utils.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

data/lib/thegamesdb/genres.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Gamesdb
+  # Genres related API Endpoints
+  module Genres
+    # Fetches genres list
+    def genres
+      url = 'Genres'
+      data = perform_request(url)
+      data['data']['genres'].map { |_id, genre| genre }
+    end
+  end
+end

data/lib/thegamesdb/images.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Gamesdb
+  # Client for TheGamesDB API (thegamesdb.net)
+  module Images
+  end
+end

data/lib/thegamesdb/platforms.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Gamesdb
+  # Platforms related API Endpoints
+  module Platforms
+    # Method for listing platforms
+    #
+    # @see https://api.thegamesdb.net/#/Platforms/Platforms
+    #
+    # @return [Array] Array of Hashes with platforms info
+    #
+    def platforms
+      url = 'Platforms'
+      params = { fields:
+        'icon,console,controller,developer,manufacturer,media,cpu,memory,graphics,sound,maxcontrollers,'\
+          'display,overview,youtube' }
+      data = perform_request(url, params)
+
+      data['data']['platforms'].map do |p|
+        Gamesdb::Utils.symbolize_keys(p.last)
+      end
+    end
+
+    # This API feature returns a set of metadata and artwork data for a specified Platform ID.
+    #
+    # @see https://api.thegamesdb.net/#/Platforms/PlatformsByPlatformID
+    #
+    # @param id [Integer|String] The numeric ID of the platform in the GamesDB
+    # database or a String with comma delimited list of Ids.
+    #
+    # @return [Hash|Array] Returns a Hash when there's one result or an Array of
+    # Hashes when there's more than one
+    #
+    def platforms_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 = perform_request(url, params)
+
+      platform_api_response(data)
+    end
+
+    # Fetches platforms by name
+    #
+    # @see https://api.thegamesdb.net/#/Platforms/PlatformsByPlatformName
+    #
+    # @param name [String] Platform name (Required)
+    #
+    # @return [Hash|Array] Returns a Hash when there's one result or an Array of
+    # Hashes when there's more than one
+    def platforms_by_name(name)
+      url = 'Platforms/ByPlatformName'
+      params = {
+        name: name,
+        fields:
+        'icon,console,controller,developer,manufacturer,media,cpu,memory,graphics,sound,maxcontrollers,display,' \
+        'overview,youtube'
+      }
+      data = perform_request(url, params)
+
+      platform_api_response(data)
+    end
+
+    # Fetch platform(s) images by platform(s) id
+    #
+    # @see https://api.thegamesdb.net/#/Platforms/PlatformsImages
+    #
+    # @param platforms_id [Integer|String] The numeric ID of the platform in the GamesDB
+    # database or a String with comma delimited list of Ids. (Required)
+    # @param filter [String] options: 'fanart', 'banner', 'boxart' (supports
+    # comma delimited list)
+    # @param page [Integer]
+    #
+    # @return Array of Hashes
+    def platform_images(platforms_id, args = {})
+      url = 'Platforms/Images'
+      args['filter[type]'] = args.delete(:type) if args[:type]
+      args = args.merge({ platforms_id: platforms_id })
+      data = perform_request(url, args)
+      data['data']['images'].values.flatten
+    end
+
+    # Auxiliary method to return either one hash when there's only one result or
+    # an Array of Hashes for several results
+    def platform_api_response(data)
+      return [] if data['data']['count'].zero?
+
+      platforms = data['data']['platforms']
+
+      response = case platforms
+                 when Hash
+                   platforms.map { |_k, platform| Gamesdb::Utils.symbolize_keys(platform) }
+                 when Array
+                   platforms.map { |platform| Gamesdb::Utils.symbolize_keys(platform) }
+                 end
+
+      return response.first if response.count == 1
+
+      response
+    end
+  end
+end

data/lib/thegamesdb/publishers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Gamesdb
+  # Publishers related API Endpoints
+  module Publishers
+    def publishers
+      url = 'Publishers'
+
+      data = perform_request(url)
+      data['data']['publishers'].map do |_id, publisher|
+        publisher
+      end
+    end
+  end
+end

data/lib/thegamesdb/utils.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Gamesdb
+  # Several reusable functions
+  module Utils
+    class << self
+      def process_logo(data, id)
+        logo = data['images'][id.to_s].select { |a| a['type'] == 'clearlogo' }
+        logo.empty? ? '' : logo.first['filename']
+      end
+
+      def process_fanart(data, id)
+        fanart = select_images(data, id, 'fanart')
+        return [] if fanart.empty?
+
+        fanart.map { |art| build_individual_fanart(art) }
+      end
+
+      def process_covers(data, id)
+        covers = {}
+        boxart = select_images(data, id, 'boxart')
+        return [] if boxart.empty?
+
+        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
+
+      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
+
+      def process_screenshots(data, id)
+        select_images(data, id, 'screenshot').map do |b|
+          Gamesdb::Utils.symbolize_keys(b)
+        end
+      end
+
+      def select_images(data, id, image_type)
+        data['images'][id.to_s].select do |a|
+          a['type'] == image_type
+        end
+      end
+
+      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
+end

data/lib/thegamesdb/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 # Gem version
 module Gamesdb
-  VERSION = '1.1.2'.freeze
+  VERSION = '2.1.0'
 end