discordrb 3.1.1 → 3.4.0

data/lib/discordrb/api/user.rb

@@ -1,21 +1,11 @@
+# frozen_string_literal: true
+
 # API calls for User object
 module Discordrb::API::User
   module_function
 
-  # Returns users based on a query
-  # https://discordapp.com/developers/docs/resources/user#query-users
-  def query(token, query, limit = nil)
-    Discordrb::API.request(
-      :users,
-      nil,
-      :get,
-      "#{Discordrb::API.api_base}/users?q=#{query}#{"&limit=#{limit}" if limit}",
-      Authorization: token
-    )
-  end
-
   # Get user data
-  # https://discordapp.com/developers/docs/resources/user#get-user
+  # https://discord.com/developers/docs/resources/user#get-user
   def resolve(token, user_id)
     Discordrb::API.request(
       :users_uid,
@@ -27,7 +17,7 @@ module Discordrb::API::User
   end
 
   # Get profile data
-  # https://discordapp.com/developers/docs/resources/user#get-current-user
+  # https://discord.com/developers/docs/resources/user#get-current-user
   def profile(token)
     Discordrb::API.request(
       :users_me,
@@ -39,7 +29,7 @@ module Discordrb::API::User
   end
 
   # Change the current bot's nickname on a server
-  def change_own_nickname(token, server_id, nick)
+  def change_own_nickname(token, server_id, nick, reason = nil)
     Discordrb::API.request(
       :guilds_sid_members_me_nick,
       server_id, # This is technically a guild endpoint
@@ -47,12 +37,13 @@ module Discordrb::API::User
       "#{Discordrb::API.api_base}/guilds/#{server_id}/members/@me/nick",
       { nick: nick }.to_json,
       Authorization: token,
-      content_type: :json
+      content_type: :json,
+      'X-Audit-Log-Reason': reason
     )
   end
 
   # Update user data
-  # https://discordapp.com/developers/docs/resources/user#modify-current-user
+  # https://discord.com/developers/docs/resources/user#modify-current-user
   def update_profile(token, email, password, new_username, avatar, new_password = nil)
     Discordrb::API.request(
       :users_me,
@@ -66,7 +57,7 @@ module Discordrb::API::User
   end
 
   # Get the servers a user is connected to
-  # https://discordapp.com/developers/docs/resources/user#get-current-user-guilds
+  # https://discord.com/developers/docs/resources/user#get-current-user-guilds
   def servers(token)
     Discordrb::API.request(
       :users_me_guilds,
@@ -78,7 +69,7 @@ module Discordrb::API::User
   end
 
   # Leave a server
-  # https://discordapp.com/developers/docs/resources/user#leave-guild
+  # https://discord.com/developers/docs/resources/user#leave-guild
   def leave_server(token, server_id)
     Discordrb::API.request(
       :users_me_guilds_sid,
@@ -90,7 +81,7 @@ module Discordrb::API::User
   end
 
   # Get the DMs for the current user
-  # https://discordapp.com/developers/docs/resources/user#get-user-dms
+  # https://discord.com/developers/docs/resources/user#get-user-dms
   def user_dms(token)
     Discordrb::API.request(
       :users_me_channels,
@@ -102,7 +93,7 @@ module Discordrb::API::User
   end
 
   # Create a DM to another user
-  # https://discordapp.com/developers/docs/resources/user#create-dm
+  # https://discord.com/developers/docs/resources/user#create-dm
   def create_pm(token, recipient_id)
     Discordrb::API.request(
       :users_me_channels,
@@ -116,7 +107,7 @@ module Discordrb::API::User
   end
 
   # Get information about a user's connections
-  # https://discordapp.com/developers/docs/resources/user#get-users-connections
+  # https://discord.com/developers/docs/resources/user#get-users-connections
   def connections(token)
     Discordrb::API.request(
       :users_me_connections,
@@ -140,8 +131,19 @@ module Discordrb::API::User
     )
   end
 
+  # Returns one of the "default" discord avatars from the CDN given a discriminator
+  def default_avatar(discrim = 0)
+    index = discrim.to_i % 5
+    "#{Discordrb::API.cdn_url}/embed/avatars/#{index}.png"
+  end
+
   # Make an avatar URL from the user and avatar IDs
-  def avatar_url(user_id, avatar_id)
-    "#{Discordrb::API.api_base}/users/#{user_id}/avatars/#{avatar_id}.jpg"
+  def avatar_url(user_id, avatar_id, format = nil)
+    format ||= if avatar_id.start_with?('a_')
+                 'gif'
+               else
+                 'webp'
+               end
+    "#{Discordrb::API.cdn_url}/avatars/#{user_id}/#{avatar_id}.#{format}"
   end
 end

data/lib/discordrb/api/webhook.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# API calls for Webhook object
+module Discordrb::API::Webhook
+  module_function
+
+  # Get a webhook
+  # https://discord.com/developers/docs/resources/webhook#get-webhook
+  def webhook(token, webhook_id)
+    Discordrb::API.request(
+      :webhooks_wid,
+      nil,
+      :get,
+      "#{Discordrb::API.api_base}/webhooks/#{webhook_id}",
+      Authorization: token
+    )
+  end
+
+  # Get a webhook via webhook token
+  # https://discord.com/developers/docs/resources/webhook#get-webhook-with-token
+  def token_webhook(webhook_token, webhook_id)
+    Discordrb::API.request(
+      :webhooks_wid,
+      nil,
+      :get,
+      "#{Discordrb::API.api_base}/webhooks/#{webhook_id}/#{webhook_token}"
+    )
+  end
+
+  # Update a webhook
+  # https://discord.com/developers/docs/resources/webhook#modify-webhook
+  def update_webhook(token, webhook_id, data, reason = nil)
+    Discordrb::API.request(
+      :webhooks_wid,
+      webhook_id,
+      :patch,
+      "#{Discordrb::API.api_base}/webhooks/#{webhook_id}",
+      data.to_json,
+      Authorization: token,
+      content_type: :json,
+      'X-Audit-Log-Reason': reason
+    )
+  end
+
+  # Update a webhook via webhook token
+  # https://discord.com/developers/docs/resources/webhook#modify-webhook-with-token
+  def token_update_webhook(webhook_token, webhook_id, data, reason = nil)
+    Discordrb::API.request(
+      :webhooks_wid,
+      webhook_id,
+      :patch,
+      "#{Discordrb::API.api_base}/webhooks/#{webhook_id}/#{webhook_token}",
+      data.to_json,
+      content_type: :json,
+      'X-Audit-Log-Reason': reason
+    )
+  end
+
+  # Deletes a webhook
+  # https://discord.com/developers/docs/resources/webhook#delete-webhook
+  def delete_webhook(token, webhook_id, reason = nil)
+    Discordrb::API.request(
+      :webhooks_wid,
+      webhook_id,
+      :delete,
+      "#{Discordrb::API.api_base}/webhooks/#{webhook_id}",
+      Authorization: token,
+      'X-Audit-Log-Reason': reason
+    )
+  end
+
+  # Deletes a webhook via webhook token
+  # https://discord.com/developers/docs/resources/webhook#delete-webhook-with-token
+  def token_delete_webhook(webhook_token, webhook_id, reason = nil)
+    Discordrb::API.request(
+      :webhooks_wid,
+      webhook_id,
+      :delete,
+      "#{Discordrb::API.api_base}/webhooks/#{webhook_id}/#{webhook_token}",
+      'X-Audit-Log-Reason': reason
+    )
+  end
+end

data/lib/discordrb/await.rb

@@ -41,9 +41,8 @@ module Discordrb
     # @return [Array] This await's key and whether or not it should be deleted. If there was no match, both are nil.
     def match(event)
       dummy_handler = EventContainer.handler_class(@type).new(@attributes, @bot)
-      return [nil, nil] unless dummy_handler.matches?(event)
+      return [nil, nil] unless event.instance_of?(@type) && dummy_handler.matches?(event)
 
-      should_delete = nil
       should_delete = true if (@block && @block.call(event) != false) || !@block
 
       [@key, should_delete]

data/lib/discordrb/bot.rb

@@ -15,6 +15,10 @@ require 'discordrb/events/roles'
 require 'discordrb/events/guilds'
 require 'discordrb/events/await'
 require 'discordrb/events/bans'
+require 'discordrb/events/raw'
+require 'discordrb/events/reactions'
+require 'discordrb/events/webhooks'
+require 'discordrb/events/invites'
 
 require 'discordrb/api'
 require 'discordrb/api/channel'
@@ -40,11 +44,12 @@ module Discordrb
     # @return [Array<Thread>] The threads.
     attr_reader :event_threads
 
-    # Whether or not the bot should parse its own messages. Off by default.
+    # @return [true, false] whether or not the bot should parse its own messages. Off by default.
     attr_accessor :should_parse_self
 
     # The bot's name which discordrb sends to Discord when making any request, so Discord can identify bots with the
     # same codebase. Not required but I recommend setting it anyway.
+    # @return [String] The bot's name.
     attr_accessor :name
 
     # @return [Array(Integer, Integer)] the current shard key
@@ -74,7 +79,8 @@ module Discordrb
     # @param token [String] The token that should be used to log in. If your bot is a bot account, you have to specify
     #   this. If you're logging in as a user, make sure to also set the account type to :user so discordrb doesn't think
     #   you're trying to log in as a bot.
-    # @param client_id [Integer] If you're logging in as a bot, the bot's client ID.
+    # @param client_id [Integer] If you're logging in as a bot, the bot's client ID. This is optional, and may be fetched
+    #   from the API by calling {Bot#bot_application} (see {Application}).
     # @param type [Symbol] This parameter lets you manually overwrite the account type. This needs to be set when
     #   logging in as a user, otherwise discordrb will treat you as a bot account. Valid values are `:user` and `:bot`.
     # @param name [String] Your bot's name. This will be sent to Discord with any API requests, who will use this to
@@ -87,31 +93,29 @@ 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/hammerandchisel/discord-api-docs/issues/17 for how to do sharding.
+    #   https://github.com/discordapp/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/hammerandchisel/discord-api-docs/issues/17 for how to do sharding.
+    #   https://github.com/discordapp/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, Array<Symbol>, nil] Intents that this bot requires. See {Discordrb::INTENTS}. If `nil`, no intents
+    #   field will be passed.
     def initialize(
-        log_mode: :normal,
-        token: nil, client_id: nil, application_id: nil,
-        type: nil, name: '', fancy_log: false, suppress_ready: false, parse_self: false,
-        shard_id: nil, num_shards: nil, redact_token: true
+      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: nil
     )
-
-      LOGGER.mode = if log_mode.is_a? TrueClass # Specifically check for `true` because people might not have updated yet
-                      :debug
-                    else
-                      log_mode
-                    end
-
+      LOGGER.mode = log_mode
       LOGGER.token = token if redact_token
 
       @should_parse_self = parse_self
 
-      if application_id
-        raise ArgumentError, 'Starting with discordrb 3.0.0, the application_id parameter has been renamed to client_id! Make sure to change this in your bot. This check will be removed in 3.1.0.'
-      end
-
       @client_id = client_id
 
       @type = type || :bot
@@ -122,8 +126,14 @@ module Discordrb
       LOGGER.fancy = fancy_log
       @prevent_ready = suppress_ready
 
+      @compress_mode = compress_mode
+
+      raise 'Token string is empty or nil' if token.nil? || token.empty?
+
+      @intents = intents == :all ? INTENTS.values.reduce(&:|) : calculate_intents(intents) if intents
+
       @token = process_token(@type, token)
-      @gateway = Gateway.new(self, @token)
+      @gateway = Gateway.new(self, @token, @shard_key, @compress_mode, @intents)
 
       init_cache
 
@@ -131,6 +141,7 @@ module Discordrb
       @should_connect_to_voice = {}
 
       @ignored_ids = Set.new
+      @ignore_bots = ignore_bots
 
       @event_threads = []
       @current_thread = 0
@@ -142,6 +153,7 @@ module Discordrb
     # @return [Hash<Integer => User>] The users by ID.
     def users
       gateway_check
+      unavailable_servers_check
       @users
     end
 
@@ -149,28 +161,24 @@ module Discordrb
     # @return [Hash<Integer => Server>] The servers by ID.
     def servers
       gateway_check
+      unavailable_servers_check
       @servers
     end
 
     # @overload emoji(id)
     #   Return an emoji by its ID
-    #   @param id [Integer] The emoji's ID.
-    #   @return emoji [GlobalEmoji, nil] the emoji object. `nil` if the emoji was not found.
+    #   @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<GlobalEmoji>] the emoji available.
+    #   @return [Array<Emoji>] the emoji available.
     def emoji(id = nil)
-      gateway_check
+      emoji_hash = servers.values.map(&:emoji).reduce(&:merge)
       if id
-        emoji = @emoji.find { |sth| sth.id == id }
+        id = id.resolve_id
+        emoji_hash[id]
       else
-        emoji = {}
-        @servers.each do |_, server|
-          server.emoji.values.each do |element|
-            emoji[element.name] = GlobalEmoji.new(element, self)
-          end
-        end
-        emoji.values
+        emoji_hash.values
       end
     end
 
@@ -198,8 +206,8 @@ module Discordrb
     # The bot's OAuth application.
     # @return [Application, nil] The bot's application info. Returns `nil` if bot is not a bot account.
     def bot_application
-      gateway_check
-      return nil unless @type == :bot
+      return unless @type == :bot
+
       response = API.oauth_application(token)
       Application.new(JSON.parse(response), self)
     end
@@ -214,37 +222,46 @@ module Discordrb
       @token
     end
 
-    # @return the raw token, without any prefix
+    # @return [String] the raw token, without any prefix
     # @see #token
     def raw_token
       @token.split(' ').last
     end
 
-    # Runs the bot, which logs into Discord and connects the WebSocket. This prevents all further execution unless it is executed with `async` = `:async`.
-    # @param async [Symbol] If it is `:async`, then the bot will allow further execution.
-    #   It doesn't necessarily have to be that, anything truthy will work,
-    #   however it is recommended to use `:async` for code readability reasons.
-    #   If the bot is run in async mode, make sure to eventually run {#sync} so
-    #   the script doesn't stop prematurely.
-    def run(async = false)
+    # Runs the bot, which logs into Discord and connects the WebSocket. This
+    # prevents all further execution unless it is executed with
+    # `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
+    #   sure to eventually call {#join} so the script doesn't stop prematurely.
+    # @note Running the bot in the background means that you can call some
+    #   methods that require a gateway connection *before* that connection is
+    #   established. In most cases an exception will be raised if you try to do
+    #   this. If you need a way to safely run code after the bot is fully
+    #   connected, use a {#ready} event handler instead.
+    def run(background = false)
       @gateway.run_async
-      return if async
+      return if background
 
       debug('Oh wait! Not exiting yet as run was run synchronously.')
       @gateway.sync
     end
 
-    # Blocks execution until the websocket stops, which should only happen manually triggered
-    # or due to an error. This is necessary to have a continuously running bot.
-    def sync
+    # Joins the bot's connection thread with the current thread.
+    # This blocks execution until the websocket stops, which should only happen
+    # manually triggered. or due to an error. This is necessary to have a
+    # continuously running bot.
+    def join
       @gateway.sync
     end
+    alias_method :sync, :join
 
     # 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.
@@ -254,22 +271,21 @@ module Discordrb
 
     # Makes the bot join an invite to a server.
     # @param invite [String, Invite] The invite to join. For possible formats see {#resolve_invite_code}.
-    def join(invite)
+    def accept_invite(invite)
       resolved = invite(invite).code
       API::Invite.accept(token, resolved)
     end
 
     # Creates an OAuth invite URL that can be used to invite this bot to a particular server.
-    # Requires the application ID to have been set during initialization.
     # @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)
-      raise 'No application ID has been set during initialization! Add one as the `application_id` named parameter while creating your bot.' unless @client_id
+      @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.
@@ -278,7 +294,7 @@ module Discordrb
     # Gets the voice bot for a particular server or channel. You can connect to a new channel using the {#voice_connect}
     # method.
     # @param thing [Channel, Server, Integer] the server or channel you want to get the voice bot for, or its ID.
-    # @return [VoiceBot, nil] the VoiceBot for the thing you specified, or nil if there is no connection yet
+    # @return [Voice::VoiceBot, nil] the VoiceBot for the thing you specified, or nil if there is no connection yet
     def voice(thing)
       id = thing.resolve_id
       return @voices[id] if @voices[id]
@@ -288,22 +304,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] 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')
@@ -325,13 +340,14 @@ 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_id [Integer] The ID of 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_id, destroy_vws = true)
-      @gateway.send_voice_state_update(server_id.to_s, nil, false, false)
-      @voices[server_id].destroy if @voices[server_id] && destroy_vws
-      @voices.delete(server_id)
+    def voice_destroy(server, destroy_vws = true)
+      server = server.resolve_id
+      @gateway.send_voice_state_update(server.to_s, nil, false, false)
+      @voices[server].destroy if @voices[server] && destroy_vws
+      @voices.delete(server)
     end
 
     # Revokes an invite to a server. Will fail unless you have the *Manage Server* permission.
@@ -343,32 +359,38 @@ module Discordrb
     end
 
     # Sends a text message to a channel given its ID and the message's content.
-    # @param channel_id [Integer] The ID that identifies 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 server_id [Integer] The ID that identifies the server to send something to.
+    # @param embed [Hash, Discordrb::Webhooks::Embed, nil] The rich embed 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.
     # @return [Message] The message that was sent.
-    def send_message(channel_id, content, tts = false, server_id = nil)
-      channel_id = channel_id.resolve_id
-      debug("Sending message to #{channel_id} with content '#{content}'")
+    def send_message(channel, content, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = 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
 
-      response = API::Channel.create_message(token, channel_id, content, [], tts, server_id)
+      response = API::Channel.create_message(token, channel, content, tts, embed&.to_hash, nil, attachments, allowed_mentions&.to_hash, message_reference)
       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_id [Integer] The ID that identifies 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 server_id [Integer] The ID that identifies the server to send something to.
-    def send_temporary_message(channel_id, content, timeout, tts = false, server_id = nil)
+    # @param embed [Hash, Discordrb::Webhooks::Embed, nil] The rich embed 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
+    def send_temporary_message(channel, content, timeout, tts = false, embed = nil, attachments = nil, allowed_mentions = nil)
       Thread.new do
-        message = send_message(channel_id, content, tts, server_id)
+        Thread.current[:discordrb_name] = "#{@current_thread}-temp-msg"
 
+        message = send_message(channel, content, tts, embed, attachments, allowed_mentions)
         sleep(timeout)
-
         message.delete
       end
 
@@ -377,12 +399,26 @@ 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_id [Integer] The ID that identifies 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.
-    def send_file(channel_id, file, caption: nil, tts: false)
-      response = API::Channel.upload_file(token, channel_id, file, caption: caption, tts: tts)
+    # @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, 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
+      end
+
+      channel = channel.resolve_id
+      response = API::Channel.upload_file(token, channel, file, caption: caption, tts: tts)
       Message.new(JSON.parse(response), self)
     end
 
@@ -390,29 +426,18 @@ module Discordrb
     # @note Discord's API doesn't directly return the server when creating it, so this method
     #   waits until the data has been received via the websocket. This may make the execution take a while.
     # @param name [String] The name the new server should have. Doesn't have to be alphanumeric.
-    # @param region [Symbol] The region where the server should be created. Possible regions are:
-    #
-    #   * `:london`
-    #   * `:amsterdam`
-    #   * `:frankfurt`
-    #   * `:us-east`
-    #   * `:us-west`
-    #   * `:us-south`
-    #   * `:us-central`
-    #   * `:singapore`
-    #   * `:sydney`
+    # @param region [Symbol] The region where the server should be created, for example 'eu-central' or 'hongkong'.
     # @return [Server] The server that was created.
-    def create_server(name, region = :london)
+    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.
@@ -431,42 +456,69 @@ module Discordrb
       API.update_oauth_application(@token, name, redirect_uris, description, icon)
     end
 
-    # Gets the user, role or emoji from a mention of the user, role or emoji.
-    # @param mention [String] The mention, which should look like `<@12314873129>`, `<@&123456789>` or `<:Name:126328:>`.
-    # @param server [Server, nil] The server of the associated mention. (recommended for role parsing, to speed things up)
-    # @return [User, Role, Emoji] The user, 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.to_i)
-      elsif /<@&(?<id>\d+)>?/ =~ mention
-        return server.role(id) if server
-        servers.each do |element|
-          role = element.role(id)
-          return role unless role.nil?
+    # 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
-      elsif /<:(\w+):(?<id>\d+)>?/ =~ mention
-        emoji.find { |element| element.id.to_i == id.to_i }
       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)
+      parse_mentions(mention, server).first
     end
 
     # Updates presence status.
-    # @param status [String] The status the bot should show up as.
-    # @param game [String, nil] The name of the game to be played/stream name on the stream.
+    # @param status [String] The status the bot should show up as. Can be `online`, `dnd`, `idle`, or `invisible`
+    # @param activity [String, nil] The name of the activity to be played/watched/listened to/stream name on the stream.
     # @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)
     # @see Gateway#send_status_update
-    def update_status(status, game, url, since = 0, afk = false)
+    def update_status(status, activity, url, since = 0, afk = false, activity_type = 0)
       gateway_check
 
-      @game = game
+      @activity = activity
       @status = status
       @streamurl = url
-      type = url ? 1 : nil
+      type = url ? 1 : activity_type
+
+      activity_obj = activity || url ? { 'name' => activity, 'url' => url, 'type' => type } : nil
+      @gateway.send_status_update(status, since, activity_obj, afk)
 
-      game_obj = game || url ? { name: game, url: url, type: type } : nil
-      @gateway.send_status_update(status, since, game_obj, afk)
+      # Update the status in the cache
+      profile.update_presence('status' => status.to_s, 'activities' => [activity_obj].compact)
     end
 
     # Sets the currently playing game to the specified game.
@@ -475,7 +527,24 @@ module Discordrb
     def game=(name)
       gateway_check
       update_status(@status, name, nil)
-      name
+    end
+
+    alias_method :playing=, :game=
+
+    # Sets the current listening status to the specified name.
+    # @param name [String] The thing to be listened to.
+    # @return [String] The thing that is now being listened to.
+    def listening=(name)
+      gateway_check
+      update_status(@status, name, nil, nil, nil, 2)
+    end
+
+    # Sets the current watching status to the specified name.
+    # @param name [String] The thing to be watched.
+    # @return [String] The thing that is now being watched.
+    def watching=(name)
+      gateway_check
+      update_status(@status, name, nil, nil, nil, 3)
     end
 
     # Sets the currently online stream to the specified name and Twitch URL.
@@ -491,7 +560,7 @@ module Discordrb
     # Sets status to online.
     def online
       gateway_check
-      update_status(:online, @game, @streamurl)
+      update_status(:online, @activity, @streamurl)
     end
 
     alias_method :on, :online
@@ -499,7 +568,7 @@ module Discordrb
     # Sets status to idle.
     def idle
       gateway_check
-      update_status(:idle, @game, nil)
+      update_status(:idle, @activity, nil)
     end
 
     alias_method :away, :idle
@@ -507,13 +576,13 @@ module Discordrb
     # Sets the bot's status to DnD (red icon).
     def dnd
       gateway_check
-      update_status(:dnd, @game, nil)
+      update_status(:dnd, @activity, nil)
     end
 
     # Sets the bot's status to invisible (appears offline).
     def invisible
       gateway_check
-      update_status(:invisible, @game, nil)
+      update_status(:invisible, @activity, nil)
     end
 
     # Sets debug mode. If debug mode is on, many things will be outputted to STDOUT.
@@ -539,29 +608,77 @@ module Discordrb
     # @yield Is executed when the await is triggered.
     # @yieldparam event [Event] The event object that was triggered.
     # @return [Await] The await that was created.
+    # @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
     end
 
+    # 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 (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.is_a?(Numeric) && !timeout.positive?
+
+      mutex = Mutex.new
+      cv = ConditionVariable.new
+      response = nil
+      block = lambda do |event|
+        mutex.synchronize do
+          response = event
+          if block_given?
+            result = yield(event)
+            cv.signal if result.is_a?(TrueClass)
+          else
+            cv.signal
+          end
+        end
+      end
+
+      handler = register_event(type, attributes, block)
+
+      if timeout
+        Thread.new do
+          sleep timeout
+          mutex.synchronize { cv.signal }
+        end
+      end
+
+      mutex.synchronize { cv.wait(mutex) }
+
+      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)
@@ -587,6 +704,7 @@ module Discordrb
       raise_event(HeartbeatEvent.new(self))
     end
 
+    # Makes the bot leave any groups with no recipients remaining
     def prune_empty_groups
       @channels.each_value do |channel|
         channel.leave_group if channel.group? && channel.recipients.empty?
@@ -595,11 +713,19 @@ module Discordrb
 
     private
 
-    # Throws a useful exception if there's currently no gateway connection
+    # Throws a useful exception if there's currently no gateway connection.
     def gateway_check
-      return if connected?
+      raise "A gateway connection is necessary to call this method! You'll have to do it inside any event (e.g. `ready`) or after `bot.run :async`." unless connected?
+    end
+
+    # Logs a warning if there are servers which are still unavailable.
+    # 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&.positive?
 
-      raise "A gateway connection is necessary to call this method! You'll have to do it inside any event (e.g. `ready`) or after `bot.run :async`."
+      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
 
     ### ##    ## ######## ######## ########  ##    ##    ###    ##        ######
@@ -640,21 +766,39 @@ module Discordrb
         member.update_username(username)
       end
 
-      member.status = data['status'].to_sym
-      member.game = data['game'] ? data['game']['name'] : nil
+      member.update_presence(data)
+
+      member.avatar_id = data['user']['avatar'] if data['user']['avatar']
 
       server.cache_member(member)
     end
 
-    # Internal handler for VOICE_STATUS_UPDATE
+    # Internal handler for VOICE_STATE_UPDATE
     def update_voice_state(data)
+      @session_id = data['session_id']
+
       server_id = data['guild_id'].to_i
       server = server(server_id)
       return unless server
 
+      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
+
       server.update_voice_state(data)
 
-      @session_id = data['session_id']
+      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
 
     # Internal handler for VOICE_SERVER_UPDATE
@@ -664,6 +808,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!')
 
@@ -676,7 +821,7 @@ 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
@@ -686,7 +831,7 @@ module Discordrb
 
       # Handle normal and private channels separately
       if server
-        server.channels << channel
+        server.add_channel(channel)
         @channels[channel.id] = channel
       elsif channel.pm?
         @pm_channels[channel.recipient.id] = channel
@@ -700,6 +845,7 @@ module Discordrb
       channel = Channel.new(data, self)
       old_channel = @channels[channel.id]
       return unless old_channel
+
       old_channel.update_from(channel)
     end
 
@@ -711,7 +857,7 @@ module Discordrb
       # Handle normal and private channels separately
       if server
         @channels.delete(channel.id)
-        server.channels.reject! { |c| c.id == channel.id }
+        server.delete_channel(channel.id)
       elsif channel.pm?
         @pm_channels.delete(channel.recipient.id)
       elsif channel.group?
@@ -756,12 +902,14 @@ module Discordrb
       member = server.member(data['user']['id'].to_i)
       member.update_roles(data['roles'])
       member.update_nick(data['nick'])
+      member.update_boosting_since(data['premium_since'])
     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)
@@ -802,7 +950,12 @@ module Discordrb
       server_id = data['guild_id'].to_i
       server = @servers[server_id]
       new_role = Role.new(role_data, self, server)
-      server.add_role(new_role)
+      existing_role = server.role(new_role.id)
+      if existing_role
+        existing_role.update_from(new_role)
+      else
+        server.add_role(new_role)
+      end
     end
 
     # Internal handler for GUILD_ROLE_DELETE
@@ -813,6 +966,13 @@ module Discordrb
       server.delete_role(role_id)
     end
 
+    # Internal handler for GUILD_EMOJIS_UPDATE
+    def update_guild_emoji(data)
+      server_id = data['guild_id'].to_i
+      server = @servers[server_id]
+      server.update_emoji_data(data)
+    end
+
     # Internal handler for MESSAGE_CREATE
     def create_message(data); end
 
@@ -825,6 +985,15 @@ module Discordrb
     # Internal handler for MESSAGE_DELETE
     def delete_message(data); end
 
+    # Internal handler for MESSAGE_REACTION_ADD
+    def add_message_reaction(data); end
+
+    # Internal handler for MESSAGE_REACTION_REMOVE
+    def remove_message_reaction(data); end
+
+    # Internal handler for MESSAGE_REACTION_REMOVE_ALL
+    def remove_all_message_reactions(data); end
+
     # Internal handler for GUILD_BAN_ADD
     def add_user_ban(data); end
 
@@ -843,16 +1012,16 @@ module Discordrb
       # Remove the "Bot " prefix if it exists
       token = token[4..-1] 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.warn("Server streaming timed out with #{@unavailable_servers} servers remaining")
-        LOGGER.warn("This means some servers are unavailable due to an outage. Notifying ready now, we'll have to live without these servers")
+        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.')
 
         # Unset the unavailable server count so this doesn't get triggered again
         @unavailable_servers = 0
@@ -911,12 +1080,22 @@ module Discordrb
         id = data['guild_id'].to_i
         server = server(id)
         server.process_chunk(data['members'])
+      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)
           debug("Ignored author with ID #{data['author']['id']}")
           return
         end
 
+        if @ignore_bots && data['author']['bot']
+          debug("Ignored Bot account with ID #{data['author']['id']}")
+          return
+        end
+
         # If create_message is overwritten with a method that returns the parsed message, use that instead, so we don't
         # parse the message twice (which is just thrown away performance)
         message = create_message(data)
@@ -940,6 +1119,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
@@ -979,31 +1162,51 @@ module Discordrb
         rescue Discordrb::Errors::NoPermission
           debug 'Typing started in channel the bot has no access to, ignoring'
         end
+      when :MESSAGE_REACTION_ADD
+        add_message_reaction(data)
+
+        return if profile.id == data['user_id'].to_i && !should_parse_self
+
+        event = ReactionAddEvent.new(data, self)
+        raise_event(event)
+      when :MESSAGE_REACTION_REMOVE
+        remove_message_reaction(data)
+
+        return if profile.id == data['user_id'].to_i && !should_parse_self
+
+        event = ReactionRemoveEvent.new(data, self)
+        raise_event(event)
+      when :MESSAGE_REACTION_REMOVE_ALL
+        remove_all_message_reactions(data)
+
+        event = ReactionRemoveAllEvent.new(data, self)
+        raise_event(event)
       when :PRESENCE_UPDATE
         # Ignore friends list presences
         return unless data['guild_id']
 
-        now_playing = data['game']
+        now_playing = data['game'].nil? ? nil : data['game']['name']
         presence_user = @users[data['user']['id'].to_i]
         played_before = presence_user.nil? ? nil : presence_user.game
         update_presence(data)
 
-        event = if now_playing != played_before
-                  PlayingEvent.new(data, self)
-                else
+        event = if now_playing == played_before
                   PresenceEvent.new(data, self)
+                else
+                  PlayingEvent.new(data, self)
                 end
 
         raise_event(event)
       when :VOICE_STATE_UPDATE
-        update_voice_state(data)
+        old_channel_id = update_voice_state(data)
 
-        event = VoiceStateUpdateEvent.new(data, self)
+        event = VoiceStateUpdateEvent.new(data, old_channel_id, self)
         raise_event(event)
       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)
 
@@ -1100,9 +1303,52 @@ module Discordrb
 
         event = ServerDeleteEvent.new(data, self)
         raise_event(event)
+      when :GUILD_EMOJIS_UPDATE
+        server_id = data['guild_id'].to_i
+        server = @servers[server_id]
+        old_emoji_data = server.emoji.clone
+        update_guild_emoji(data)
+        new_emoji_data = server.emoji
+
+        created_ids = new_emoji_data.keys - old_emoji_data.keys
+        deleted_ids = old_emoji_data.keys - new_emoji_data.keys
+        updated_ids = old_emoji_data.select do |k, v|
+          new_emoji_data[k] && (v.name != new_emoji_data[k].name || v.roles != new_emoji_data[k].roles)
+        end.keys
+
+        event = ServerEmojiChangeEvent.new(server, data, self)
+        raise_event(event)
+
+        created_ids.each do |e|
+          event = ServerEmojiCreateEvent.new(server, new_emoji_data[e], self)
+          raise_event(event)
+        end
+
+        deleted_ids.each do |e|
+          event = ServerEmojiDeleteEvent.new(server, old_emoji_data[e], self)
+          raise_event(event)
+        end
+
+        updated_ids.each do |e|
+          event = ServerEmojiUpdateEvent.new(server, old_emoji_data[e], new_emoji_data[e], self)
+          raise_event(event)
+        end
+      when :WEBHOOKS_UPDATE
+        event = WebhookUpdateEvent.new(data, self)
+        raise_event(event)
       else
         # another event that we don't support yet
-        debug "Event #{type} has been received but is unsupported, ignoring"
+        debug "Event #{type} has been received but is unsupported. Raising UnknownEvent"
+
+        event = UnknownEvent.new(type, data, self)
+        raise_event(event)
+      end
+
+      # The existence of this array is checked before for performance reasons, since this has to be done for *every*
+      # dispatch.
+      if @event_handlers && @event_handlers[RawEvent]
+        event = RawEvent.new(type, data, self)
+        raise_event(event)
       end
     rescue Exception => e
       LOGGER.error('Gateway message error!')
@@ -1124,7 +1370,9 @@ module Discordrb
 
       @event_handlers ||= {}
       handlers = @event_handlers[event.class]
-      (handlers || []).each do |handler|
+      return unless handlers
+
+      handlers.dup.each do |handler|
         call_event(handler, event) if handler.matches?(event)
       end
     end
@@ -1139,7 +1387,7 @@ module Discordrb
         begin
           handler.call(event)
           handler.after_call(event)
-        rescue => e
+        rescue StandardError => e
           log_exception(e)
         ensure
           @event_threads.delete(t)
@@ -1152,6 +1400,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
 
@@ -1159,5 +1408,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