discordrb 3.4.3 → 3.6.0

data/lib/discordrb/data/server.rb

@@ -64,38 +64,20 @@ module Discordrb
     # @!visibility private
     def initialize(data, bot)
       @bot = bot
-      @owner_id = data['owner_id'].to_i
       @id = data['id'].to_i
-
-      process_channels(data['channels'])
-      update_data(data)
-
-      @large = data['large']
-      @member_count = data['member_count']
-      @splash_id = nil
-      @banner_id = nil
-      @features = data['features'].map { |element| element.downcase.to_sym }
       @members = {}
       @voice_states = {}
       @emoji = {}
 
-      process_roles(data['roles'])
-      process_emoji(data['emojis'])
-      process_members(data['members'])
-      process_presences(data['presences'])
-      process_voice_states(data['voice_states'])
+      update_data(data)
 
       # Whether this server's members have been chunked (resolved using op 8 and GUILD_MEMBERS_CHUNK) yet
       @chunked = false
-      @processed_chunk_members = 0
-
-      @booster_count = data['premium_subscription_count'] || 0
-      @boost_level = data['premium_tier']
     end
 
     # @return [Member] The server owner.
     def owner
-      @owner ||= member(@owner_id)
+      member(@owner_id)
     end
 
     # The default channel is the text channel on this server with the highest position
@@ -143,10 +125,15 @@ module Discordrb
     end
 
     # @return [Array<Member>] an array of all the members on this server.
+    # @raise [RuntimeError] if the bot was not started with the :server_member intent
     def members
       return @members.values if @chunked
 
       @bot.debug("Members for server #{@id} not chunked yet - initiating")
+
+      # If the SERVER_MEMBERS intent flag isn't set, the gateway won't respond when we ask for members.
+      raise 'The :server_members intent is required to get server members' if @bot.gateway.intents.nobits?(INTENTS[:server_members])
+
       @bot.request_chunks(@id)
       sleep 0.05 until @chunked
       @members.values
@@ -189,78 +176,73 @@ module Discordrb
       AuditLogs.new(self, @bot, JSON.parse(API::Server.audit_logs(@bot.token, @id, limit, user, action, before)))
     end
 
-    # Cache @embed
+    # Cache @widget
     # @note For internal use only
     # @!visibility private
-    def cache_embed_data
-      data = JSON.parse(API::Server.embed(@bot.token, @id))
-      @embed_enabled = data['enabled']
-      @embed_channel_id = data['channel_id']
+    def cache_widget_data
+      data = JSON.parse(API::Server.widget(@bot.token, @id))
+      @widget_enabled = data['enabled']
+      @widget_channel_id = data['channel_id']
     end
 
     # @return [true, false] whether or not the server has widget enabled
-    def embed_enabled?
-      cache_embed_data if @embed_enabled.nil?
-      @embed_enabled
+    def widget_enabled?
+      cache_widget_data if @widget_enabled.nil?
+      @widget_enabled
     end
-    alias_method :widget_enabled, :embed_enabled?
-    alias_method :widget?, :embed_enabled?
-    alias_method :embed?, :embed_enabled?
+    alias_method :widget?, :widget_enabled?
+    alias_method :embed_enabled, :widget_enabled?
+    alias_method :embed?, :widget_enabled?
 
-    # @return [Channel, nil] the channel the server embed will make an invite for.
-    def embed_channel
-      cache_embed_data if @embed_enabled.nil?
-      @bot.channel(@embed_channel_id) if @embed_channel_id
+    # @return [Channel, nil] the channel the server widget will make an invite for.
+    def widget_channel
+      cache_widget_data if @widget_enabled.nil?
+      @bot.channel(@widget_channel_id) if @widget_channel_id
     end
-    alias_method :widget_channel, :embed_channel
+    alias_method :embed_channel, :widget_channel
 
-    # Sets whether this server's embed (widget) is enabled
+    # Sets whether this server's widget is enabled
     # @param value [true, false]
-    def embed_enabled=(value)
-      modify_embed(value, embed_channel)
+    def widget_enabled=(value)
+      modify_widget(value, widget_channel)
     end
+    alias_method :embed_enabled=, :widget_enabled=
 
-    alias_method :widget_enabled=, :embed_enabled=
-
-    # Sets whether this server's embed (widget) is enabled
+    # Sets whether this server's widget is enabled
     # @param value [true, false]
     # @param reason [String, nil] the reason to be shown in the audit log for this action
-    def set_embed_enabled(value, reason = nil)
-      modify_embed(value, embed_channel, reason)
+    def set_widget_enabled(value, reason = nil)
+      modify_widget(value, widget_channel, reason)
     end
+    alias_method :set_embed_enabled, :set_widget_enabled
 
-    alias_method :set_widget_enabled, :set_embed_enabled
-
-    # Changes the channel on the server's embed (widget)
-    # @param channel [Channel, String, Integer] the channel, or its ID, to be referenced by the embed
-    def embed_channel=(channel)
-      modify_embed(embed?, channel)
+    # Changes the channel on the server's widget
+    # @param channel [Channel, String, Integer] the channel, or its ID, to be referenced by the widget
+    def widget_channel=(channel)
+      modify_widget(widget?, channel)
     end
+    alias_method :embed_channel=, :widget_channel=
 
-    alias_method :widget_channel=, :embed_channel=
-
-    # Changes the channel on the server's embed (widget)
-    # @param channel [Channel, String, Integer] the channel, or its ID, to be referenced by the embed
+    # Changes the channel on the server's widget
+    # @param channel [Channel, String, Integer] the channel, or its ID, to be referenced by the widget
     # @param reason [String, nil] the reason to be shown in the audit log for this action
-    def set_embed_channel(channel, reason = nil)
-      modify_embed(embed?, channel, reason)
+    def set_widget_channel(channel, reason = nil)
+      modify_widget(widget?, channel, reason)
     end
+    alias_method :set_embed_channel, :set_widget_channel
 
-    alias_method :set_widget_channel, :set_embed_channel
-
-    # Changes the channel on the server's embed (widget), and sets whether it is enabled.
-    # @param enabled [true, false] whether the embed (widget) is enabled
-    # @param channel [Channel, String, Integer] the channel, or its ID, to be referenced by the embed
+    # Changes the channel on the server's widget, and sets whether it is enabled.
+    # @param enabled [true, false] whether the widget is enabled
+    # @param channel [Channel, String, Integer] the channel, or its ID, to be referenced by the widget
     # @param reason [String, nil] the reason to be shown in the audit log for this action
-    def modify_embed(enabled, channel, reason = nil)
-      cache_embed_data if @embed_enabled.nil?
-      channel_id = channel ? channel.resolve_id : @embed_channel_id
-      response = JSON.parse(API::Server.modify_embed(@bot.token, @id, enabled, channel_id, reason))
-      @embed_enabled = response['enabled']
-      @embed_channel_id = response['channel_id']
+    def modify_widget(enabled, channel, reason = nil)
+      cache_widget_data if @widget_enabled.nil?
+      channel_id = channel ? channel.resolve_id : @widget_channel_id
+      response = JSON.parse(API::Server.modify_widget(@bot.token, @id, enabled, channel_id, reason))
+      @widget_enabled = response['enabled']
+      @widget_channel_id = response['channel_id']
     end
-
-    alias_method :modify_widget, :modify_embed
+    alias_method :modify_embed, :modify_widget
 
     # @param include_idle [true, false] Whether to count idle members as online.
     # @param include_bots [true, false] Whether to include bot accounts in the count.
@@ -338,6 +320,11 @@ module Discordrb
       @channels.reject { |c| c.parent || c.category? }
     end
 
+    # @return [ServerPreview] the preview of this server shown in the discovery page.
+    def preview
+      @bot.server_preview(@id)
+    end
+
     # @return [String, nil] the widget URL to the server that displays the amount of online members in a
     #   stylish way. `nil` if the widget is not enabled.
     def widget_url
@@ -410,7 +397,7 @@ module Discordrb
     # @!visibility private
     def delete_role(role_id)
       @roles.reject! { |r| r.id == role_id }
-      @members.each do |_, member|
+      @members.each_value do |member|
         new_roles = member.roles.reject { |r| r.id == role_id }
         member.update_roles(new_roles)
       end
@@ -444,7 +431,7 @@ module Discordrb
     # @!visibility private
     def delete_member(user_id)
       @members.delete(user_id)
-      @member_count -= 1
+      @member_count -= 1 unless @member_count <= 0
     end
 
     # Checks whether a member is cached
@@ -520,14 +507,19 @@ module Discordrb
     # Creates a role on this server which can then be modified. It will be initialized
     # with the regular role defaults the client uses unless specified, i.e. name is "new role",
     # permissions are the default, colour is the default etc.
-    # @param name [String] Name of the role to create
-    # @param colour [Integer, ColourRGB, #combined] The roles colour
-    # @param hoist [true, false]
-    # @param mentionable [true, false]
+    # @param name [String] Name of the role to create.
+    # @param colour [Integer, ColourRGB, #combined] The primary colour of the role to create.
+    # @param hoist [true, false] whether members of this role should be displayed seperately in the members list.
+    # @param mentionable [true, false] whether this role can mentioned by anyone in the server.
     # @param permissions [Integer, Array<Symbol>, Permissions, #bits] The permissions to write to the new role.
+    # @param icon [String, #read, nil] The base64 encoded image data, or a file like object that responds to #read.
+    # @param unicode_emoji [String, nil] The unicode emoji of the role to create, or nil.
+    # @param display_icon [String, File, #read, nil] The icon to display for the role. Overrides the **icon** and **unicode_emoji** parameters if passed.
     # @param reason [String] The reason the for the creation of this role.
+    # @param secondary_colour [Integer, ColourRGB, nil] The secondary colour of the role to create.
+    # @param tertiary_colour [Integer, ColourRGB, nil] The tertiary colour of the role to create.
     # @return [Role] the created role.
-    def create_role(name: 'new role', colour: 0, hoist: false, mentionable: false, permissions: 104_324_161, reason: nil)
+    def create_role(name: 'new role', colour: 0, hoist: false, mentionable: false, permissions: 104_324_161, secondary_colour: nil, tertiary_colour: nil, icon: nil, unicode_emoji: nil, display_icon: nil, reason: nil)
       colour = colour.respond_to?(:combined) ? colour.combined : colour
 
       permissions = if permissions.is_a?(Array)
@@ -538,7 +530,21 @@ module Discordrb
                       permissions
                     end
 
-      response = API::Server.create_role(@bot.token, @id, name, colour, hoist, mentionable, permissions, reason)
+      icon = icon.respond_to?(:read) ? Discordrb.encode64(icon) : icon
+
+      colours = {
+        primary_color: colour&.to_i,
+        tertiary_color: tertiary_colour&.to_i,
+        secondary_color: secondary_colour&.to_i
+      }
+
+      if display_icon.is_a?(String)
+        unicode_emoji = display_icon
+      elsif display_icon.respond_to?(:read)
+        icon = Discordrb.encode64(display_icon)
+      end
+
+      response = API::Server.create_role(@bot.token, @id, name, nil, hoist, mentionable, permissions&.to_s, reason, colours, icon, unicode_emoji)
 
       role = Role.new(JSON.parse(response), @bot, self)
       @roles << role
@@ -552,13 +558,9 @@ module Discordrb
     # @param reason [String] The reason the for the creation of this emoji.
     # @return [Emoji] The emoji that has been added.
     def add_emoji(name, image, roles = [], reason: nil)
-      image_string = image
-      if image.respond_to? :read
-        image_string = 'data:image/jpg;base64,'
-        image_string += Base64.strict_encode64(image.read)
-      end
+      image = image.respond_to?(:read) ? Discordrb.encode64(image) : image
 
-      data = JSON.parse(API::Server.add_emoji(@bot.token, @id, image_string, name, roles.map(&:resolve_id), reason))
+      data = JSON.parse(API::Server.add_emoji(@bot.token, @id, image, name, roles.map(&:resolve_id), reason))
       new_emoji = Emoji.new(data, @bot, self)
       @emoji[new_emoji.id] = new_emoji
     end
@@ -586,7 +588,7 @@ module Discordrb
     # The amount of emoji the server can have, based on its current Nitro Boost Level.
     # @return [Integer] the max amount of emoji
     def max_emoji
-      case @level
+      case @boost_level
       when 1
         100
       when 2
@@ -598,9 +600,24 @@ module Discordrb
       end
     end
 
+    # Searches a server for members that matches a username or a nickname.
+    # @param name [String] The username or nickname to search for.
+    # @param limit [Integer] The maximum number of members between 1-1000 to return. Returns 1 member by default.
+    # @return [Array<Member>, nil] An array of member objects that match the given parameters, or nil for no members.
+    def search_members(name:, limit: nil)
+      response = JSON.parse(API::Server.search_guild_members(@bot.token, @id, name, limit))
+      return nil if response.empty?
+
+      response.map { |mem| Member.new(mem, self, @bot) }
+    end
+
+    # Retrieve banned users from this server.
+    # @param limit [Integer] Number of users to return (up to maximum 1000, default 1000).
+    # @param before_id [Integer] Consider only users before given user id.
+    # @param after_id [Integer] Consider only users after given user id.
     # @return [Array<ServerBan>] a list of banned users on this server and the reason they were banned.
-    def bans
-      response = JSON.parse(API::Server.bans(@bot.token, @id))
+    def bans(limit: nil, before_id: nil, after_id: nil)
+      response = JSON.parse(API::Server.bans(@bot.token, @id, limit, before_id, after_id))
       response.map do |e|
         ServerBan.new(self, User.new(e['user'], @bot), e['reason'])
       end
@@ -608,10 +625,17 @@ module Discordrb
 
     # Bans a user from this server.
     # @param user [User, String, Integer] The user to ban.
-    # @param message_days [Integer] How many days worth of messages sent by the user should be deleted.
+    # @param message_days [Integer] How many days worth of messages sent by the user should be deleted. This is deprecated and will be removed in 4.0.
+    # @param message_seconds [Integer] How many seconds of messages sent by the user should be deleted.
     # @param reason [String] The reason the user is being banned.
-    def ban(user, message_days = 0, reason: nil)
-      API::Server.ban_user(@bot.token, @id, user.resolve_id, message_days, reason)
+    def ban(user, message_days = 0, message_seconds: nil, reason: nil)
+      delete_messages = if message_days != 0 && message_days
+                          message_days * 86_400
+                        else
+                          message_seconds || 0
+                        end
+
+      API::Server.ban_user!(@bot.token, @id, user.resolve_id, delete_messages, reason)
     end
 
     # Unbans a previously banned user from this server.
@@ -621,6 +645,20 @@ module Discordrb
       API::Server.unban_user(@bot.token, @id, user.resolve_id, reason)
     end
 
+    # Ban up to 200 users from this server in one go.
+    # @param users [Array<User, String, Integer>] Array of up to 200 users to ban.
+    # @param message_seconds [Integer] How many seconds of messages sent by the users should be deleted.
+    # @param reason [String] The reason these users are being banned.
+    # @return [BulkBan]
+    def bulk_ban(users:, message_seconds: 0, reason: nil)
+      raise ArgumentError, 'Can only ban between 1 and 200 users!' unless users.size.between?(1, 200)
+
+      return ban(users.first, 0, message_seconds: message_seconds, reason: reason) if users.size == 1
+
+      response = API::Server.bulk_ban(@bot.token, @id, users.map(&:resolve_id), message_seconds, reason)
+      BulkBan.new(JSON.parse(response), self, reason)
+    end
+
     # Kicks a user from this server.
     # @param user [User, String, Integer] The user to kick.
     # @param reason [String] The reason the user is being kicked.
@@ -628,16 +666,12 @@ module Discordrb
       API::Server.remove_member(@bot.token, @id, user.resolve_id, reason)
     end
 
-    # Forcibly moves a user into a different voice channel. Only works if the bot has the permission needed.
+    # Forcibly moves a user into a different voice channel.
+    # Only works if the bot has the permission needed and if the user is already connected to some voice channel on this server.
     # @param user [User, String, Integer] The user to move.
-    # @param channel [Channel, String, Integer] The voice channel to move into.
+    # @param channel [Channel, String, Integer, nil] The voice channel to move into. (If nil, the user is disconnected from the voice channel)
     def move(user, channel)
-      API::Server.update_member(@bot.token, @id, user.resolve_id, channel_id: channel.resolve_id)
-    end
-
-    # Deletes this server. Be aware that this is permanent and impossible to undo, so be careful!
-    def delete
-      API::Server.delete(@bot.token, @id)
+      API::Server.update_member(@bot.token, @id, user.resolve_id, channel_id: channel&.resolve_id)
     end
 
     # Leave the server.
@@ -645,12 +679,6 @@ module Discordrb
       API::User.leave_server(@bot.token, @id)
     end
 
-    # Transfers server ownership to another user.
-    # @param user [User, String, Integer] The user who should become the new owner.
-    def owner=(user)
-      API::Server.transfer_ownership(@bot.token, @id, user.resolve_id)
-    end
-
     # Sets the server's name.
     # @param name [String] The new server name.
     def name=(name)
@@ -682,10 +710,8 @@ module Discordrb
     # Sets the server's icon.
     # @param icon [String, #read] The new icon, in base64-encoded JPG format.
     def icon=(icon)
-      if icon.respond_to? :read
-        icon_string = 'data:image/jpg;base64,'
-        icon_string += Base64.strict_encode64(icon.read)
-        update_server_data(icon_id: icon_string)
+      if icon.respond_to?(:read)
+        update_server_data(icon_id: Discordrb.encode64(icon))
       else
         update_server_data(icon_id: icon)
       end
@@ -805,19 +831,16 @@ module Discordrb
     # Processes a GUILD_MEMBERS_CHUNK packet, specifically the members field
     # @note For internal use only
     # @!visibility private
-    def process_chunk(members)
+    def process_chunk(members, chunk_index, chunk_count)
       process_members(members)
-      @processed_chunk_members += members.length
-      LOGGER.debug("Processed one chunk on server #{@id} - length #{members.length}")
+      LOGGER.debug("Processed chunk #{chunk_index + 1}/#{chunk_count} server #{@id} - index #{chunk_index} - length #{members.length}")
 
-      # Don't bother with the rest of the method if it's not truly the last packet
-      return unless @processed_chunk_members == @member_count
+      return if chunk_index + 1 < chunk_count
 
       LOGGER.debug("Finished chunking server #{@id}")
 
       # Reset everything to normal
       @chunked = true
-      @processed_chunk_members = 0
     end
 
     # @return [Channel, nil] the AFK voice channel of this server, or `nil` if none is set.
@@ -841,18 +864,35 @@ module Discordrb
       @afk_timeout = new_data[:afk_timeout] || new_data['afk_timeout'] || @afk_timeout
 
       afk_channel_id = new_data[:afk_channel_id] || new_data['afk_channel_id'] || @afk_channel
-      @afk_channel_id = afk_channel_id.nil? ? nil : afk_channel_id.resolve_id
-      embed_channel_id = new_data[:embed_channel_id] || new_data['embed_channel_id'] || @embed_channel
-      @embed_channel_id = embed_channel_id.nil? ? nil : embed_channel_id.resolve_id
+      @afk_channel_id = afk_channel_id&.resolve_id
+      widget_channel_id = new_data[:widget_channel_id] || new_data['widget_channel_id'] || @widget_channel
+      @widget_channel_id = widget_channel_id&.resolve_id
       system_channel_id = new_data[:system_channel_id] || new_data['system_channel_id'] || @system_channel
-      @system_channel_id = system_channel_id.nil? ? nil : system_channel_id.resolve_id
+      @system_channel_id = system_channel_id&.resolve_id
 
-      @embed_enabled = new_data[:embed_enabled] || new_data['embed_enabled']
+      @widget_enabled = new_data[:widget_enabled] || new_data['widget_enabled']
       @splash = new_data[:splash_id] || new_data['splash_id'] || @splash_id
 
       @verification_level = new_data[:verification_level] || new_data['verification_level'] || @verification_level
       @explicit_content_filter = new_data[:explicit_content_filter] || new_data['explicit_content_filter'] || @explicit_content_filter
       @default_message_notifications = new_data[:default_message_notifications] || new_data['default_message_notifications'] || @default_message_notifications
+
+      @large = new_data.key?('large') ? new_data['large'] : @large
+      @member_count = new_data['member_count'] || @member_count || 0
+      @splash_id = new_data['splash'] || @splash_id
+      @banner_id = new_data['banner'] || @banner_id
+      @features = new_data['features'] ? new_data['features'].map { |element| element.downcase.to_sym } : @features || []
+      @booster_count = new_data['premium_subscription_count'] || @booster_count || 0
+      @boost_level = new_data['premium_tier'] || @boost_level
+      @owner_id = new_data['owner_id'].to_i
+
+      process_channels(new_data['channels']) if new_data['channels']
+      process_roles(new_data['roles']) if new_data['roles']
+      process_emoji(new_data['emojis']) if new_data['emojis']
+      process_members(new_data['members']) if new_data['members']
+      process_presences(new_data['presences']) if new_data['presences']
+      process_voice_states(new_data['voice_states']) if new_data['voice_states']
+      process_active_threads(new_data['threads']) if new_data['threads']
     end
 
     # Adds a channel to this server's cache
@@ -970,6 +1010,19 @@ module Discordrb
         update_voice_state(element)
       end
     end
+
+    def process_active_threads(threads)
+      @channels ||= []
+      @channels_by_id ||= {}
+
+      return unless threads
+
+      threads.each do |element|
+        thread = @bot.ensure_channel(element, self)
+        @channels << thread
+        @channels_by_id[thread.id] = thread
+      end
+    end
   end
 
   # A ban entry on a server
@@ -999,4 +1052,27 @@ module Discordrb
     alias_method :unban, :remove
     alias_method :lift, :remove
   end
+
+  # A bulk ban entry on a server
+  class BulkBan
+    # @return [Server] The server this bulk ban belongs to.
+    attr_reader :server
+
+    # @return [String, nil] The reason these users were banned.
+    attr_reader :reason
+
+    # @return [Array<Integer>] Array of user IDs that were banned.
+    attr_reader :banned_users
+
+    # @return [Array<Integer>] Array of user IDs that couldn't be banned.
+    attr_reader :failed_users
+
+    # @!visibility private
+    def initialize(data, server, reason)
+      @server = server
+      @reason = reason
+      @banned_users = data['banned_users']&.map(&:resolve_id) || []
+      @failed_users = data['failed_users']&.map(&:resolve_id) || []
+    end
+  end
 end

data/lib/discordrb/data/server_preview.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # Publicly accessible information about a discoverable server.
+  class ServerPreview
+    include IDObject
+    include ServerAttributes
+
+    # @return [String, nil] the ID of the server's invite splash screen.
+    # @see #splash_url
+    attr_reader :splash_id
+
+    # @return [String, nil] the ID of the server's discovery splash screen.
+    # @see #discovery_splash_url
+    attr_reader :discovery_splash_id
+
+    # @return [Hash<Integer => Emoji>] a hash of all the emojis usable on this server.
+    attr_reader :emojis
+
+    # @return [Array<Symbol>] the features of this server, e.g. `:banner` or `:verified`.
+    attr_reader :features
+
+    # @return [Integer] the approximate number of members on this server, offline or not.
+    attr_reader :member_count
+
+    # @return [Integer] the approximate number of members that aren't offline on this server.
+    attr_reader :presence_count
+
+    # @return [String, nil] the description of this server that's shown in the discovery tab.
+    attr_reader :description
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+      @id = data['id'].to_i
+      @name = data['name']
+      @icon_id = data['icon']
+      @splash_id = data['splash']
+      @description = data['description']
+      @discovery_splash_id = data['discovery_splash']
+      @member_count = data['approximate_member_count']
+      @presence_count = data['approximate_presence_count']
+      @features = data['features'].map { |feature| feature.downcase.to_sym }
+      @emojis = data['emojis'].to_h { |emoji| [emoji['id'].to_i, Emoji.new(emoji, bot)] }
+    end
+
+    # Get the server associated with this server preview.
+    # @return [Server] the server associated with this server preview.
+    # @raise [Discordrb::Errors::NoPermission] this can happen when the bot is not in the associated server.
+    def server
+      @bot.server(@id)
+    end
+
+    # Utility method to get a server preview's splash URL.
+    # @param format [String] the URL will default to `webp`. You can otherwise specify one of `jpg` or `png` to override this.
+    # @return [String, nil] the URL to the server's splash image, or `nil` if the server doesn't have a splash image.
+    def splash_url(format = 'webp')
+      API.splash_url(@id, @splash_id, format) if @splash_id
+    end
+
+    # Utility method to get a server preview's discovery splash URL.
+    # @param format [String] the URL will default to `webp`. You can otherwise specify one of `jpg` or `png` to override this.
+    # @return [String, nil] the URL to the server's discovery splash image, or `nil` if the server doesn't have a discovery splash image.
+    def discovery_splash_url(format = 'webp')
+      API.discovery_splash_url(@id, @discovery_splash_id, format) if @discovery_splash_id
+    end
+  end
+end