thegamesdb 0.2.0 → 2.0.0

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|
+        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| symbolize_keys(platform) }
+                 when Array
+                   platforms.map { |platform| 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/version.rb

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

data/test/client_test.rb

@@ -0,0 +1,16 @@
+# 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
+  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).must_equal 8168
+      expect(@developers.first.keys).must_equal(['id', 'name'])
+    end
+  end
+end

data/test/games_test.rb

@@ -1,63 +1,167 @@
-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 "Gamesdb - games", :vcr do
   describe 'game' do
     before do
-      @game = Gamesdb.game(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[:title].must_be_kind_of String
-      @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 'games_list' do
+  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
-      @games_list = Gamesdb.games_list('turrican')
+      @game = client.games_by_id(3)
+    end
+
+    it 'should return an empty array' do
+      expect(@game).must_equal []
+    end
+  end
+
+  describe 'games by name' do
+    before do
+      @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 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 art', :vcr do
+  describe 'games by name pages' do
     before do
-      @images = Gamesdb.art('216')
+      @first_page = client.games_by_name('mario', page: 1)
+      @second_page = client.games_by_name('mario', page: 2)
     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][:thumb].must_be_kind_of String
+    it 'should return games in platform by id' do
+      expect(@first_page.count).wont_be :<, 0
+      expect(@first_page.count).must_equal 20
     end
 
-    it 'should return screenshots' do
-      @images[:screenshot].count.wont_be :<, 0
-      @images[:screenshot].first[:original][1].must_be_kind_of String
-      @images[:screenshot].first[:original].first[:width].must_be_kind_of String
-      @images[:screenshot].first[:original].first[:height].must_be_kind_of String
-      @images[:screenshot].first[:thumb].must_be_kind_of String
+    it 'should return games in the platform for the second page' do
+      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 = client.games_by_name('mario', platform: 7)
     end
 
-    it 'should return fanart' do
-      @images[:fanart].count.wont_be :<, 0
-      @images[:fanart].first[:original][1].must_be_kind_of String
-      @images[:fanart].first[:original].first[:width].must_be_kind_of String
-      @images[:fanart].first[:original].first[:height].must_be_kind_of String
-      @images[:fanart].first[:thumb].must_be_kind_of String
+    it 'should return a list' do
+      @games_list.each do |game|
+        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
+
+  describe 'games art', :vcr do
+    describe 'when most of the art is available' do
+      before do
+        @images = client.games_images('218')
+      end
+
+      it 'should return logo and boxart' do
+        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
+        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
+        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 = client.games_images(65_238)
+      end
+
+      it 'should return an empty array' do
+        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 16: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 02: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
 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

data/test/platform_test.rb

@@ -1,94 +1,147 @@
-describe "GamesDB - platforms", :vcr do
+# frozen_string_literal: true
+
+require_relative './test_helper'
+
+describe 'GamesDB - platforms', :vcr do
+  let(:client) { Gamesdb::Client.new(ENV['GAMESDB_API_KEY']) }
+
   describe 'platforms' do
     before do
-      @platforms = Gamesdb.platforms
+      @platforms = client.platforms
     end
 
     it 'should get gaming platforms' do
-      @platforms.count.wont_be :<, 0
+      expect(@platforms.count).wont_be :<, 0
+      expect(@platforms.count).must_equal 114
     end
 
     it 'should have a valid name' do
-      @platforms[0][:name].must_be_kind_of String
+      expect(@platforms[0][:name]).must_be_kind_of String
     end
 
     it 'should have a valid id' do
-      @platforms[0][:id].must_be_kind_of Integer
+      expect(@platforms[0][:id]).must_be_kind_of Integer
     end
 
-    it 'should have a valid slug' do
-      @platforms[0][:slug].must_be_kind_of String
+    it 'should have a valid alias' do
+      expect(@platforms[0][:alias]).must_be_kind_of String
+    end
+
+    it 'should have valid fields for other stuff' do
+      nes = @platforms.select { |p| p[:id] == 7 }.first
+      expect(nes[:icon]).must_be_kind_of String
+      expect(nes[:console]).must_be_kind_of String
+      expect(nes[:controller]).must_be_kind_of String
+      expect(nes[:developer]).must_be_kind_of String
+      expect(nes[:manufacturer]).must_be_kind_of String
+      expect(nes[:maxcontrollers]).must_be_kind_of String
+      expect(nes[:cpu]).must_be_kind_of String
+      expect(nes[:memory]).must_be_kind_of String
+      expect(nes[:sound]).must_be_kind_of String
+      expect(nes[:display]).must_be_kind_of String
+      expect(nes[:overview]).must_be_kind_of String
     end
   end
 
-  describe 'platform_games' do
+  describe 'games by platform' do
     before do
-      platforms = Gamesdb.platforms
-      @games_by_id = Gamesdb.platform_games(platforms[0][:id])
-      @games_by_slug = Gamesdb.platform_games(platforms[0][:slug])
+      platforms = client.platforms
+      @first_page = client.games_by_platform_id(platforms[0][:id])
+      @second_page = client.games_by_platform_id(platforms[0][:id], 2)
     end
 
     it 'should return games in platform by id' do
-      @games_by_id.count.wont_be :<, 0
+      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
+      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 platform parameters' do
+    before do
+      @games1 = client.games_by_platform_id(4950)
+      @games2 = client.games_by_platform_id(4948)
+      @games3 = client.games_by_platform_id('4950,4948')
     end
 
-    it 'should return games in platform' do
-      @games_by_slug.count.wont_be :<, 0
+    it 'supports comma separated list' do
+      expect(@games1.count).must_equal 20
+      expect(@games2.count).must_equal 1
+      expect(@games3.count).must_equal 20
+
+      expect(@games3 - @games1).must_equal @games2
     end
   end
 
   describe 'platform' do
     describe 'assigning basic info' do
       before do
-        @platform = Gamesdb.platform 6
+        @platform = client.platforms_by_id(6)
       end
 
       it 'should return valid platform info' do
-        @platform[:name].must_equal 'Super Nintendo (SNES)'
-        @platform[:overview].must_be_kind_of String
-        @platform[:developer].must_be_kind_of String
-        @platform[:manufacturer].must_equal 'Nintendo'
-        @platform[:cpu].must_be_kind_of String
-        @platform[:memory].must_be_kind_of String
-        @platform[:sound].must_be_kind_of String
-        @platform[:display].must_be_kind_of String
-      end
-
-      it 'should assign images if provided' do
-        images = @platform[:Images]
-        images[:boxart][1].must_equal 'platform/boxart/6-2.jpg'
-        images[:boxart].first[:width].must_equal '500'
-        images[:boxart].first[:height].must_equal '750'
-        images[:consoleart].must_equal 'platform/consoleart/6.png'
-        images[:controllerart].must_equal 'platform/controllerart/6.png'
+        expect(@platform[:name]).must_equal 'Super Nintendo (SNES)'
+        expect(@platform[:overview]).must_be_kind_of String
+        expect(@platform[:developer]).must_be_kind_of String
+        expect(@platform[:manufacturer]).must_equal 'Nintendo'
+        expect(@platform[:cpu]).must_be_kind_of String
+        expect(@platform[:memory]).must_be_kind_of String
+        expect(@platform[:sound]).must_be_kind_of String
+        expect(@platform[:display]).must_be_kind_of String
       end
     end
 
     describe 'without hardware or images' do
       before do
-        @platform = Gamesdb.platform 4916
+        @platform = client.platforms_by_id(4916)
       end
 
       it 'should return valid platform info' do
-        @platform[:name].must_equal 'Android'
-        @platform[:overview].must_be_kind_of String
-        @platform[:developer].must_be_kind_of String
-        @platform[:manufacturer].must_be_nil
-        @platform[:cpu].must_be_nil
-        @platform[:memory].must_be_nil
-        @platform[:sound].must_be_nil
-        @platform[:display].must_be_nil
+        expect(@platform[:name]).must_equal 'Android'
+        expect(@platform[:overview]).must_be_kind_of String
+        expect(@platform[:developer]).must_be_kind_of String
+        expect(@platform[:manufacturer]).must_be_nil
+        expect(@platform[:cpu]).must_be_nil
+        expect(@platform[:memory]).must_be_nil
+        expect(@platform[:sound]).must_be_nil
+        expect(@platform[:display]).must_be_nil
       end
+    end
+  end
 
-      it 'should not fail hard if no images are provided' do
-        images = @platform[:Images]
+  describe 'platforms by name' do
+    it 'should return platforms' do
+      @platforms = client.platforms_by_name('Nintendo')
 
-        images[:boxart][1].must_equal 'platform/boxart/4916-2.jpg'
-        images[:boxart].first[:width].must_equal '820'
-        images[:boxart].first[:height].must_equal '1080'
-        images[:consoleart].must_be_nil
-        images[:controllerart].must_be_nil
-      end
+      expect(@platforms.count).must_equal 14
+      names = @platforms.sort_by { |p| p[:name] }.map { |p| p[:name] }
+      expect(names).must_equal [
+        'Nintendo 3DS', 'Nintendo 64', 'Nintendo DS', 'Nintendo Entertainment System (NES)',
+        'Nintendo Game Boy', 'Nintendo Game Boy Advance', 'Nintendo Game Boy Color', 'Nintendo GameCube',
+        'Nintendo Pokémon Mini', 'Nintendo Switch', 'Nintendo Virtual Boy', 'Nintendo Wii', 'Nintendo Wii U',
+        'Super Nintendo (SNES)'
+      ]
+    end
+  end
+
+  describe 'platform images' do
+    it 'should return all images for a platform' do
+      @images = client.platform_images(7)
+
+      expect(@images.count).must_equal(10)
+      expect(@images.first.keys).must_equal(['id', 'type', 'filename'])
+    end
+
+    it 'should filter image type for a platform' do
+      @images = client.platform_images(7, type: 'boxart')
+
+      expect(@images.count).must_equal(1)
+      expect(@images.first).must_equal({ 'id' => 222, 'type' => 'boxart', 'filename' => 'platform/boxart/7-2.jpg' })
     end
   end
 end