discordrb 3.3.0 → 3.5.0

data/lib/discordrb/bot.rb

@@ -18,11 +18,17 @@ require 'discordrb/events/bans'
 require 'discordrb/events/raw'
 require 'discordrb/events/reactions'
 require 'discordrb/events/webhooks'
+require 'discordrb/events/invites'
+require 'discordrb/events/interactions'
+require 'discordrb/events/threads'
 
 require 'discordrb/api'
 require 'discordrb/api/channel'
 require 'discordrb/api/server'
 require 'discordrb/api/invite'
+require 'discordrb/api/interaction'
+require 'discordrb/api/application'
+
 require 'discordrb/errors'
 require 'discordrb/data'
 require 'discordrb/await'
@@ -92,21 +98,25 @@ module Discordrb
     # @param parse_self [true, false] Whether the bot should react on its own messages. It's best to turn this off
     #   unless you really need this so you don't inadvertently create infinite loops.
     # @param shard_id [Integer] The number of the shard this bot should handle. See
-    #   https://github.com/discordapp/discord-api-docs/issues/17 for how to do sharding.
+    #   https://github.com/discord/discord-api-docs/issues/17 for how to do sharding.
     # @param num_shards [Integer] The total number of shards that should be running. See
-    #   https://github.com/discordapp/discord-api-docs/issues/17 for how to do sharding.
+    #   https://github.com/discord/discord-api-docs/issues/17 for how to do sharding.
     # @param redact_token [true, false] Whether the bot should redact the token in logs. Default is true.
     # @param ignore_bots [true, false] Whether the bot should ignore bot accounts or not. Default is false.
     # @param compress_mode [:none, :large, :stream] Sets which compression mode should be used when connecting
     #   to Discord's gateway. `:none` will request that no payloads are received compressed (not recommended for
     #   production bots). `:large` will request that large payloads are received compressed. `:stream` will request
     #   that all data be received in a continuous compressed stream.
+    # @param intents [:all, :unprivileged, Array<Symbol>, :none] Gateway intents that this bot requires. `:all` will
+    #   request all intents. `:unprivileged` will request only intents that are not defined as "Privileged". `:none`
+    #   will request no intents. An array of symbols will request only those intents specified.
+    # @see Discordrb::INTENTS
     def initialize(
-        log_mode: :normal,
-        token: nil, client_id: nil,
-        type: nil, name: '', fancy_log: false, suppress_ready: false, parse_self: false,
-        shard_id: nil, num_shards: nil, redact_token: true, ignore_bots: false,
-        compress_mode: :stream
+      log_mode: :normal,
+      token: nil, client_id: nil,
+      type: nil, name: '', fancy_log: false, suppress_ready: false, parse_self: false,
+      shard_id: nil, num_shards: nil, redact_token: true, ignore_bots: false,
+      compress_mode: :large, intents: :all
     )
       LOGGER.mode = log_mode
       LOGGER.token = token if redact_token
@@ -125,8 +135,21 @@ module Discordrb
 
       @compress_mode = compress_mode
 
+      raise 'Token string is empty or nil' if token.nil? || token.empty?
+
+      @intents = case intents
+                 when :all
+                   ALL_INTENTS
+                 when :unprivileged
+                   UNPRIVILEGED_INTENTS
+                 when :none
+                   NO_INTENTS
+                 else
+                   calculate_intents(intents)
+                 end
+
       @token = process_token(@type, token)
-      @gateway = Gateway.new(self, @token, @shard_key, @compress_mode)
+      @gateway = Gateway.new(self, @token, @shard_key, @compress_mode, @intents)
 
       init_cache
 
@@ -140,6 +163,8 @@ module Discordrb
       @current_thread = 0
 
       @status = :online
+
+      @application_commands = {}
     end
 
     # The list of users the bot shares a server with.
@@ -158,18 +183,23 @@ module Discordrb
       @servers
     end
 
+    # The list of members in threads the bot can see.
+    # @return [Hash<Integer => Hash<Integer => Hash<String => Object>>]
+    def thread_members
+      gateway_check
+      unavailable_servers_check
+      @thread_members
+    end
+
     # @overload emoji(id)
     #   Return an emoji by its ID
-    #   @param id [Integer, #resolve_id] The emoji's ID.
+    #   @param id [String, Integer] The emoji's ID.
     #   @return [Emoji, nil] the emoji object. `nil` if the emoji was not found.
     # @overload emoji
     #   The list of emoji the bot can use.
     #   @return [Array<Emoji>] the emoji available.
     def emoji(id = nil)
-      gateway_check
-      unavailable_servers_check
-
-      emoji_hash = @servers.values.map(&:emoji).reduce(&:merge)
+      emoji_hash = servers.values.map(&:emoji).reduce(&:merge)
       if id
         id = id.resolve_id
         emoji_hash[id]
@@ -193,8 +223,10 @@ module Discordrb
     # to edit user data like the current username (see {Profile#username=}).
     # @return [Profile] The bot's profile that can be used to edit data.
     def profile
-      gateway_check
-      @profile
+      return @profile if @profile
+
+      response = Discordrb::API::User.profile(@token)
+      @profile = Profile.new(JSON.parse(response), self)
     end
 
     alias_method :bot_user, :profile
@@ -203,6 +235,7 @@ module Discordrb
     # @return [Application, nil] The bot's application info. Returns `nil` if bot is not a bot account.
     def bot_application
       return unless @type == :bot
+
       response = API.oauth_application(token)
       Application.new(JSON.parse(response), self)
     end
@@ -225,7 +258,7 @@ module Discordrb
 
     # Runs the bot, which logs into Discord and connects the WebSocket. This
     # prevents all further execution unless it is executed with
-    # `backround` = `true`.
+    # `background` = `true`.
     # @param background [true, false] If it is `true`, then the bot will run in
     #   another thread to allow further execution. If it is `false`, this method
     #   will block until {#stop} is called. If the bot is run with `true`, make
@@ -254,9 +287,9 @@ module Discordrb
 
     # Stops the bot gracefully, disconnecting the websocket without immediately killing the thread. This means that
     # Discord is immediately aware of the closed connection and makes the bot appear offline instantly.
-    # @param no_sync [true, false] Whether or not to disable use of synchronize in the close method. This should be true if called from a trap context.
-    def stop(no_sync = false)
-      @gateway.stop(no_sync)
+    # @note This method no longer takes an argument as of 3.4.0
+    def stop(_no_sync = nil)
+      @gateway.stop
     end
 
     # @return [true, false] whether or not the bot is currently connected to Discord.
@@ -273,14 +306,14 @@ module Discordrb
 
     # Creates an OAuth invite URL that can be used to invite this bot to a particular server.
     # @param server [Server, nil] The server the bot should be invited to, or nil if a general invite should be created.
-    # @param permission_bits [Integer, String] Permission bits that should be appended to invite url.
+    # @param permission_bits [String, Integer] Permission bits that should be appended to invite url.
     # @return [String] the OAuth invite URL.
     def invite_url(server: nil, permission_bits: nil)
       @client_id ||= bot_application.id
 
       server_id_str = server ? "&guild_id=#{server.id}" : ''
       permission_bits_str = permission_bits ? "&permissions=#{permission_bits}" : ''
-      "https://discordapp.com/oauth2/authorize?&client_id=#{@client_id}#{server_id_str}#{permission_bits_str}&scope=bot"
+      "https://discord.com/oauth2/authorize?&client_id=#{@client_id}#{server_id_str}#{permission_bits_str}&scope=bot"
     end
 
     # @return [Hash<Integer => VoiceBot>] the voice connections this bot currently has, by the server ID to which they are connected.
@@ -299,22 +332,21 @@ module Discordrb
 
       server_id = channel.server.id
       return @voices[server_id] if @voices[server_id]
-
-      nil
     end
 
     # Connects to a voice channel, initializes network connections and returns the {Voice::VoiceBot} over which audio
     # data can then be sent. After connecting, the bot can also be accessed using {#voice}. If the bot is already
     # connected to voice, the existing connection will be terminated - you don't have to call
     # {Discordrb::Voice::VoiceBot#destroy} before calling this method.
-    # @param chan [Channel, Integer, #resolve_id] The voice channel to connect to.
-    # @param encrypted [true, false] Whether voice communication should be encrypted using RbNaCl's SecretBox
+    # @param chan [Channel, String, Integer] The voice channel, or its ID, to connect to.
+    # @param encrypted [true, false] Whether voice communication should be encrypted using
     #   (uses an XSalsa20 stream cipher for encryption and Poly1305 for authentication)
     # @return [Voice::VoiceBot] the initialized bot over which audio data can then be sent.
     def voice_connect(chan, encrypted = true)
+      raise ArgumentError, 'Unencrypted voice connections are no longer supported.' unless encrypted
+
       chan = channel(chan.resolve_id)
       server_id = chan.server.id
-      @should_encrypt_voice = encrypted
 
       if @voices[chan.id]
         debug('Voice bot exists already! Destroying it')
@@ -336,7 +368,7 @@ module Discordrb
 
     # Disconnects the client from a specific voice connection given the server ID. Usually it's more convenient to use
     # {Discordrb::Voice::VoiceBot#destroy} rather than this.
-    # @param server [Server, Integer, #resolve_id] The server the voice connection is on.
+    # @param server [Server, String, Integer] The server, or server ID, the voice connection is on.
     # @param destroy_vws [true, false] Whether or not the VWS should also be destroyed. If you're calling this method
     #   directly, you should leave it as true.
     def voice_destroy(server, destroy_vws = true)
@@ -355,31 +387,41 @@ module Discordrb
     end
 
     # Sends a text message to a channel given its ID and the message's content.
-    # @param channel [Channel, Integer, #resolve_id] The channel to send something to.
+    # @param channel [Channel, String, Integer] The channel, or its ID, to send something to.
     # @param content [String] The text that should be sent as a message. It is limited to 2000 characters (Discord imposed).
     # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
-    # @param embed [Hash, Discordrb::Webhooks::Embed, nil] The rich embed to append to this message.
+    # @param embeds [Hash, Discordrb::Webhooks::Embed, Array<Hash>, Array<Discordrb::Webhooks::Embed> nil] The rich embed(s) to append to this message.
+    # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
+    # @param message_reference [Message, String, Integer, nil] The message, or message ID, to reply to if any.
+    # @param components [View, Array<Hash>] Interaction components to associate with this message.
     # @return [Message] The message that was sent.
-    def send_message(channel, content, tts = false, embed = nil)
+    def send_message(channel, content, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil)
       channel = channel.resolve_id
       debug("Sending message to #{channel} with content '#{content}'")
+      allowed_mentions = { parse: [] } if allowed_mentions == false
+      message_reference = { message_id: message_reference.id } if message_reference.respond_to?(:id)
+      embeds = (embeds.instance_of?(Array) ? embeds.map(&:to_hash) : [embeds&.to_hash]).compact
 
-      response = API::Channel.create_message(token, channel, content, tts, embed ? embed.to_hash : nil)
+      response = API::Channel.create_message(token, channel, content, tts, embeds, nil, attachments, allowed_mentions&.to_hash, message_reference, components)
       Message.new(JSON.parse(response), self)
     end
 
     # Sends a text message to a channel given its ID and the message's content,
     # then deletes it after the specified timeout in seconds.
-    # @param channel [Channel, Integer, #resolve_id] The channel to send something to.
+    # @param channel [Channel, String, Integer] The channel, or its ID, to send something to.
     # @param content [String] The text that should be sent as a message. It is limited to 2000 characters (Discord imposed).
     # @param timeout [Float] The amount of time in seconds after which the message sent will be deleted.
     # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
-    # @param embed [Hash, Discordrb::Webhooks::Embed, nil] The rich embed to append to this message.
-    def send_temporary_message(channel, content, timeout, tts = false, embed = nil)
+    # @param embeds [Hash, Discordrb::Webhooks::Embed, Array<Hash>, Array<Discordrb::Webhooks::Embed> nil] The rich embed(s) to append to this message.
+    # @param attachments [Array<File>] Files that can be referenced in embeds via `attachment://file.png`
+    # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
+    # @param message_reference [Message, String, Integer, nil] The message, or message ID, to reply to if any.
+    # @param components [View, Array<Hash>] Interaction components to associate with this message.
+    def send_temporary_message(channel, content, timeout, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil)
       Thread.new do
         Thread.current[:discordrb_name] = "#{@current_thread}-temp-msg"
 
-        message = send_message(channel, content, tts, embed)
+        message = send_message(channel, content, tts, embeds, attachments, allowed_mentions, message_reference, components)
         sleep(timeout)
         message.delete
       end
@@ -389,13 +431,25 @@ module Discordrb
 
     # Sends a file to a channel. If it is an image, it will automatically be embedded.
     # @note This executes in a blocking way, so if you're sending long files, be wary of delays.
-    # @param channel [Channel, Integer, #resolve_id] The channel to send something to.
+    # @param channel [Channel, String, Integer] The channel, or its ID, to send something to.
     # @param file [File] The file that should be sent.
     # @param caption [string] The caption for the file.
     # @param tts [true, false] Whether or not this file's caption should be sent using Discord text-to-speech.
+    # @param filename [String] Overrides the filename of the uploaded file
+    # @param spoiler [true, false] Whether or not this file should appear as a spoiler.
     # @example Send a file from disk
     #   bot.send_file(83281822225530880, File.open('rubytaco.png', 'r'))
-    def send_file(channel, file, caption: nil, tts: false)
+    def send_file(channel, file, caption: nil, tts: false, filename: nil, spoiler: nil)
+      if file.respond_to?(:read)
+        if spoiler
+          filename ||= File.basename(file.path)
+          filename = "SPOILER_#{filename}" unless filename.start_with? 'SPOILER_'
+        end
+        # https://github.com/rest-client/rest-client/blob/v2.0.2/lib/restclient/payload.rb#L160
+        file.define_singleton_method(:original_filename) { filename } if filename
+        file.define_singleton_method(:path) { filename } if filename
+      end
+
       channel = channel.resolve_id
       response = API::Channel.upload_file(token, channel, file, caption: caption, tts: tts)
       Message.new(JSON.parse(response), self)
@@ -410,14 +464,13 @@ module Discordrb
     def create_server(name, region = :'eu-central')
       response = API::Server.create(token, name, region)
       id = JSON.parse(response)['id'].to_i
-      sleep 0.1 until @servers[id]
-      server = @servers[id]
+      sleep 0.1 until (server = @servers[id])
       debug "Successfully created server #{server.id} with name #{server.name}"
       server
     end
 
     # Creates a new application to do OAuth authorization with. This allows you to use OAuth to authorize users using
-    # Discord. For information how to use this, see the docs: https://discordapp.com/developers/docs/topics/oauth2
+    # Discord. For information how to use this, see the docs: https://discord.com/developers/docs/topics/oauth2
     # @param name [String] What your application should be called.
     # @param redirect_uris [Array<String>] URIs that Discord should redirect your users to after authorizing.
     # @return [Array(String, String)] your applications' client ID and client secret to be used in OAuth authorization.
@@ -436,28 +489,46 @@ module Discordrb
       API.update_oauth_application(@token, name, redirect_uris, description, icon)
     end
 
-    # Gets the user, channel, role or emoji from a mention of the user, channel, role or emoji.
+    # Gets the users, channels, roles and emoji from a string.
+    # @param mentions [String] The mentions, which should look like `<@12314873129>`, `<#123456789>`, `<@&123456789>` or `<:name:126328:>`.
+    # @param server [Server, nil] The server of the associated mentions. (recommended for role parsing, to speed things up)
+    # @return [Array<User, Channel, Role, Emoji>] The array of users, channels, roles and emoji identified by the mentions, or `nil` if none exists.
+    def parse_mentions(mentions, server = nil)
+      array_to_return = []
+      # While possible mentions may be in message
+      while mentions.include?('<') && mentions.include?('>')
+        # Removing all content before the next possible mention
+        mentions = mentions.split('<', 2)[1]
+        # Locate the first valid mention enclosed in `<...>`, otherwise advance to the next open `<`
+        next unless mentions.split('>', 2).first.length < mentions.split('<', 2).first.length
+
+        # Store the possible mention value to be validated with RegEx
+        mention = mentions.split('>', 2).first
+        if /@!?(?<id>\d+)/ =~ mention
+          array_to_return << user(id) unless user(id).nil?
+        elsif /#(?<id>\d+)/ =~ mention
+          array_to_return << channel(id, server) unless channel(id, server).nil?
+        elsif /@&(?<id>\d+)/ =~ mention
+          if server
+            array_to_return << server.role(id) unless server.role(id).nil?
+          else
+            @servers.each_value do |element|
+              array_to_return << element.role(id) unless element.role(id).nil?
+            end
+          end
+        elsif /(?<animated>^a|^${0}):(?<name>\w+):(?<id>\d+)/ =~ mention
+          array_to_return << (emoji(id) || Emoji.new({ 'animated' => !animated.nil?, 'name' => name, 'id' => id }, self, nil))
+        end
+      end
+      array_to_return
+    end
+
+    # Gets the user, channel, role or emoji from a string.
     # @param mention [String] The mention, which should look like `<@12314873129>`, `<#123456789>`, `<@&123456789>` or `<:name:126328:>`.
     # @param server [Server, nil] The server of the associated mention. (recommended for role parsing, to speed things up)
     # @return [User, Channel, Role, Emoji] The user, channel, role or emoji identified by the mention, or `nil` if none exists.
     def parse_mention(mention, server = nil)
-      # Mention format: <@id>
-      if /<@!?(?<id>\d+)>/ =~ mention
-        user(id)
-      elsif /<#(?<id>\d+)>/ =~ mention
-        channel(id, server)
-      elsif /<@&(?<id>\d+)>/ =~ mention
-        return server.role(id) if server
-        @servers.values.each do |element|
-          role = element.role(id)
-          return role unless role.nil?
-        end
-
-        # Return nil if no role is found
-        nil
-      elsif /<(?<animated>a)?:(?<name>\w+):(?<id>\d+)>/ =~ mention
-        emoji(id) || Emoji.new({ 'animated' => !animated.nil?, 'name' => name, 'id' => id }, self, nil)
-      end
+      parse_mentions(mention, server).first
     end
 
     # Updates presence status.
@@ -466,7 +537,8 @@ module Discordrb
     # @param url [String, nil] The Twitch URL to display as a stream. nil for no stream.
     # @param since [Integer] When this status was set.
     # @param afk [true, false] Whether the bot is AFK.
-    # @param activity_type [Integer] The type of activity status to display. Can be 0 (Playing), 1 (Streaming), 2 (Listening), 3 (Watching)
+    # @param activity_type [Integer] The type of activity status to display.
+    #   Can be 0 (Playing), 1 (Streaming), 2 (Listening), 3 (Watching), or 5 (Competing).
     # @see Gateway#send_status_update
     def update_status(status, activity, url, since = 0, afk = false, activity_type = 0)
       gateway_check
@@ -480,7 +552,7 @@ module Discordrb
       @gateway.send_status_update(status, since, activity_obj, afk)
 
       # Update the status in the cache
-      profile.update_presence('status' => status.to_s, 'game' => activity_obj)
+      profile.update_presence('status' => status.to_s, 'activities' => [activity_obj].compact)
     end
 
     # Sets the currently playing game to the specified game.
@@ -489,7 +561,6 @@ module Discordrb
     def game=(name)
       gateway_check
       update_status(@status, name, nil)
-      name
     end
 
     alias_method :playing=, :game=
@@ -500,7 +571,6 @@ module Discordrb
     def listening=(name)
       gateway_check
       update_status(@status, name, nil, nil, nil, 2)
-      name
     end
 
     # Sets the current watching status to the specified name.
@@ -509,7 +579,6 @@ module Discordrb
     def watching=(name)
       gateway_check
       update_status(@status, name, nil, nil, nil, 3)
-      name
     end
 
     # Sets the currently online stream to the specified name and Twitch URL.
@@ -522,6 +591,14 @@ module Discordrb
       name
     end
 
+    # Sets the currently competing status to the specified name.
+    # @param name [String] The name of the game to be competing in.
+    # @return [String] The game that is being competed in now.
+    def competing=(name)
+      gateway_check
+      update_status(@status, name, nil, nil, nil, 5)
+    end
+
     # Sets status to online.
     def online
       gateway_check
@@ -550,6 +627,36 @@ module Discordrb
       update_status(:invisible, @activity, nil)
     end
 
+    # Join a thread
+    # @param channel [Channel, Integer, String]
+    def join_thread(channel)
+      API::Channel.join_thread(@token, channel.resolve_id)
+      nil
+    end
+
+    # Leave a thread
+    # @param channel [Channel, Integer, String]
+    def leave_thread(channel)
+      API::Channel.leave_thread(@token, channel.resolve_id)
+      nil
+    end
+
+    # Add a member to a thread
+    # @param channel [Channel, Integer, String]
+    # @param member [Member, Integer, String]
+    def add_thread_member(channel, member)
+      API::Channel.add_thread_member(@token, channel.resolve_id, member.resolve_id)
+      nil
+    end
+
+    # Remove a member from a thread
+    # @param channel [Channel, Integer, String]
+    # @param member [Member, Integer, String]
+    def remove_thread_member(channel, member)
+      API::Channel.remove_thread_member(@token, channel.resolve_id, member.resolve_id)
+      nil
+    end
+
     # Sets debug mode. If debug mode is on, many things will be outputted to STDOUT.
     def debug=(new_debug)
       LOGGER.debug = new_debug
@@ -576,6 +683,7 @@ module Discordrb
     # @deprecated Will be changed to blocking behavior in v4.0. Use {#add_await!} instead.
     def add_await(key, type, attributes = {}, &block)
       raise "You can't await an AwaitEvent!" if type == Discordrb::Events::AwaitEvent
+
       await = Await.new(self, key, type, attributes, block)
       @awaits ||= {}
       @awaits[key] = await
@@ -583,14 +691,17 @@ module Discordrb
 
     # Awaits an event, blocking the current thread until a response is received.
     # @param type [Class] The event class that should be listened for.
-    # @option attributes [Numeric] :timeout the amount of time to wait for a response before returning `nil`. Waits forever if omitted.
+    # @option attributes [Numeric] :timeout the amount of time (in seconds) to wait for a response before returning `nil`. Waits forever if omitted.
+    # @yield Executed when a matching event is received.
+    # @yieldparam event [Event] The event object that was triggered.
+    # @yieldreturn [true, false] Whether the event matches extra await criteria described by the block
     # @return [Event, nil] The event object that was triggered, or `nil` if a `timeout` was set and no event was raised in time.
     # @raise [ArgumentError] if `timeout` is given and is not a positive numeric value
     def add_await!(type, attributes = {})
       raise "You can't await an AwaitEvent!" if type == Discordrb::Events::AwaitEvent
 
       timeout = attributes[:timeout]
-      raise ArgumentError, 'Timeout must be a number > 0' if timeout && timeout.is_a?(Numeric) && timeout <= 0
+      raise ArgumentError, 'Timeout must be a number > 0' if timeout.is_a?(Numeric) && !timeout.positive?
 
       mutex = Mutex.new
       cv = ConditionVariable.new
@@ -598,7 +709,12 @@ module Discordrb
       block = lambda do |event|
         mutex.synchronize do
           response = event
-          cv.signal
+          if block_given?
+            result = yield(event)
+            cv.signal if result.is_a?(TrueClass)
+          else
+            cv.signal
+          end
         end
       end
 
@@ -615,25 +731,26 @@ module Discordrb
 
       remove_handler(handler)
       raise 'ConditionVariable was signaled without returning an event!' if response.nil? && timeout.nil?
+
       response
     end
 
     # Add a user to the list of ignored users. Those users will be ignored in message events at event processing level.
     # @note Ignoring a user only prevents any message events (including mentions, commands etc.) from them! Typing and
     #   presence and any other events will still be received.
-    # @param user [User, Integer, #resolve_id] The user, or its ID, to be ignored.
+    # @param user [User, String, Integer] The user, or its ID, to be ignored.
     def ignore_user(user)
       @ignored_ids << user.resolve_id
     end
 
     # Remove a user from the ignore list.
-    # @param user [User, Integer, #resolve_id] The user, or its ID, to be unignored.
+    # @param user [User, String, Integer] The user, or its ID, to be unignored.
     def unignore_user(user)
       @ignored_ids.delete(user.resolve_id)
     end
 
     # Checks whether a user is being ignored.
-    # @param user [User, Integer, #resolve_id] The user, or its ID, to check.
+    # @param user [User, String, Integer] The user, or its ID, to check.
     # @return [true, false] whether or not the user is ignored.
     def ignored?(user)
       @ignored_ids.include?(user.resolve_id)
@@ -666,6 +783,118 @@ module Discordrb
       end
     end
 
+    # Get all application commands.
+    # @param server_id [String, Integer, nil] The ID of the server to get the commands from. Global if `nil`.
+    # @return [Array<ApplicationCommand>]
+    def get_application_commands(server_id: nil)
+      resp = if server_id
+               API::Application.get_guild_commands(@token, profile.id, server_id)
+             else
+               API::Application.get_global_commands(@token, profile.id)
+             end
+
+      JSON.parse(resp).map do |command_data|
+        ApplicationCommand.new(command_data, self, server_id)
+      end
+    end
+
+    # Get an application command by ID.
+    # @param command_id [String, Integer]
+    # @param server_id [String, Integer, nil] The ID of the server to get the command from. Global if `nil`.
+    def get_application_command(command_id, server_id: nil)
+      resp = if server_id
+               API::Application.get_guild_command(@token, profile.id, server_id, command_id)
+             else
+               API::Application.get_global_command(@token, profile.id, command_id)
+             end
+      ApplicationCommand.new(JSON.parse(resp), self, server_id)
+    end
+
+    # @yieldparam [OptionBuilder]
+    # @yieldparam [PermissionBuilder]
+    # @example
+    #   bot.register_application_command(:reddit, 'Reddit Commands') do |cmd|
+    #     cmd.subcommand_group(:subreddit, 'Subreddit Commands') do |group|
+    #       group.subcommand(:hot, "What's trending") do |sub|
+    #         sub.string(:subreddit, 'Subreddit to search')
+    #       end
+    #       group.subcommand(:new, "What's new") do |sub|
+    #         sub.string(:since, 'How long ago', choices: ['this hour', 'today', 'this week', 'this month', 'this year', 'all time'])
+    #         sub.string(:subreddit, 'Subreddit to search')
+    #       end
+    #     end
+    #   end
+    def register_application_command(name, description, server_id: nil, default_permission: nil, type: :chat_input)
+      type = ApplicationCommand::TYPES[type] || type
+
+      builder = Interactions::OptionBuilder.new
+      permission_builder = Interactions::PermissionBuilder.new
+      yield(builder, permission_builder) if block_given?
+
+      resp = if server_id
+               API::Application.create_guild_command(@token, profile.id, server_id, name, description, builder.to_a, default_permission, type)
+             else
+               API::Application.create_global_command(@token, profile.id, name, description, builder.to_a, default_permission, type)
+             end
+      cmd = ApplicationCommand.new(JSON.parse(resp), self, server_id)
+
+      if permission_builder.to_a.any?
+        raise ArgumentError, 'Permissions can only be set for guild commands' unless server_id
+
+        edit_application_command_permissions(cmd.id, server_id, permission_builder.to_a)
+      end
+
+      cmd
+    end
+
+    # @yieldparam [OptionBuilder]
+    # @yieldparam [PermissionBuilder]
+    def edit_application_command(command_id, server_id: nil, name: nil, description: nil, default_permission: nil, type: :chat_input)
+      type = ApplicationCommand::TYPES[type] || type
+
+      builder = Interactions::OptionBuilder.new
+      permission_builder = Interactions::PermissionBuilder.new
+
+      yield(builder, permission_builder) if block_given?
+
+      resp = if server_id
+               API::Application.edit_guild_command(@token, profile.id, server_id, command_id, name, description, builder.to_a, default_permission, type)
+             else
+               API::Application.edit_guild_command(@token, profile.id, command_id, name, description, builder.to_a, default_permission.type)
+             end
+      cmd = ApplicationCommand.new(JSON.parse(resp), self, server_id)
+
+      if permission_builder.to_a.any?
+        raise ArgumentError, 'Permissions can only be set for guild commands' unless server_id
+
+        edit_application_command_permissions(cmd.id, server_id, permission_builder.to_a)
+      end
+
+      cmd
+    end
+
+    # Remove an application command from the commands registered with discord.
+    # @param command_id [String, Integer] The ID of the command to remove.
+    # @param server_id [String, Integer] The ID of the server to delete this command from, global if `nil`.
+    def delete_application_command(command_id, server_id: nil)
+      if server_id
+        API::Application.delete_guild_command(@token, profile.id, server_id, command_id)
+      else
+        API::Application.delete_global_command(@token, profile.id, command_id)
+      end
+    end
+
+    # @param command_id [Integer, String]
+    # @param server_id [Integer, String]
+    # @param permissions [Array<Hash>] An array of objects formatted as `{ id: ENTITY_ID, type: 1 or 2, permission: true or false }`
+    def edit_application_command_permissions(command_id, server_id, permissions = [])
+      builder = Interactions::PermissionBuilder.new
+      yield builder if block_given?
+
+      permissions += builder.to_a
+      API::Application.edit_guild_command_permissions(@token, profile.id, server_id, command_id, permissions)
+    end
+
     private
 
     # Throws a useful exception if there's currently no gateway connection.
@@ -677,7 +906,8 @@ module Discordrb
     # e.g. due to a Discord outage or because the servers are large and taking a while to load.
     def unavailable_servers_check
       # Return unless there are servers that are unavailable.
-      return unless @unavailable_servers && @unavailable_servers > 0
+      return unless @unavailable_servers&.positive?
+
       LOGGER.warn("#{@unavailable_servers} servers haven't been cached yet.")
       LOGGER.warn('Servers may be unavailable due to an outage, or your bot is on very large servers that are taking a while to load.')
     end
@@ -716,10 +946,16 @@ module Discordrb
 
       username = data['user']['username']
       if username && !member_is_new # Don't set the username for newly-cached members
-        debug "Implicitly updating presence-obtained information for member #{user_id}"
+        debug "Implicitly updating presence-obtained information username for member #{user_id}"
         member.update_username(username)
       end
 
+      global_name = data['user']['global_name']
+      if global_name && !member_is_new # Don't set the global_name for newly-cached members
+        debug "Implicitly updating presence-obtained information global_name for member #{user_id}"
+        member.update_global_name(global_name)
+      end
+
       member.update_presence(data)
 
       member.avatar_id = data['user']['avatar'] if data['user']['avatar']
@@ -737,10 +973,21 @@ module Discordrb
 
       user_id = data['user_id'].to_i
       old_voice_state = server.voice_states[user_id]
-      old_channel_id = old_voice_state.voice_channel.id if old_voice_state
+      old_channel_id = old_voice_state.voice_channel&.id if old_voice_state
 
       server.update_voice_state(data)
 
+      existing_voice = @voices[server_id]
+      if user_id == @profile.id && existing_voice
+        new_channel_id = data['channel_id']
+        if new_channel_id
+          new_channel = channel(new_channel_id)
+          existing_voice.channel = new_channel
+        else
+          voice_destroy(server_id)
+        end
+      end
+
       old_channel_id
     end
 
@@ -751,6 +998,7 @@ module Discordrb
 
       debug("Voice server update received! chan: #{channel.inspect}")
       return unless channel
+
       @should_connect_to_voice.delete(server_id)
       debug('Updating voice server!')
 
@@ -763,19 +1011,19 @@ module Discordrb
       end
 
       debug('Got data, now creating the bot.')
-      @voices[server_id] = Discordrb::Voice::VoiceBot.new(channel, self, token, @session_id, endpoint, @should_encrypt_voice)
+      @voices[server_id] = Discordrb::Voice::VoiceBot.new(channel, self, token, @session_id, endpoint)
     end
 
     # Internal handler for CHANNEL_CREATE
     def create_channel(data)
-      channel = Channel.new(data, self)
+      channel = data.is_a?(Discordrb::Channel) ? data : Channel.new(data, self)
       server = channel.server
 
       # Handle normal and private channels separately
       if server
         server.add_channel(channel)
         @channels[channel.id] = channel
-      elsif channel.pm?
+      elsif channel.private?
         @pm_channels[channel.recipient.id] = channel
       elsif channel.group?
         @channels[channel.id] = channel
@@ -787,6 +1035,7 @@ module Discordrb
       channel = Channel.new(data, self)
       old_channel = @channels[channel.id]
       return unless old_channel
+
       old_channel.update_from(channel)
     end
 
@@ -804,6 +1053,8 @@ module Discordrb
       elsif channel.group?
         @channels.delete(channel.id)
       end
+
+      @thread_members.delete(channel.id) if channel.thread?
     end
 
     # Internal handler for CHANNEL_RECIPIENT_ADD
@@ -843,12 +1094,16 @@ module Discordrb
       member = server.member(data['user']['id'].to_i)
       member.update_roles(data['roles'])
       member.update_nick(data['nick'])
+      member.update_global_name(data['user']['global_name']) if data['user']['global_name']
+      member.update_boosting_since(data['premium_since'])
+      member.update_communication_disabled_until(data['communication_disabled_until'])
     end
 
     # Internal handler for GUILD_MEMBER_DELETE
     def delete_guild_member(data)
       server_id = data['guild_id'].to_i
       server = self.server(server_id)
+      return unless server
 
       user_id = data['user']['id'].to_i
       server.delete_member(user_id)
@@ -858,7 +1113,7 @@ module Discordrb
 
     # Internal handler for GUILD_CREATE
     def create_guild(data)
-      ensure_server(data)
+      ensure_server(data, true)
     end
 
     # Internal handler for GUILD_UPDATE
@@ -949,15 +1204,15 @@ module Discordrb
 
     def process_token(type, token)
       # Remove the "Bot " prefix if it exists
-      token = token[4..-1] if token.start_with? 'Bot '
+      token = token[4..] if token.start_with? 'Bot '
 
-      token = 'Bot ' + token unless type == :user
+      token = "Bot #{token}" unless type == :user
       token
     end
 
     def handle_dispatch(type, data)
       # Check whether there are still unavailable servers and there have been more than 10 seconds since READY
-      if @unavailable_servers && @unavailable_servers > 0 && (Time.now - @unavailable_timeout_time) > 10
+      if @unavailable_servers&.positive? && (Time.now - @unavailable_timeout_time) > 10 && !((@intents || 0) & INTENTS[:servers]).zero?
         # The server streaming timed out!
         LOGGER.debug("Server streaming timed out with #{@unavailable_servers} servers remaining")
         LOGGER.debug('Calling ready now because server loading is taking a long time. Servers may be unavailable due to an outage, or your bot is on very large servers.')
@@ -986,14 +1241,14 @@ module Discordrb
         data['guilds'].each do |element|
           # Check for true specifically because unavailable=false indicates that a previously unavailable server has
           # come online
-          if element['unavailable'].is_a? TrueClass
+          if element['unavailable']
             @unavailable_servers += 1
 
             # Ignore any unavailable servers
             next
           end
 
-          ensure_server(element)
+          ensure_server(element, true)
         end
 
         # Add PM and group channels
@@ -1018,9 +1273,14 @@ module Discordrb
       when :GUILD_MEMBERS_CHUNK
         id = data['guild_id'].to_i
         server = server(id)
-        server.process_chunk(data['members'])
+        server.process_chunk(data['members'], data['chunk_index'], data['chunk_count'])
+      when :INVITE_CREATE
+        invite = Invite.new(data, self)
+        raise_event(InviteCreateEvent.new(data, invite, self))
+      when :INVITE_DELETE
+        raise_event(InviteDeleteEvent.new(data, self))
       when :MESSAGE_CREATE
-        if ignored?(data['author']['id'].to_i)
+        if ignored?(data['author']['id'])
           debug("Ignored author with ID #{data['author']['id']}")
           return
         end
@@ -1037,6 +1297,13 @@ module Discordrb
 
         return if message.from_bot? && !should_parse_self
 
+        # Dispatch a ChannelCreateEvent for channels we don't have cached
+        if message.channel.private? && @pm_channels[message.channel.recipient.id].nil?
+          create_channel(message.channel)
+
+          raise_event(ChannelCreateEvent.new(message.channel, self))
+        end
+
         event = MessageEvent.new(message, self)
         raise_event(event)
 
@@ -1053,6 +1320,10 @@ module Discordrb
         update_message(data)
 
         message = Message.new(data, self)
+
+        event = MessageUpdateEvent.new(message, self)
+        raise_event(event)
+
         return if message.from_bot? && !should_parse_self
 
         unless message.author
@@ -1115,18 +1386,28 @@ module Discordrb
         # Ignore friends list presences
         return unless data['guild_id']
 
-        now_playing = data['game'].nil? ? nil : data['game']['name']
+        new_activities = (data['activities'] || []).map { |act_data| Activity.new(act_data, self) }
         presence_user = @users[data['user']['id'].to_i]
-        played_before = presence_user.nil? ? nil : presence_user.game
+        old_activities = (presence_user&.activities || [])
         update_presence(data)
 
-        event = if now_playing != played_before
-                  PlayingEvent.new(data, self)
-                else
-                  PresenceEvent.new(data, self)
-                end
+        # Starting a new game
+        playing_change = new_activities.reject do |act|
+          old_activities.find { |old| old.name == act.name }
+        end
 
-        raise_event(event)
+        # Exiting an existing game
+        playing_change += old_activities.reject do |old|
+          new_activities.find { |act| act.name == old.name }
+        end
+
+        if playing_change.any?
+          playing_change.each do |act|
+            raise_event(PlayingEvent.new(data, act, self))
+          end
+        else
+          raise_event(PresenceEvent.new(data, self))
+        end
       when :VOICE_STATE_UPDATE
         old_channel_id = update_voice_state(data)
 
@@ -1135,7 +1416,8 @@ module Discordrb
       when :VOICE_SERVER_UPDATE
         update_voice_server(data)
 
-        # no event as this is irrelevant to users
+        event = VoiceServerUpdateEvent.new(data, self)
+        raise_event(event)
       when :CHANNEL_CREATE
         create_channel(data)
 
@@ -1262,9 +1544,93 @@ module Discordrb
           event = ServerEmojiUpdateEvent.new(server, old_emoji_data[e], new_emoji_data[e], self)
           raise_event(event)
         end
+      when :INTERACTION_CREATE
+        event = InteractionCreateEvent.new(data, self)
+        raise_event(event)
+
+        case data['type']
+        when Interaction::TYPES[:command]
+          event = ApplicationCommandEvent.new(data, self)
+
+          Thread.new do
+            Thread.current[:discordrb_name] = "it-#{event.interaction.id}"
+
+            begin
+              debug("Executing application command #{event.command_name}:#{event.command_id}")
+
+              @application_commands[event.command_name]&.call(event)
+            rescue StandardError => e
+              log_exception(e)
+            end
+          end
+        when Interaction::TYPES[:component]
+          case data['data']['component_type']
+          when Webhooks::View::COMPONENT_TYPES[:button]
+            event = ButtonEvent.new(data, self)
+
+            raise_event(event)
+          when Webhooks::View::COMPONENT_TYPES[:string_select]
+            event = StringSelectEvent.new(data, self)
+
+            raise_event(event)
+          when Webhooks::View::COMPONENT_TYPES[:user_select]
+            event = UserSelectEvent.new(data, self)
+
+            raise_event(event)
+          when Webhooks::View::COMPONENT_TYPES[:role_select]
+            event = RoleSelectEvent.new(data, self)
+
+            raise_event(event)
+          when Webhooks::View::COMPONENT_TYPES[:mentionable_select]
+            event = MentionableSelectEvent.new(data, self)
+
+            raise_event(event)
+          when Webhooks::View::COMPONENT_TYPES[:channel_select]
+            event = ChannelSelectEvent.new(data, self)
+
+            raise_event(event)
+          end
+        when Interaction::TYPES[:modal_submit]
+
+          event = ModalSubmitEvent.new(data, self)
+          raise_event(event)
+        end
       when :WEBHOOKS_UPDATE
         event = WebhookUpdateEvent.new(data, self)
         raise_event(event)
+      when :THREAD_CREATE
+        create_channel(data)
+
+        event = ThreadCreateEvent.new(data, self)
+        raise_event(event)
+      when :THREAD_UPDATE
+        update_channel(data)
+
+        event = ThreadUpdateEvent.new(data, self)
+        raise_event(event)
+      when :THREAD_DELETE
+        delete_channel(data)
+        @thread_members.delete(data['id']&.resolve_id)
+
+        # raise ThreadDeleteEvent
+      when :THREAD_LIST_SYNC
+        data['members'].map { |member| ensure_thread_member(member) }
+        data['threads'].map { |channel| ensure_channel(channel, data['guild_id']) }
+
+        # raise ThreadListSyncEvent?
+      when :THREAD_MEMBER_UPDATE
+        ensure_thread_member(data)
+      when :THREAD_MEMBERS_UPDATE
+        data['added_members']&.each do |added_member|
+          ensure_thread_member(added_member) if added_member['user_id']
+        end
+
+        data['removed_member_ids']&.each do |member_id|
+          @thread_members[data['id']&.resolve_id]&.delete(member_id&.resolve_id)
+        end
+
+        event = ThreadMembersUpdateEvent.new(data, self)
+        raise_event(event)
       else
         # another event that we don't support yet
         debug "Event #{type} has been received but is unsupported. Raising UnknownEvent"
@@ -1300,6 +1666,7 @@ module Discordrb
       @event_handlers ||= {}
       handlers = @event_handlers[event.class]
       return unless handlers
+
       handlers.dup.each do |handler|
         call_event(handler, event) if handler.matches?(event)
       end
@@ -1315,7 +1682,7 @@ module Discordrb
         begin
           handler.call(event)
           handler.after_call(event)
-        rescue => e
+        rescue StandardError => e
           log_exception(e)
         ensure
           @event_threads.delete(t)
@@ -1328,6 +1695,7 @@ module Discordrb
       @awaits.each do |_, await|
         key, should_delete = await.match(event)
         next unless key
+
         debug("should_delete: #{should_delete}")
         @awaits.delete(await.key) if should_delete
 
@@ -1335,5 +1703,24 @@ module Discordrb
         raise_event(await_event)
       end
     end
+
+    def calculate_intents(intents)
+      intents.reduce(0) do |sum, intent|
+        case intent
+        when Symbol
+          if INTENTS[intent]
+            sum | INTENTS[intent]
+          else
+            LOGGER.warn("Unknown intent: #{intent}")
+            sum
+          end
+        when Integer
+          sum | intent
+        else
+          LOGGER.warn("Invalid intent: #{intent}")
+          sum
+        end
+      end
+    end
   end
 end