discordrb 2.1.3 → 3.0.0

data/lib/discordrb/api/user.rb

@@ -0,0 +1,134 @@
+# 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
+  def resolve(token, user_id)
+    Discordrb::API.request(
+      :users_uid,
+      nil,
+      :get,
+      "#{Discordrb::API.api_base}/users/#{user_id}",
+      Authorization: token
+    )
+  end
+
+  # Get profile data
+  # https://discordapp.com/developers/docs/resources/user#get-current-user
+  def profile(token)
+    Discordrb::API.request(
+      :users_me,
+      nil,
+      :get,
+      "#{Discordrb::API.api_base}/users/@me",
+      Authorization: token
+    )
+  end
+
+  # Change the current bot's nickname on a server
+  def change_own_nickname(token, server_id, nick)
+    Discordrb::API.request(
+      :guilds_sid_members_me_nick,
+      server_id, # This is technically a guild endpoint
+      :patch,
+      "#{Discordrb::API.api_base}/guilds/#{server_id}/members/@me/nick",
+      { nick: nick }.to_json,
+      Authorization: token,
+      content_type: :json
+    )
+  end
+
+  # Update user data
+  # https://discordapp.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,
+      nil,
+      :patch,
+      "#{Discordrb::API.api_base}/users/@me",
+      { avatar: avatar, email: email, new_password: new_password, password: password, username: new_username }.to_json,
+      Authorization: token,
+      content_type: :json
+    )
+  end
+
+  # Get the servers a user is connected to
+  # https://discordapp.com/developers/docs/resources/user#get-current-user-guilds
+  def servers(token)
+    Discordrb::API.request(
+      :users_me_guilds,
+      nil,
+      :get,
+      "#{Discordrb::API.api_base}/users/@me/guilds",
+      Authorization: token
+    )
+  end
+
+  # Leave a server
+  # https://discordapp.com/developers/docs/resources/user#leave-guild
+  def leave_server(token, server_id)
+    Discordrb::API.request(
+      :users_me_guilds_sid,
+      nil,
+      :delete,
+      "#{Discordrb::API.api_base}/users/@me/guilds/#{server_id}",
+      Authorization: token
+    )
+  end
+
+  # Get the DMs for the current user
+  # https://discordapp.com/developers/docs/resources/user#get-user-dms
+  def user_dms(token)
+    Discordrb::API.request(
+      :users_me_channels,
+      nil,
+      :get,
+      "#{Discordrb::API.api_base}/users/@me/channels",
+      Authorization: token
+    )
+  end
+
+  # Create a DM to another user
+  # https://discordapp.com/developers/docs/resources/user#create-dm
+  def create_pm(token, recipient_id)
+    Discordrb::API.request(
+      :users_me_channels,
+      nil,
+      :post,
+      "#{Discordrb::API.api_base}/users/@me/channels",
+      { recipient_id: recipient_id }.to_json,
+      Authorization: token,
+      content_type: :json
+    )
+  end
+
+  # Get information about a user's connections
+  # https://discordapp.com/developers/docs/resources/user#get-users-connections
+  def connections(token)
+    Discordrb::API.request(
+      :users_me_connections,
+      nil,
+      :get,
+      "#{Discordrb::API.api_base}/users/@me/connections",
+      Authorization: token
+    )
+  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"
+  end
+end

data/lib/discordrb/bot.rb

@@ -17,78 +17,22 @@ require 'discordrb/events/await'
 require 'discordrb/events/bans'
 
 require 'discordrb/api'
+require 'discordrb/api/channel'
+require 'discordrb/api/server'
+require 'discordrb/api/invite'
 require 'discordrb/errors'
 require 'discordrb/data'
 require 'discordrb/await'
-require 'discordrb/token_cache'
 require 'discordrb/container'
 require 'discordrb/websocket'
 require 'discordrb/cache'
+require 'discordrb/gateway'
 
 require 'discordrb/voice/voice_bot'
 
 module Discordrb
-  # Gateway packet opcodes
-  module Opcodes
-    # **Received** when Discord dispatches an event to the gateway (like MESSAGE_CREATE, PRESENCE_UPDATE or whatever).
-    # The vast majority of received packets will have this opcode.
-    DISPATCH = 0
-
-    # **Two-way**: The client has to send a packet with this opcode every ~40 seconds (actual interval specified in
-    # READY or RESUMED) and the current sequence number, otherwise it will be disconnected from the gateway. In certain
-    # cases Discord may also send one, specifically if two clients are connected at once.
-    HEARTBEAT = 1
-
-    # **Sent**: This is one of the two possible ways to initiate a session after connecting to the gateway. It
-    # should contain the authentication token along with other stuff the server has to know right from the start, such
-    # as large_threshold and, for older gateway versions, the desired version.
-    IDENTIFY = 2
-
-    # **Sent**: Packets with this opcode are used to change the user's status and played game. (Sending this is never
-    # necessary for a gateway client to behave correctly)
-    PRESENCE = 3
-
-    # **Sent**: Packets with this opcode are used to change a user's voice state (mute/deaf/unmute/undeaf/etc.). It is
-    # also used to connect to a voice server in the first place. (Sending this is never necessary for a gateway client
-    # to behave correctly)
-    VOICE_STATE = 4
-
-    # **Sent**: This opcode is used to ping a voice server, whatever that means. The functionality of this opcode isn't
-    # known well but non-user clients should never send it.
-    VOICE_PING = 5
-
-    # **Sent**: This is the other of two possible ways to initiate a gateway session (other than {IDENTIFY}). Rather
-    # than starting an entirely new session, it resumes an existing session by replaying all events from a given
-    # sequence number. It should be used to recover from a connection error or anything like that when the session is
-    # still valid - sending this with an invalid session will cause an error to occur.
-    RESUME = 6
-
-    # **Received**: Discord sends this opcode to indicate that the client should reconnect to a different gateway
-    # server because the old one is currently being decommissioned. Counterintuitively, this opcode also invalidates the
-    # session - the client has to create an entirely new session with the new gateway instead of resuming the old one.
-    RECONNECT = 7
-
-    # **Sent**: This opcode identifies packets used to retrieve a list of members from a particular server. There is
-    # also a REST endpoint available for this, but it is inconvenient to use because the client has to implement
-    # pagination itself, whereas sending this opcode lets Discord handle the pagination and the client can just add
-    # members when it receives them. (Sending this is never necessary for a gateway client to behave correctly)
-    REQUEST_MEMBERS = 8
-
-    # **Received**: The functionality of this opcode is less known than the others but it appears to specifically
-    # tell the client to invalidate its local session and continue by {IDENTIFY}ing.
-    INVALIDATE_SESSION = 9
-  end
-
   # Represents a Discord bot, including servers, users, etc.
   class Bot
-    # The list of users the bot shares a server with.
-    # @return [Hash<Integer => User>] The users by ID.
-    attr_reader :users
-
-    # The list of servers the bot is currently in.
-    # @return [Hash<Integer => Server>] The servers by ID.
-    attr_reader :servers
-
     # The list of currently running threads used to parse and call events.
     # The threads will have a local variable `:discordrb_name` in the format of `et-1234`, where
     # "et" stands for "event thread" and the number is a continually incrementing number representing
@@ -96,12 +40,6 @@ module Discordrb
     # @return [Array<Thread>] The threads.
     attr_reader :event_threads
 
-    # The bot's user profile. This special user object can be used
-    # to edit user data like the current username (see {Profile#username=}).
-    # @return [Profile] The bot's profile that can be used to edit data.
-    attr_reader :profile
-    alias_method :bot_user, :profile
-
     # Whether or not the bot should parse its own messages. Off by default.
     attr_accessor :should_parse_self
 
@@ -115,33 +53,30 @@ module Discordrb
     # @return [Hash<Symbol => Await>] the list of registered {Await}s.
     attr_reader :awaits
 
+    # The gateway connection is an internal detail that is useless to most people. It is however essential while
+    # debugging or developing discordrb itself, or while writing very custom bots.
+    # @return [Gateway] the underlying {Gateway} object.
+    attr_reader :gateway
+
     include EventContainer
     include Cache
 
     # Makes a new bot with the given authentication data. It will be ready to be added event handlers to and can
     # eventually be run with {#run}.
     #
-    # Depending on the authentication information present, discordrb will deduce whether you're running on a user or a
-    # bot account. (Discord recommends using bot accounts whenever possible.) The following sets of authentication
-    # information are valid:
-    #  * token + application_id (bot account)
-    #  * email + password (user account)
-    #  * email + password + token (user account; the given token will be used for authentication instead of email
-    #    and password)
+    # As support for logging in using username and password has been removed in version 3.0.0, only a token login is
+    # possible. Be sure to specify the `type` parameter as `:user` if you're logging in as a user.
     #
     # Simply creating a bot won't be enough to start sending messages etc. with, only a limited set of methods can
     # be used after logging in. If you want to do something when the bot has connected successfully, either do it in the
     # {#ready} event, or use the {#run} method with the :async parameter and do the processing after that.
-    # @param email [String] The email for your (or the bot's) Discord account.
-    # @param password [String] The valid password that should be used to log in to the account.
     # @param log_mode [Symbol] The mode this bot should use for logging. See {Logger#mode=} for a list of modes.
     # @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 application_id [Integer] If you're logging in as a bot, the bot's application ID.
-    # @param type [Symbol] This parameter lets you manually overwrite the account type. If this isn't specified, it will
-    #   be determined by checking what other attributes are there. The only use case for this is if you want to log in
-    #   as a user but only with a token. Valid values are :user and :bot.
+    # @param client_id [Integer] If you're logging in as a bot, the bot's client ID.
+    # @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
     #   trace the source of excessive API requests; it's recommended to set this to something if you make bots that many
     #   people will host on their servers separately.
@@ -155,16 +90,13 @@ module Discordrb
     #   https://github.com/hammerandchisel/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.
+    # @param redact_token [true, false] Whether the bot should redact the token in logs. Default is true.
     def initialize(
-        email: nil, password: nil, log_mode: :normal,
-        token: nil, application_id: nil,
+        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)
-      # Make sure people replace the login details in the example files...
-      if email.is_a?(String) && email.end_with?('example.com')
-        puts 'You have to replace the login details in the example files with your own!'
-        exit
-      end
+        shard_id: nil, num_shards: nil, redact_token: true
+    )
 
       LOGGER.mode = if log_mode.is_a? TrueClass # Specifically check for `true` because people might not have updated yet
                       :debug
@@ -172,15 +104,17 @@ module Discordrb
                       log_mode
                     end
 
-      @should_parse_self = parse_self
+      LOGGER.token = token if redact_token
 
-      @email = email
-      @password = password
+      @should_parse_self = parse_self
 
-      @application_id = application_id
+      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
 
-      @type = determine_account_type(type, email, password, token, application_id)
+      @client_id = client_id
 
+      @type = type || :bot
       @name = name
 
       @shard_key = num_shards ? [shard_id, num_shards] : nil
@@ -188,10 +122,8 @@ module Discordrb
       LOGGER.fancy = fancy_log
       @prevent_ready = suppress_ready
 
-      debug('Creating token cache')
-      token_cache = Discordrb::TokenCache.new
-      debug('Token cache created successfully')
-      @token = login(type, email, password, token, token_cache)
+      @token = process_token(@type, token)
+      @gateway = Gateway.new(self, @token)
 
       init_cache
 
@@ -202,8 +134,45 @@ module Discordrb
 
       @event_threads = []
       @current_thread = 0
+
+      @status = :online
+    end
+
+    # The list of users the bot shares a server with.
+    # @return [Hash<Integer => User>] The users by ID.
+    def users
+      gateway_check
+      @users
+    end
+
+    # The list of servers the bot is currently in.
+    # @return [Hash<Integer => Server>] The servers by ID.
+    def servers
+      gateway_check
+      @servers
     end
 
+    # The bot's user profile. This special user object can be used
+    # 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
+    end
+
+    alias_method :bot_user, :profile
+
+    # 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
+      response = API.oauth_application(token)
+      Application.new(JSON.parse(response), self)
+    end
+
+    alias_method :bot_app, :bot_application
+
     # The Discord API token received when logging in. Useful to explicitly call
     # {API} methods.
     # @return [String] The API token.
@@ -225,85 +194,49 @@ module Discordrb
     #   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)
-      run_async
+      @gateway.run_async
       return if async
 
       debug('Oh wait! Not exiting yet as run was run synchronously.')
-      sync
-    end
-
-    # Runs the bot asynchronously. Equivalent to #run with the :async parameter.
-    # @see #run
-    def run_async
-      # Handle heartbeats
-      @heartbeat_interval = 1
-      @heartbeat_active = false
-      @heartbeat_thread = Thread.new do
-        Thread.current[:discordrb_name] = 'heartbeat'
-        loop do
-          if @heartbeat_active
-            send_heartbeat
-            sleep @heartbeat_interval
-          else
-            sleep 1
-          end
-        end
-      end
-
-      @ws_thread = Thread.new do
-        Thread.current[:discordrb_name] = 'websocket'
-
-        # Initialize falloff so we wait for more time before reconnecting each time
-        @falloff = 1.0
-
-        loop do
-          websocket_connect
-
-          if @reconnect_url
-            # We got an op 7! Don't wait before reconnecting
-            LOGGER.info('Got an op 7, reconnecting right away')
-          else
-            wait_for_reconnect
-          end
-
-          # Restart the loop, i. e. reconnect
-        end
-
-        LOGGER.warn('The WS loop exited! Not sure if this is a good thing')
-      end
-
-      debug('WS thread created! Now waiting for confirmation that everything worked')
-      @ws_success = false
-      sleep(0.5) until @ws_success
-      debug('Confirmation received! Exiting run.')
+      @gateway.sync
     end
 
-    # Prevents all further execution until the websocket thread stops (e. g. through a closed connection).
+    # 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
-      @ws_thread.join
+      @gateway.sync
+    end
+
+    # 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)
     end
 
-    # Kills the websocket thread, stopping all connections to Discord.
-    def stop
-      @ws_thread.kill
+    # @return [true, false] whether or not the bot is currently connected to Discord.
+    def connected?
+      @gateway.open?
     end
 
     # 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)
       resolved = invite(invite).code
-      API.join_server(token, resolved)
+      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.
     # @return [String] the OAuth invite URL.
-    def invite_url(server = nil)
-      raise 'No application ID has been set during initialization! Add one as the `application_id` named parameter while creating your bot.' unless @application_id
+    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
 
-      guild_id_str = server ? "&guild_id=#{server.id}" : ''
-      "https://discordapp.com/oauth2/authorize?&client_id=#{@application_id}#{guild_id_str}&scope=bot"
+      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"
     end
 
     # @return [Hash<Integer => VoiceBot>] the voice connections this bot currently has, by the server ID to which they are connected.
@@ -347,19 +280,9 @@ module Discordrb
 
       debug("Got voice channel: #{chan}")
 
-      data = {
-        op: Opcodes::VOICE_STATE,
-        d: {
-          guild_id: server_id.to_s,
-          channel_id: chan.id.to_s,
-          self_mute: false,
-          self_deaf: false
-        }
-      }
-      debug("Voice channel init packet is: #{data.to_json}")
-
       @should_connect_to_voice[server_id] = chan
-      @ws.send(data.to_json)
+      @gateway.send_voice_state_update(server_id.to_s, chan.id.to_s, false, false)
+
       debug('Voice channel init packet sent! Now waiting.')
 
       sleep(0.05) until @voices[server_id]
@@ -373,19 +296,7 @@ module Discordrb
     # @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)
-      data = {
-        op: Opcodes::VOICE_STATE,
-        d: {
-          guild_id: server_id.to_s,
-          channel_id: nil,
-          self_mute: false,
-          self_deaf: false
-        }
-      }
-
-      debug("Voice channel destroy packet is: #{data.to_json}")
-      @ws.send(data.to_json)
-
+      @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)
     end
@@ -395,28 +306,50 @@ module Discordrb
     # @param code [String, Invite] The invite to revoke. For possible formats see {#resolve_invite_code}.
     def delete_invite(code)
       invite = resolve_invite_code(code)
-      API.delete_invite(token, invite)
+      API::Invite.delete(token, invite)
     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 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.
     # @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}'")
 
-      response = API.send_message(token, channel_id, content, [], tts, server_id)
+      response = API::Channel.create_message(token, channel_id, content, [], tts, server_id)
       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 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)
+      Thread.new do
+        message = send_message(channel_id, content, tts, server_id)
+
+        sleep(timeout)
+
+        message.delete
+      end
+
+      nil
+    end
+
     # 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 file [File] The file that should be sent.
-    def send_file(channel_id, file)
-      response = API.send_file(token, channel_id, file)
+    # @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)
       Message.new(JSON.parse(response), self)
     end
 
@@ -437,7 +370,7 @@ module Discordrb
     #   * `:sydney`
     # @return [Server] The server that was created.
     def create_server(name, region = :london)
-      response = API.create_server(token, name, region)
+      response = API::Server.create(token, name, region)
       id = JSON.parse(response)['id'].to_i
       sleep 0.1 until @servers[id]
       server = @servers[id]
@@ -474,43 +407,70 @@ module Discordrb
       user(id.to_i)
     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 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.
+    # @see Gateway#send_status_update
+    def update_status(status, game, url, since = 0, afk = false)
+      gateway_check
+
+      @game = game
+      @status = status
+      @streamurl = url
+      type = url ? 1 : nil
+
+      game_obj = game || url ? { name: game, url: url, type: type } : nil
+      @gateway.send_status_update(status, since, game_obj, afk)
+    end
+
     # Sets the currently playing game to the specified game.
     # @param name [String] The name of the game to be played.
     # @return [String] The game that is being played now.
     def game=(name)
-      @game = name
-
-      data = {
-        op: Opcodes::PRESENCE,
-        d: {
-          idle_since: nil,
-          game: name ? { name: name } : nil
-        }
-      }
+      gateway_check
+      update_status(@status, name, nil)
+      name
+    end
 
-      @ws.send(data.to_json)
+    # Sets the currently online stream to the specified name and Twitch URL.
+    # @param name [String] The name of the stream to display.
+    # @param url [String] The url of the current Twitch stream.
+    # @return [String] The stream name that is being displayed now.
+    def stream(name, url)
+      gateway_check
+      update_status(@status, name, url)
       name
     end
 
-    # Injects a reconnect event (op 7) into the event processor, causing Discord to reconnect to the given gateway URL.
-    # If the URL is set to nil, it will reconnect and get an entirely new gateway URL. This method has not much use
-    # outside of testing and implementing highly custom reconnect logic.
-    # @param url [String, nil] the URL to connect to or nil if one should be obtained from Discord.
-    def inject_reconnect(url)
-      websocket_message({
-        op: Opcodes::RECONNECT,
-        d: {
-          url: url
-        }
-      }.to_json)
+    # Sets status to online.
+    def online
+      gateway_check
+      update_status(:online, @game, @streamurl)
+    end
+
+    alias_method :on, :online
+
+    # Sets status to idle.
+    def idle
+      gateway_check
+      update_status(:idle, @game, nil)
+    end
+
+    alias_method :away, :idle
+
+    # Sets the bot's status to DnD (red icon).
+    def dnd
+      gateway_check
+      update_status(:dnd, @game, nil)
     end
 
-    # Injects a resume packet (op 6) into the gateway. If this is done with a running connection, it will cause an
-    # error. It has no use outside of testing stuff that I know of, but if you want to use it anyway for some reason,
-    # here it is.
-    # @param seq [Integer, nil] The sequence ID to inject, or nil if the currently tracked one should be used.
-    def inject_resume(seq)
-      resume(seq || @sequence, raw_token, @session_id)
+    # Sets the bot's status to invisible (appears offline).
+    def invisible
+      gateway_check
+      update_status(:invisible, @game, nil)
     end
 
     # Sets debug mode. If debug mode is on, many things will be outputted to STDOUT.
@@ -574,26 +534,29 @@ module Discordrb
       LOGGER.log_exception(e)
     end
 
-    private
+    # Dispatches an event to this bot. Called by the gateway connection handler used internally.
+    def dispatch(type, data)
+      handle_dispatch(type, data)
+    end
 
-    # Determines the type of an account by checking which parameters are given
-    def determine_account_type(type, email, password, token, application_id)
-      # Case 1: if a type is already given, return it
-      return type if type
+    # Raises a heartbeat event. Called by the gateway connection handler used internally.
+    def raise_heartbeat_event
+      raise_event(HeartbeatEvent.new(self))
+    end
 
-      # Case 2: user accounts can't have application IDs so if one is given, return bot type
-      return :bot if application_id
+    def prune_empty_groups
+      @channels.each_value do |channel|
+        channel.leave_group if channel.group? && channel.recipients.empty?
+      end
+    end
 
-      # Case 3: bot accounts can't have emails and passwords so if either is given, assume user
-      return :user if email || password
+    private
 
-      # Case 4: If we're here and no token is given, throw an exception because that's impossible
-      raise ArgumentError, "Can't login because no authentication data was given! Specify at least a token" unless token
+    # Throws a useful exception if there's currently no gateway connection
+    def gateway_check
+      return if connected?
 
-      # Case 5: Only a token has been specified, we can assume it's a bot but we should tell the user
-      # to specify the application ID:
-      LOGGER.warn('The application ID is missing! Logging in as a bot will work but some OAuth-related functionality will be unavailable!')
-      :bot
+      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`."
     end
 
     ### ##    ## ######## ######## ########  ##    ##    ###    ##        ######
@@ -606,7 +569,7 @@ module Discordrb
 
     # Internal handler for PRESENCE_UPDATE
     def update_presence(data)
-      # Friends list presences have no guild ID so ignore these to not cause an error
+      # Friends list presences have no server ID so ignore these to not cause an error
       return unless data['guild_id']
 
       user_id = data['user']['id'].to_i
@@ -642,28 +605,11 @@ module Discordrb
 
     # Internal handler for VOICE_STATUS_UPDATE
     def update_voice_state(data)
-      user_id = data['user_id'].to_i
       server_id = data['guild_id'].to_i
       server = server(server_id)
       return unless server
 
-      user = server.member(user_id)
-
-      unless user
-        warn "Invalid user for voice state update: #{user_id} on #{server_id}, ignoring"
-        return
-      end
-
-      channel_id = data['channel_id']
-      channel = nil
-      channel = self.channel(channel_id.to_i) if channel_id
-
-      user.update_voice_state(
-        channel,
-        data['mute'],
-        data['deaf'],
-        data['self_mute'],
-        data['self_deaf'])
+      server.update_voice_state(data)
 
       @session_id = data['session_id']
     end
@@ -699,8 +645,10 @@ module Discordrb
       if server
         server.channels << channel
         @channels[channel.id] = channel
-      else
-        @private_channels[channel.id] = channel
+      elsif channel.pm?
+        @pm_channels[channel.recipient.id] = channel
+      elsif channel.group?
+        @channels[channel.id] = channel
       end
     end
 
@@ -721,11 +669,33 @@ module Discordrb
       if server
         @channels.delete(channel.id)
         server.channels.reject! { |c| c.id == channel.id }
-      else
-        @private_channels.delete(channel.id)
+      elsif channel.pm?
+        @pm_channels.delete(channel.recipient.id)
+      elsif channel.group?
+        @channels.delete(channel.id)
       end
     end
 
+    # Internal handler for CHANNEL_RECIPIENT_ADD
+    def add_recipient(data)
+      channel_id = data['channel_id'].to_i
+      channel = self.channel(channel_id)
+
+      recipient_user = ensure_user(data['user'])
+      recipient = Recipient.new(recipient_user, channel, self)
+      channel.add_recipient(recipient)
+    end
+
+    # Internal handler for CHANNEL_RECIPIENT_REMOVE
+    def remove_recipient(data)
+      channel_id = data['channel_id'].to_i
+      channel = self.channel(channel_id)
+
+      recipient_user = ensure_user(data['user'])
+      recipient = Recipient.new(recipient_user, channel, self)
+      channel.remove_recipient(recipient)
+    end
+
     # Internal handler for GUILD_MEMBER_ADD
     def add_guild_member(data)
       server_id = data['guild_id'].to_i
@@ -826,19 +796,6 @@ module Discordrb
     ##       ##     ## ##    ##   ##  ##   ###
     ########  #######   ######   #### ##    ##
 
-    def login(type, email, password, token, token_cache)
-      # Don't bother with any login code if a token is already specified
-      return process_token(type, token) if token
-
-      # If a bot account attempts logging in without a token, throw an error
-      raise ArgumentError, 'Bot account detected (type == :bot) but no token was found! Please specify a token in the Bot initializer, or use a user account.' if type == :bot
-
-      # If the type is not a user account at this point, it must be invalid
-      raise ArgumentError, 'Invalid type specified! Use either :bot or :user' if type == :user
-
-      user_login(email, password, token_cache)
-    end
-
     def process_token(type, token)
       # Remove the "Bot " prefix if it exists
       token = token[4..-1] if token.start_with? 'Bot '
@@ -847,162 +804,7 @@ module Discordrb
       token
     end
 
-    def user_login(email, password, token_cache)
-      debug('Logging in')
-
-      # Attempt to retrieve the token from the cache
-      retrieved_token = retrieve_token(email, password, token_cache)
-      return retrieved_token if retrieved_token
-
-      login_attempts ||= 0
-
-      # Login
-      login_response = JSON.parse(API.login(email, password))
-      token = login_response['token']
-      raise Discordrb::Errors::InvalidAuthenticationError unless token
-      debug('Received token from Discord!')
-
-      # Cache the token
-      token_cache.store_token(email, password, token)
-
-      token
-    rescue RestClient::BadRequest
-      raise Discordrb::Errors::InvalidAuthenticationError
-    rescue SocketError, RestClient::RequestFailed => e # RequestFailed handles the 52x error codes Cloudflare sometimes sends that aren't covered by specific RestClient classes
-      if login_attempts && login_attempts > 100
-        LOGGER.error("User login failed permanently after #{login_attempts} attempts")
-        raise
-      else
-        LOGGER.error("User login failed! Trying again in 5 seconds, #{100 - login_attempts} remaining")
-        LOGGER.log_exception(e)
-        retry
-      end
-    end
-
-    def retrieve_token(email, password, token_cache)
-      # First, attempt to get the token from the cache
-      token = token_cache.token(email, password)
-      debug('Token successfully obtained from cache!') if token
-      token
-    end
-
-    def find_gateway
-      # If the reconnect URL is set, it means we got an op 7 earlier and should reconnect to the new URL
-      if @reconnect_url
-        debug("Reconnecting to URL #{@reconnect_url}")
-        url = @reconnect_url
-        @reconnect_url = nil # Unset the URL so we don't connect to the same URL again if the connection fails
-        url
-      else
-        # Get the correct gateway URL from Discord
-        response = API.gateway(token)
-        JSON.parse(response)['url']
-      end
-    end
-
-    def process_gateway
-      raw_url = find_gateway
-
-      # Append a slash in case it's not there (I'm not sure how well WSCS handles it otherwise)
-      raw_url += '/' unless raw_url.end_with? '/'
-
-      # Add the parameters we want
-      raw_url + "?encoding=json&v=#{GATEWAY_VERSION}"
-    end
-
-    ##      ##  ######     ######## ##     ## ######## ##    ## ########  ######
-    ##  ##  ## ##    ##    ##       ##     ## ##       ###   ##    ##    ##    ##
-    ##  ##  ## ##          ##       ##     ## ##       ####  ##    ##    ##
-    ##  ##  ##  ######     ######   ##     ## ######   ## ## ##    ##     ######
-    ##  ##  ##       ##    ##        ##   ##  ##       ##  ####    ##          ##
-    ##  ##  ## ##    ##    ##         ## ##   ##       ##   ###    ##    ##    ##
-    ####  ###   ######     ########    ###    ######## ##    ##    ##     ######
-
-    # Desired gateway version
-    GATEWAY_VERSION = 4
-
-    def websocket_connect
-      debug('Attempting to get gateway URL...')
-      gateway_url = process_gateway
-      debug("Success! Gateway URL is #{gateway_url}.")
-      debug('Now running bot')
-
-      @ws = Discordrb::WebSocket.new(
-        gateway_url,
-        method(:websocket_open),
-        method(:websocket_message),
-        method(:websocket_close),
-        proc { |e| LOGGER.error "Gateway error: #{e}" }
-      )
-
-      @ws.thread[:discordrb_name] = 'gateway'
-      @ws.thread.join
-    rescue => e
-      LOGGER.error 'Error while connecting to the gateway!'
-      LOGGER.log_exception e
-      raise
-    end
-
-    def websocket_reconnect(url)
-      # In here, we do nothing except set the reconnect URL and close the current connection.
-      @reconnect_url = url
-      @ws.close
-
-      # Reset the packet sequence number so we don't try to resume the connection afterwards
-      @sequence = 0
-
-      # Let's hope the reconnect handler reconnects us correctly...
-    end
-
-    def websocket_message(event)
-      if event.byteslice(0) == 'x'
-        # The message is encrypted
-        event = Zlib::Inflate.inflate(event)
-      end
-
-      # Parse packet
-      packet = JSON.parse(event)
-
-      if @prevent_ready && packet['t'] == 'READY'
-        debug('READY packet was received and suppressed')
-      elsif @prevent_ready && packet['t'] == 'GUILD_MEMBERS_CHUNK'
-        # Ignore chunks as they will be handled later anyway
-      else
-        LOGGER.in(event.to_s)
-      end
-
-      opcode = packet['op'].to_i
-
-      if opcode == Opcodes::HEARTBEAT
-        # If Discord sends us a heartbeat, simply reply with a heartbeat with the packet's sequence number
-        @sequence = packet['s'].to_i
-
-        LOGGER.info("Received an op1 (seq: #{@sequence})! This means another client connected while this one is already running. Replying with the same seq")
-        send_heartbeat
-
-        return
-      end
-
-      if opcode == Opcodes::RECONNECT
-        websocket_reconnect(packet['d'] ? packet['d']['url'] : nil)
-        return
-      end
-
-      if opcode == Opcodes::INVALIDATE_SESSION
-        LOGGER.info "We got an opcode 9 from Discord! Invalidating the session. You probably don't have to worry about this."
-        invalidate_session
-        LOGGER.debug 'Session invalidated!'
-
-        LOGGER.debug 'Reconnecting with IDENTIFY'
-        websocket_open # Since we just invalidated the session, pretending we just opened the WS again will re-identify
-        LOGGER.debug "Re-identified! Let's hope everything works fine."
-        return
-      end
-
-      raise "Got an unexpected opcode (#{opcode}) in a gateway event!
-              Please report this issue along with the following information:
-              v#{GATEWAY_VERSION} #{packet}" unless opcode == Opcodes::DISPATCH
-
+    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
         # The server streaming timed out!
@@ -1015,26 +817,14 @@ module Discordrb
         notify_ready
       end
 
-      # Keep track of the packet sequence (continually incrementing number for every packet) so we can resume a
-      # connection if we disconnect
-      @sequence = packet['s'].to_i
-
-      data = packet['d']
-      type = packet['t'].intern
       case type
       when :READY
-        LOGGER.info("Discord using gateway protocol version: #{data['v']}, requested: #{GATEWAY_VERSION}")
+        # As READY may be called multiple times over a single process lifetime, we here need to reset the cache entirely
+        # to prevent possible inconsistencies, like objects referencing old versions of other objects which have been
+        # replaced.
+        init_cache
 
-        # Set the session ID in case we get disconnected and have to resume
-        @session_id = data['session_id']
-
-        # Activate the heartbeats
-        @heartbeat_interval = data['heartbeat_interval'].to_f / 1000.0
-        @heartbeat_active = true
-        debug("Desired heartbeat_interval: #{@heartbeat_interval}")
-        send_heartbeat
-
-        @profile = Profile.new(data['user'], self, @email, @password)
+        @profile = Profile.new(data['user'], self)
 
         # Initialize servers
         @servers = {}
@@ -1055,33 +845,25 @@ module Discordrb
           ensure_server(element)
         end
 
-        # Add private channels
+        # Add PM and group channels
         data['private_channels'].each do |element|
           channel = ensure_channel(element)
-          @private_channels[channel.recipient.id] = channel
+          if channel.pm?
+            @pm_channels[channel.recipient.id] = channel
+          else
+            @channels[channel.id] = channel
+          end
         end
 
         # Don't notify yet if there are unavailable servers because they need to get available before the bot truly has
         # all the data
-        if @unavailable_servers == 0
+        if @unavailable_servers.zero?
           # No unavailable servers - we're ready!
           notify_ready
         end
 
         @ready_time = Time.now
         @unavailable_timeout_time = Time.now
-      when :RESUMED
-        # The RESUMED event is received after a successful op 6 (resume). It does nothing except tell the bot the
-        # connection is initiated (like READY would) and set a new heartbeat interval.
-        debug('Connection resumed')
-
-        @heartbeat_interval = data['heartbeat_interval'].to_f / 1000.0
-
-        # Since we disabled it earlier so we don't send any heartbeats in between close and resume,, make sure to
-        # re-enable heartbeating
-        @heartbeat_active = true
-
-        debug("Desired heartbeat_interval: #{@heartbeat_interval}")
       when :GUILD_MEMBERS_CHUNK
         id = data['guild_id'].to_i
         server = server(id)
@@ -1128,6 +910,22 @@ module Discordrb
 
         event = MessageDeleteEvent.new(data, self)
         raise_event(event)
+      when :MESSAGE_DELETE_BULK
+        debug("MESSAGE_DELETE_BULK will raise #{data['ids'].length} events")
+
+        data['ids'].each do |single_id|
+          # Form a data hash for a single ID so the methods get what they want
+          single_data = {
+            'id' => single_id,
+            'channel_id' => data['channel_id']
+          }
+
+          # Raise as normal
+          delete_message(single_data)
+
+          event = MessageDeleteEvent.new(single_data, self)
+          raise_event(event)
+        end
       when :TYPING_START
         start_typing(data)
 
@@ -1177,6 +975,16 @@ module Discordrb
 
         event = ChannelDeleteEvent.new(data, self)
         raise_event(event)
+      when :CHANNEL_RECIPIENT_ADD
+        add_recipient(data)
+
+        event = ChannelRecipientAddEvent.new(data, self)
+        raise_event(event)
+      when :CHANNEL_RECIPIENT_REMOVE
+        remove_recipient(data)
+
+        event = ChannelRecipientRemoveEvent.new(data, self)
+        raise_event(event)
       when :GUILD_MEMBER_ADD
         add_guild_member(data)
 
@@ -1225,7 +1033,7 @@ module Discordrb
           @unavailable_servers -= 1 if @unavailable_servers
           @unavailable_timeout_time = Time.now
 
-          notify_ready if @unavailable_servers == 0
+          notify_ready if @unavailable_servers.zero?
 
           # Return here so the event doesn't get triggered
           return
@@ -1241,147 +1049,29 @@ module Discordrb
       when :GUILD_DELETE
         delete_guild(data)
 
+        if d['unavailable'].is_a? TrueClass
+          LOGGER.warn("Server #{d['id']} is unavailable due to an outage!")
+          return # Don't raise an event
+        end
+
         event = ServerDeleteEvent.new(data, self)
         raise_event(event)
       else
         # another event that we don't support yet
-        debug "Event #{packet['t']} has been received but is unsupported, ignoring"
+        debug "Event #{type} has been received but is unsupported, ignoring"
       end
     rescue Exception => e
       LOGGER.error('Gateway message error!')
       log_exception(e)
     end
 
-    def websocket_close(event)
-      # Don't handle nil events (for example if the disconnect came from our side)
-      return unless event
-
-      # Handle actual close frames and errors separately
-      if event.respond_to? :code
-        LOGGER.error(%(Disconnected from WebSocket - code #{event.code} with reason: "#{event.data}"))
-
-        if event.code.to_i == 4006
-          # If we got disconnected with a 4006, it means we sent a resume when Discord wanted an identify. To battle this,
-          # we invalidate the local session so we'll just send an identify next time
-          debug('Apparently we just sent the wrong type of initiation packet (resume rather than identify) to Discord. (Sorry!)
-                Invalidating session so this is fixed next time')
-          invalidate_session
-        end
-      else
-        LOGGER.error('Disconnected from WebSocket due to an exception!')
-        LOGGER.log_exception event
-      end
-
-      raise_event(DisconnectEvent.new(self))
-
-      # Stop sending heartbeats
-      @heartbeat_active = false
-
-      # Safely close the WS connection and handle any errors that occur there
-      begin
-        @ws.close
-      rescue => e
-        LOGGER.warn 'Got the following exception while closing the WS after being disconnected:'
-        LOGGER.log_exception e
-      end
-    rescue => e
-      LOGGER.log_exception e
-      raise
-    end
-
-    def websocket_open
-      # If we've already received packets (packet sequence > 0) resume an existing connection instead of identifying anew
-      if @sequence && @sequence > 0
-        resume(@sequence, raw_token, @session_id)
-        return
-      end
-
-      identify(raw_token, 100, GATEWAY_VERSION)
-    end
-
-    # Identify the client to the gateway
-    def identify(token, large_threshold, version)
-      # Send the initial packet
-      packet = {
-        op: Opcodes::IDENTIFY, # Opcode
-        d: {                   # Packet data
-          v: version,          # WebSocket protocol version
-          token: token,
-          properties: { # I'm unsure what these values are for exactly, but they don't appear to impact bot functionality in any way.
-            :'$os' => RUBY_PLATFORM.to_s,
-            :'$browser' => 'discordrb',
-            :'$device' => 'discordrb',
-            :'$referrer' => '',
-            :'$referring_domain' => ''
-          },
-          large_threshold: large_threshold,
-          compress: true
-        }
-      }
-
-      # Discord is very strict about the existence of the shard parameter, so only add it if it actually exists
-      packet[:d][:shard] = @shard_key if @shard_key
-
-      @ws.send(packet.to_json)
-    end
-
-    # Resume a previous gateway connection when reconnecting to a different server
-    def resume(seq, token, session_id)
-      data = {
-        op: Opcodes::RESUME,
-        d: {
-          seq: seq,
-          token: token,
-          session_id: session_id
-        }
-      }
-
-      @ws.send(data.to_json)
-    end
-
-    # Invalidate the current session (whatever this means)
-    def invalidate_session
-      @sequence = 0
-      @session_id = nil
-    end
-
     # Notifies everything there is to be notified that the connection is now ready
     def notify_ready
       # Make sure to raise the event
       raise_event(ReadyEvent.new(self))
       LOGGER.good 'Ready'
 
-      # Tell the run method that everything was successful
-      @ws_success = true
-    end
-
-    # Separate method to wait an ever-increasing amount of time before reconnecting after being disconnected in an
-    # unexpected way
-    def wait_for_reconnect
-      # We disconnected in an unexpected way! Wait before reconnecting so we don't spam Discord's servers.
-      debug("Attempting to reconnect in #{@falloff} seconds.")
-      sleep @falloff
-
-      # Calculate new falloff
-      @falloff *= 1.5
-      @falloff = 115 + (rand * 10) if @falloff > 120 # Cap the falloff at 120 seconds and then add some random jitter
-    end
-
-    def send_heartbeat(sequence = nil)
-      sequence ||= @sequence
-
-      raise_event(HeartbeatEvent.new(self))
-
-      LOGGER.out("Sending heartbeat with sequence #{sequence}")
-      data = {
-        op: Opcodes::HEARTBEAT,
-        d: sequence
-      }
-
-      @ws.send(data.to_json)
-    rescue => e
-      LOGGER.error('Got an error while sending a heartbeat! Carrying on anyway because heartbeats are vital for the connection to stay alive')
-      LOGGER.log_exception(e)
+      @gateway.notify_ready
     end
 
     def raise_event(event)