discordrb 1.8.1 → 2.0.0

data/lib/discordrb/container.rb

@@ -1,15 +1,13 @@
+# frozen_string_literal: true
+
 require 'discordrb/events/message'
 require 'discordrb/events/typing'
 require 'discordrb/events/lifetime'
 require 'discordrb/events/presence'
 require 'discordrb/events/voice_state_update'
-require 'discordrb/events/channel_create'
-require 'discordrb/events/channel_update'
-require 'discordrb/events/channel_delete'
+require 'discordrb/events/channels'
 require 'discordrb/events/members'
-require 'discordrb/events/guild_role_create'
-require 'discordrb/events/guild_role_delete'
-require 'discordrb/events/guild_role_update'
+require 'discordrb/events/roles'
 require 'discordrb/events/guilds'
 require 'discordrb/events/await'
 require 'discordrb/events/bans'
@@ -189,30 +187,30 @@ module Discordrb
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String] :username Matches the username of the joined user.
     # @yield The block is executed when the event is raised.
-    # @yieldparam event [GuildMemberAddEvent] The event that was raised.
-    # @return [GuildMemberAddEventHandler] The event handler that was registered.
+    # @yieldparam event [ServerMemberAddEvent] The event that was raised.
+    # @return [ServerMemberAddEventHandler] The event handler that was registered.
     def member_join(attributes = {}, &block)
-      register_event(GuildMemberAddEvent, attributes, block)
+      register_event(ServerMemberAddEvent, attributes, block)
     end
 
     # This **event** is raised when a member update happens.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String] :username Matches the username of the updated user.
     # @yield The block is executed when the event is raised.
-    # @yieldparam event [GuildMemberUpdateEvent] The event that was raised.
-    # @return [GuildMemberUpdateEventHandler] The event handler that was registered.
+    # @yieldparam event [ServerMemberUpdateEvent] The event that was raised.
+    # @return [ServerMemberUpdateEventHandler] The event handler that was registered.
     def member_update(attributes = {}, &block)
-      register_event(GuildMemberUpdateEvent, attributes, block)
+      register_event(ServerMemberUpdateEvent, attributes, block)
     end
 
     # This **event** is raised when a member leaves a server.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String] :username Matches the username of the member.
     # @yield The block is executed when the event is raised.
-    # @yieldparam event [GuildMemberDeleteEvent] The event that was raised.
-    # @return [GuildMemberDeleteEventHandler] The event handler that was registered.
+    # @yieldparam event [ServerMemberDeleteEvent] The event that was raised.
+    # @return [ServerMemberDeleteEventHandler] The event handler that was registered.
     def member_leave(attributes = {}, &block)
-      register_event(GuildMemberDeleteEvent, attributes, block)
+      register_event(ServerMemberDeleteEvent, attributes, block)
     end
 
     # This **event** is raised when a user is banned from a server.
@@ -243,20 +241,20 @@ module Discordrb
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String, Integer, Server] :server Matches the server that was created.
     # @yield The block is executed when the event is raised.
-    # @yieldparam event [GuildCreateEvent] The event that was raised.
-    # @return [GuildCreateEventHandler] The event handler that was registered.
+    # @yieldparam event [ServerCreateEvent] The event that was raised.
+    # @return [ServerCreateEventHandler] The event handler that was registered.
     def server_create(attributes = {}, &block)
-      register_event(GuildCreateEvent, attributes, block)
+      register_event(ServerCreateEvent, attributes, block)
     end
 
     # This **event** is raised when a server is updated, for example if the name or region has changed.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String, Integer, Server] :server Matches the server that was updated.
     # @yield The block is executed when the event is raised.
-    # @yieldparam event [GuildUpdateEvent] The event that was raised.
-    # @return [GuildUpdateEventHandler] The event handler that was registered.
+    # @yieldparam event [ServerUpdateEvent] The event that was raised.
+    # @return [ServerUpdateEventHandler] The event handler that was registered.
     def server_update(attributes = {}, &block)
-      register_event(GuildUpdateEvent, attributes, block)
+      register_event(ServerUpdateEvent, attributes, block)
     end
 
     # This **event** is raised when a server is deleted, or when the bot leaves a server. (These two cases are identical
@@ -264,10 +262,10 @@ module Discordrb
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String, Integer, Server] :server Matches the server that was deleted.
     # @yield The block is executed when the event is raised.
-    # @yieldparam event [GuildDeleteEvent] The event that was raised.
-    # @return [GuildDeleteEventHandler] The event handler that was registered.
+    # @yieldparam event [ServerDeleteEvent] The event that was raised.
+    # @return [ServerDeleteEventHandler] The event handler that was registered.
     def server_delete(attributes = {}, &block)
-      register_event(GuildDeleteEvent, attributes, block)
+      register_event(ServerDeleteEvent, attributes, block)
     end
 
     # This **event** is raised when an {Await} is triggered. It provides an easy way to execute code
@@ -330,7 +328,8 @@ module Discordrb
     # @param container [Module] A module that `extend`s {EventContainer} from which the handlers will be added.
     def include_events(container)
       handlers = container.instance_variable_get '@event_handlers'
-      raise "Couldn't include the container #{container} as it doesn't have any event handlers - have you tried to include a commands container into an event-only bot?" unless handlers
+      return unless handlers
+
       @event_handlers ||= {}
       @event_handlers.merge!(handlers) { |_, old, new| old + new }
     end

data/lib/discordrb/data.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # These classes hold relevant Discord data, such as messages or channels.
 
 require 'ostruct'
@@ -10,13 +12,55 @@ require 'base64'
 # Discordrb module
 module Discordrb
   # The unix timestamp Discord IDs are based on
-  DISCORD_EPOCH = 1420070400000
+  DISCORD_EPOCH = 1_420_070_400_000
 
   # Compares two objects based on IDs - either the objects' IDs are equal, or one object is equal to the other's ID.
   def self.id_compare(one_id, other)
     other.respond_to?(:resolve_id) ? (one_id.resolve_id == other.resolve_id) : (one_id == other)
   end
 
+  # The maximum length a Discord message can have
+  CHARACTER_LIMIT = 2000
+
+  # Splits a message into chunks of 2000 characters. Attempts to split by lines if possible.
+  # @param msg [String] The message to split.
+  # @return [Array<String>] the message split into chunks
+  def self.split_message(msg)
+    # If the messages is empty, return an empty array
+    return [] if msg.empty?
+
+    # Split the message into lines
+    lines = msg.lines
+
+    # Turn the message into a "triangle" of consecutively longer slices, for example the array [1,2,3,4] would become
+    # [
+    #  [1],
+    #  [1, 2],
+    #  [1, 2, 3],
+    #  [1, 2, 3, 4]
+    # ]
+    tri = [*0..(lines.length - 1)].map { |i| lines.combination(i + 1).first }
+
+    # Join the individual elements together to get an array of strings with consecutively more lines
+    joined = tri.map { |e| e.join("\n") }
+
+    # Find the largest element that is still below the character limit, or if none such element exists return the first
+    ideal = joined.max_by { |e| e.length > CHARACTER_LIMIT ? -1 : e.length }
+
+    # If it's still larger than the character limit (none was smaller than it) split it into slices with the length
+    # being the character limit, otherwise just return an array with one element
+    ideal_ary = (ideal.length > CHARACTER_LIMIT) ? ideal.chars.each_slice(CHARACTER_LIMIT).map(&:join) : [ideal]
+
+    # Slice off the ideal part and strip newlines
+    rest = msg[ideal.length..-1].strip
+
+    # If none remains, return an empty array -> we're done
+    return [] unless rest
+
+    # Otherwise, call the method recursively to split the rest of the string and add it onto the ideal array
+    ideal_ary + split_message(rest)
+  end
+
   # Mixin for objects that have IDs
   module IDObject
     # @return [Integer] the ID which uniquely identifies this object across Discord.
@@ -38,27 +82,49 @@ module Discordrb
     end
   end
 
-  # User on Discord, including internal data like discriminators
-  class User
-    include IDObject
-
+  # Mixin for the attributes users should have
+  module UserAttributes
     # @return [String] this user's username
     attr_reader :username
+    alias_method :name, :username
 
     # @return [String] this user's discriminator which is used internally to identify users with identical usernames.
     attr_reader :discriminator
+    alias_method :discrim, :discriminator
     alias_method :tag, :discriminator
     alias_method :discord_tag, :discriminator
 
+    # @return [true, false] whether this user is a Discord bot account
+    attr_reader :bot_account
+    alias_method :bot_account?, :bot_account
+
     # @return [String] the ID of this user's current avatar, can be used to generate an avatar URL.
     # @see #avatar_url
     attr_reader :avatar_id
 
-    # @return [Channel, nil] the voice channel this user is on currently.
-    attr_reader :voice_channel
+    # Utility function to mention users in messages
+    # @return [String] the mention code in the form of <@id>
+    def mention
+      "<@#{@id}>"
+    end
 
-    # @return [Hash<Integer => Array<Role>>] the roles this user has, grouped by server ID.
-    attr_reader :roles
+    # Utility function to get Discord's distinct representation of a user, i. e. username + discriminator
+    # @return [String] distinct representation of user
+    def distinct
+      "#{@username}##{@discriminator}"
+    end
+
+    # Utility function to get a user's avatar URL.
+    # @return [String] the URL to the avatar image.
+    def avatar_url
+      API.avatar_url(@id, @avatar_id)
+    end
+  end
+
+  # User on Discord, including internal data like discriminators
+  class User
+    include IDObject
+    include UserAttributes
 
     # @!attribute [r] status
     #   @return [Symbol] the current online status of the user (`:online`, `:offline` or `:idle`)
@@ -68,16 +134,6 @@ module Discordrb
     #   @return [String, nil] the game the user is currently playing, or `nil` if none is being played.
     attr_accessor :game
 
-    # @!attribute [r] self_mute
-    #   @return [true, false] whether or not the user is currently muted by the bot.
-    attr_accessor :self_mute
-
-    # @todo Fix these (server_mute and _deaf should be server specific, not sure about self_deaf or what it does anyway)
-    # @!visibility private
-    attr_accessor :server_mute, :server_deaf, :self_deaf
-
-    alias_method :name, :username
-
     def initialize(data, bot)
       @bot = bot
 
@@ -87,26 +143,10 @@ module Discordrb
       @avatar_id = data['avatar']
       @roles = {}
 
-      @status = :offline
-    end
-
-    # Gets the user's avatar ID.
-    # @deprecated Use {#avatar_id} instead.
-    def avatar
-      LOGGER.debug('Warning: Deprecated reader User.avatar was used! Use User.avatar_id (or User.avatar_url if you just want the URL) instead.', true)
-      @avatar_id
-    end
-
-    # Utility function to mention users in messages
-    # @return [String] the mention code in the form of <@id>
-    def mention
-      "<@#{@id}>"
-    end
+      @bot_account = false
+      @bot_account = true if data['bot']
 
-    # Utility function to get a user's avatar URL.
-    # @return [String] the URL to the avatar image.
-    def avatar_url
-      API.avatar_url(@id, @avatar_id)
+      @status = :offline
     end
 
     # Get a user's PM channel or send them a PM
@@ -128,44 +168,6 @@ module Discordrb
       end
     end
 
-    # Changes a user's voice channel.
-    # @note For internal use only
-    # @!visibility private
-    def move(to_channel)
-      return if to_channel && to_channel.type != 'voice'
-      @voice_channel = to_channel
-    end
-
-    # Adds a role to this user on the specified server.
-    # @param server [Server] The server on which to add the role.
-    # @param role [Role] The role to add.
-    def add_role(server, role)
-      user_roles = @roles[server.id] || []
-      user_roles << role
-      ids = user_roles.map(&:id)
-      API.update_user_roles(@bot.token, server.id, @id, ids)
-    end
-
-    # Removes a role from this user on the specified server.
-    # @param server [Server] The server on which to remove the role.
-    # @param role [Role] The role to remove.
-    def remove_role(server, role)
-      user_roles = @roles[server.id] || []
-
-      # If the given role has an ID (i.e. is a Role object), then check whether its ID is equal, otherwise check whether it's equal directly
-      user_roles.delete_if { |e| e == role }
-      ids = user_roles.map(&:id)
-      API.update_user_roles(@bot.token, server.id, @id, ids)
-    end
-
-    # Set this user's roles in the cache
-    # @note For internal use only
-    # @!visibility private
-    def update_roles(server, roles)
-      @roles ||= {}
-      @roles[server.id] = roles
-    end
-
     # Set the user's name
     # @note for internal use only
     # @!visibility private
@@ -173,24 +175,6 @@ module Discordrb
       @username = username
     end
 
-    # Merge this user's roles with the roles from another instance of this user (from another server)
-    # @note For internal use only
-    # @!visibility private
-    def merge_roles(server, roles)
-      @roles[server.id] = if @roles[server.id]
-                            (@roles[server.id] + roles).uniq
-                          else
-                            roles
-                          end
-    end
-
-    # Delete a specific server from the roles (in case a user leaves a server)
-    # @note For internal use only
-    # @!visibility private
-    def delete_roles(server_id)
-      @roles.delete(server_id)
-    end
-
     # Add an await for a message from this user. Specifically, this adds a global await for a MessageEvent with this
     # user's ID as a :from attribute.
     # @see Bot#add_await
@@ -198,54 +182,218 @@ module Discordrb
       @bot.add_await(key, Discordrb::Events::MessageEvent, { from: @id }.merge(attributes), &block)
     end
 
+    # Gets the member this user is on a server
+    # @param server [Server] The server to get the member for
+    # @return [Member] this user as a member on a particular server
+    def on(server)
+      id = server.resolve_id
+      @bot.server(id).member(@id)
+    end
+
     # Is the user the bot?
     # @return [true, false] whether this user is the bot
-    def bot?
-      @bot.bot_user.id == @id
+    def current_bot?
+      @bot.profile.id == @id
     end
 
-    # Determines whether this user has a specific permission on a server (and channel).
+    # The inspect method is overwritten to give more useful output
+    def inspect
+      "<User username=#{@username} id=#{@id} discriminator=#{@discriminator}>"
+    end
+  end
+
+  # Mixin for the attributes members and private members should have
+  module MemberAttributes
+    # @return [true, false] whether this member is muted server-wide.
+    attr_reader :mute
+    alias_method :muted?, :mute
+
+    # @return [true, false] whether this member is deafened server-wide.
+    attr_reader :deaf
+    alias_method :deafened?, :deaf
+
+    # @return [Time] when this member joined the server.
+    attr_reader :joined_at
+
+    # @return [Array<Role>] the roles this member has.
+    attr_reader :roles
+
+    # @return [Server] the server this member is on.
+    attr_reader :server
+
+    # @return [Channel] the voice channel the user is in.
+    attr_reader :voice_channel
+  end
+
+  # Mixin to calculate resulting permissions from overrides etc.
+  module PermissionCalculator
+    # Checks whether this user can do the particular action, regardless of whether it has the permission defined,
+    # through for example being the server owner or having the Manage Roles permission
     # @param action [Symbol] The permission that should be checked. See also {Permissions::Flags} for a list.
-    # @param server [Server] The server on which the permission should be checked.
     # @param channel [Channel, nil] If channel overrides should be checked too, this channel specifies where the overrides should be checked.
     # @return [true, false] whether or not this user has the permission.
-    def permission?(action, server, channel = nil)
+    def permission?(action, channel = nil)
+      # If the member is the server owner, it irrevocably has all permissions.
+      return true if owner?
+
+      # First, check whether the user has Manage Roles defined.
+      # (Coincidentally, Manage Permissions is the same permission as Manage Roles, and a
+      # Manage Permissions deny overwrite will override Manage Roles, so we can just check for
+      # Manage Roles once and call it a day.)
+      return true if defined_permission?(:manage_roles, channel)
+
+      # Otherwise, defer to defined_permission
+      defined_permission?(action, channel)
+    end
+
+    # Checks whether this user has a particular permission defined (i. e. not implicit, through for example
+    # Manage Roles)
+    # @param action [Symbol] The permission that should be checked. See also {Permissions::Flags} for a list.
+    # @param channel [Channel, nil] If channel overrides should be checked too, this channel specifies where the overrides should be checked.
+    # @return [true, false] whether or not this user has the permission defined.
+    def defined_permission?(action, channel = nil)
+      # Get the permission the user's roles have
+      role_permission = defined_role_permission?(action, channel)
+
+      # Once we have checked the role permission, we have to check the channel overrides for the
+      # specific user
+      user_specific_override = permission_overwrite(action, channel, id) # Use the ID reader as members have no ID instance variable
+
+      # Merge the two permissions - if an override is defined, it has to be allow, otherwise we only care about the role
+      return role_permission unless user_specific_override
+      user_specific_override == :allow
+    end
+
+    # Define methods for querying permissions
+    Discordrb::Permissions::Flags.each_value do |flag|
+      define_method "can_#{flag}?" do |channel = nil|
+        permission? flag, channel
+      end
+    end
+
+    private
+
+    def defined_role_permission?(action, channel)
       # For each role, check if
       #   (1) the channel explicitly allows or permits an action for the role and
       #   (2) if the user is allowed to do the action if the channel doesn't specify
-      return false unless @roles[server.id]
-
-      @roles[server.id].reduce(false) do |can_act, role|
-        channel_allow = nil
-        if channel && channel.permission_overwrites[role.id]
-          allow = channel.permission_overwrites[role.id].allow
-          deny = channel.permission_overwrites[role.id].deny
-          if allow.instance_variable_get("@#{action}")
-            channel_allow = true
-          elsif deny.instance_variable_get("@#{action}")
-            channel_allow = false
-          end
-          # If the channel has nothing to say on the matter, we can defer to the role itself
-        end
-        can_act = if channel_allow.nil?
-                    role.permissions.instance_variable_get("@#{action}") || can_act
+      @roles.reduce(false) do |can_act, role|
+        # Get the override defined for the role on the channel
+        channel_allow = permission_overwrite(action, channel, role.id)
+        can_act = if channel_allow
+                    # If the channel has an override, check whether it is an allow - if yes,
+                    # the user can act, if not, it can't
+                    channel_allow == :allow
                   else
-                    channel_allow
+                    # Otherwise defer to the role
+                    role.permissions.instance_variable_get("@#{action}") || can_act
                   end
         can_act
       end
     end
 
-    # Define methods for querying permissions
-    Discordrb::Permissions::Flags.each_value do |flag|
-      define_method "can_#{flag}?" do |server, channel = nil|
-        permission? flag, server, channel
+    def permission_overwrite(action, channel, id)
+      # If no overwrites are defined, or no channel is set, no overwrite will be present
+      return nil unless channel && channel.permission_overwrites[id]
+
+      # Otherwise, check the allow and deny objects
+      allow = channel.permission_overwrites[id].allow
+      deny = channel.permission_overwrites[id].deny
+      if allow.instance_variable_get("@#{action}")
+        :allow
+      elsif deny.instance_variable_get("@#{action}")
+        :deny
       end
+
+      # If there's no variable defined, nil will implicitly be returned
     end
+  end
 
-    # The inspect method is overwritten to give more useful output
+  # A member is a user on a server. It differs from regular users in that it has roles, voice statuses and things like
+  # that.
+  class Member < DelegateClass(User)
+    include MemberAttributes
+
+    # @!visibility private
+    def initialize(data, server, bot)
+      @bot = bot
+
+      @user = bot.ensure_user(data['user'])
+      super @user # Initialize the delegate class
+
+      # Somehow, Discord doesn't send the server ID in the standard member format...
+      raise ArgumentError, 'Cannot create a member without any information about the server!' if server.nil? && data['guild_id'].nil?
+      @server = server || bot.server(data['guild_id'].to_i)
+
+      # Initialize the roles by getting the roles from the server one-by-one
+      update_roles(data['roles'])
+
+      @deaf = data['deaf']
+      @mute = data['mute']
+      @joined_at = data['joined_at'] ? Time.parse(data['joined_at']) : nil
+    end
+
+    # @return [true, false] whether this member is the server owner.
+    def owner?
+      @server.owner == self
+    end
+
+    # Update this member's roles
+    # @note For internal use only.
+    # @!visibility private
+    def update_roles(roles)
+      @roles = roles.map do |role_id|
+        @server.role(role_id.to_i)
+      end
+    end
+
+    # Update this member's voice state
+    # @note For internal use only.
+    # @!visibility private
+    def update_voice_state(channel, mute, deaf, self_mute, self_deaf)
+      @voice_channel = channel
+      @mute = mute
+      @deaf = deaf
+      @self_mute = self_mute
+      @self_deaf = self_deaf
+    end
+
+    include PermissionCalculator
+
+    # Overwriting inspect for debug purposes
     def inspect
-      "<User username=#{@username} id=#{@id} discriminator=#{@discriminator}>"
+      "<Member user=#{@user.inspect} server=#{@server.inspect} joined_at=#{@joined_at} roles=#{@roles.inspect} voice_channel=#{@voice_channel.inspect} mute=#{@mute} deaf=#{@deaf} self_mute=#{@self_mute} self_deaf=#{@self_deaf}>"
+    end
+  end
+
+  # Recipients are members on private channels - they exist for completeness purposes, but all
+  # the attributes will be empty.
+  class Recipient < DelegateClass(User)
+    include MemberAttributes
+
+    # @return [Channel] the private channel this recipient is the recipient of.
+    attr_reader :channel
+
+    # @!visibility private
+    def initialize(user, channel, bot)
+      @bot = bot
+      @channel = channel
+      raise ArgumentError, 'Tried to create a recipient for a public channel!' unless @channel.private?
+
+      @user = user
+      super @user
+
+      # Member attributes
+      @mute = @deaf = @self_mute = @self_deaf = false
+      @voice_channel = nil
+      @server = nil
+      @roles = []
+      @joined_at = @channel.creation_time
+    end
+
+    # Overwriting inspect for debug purposes
+    def inspect
+      "<Recipient user=#{@user.inspect} channel=#{@channel.inspect}>"
     end
   end
 
@@ -260,38 +408,39 @@ module Discordrb
 
     # Whether or not the user is the bot. The Profile can only ever be the bot user, so this always returns true.
     # @return [true]
-    def bot?
+    def current_bot?
       true
     end
 
     # Sets the bot's username.
     # @param username [String] The new username.
     def username=(username)
-      update_server_data(username: username)
+      update_profile_data(username: username)
     end
 
     # Sets the bot's email address. If you use this method, make sure that the login email in the script matches this
     # one afterwards, so the bot doesn't have any trouble logging in in the future.
     # @param email [String] The new email address.
     def email=(email)
-      update_server_data(email: email)
+      update_profile_data(email: email)
     end
 
     # Changes the bot's password. This will invalidate all tokens so you will have to relog the bot.
     # @param password [String] The new password.
     def password=(password)
-      update_server_data(new_password: password)
+      update_profile_data(new_password: password)
     end
 
     # Changes the bot's avatar.
-    # @param avatar [String, File] A JPG file to be used as the avatar, either as a File object or as a base64-encoded String.
+    # @param avatar [String, #read] A JPG file to be used as the avatar, either
+    #  something readable (e. g. File) or as a data URL.
     def avatar=(avatar)
       if avatar.respond_to? :read
         avatar_string = 'data:image/jpg;base64,'
         avatar_string += Base64.strict_encode64(avatar.read)
-        update_server_data(avatar: avatar_string)
+        update_profile_data(avatar: avatar_string)
       else
-        update_server_data(avatar: avatar)
+        update_profile_data(avatar: avatar)
       end
     end
 
@@ -312,7 +461,7 @@ module Discordrb
 
     private
 
-    def update_server_data(new_data)
+    def update_profile_data(new_data)
       API.update_user(@bot.token,
                       new_data[:email] || @email,
                       @password,
@@ -525,14 +674,7 @@ module Discordrb
     # @return [String] the type of this channel (currently either 'text' or 'voice')
     attr_reader :type
 
-    # @note This data is sent by Discord and it's possible for this to falsely be true for certain kinds of integration
-    #   channels (like Twitch subscriber ones). This appears to be a Discord bug that I can't reproduce myself, due to
-    #   not having any integrations in place. If this occurs to you please tell me.
-    # @deprecated Use {#private?} instead, it's guaranteed to be accurate.
-    # @return [true, false] whether or not this channel is a private messaging channel.
-    attr_reader :is_private
-
-    # @return [User, nil] the recipient of the private messages, or nil if this is not a PM channel
+    # @return [Recipient, nil] the recipient of the private messages, or nil if this is not a PM channel
     attr_reader :recipient
 
     # @return [String] the channel's topic
@@ -546,7 +688,7 @@ module Discordrb
     # @return [Hash<Integer => OpenStruct>] the channel's permission overwrites
     attr_reader :permission_overwrites
 
-    # @return [true, false] whether or not this channel is a PM channel, with more accuracy than {#is_private}.
+    # @return [true, false] whether or not this channel is a PM channel.
     def private?
       @server.nil?
     end
@@ -570,12 +712,16 @@ module Discordrb
 
       @is_private = data['is_private']
       if @is_private
-        @recipient = User.new(data['recipient'], bot)
+        recipient_user = bot.ensure_user(data['recipient'])
+        @recipient = Recipient.new(recipient_user, self, bot)
         @name = @recipient.username
       else
         @name = data['name']
-        @server = bot.server(data['guild_id'].to_i)
-        @server ||= server
+        @server = if server
+                    server
+                  else
+                    bot.server(data['guild_id'].to_i)
+                  end
       end
 
       # Populate permission overwrites
@@ -609,6 +755,18 @@ module Discordrb
       @bot.send_message(@id, content, tts)
     end
 
+    # Sends multiple messages to a channel
+    # @param content [Array<String>] The messages to send.
+    def send_multiple(content)
+      content.each { |e| send_message(e) }
+    end
+
+    # Splits a message into chunks whose length is at most the Discord character limit, then sends them individually.
+    # Useful for sending long messages, but be wary of rate limits!
+    def split_send(content)
+      send_multiple(Discordrb.split_message(content))
+    end
+
     # Sends a file to this channel. If it is an image, it will be embedded.
     # @param file [File] The file to send. There's no clear size limit for this, you'll have to attempt it for yourself (most non-image files are fine, large images may fail to embed)
     def send_file(file)
@@ -641,20 +799,46 @@ module Discordrb
       update_channel_data
     end
 
+    # Defines a permission overwrite for this channel that sets the specified thing to the specified allow and deny
+    # permission sets, or change an existing one.
+    # @param thing [User, Role] What to define an overwrite for.
+    # @param allow [#bits, Permissions, Integer] The permission sets that should receive an `allow` override (i. e. a
+    #   green checkmark on Discord)
+    # @param deny [#bits, Permissions, Integer] The permission sets that should receive a `deny` override (i. e. a red
+    #   cross on Discord)
+    # @example Define a permission overwrite for a user that can then mention everyone and use TTS, but not create any invites
+    #   allow = Discordrb::Permissions.new
+    #   allow.can_mention_everyone = true
+    #   allow.can_send_tts_messages = true
+    #
+    #   deny = Discordrb::Permissions.new
+    #   deny.can_create_instant_invite = true
+    #
+    #   channel.define_overwrite(user, allow, deny)
+    def define_overwrite(thing, allow, deny)
+      allow_bits = allow.respond_to?(:bits) ? allow.bits : allow
+      deny_bits = deny.respond_to?(:bits) ? deny.bits : deny
+
+      if thing.is_a? User
+        API.update_user_overrides(@bot.token, @id, thing.id, allow_bits, deny_bits)
+      elsif thing.is_a? Role
+        API.update_role_overrides(@bot.token, @id, thing.id, allow_bits, deny_bits)
+      end
+    end
+
     # Updates the cached data from another channel.
     # @note For internal use only
     # @!visibility private
     def update_from(other)
       @topic = other.topic
       @name = other.name
-      @is_private = other.is_private
       @recipient = other.recipient
       @permission_overwrites = other.permission_overwrites
     end
 
     # The list of users currently in this channel. This is mostly useful for a voice channel, for a text channel it will
     # just return the users on the server that are online.
-    # @return [Array<User>] the users in this channel
+    # @return [Array<Member>] the users in this channel
     def users
       if @type == 'text'
         @server.members.select { |u| u.status != :offline }
@@ -746,6 +930,53 @@ module Discordrb
     end
   end
 
+  # An attachment to a message
+  class Attachment
+    include IDObject
+
+    # @return [Message] the message this attachment belongs to.
+    attr_reader :message
+
+    # @return [String] the CDN URL this attachment can be downloaded at.
+    attr_reader :url
+
+    # @return [String] the attachment's proxy URL - I'm not sure what exactly this does, but I think it has something to
+    #   do with CDNs
+    attr_reader :proxy_url
+
+    # @return [String] the attachment's filename.
+    attr_reader :filename
+
+    # @return [Integer] the attachment's file size in bytes.
+    attr_reader :size
+
+    # @return [Integer, nil] the width of an image file, in pixels, or nil if the file is not an image.
+    attr_reader :width
+
+    # @return [Integer, nil] the height of an image file, in pixels, or nil if the file is not an image.
+    attr_reader :height
+
+    # @!visibility private
+    def initialize(data, message, bot)
+      @bot = bot
+      @message = message
+
+      @url = data['url']
+      @proxy_url = data['proxy_url']
+      @filename = data['filename']
+
+      @size = data['size']
+
+      @width = data['width']
+      @height = data['height']
+    end
+
+    # @return [true, false] whether this file is an image file.
+    def image?
+      !(@width.nil? || @height.nil?)
+    end
+  end
+
   # A message on Discord that was sent to a text channel
   class Message
     include IDObject
@@ -753,7 +984,7 @@ module Discordrb
     # @return [String] the content of this message.
     attr_reader :content
 
-    # @return [User] the user that sent this message.
+    # @return [Member] the user that sent this message.
     attr_reader :author
 
     # @return [Channel] the channel in which this message was sent.
@@ -765,6 +996,9 @@ module Discordrb
     # @return [Array<User>] the users that were mentioned in this message.
     attr_reader :mentions
 
+    # @return [Array<Attachment>] the files attached to this message.
+    attr_reader :attachments
+
     alias_method :user, :author
     alias_method :text, :content
     alias_method :to_s, :content
@@ -773,16 +1007,29 @@ module Discordrb
     def initialize(data, bot)
       @bot = bot
       @content = data['content']
-      @author = bot.user(data['author']['id'].to_i)
       @channel = bot.channel(data['channel_id'].to_i)
-      @timestamp = Time.parse(data['timestamp'])
+
+      @author = if data['author']
+                  if @channel.private?
+                    # Turn the message user into a recipient - we can't use the channel recipient
+                    # directly because the bot may also send messages to the channel
+                    Recipient.new(bot.user(data['author']['id'].to_i), @channel, bot)
+                  else
+                    @channel.server.member(data['author']['id'].to_i)
+                  end
+                end
+
+      @timestamp = Time.parse(data['timestamp']) if data['timestamp']
       @id = data['id'].to_i
 
       @mentions = []
 
       data['mentions'].each do |element|
-        @mentions << User.new(element, bot)
-      end
+        @mentions << bot.ensure_user(element)
+      end if data['mentions']
+
+      @attachments = []
+      @attachments = data['attachments'].map { |e| Attachment.new(e, self, @bot) } if data['attachments']
     end
 
     # Replies to this message with the specified content.
@@ -793,13 +1040,16 @@ module Discordrb
 
     # Edits this message to have the specified content instead.
     # @param new_content [String] the new content the message should have.
+    # @return [Message] the resulting message.
     def edit(new_content)
-      API.edit_message(@bot.token, @channel.id, @id, new_content)
+      response = API.edit_message(@bot.token, @channel.id, @id, new_content)
+      Message.new(JSON.parse(response), @bot)
     end
 
     # Deletes this message.
     def delete
       API.delete_message(@bot.token, @channel.id, @id)
+      nil
     end
 
     # Add an {Await} for a message with the same user and channel.
@@ -810,7 +1060,7 @@ module Discordrb
 
     # @return [true, false] whether this message was sent by the current {Bot}.
     def from_bot?
-      @author.bot?
+      @author && @author.current_bot?
     end
 
     # The inspect method is overwritten to give more useful output
@@ -819,27 +1069,32 @@ module Discordrb
     end
   end
 
+  # Basic attributes a server should have
+  module ServerAttributes
+    # @return [String] this server's name.
+    attr_reader :name
+
+    # @return [String] the hexadecimal ID used to identify this server's icon.
+    attr_reader :icon_id
+
+    # Utility function to get the URL for the icon image
+    # @return [String] the URL to the icon image
+    def icon_url
+      API.icon_url(@id, @icon_id)
+    end
+  end
+
   # A server on Discord
   class Server
     include IDObject
+    include ServerAttributes
 
     # @return [String] the region the server is on (e. g. `amsterdam`).
     attr_reader :region
 
-    # @return [String] this server's name.
-    attr_reader :name
-
-    # @deprecated Use #owner instead, then get the resulting {User}'s ID.
-    # @return [Integer] the server owner's user ID.
-    attr_reader :owner_id
-
-    # @return [User] The server owner.
+    # @return [Member] The server owner.
     attr_reader :owner
 
-    # @return [Array<User>] an array of all the users on this server.
-    attr_reader :members
-    alias_method :users, :members
-
     # @return [Array<Channel>] an array of all the channels (text and voice) on this server.
     attr_reader :channels
 
@@ -854,33 +1109,34 @@ module Discordrb
     # @return [Integer] the absolute number of members on this server, offline or not.
     attr_reader :member_count
 
-    # @todo Make this behave like user.avatar where a URL is available as well.
-    # @return [String] the hexadecimal ID used to identify this server's icon.
-    attr_reader :icon
-
     # @return [Integer] the amount of time after which a voice user gets moved into the AFK channel, in seconds.
     attr_reader :afk_timeout
 
-    # @todo Make this a reader that returns a {Channel}
-    # @return [Integer] the channel ID of the AFK channel, or `nil` if none is set.
-    attr_reader :afk_channel_id
+    # @return [Channel, nil] the AFK voice channel of this server, or nil if none is set
+    attr_reader :afk_channel
 
     # @!visibility private
     def initialize(data, bot)
       @bot = bot
       @owner_id = data['owner_id'].to_i
-      @owner = bot.user(@owner_id)
       @id = data['id'].to_i
       update_data(data)
 
       @large = data['large']
       @member_count = data['member_count']
+      @members = {}
 
       process_roles(data['roles'])
       process_members(data['members'])
       process_presences(data['presences'])
       process_channels(data['channels'])
       process_voice_states(data['voice_states'])
+
+      # Whether this server's members have been chunked (resolved using op 8 and GUILD_MEMBERS_CHUNK) yet
+      @chunked = false
+      @processed_chunk_members = 0
+
+      @owner = member(@owner_id)
     end
 
     # @return [Channel] The default channel on this server (usually called #general)
@@ -896,6 +1152,28 @@ module Discordrb
       @roles.find { |e| e.id == id }
     end
 
+    # Gets a member on this server based on user ID
+    # @param id [Integer] The user ID to look for
+    def member(id)
+      id = id.resolve_id
+      return @members[id] if member_cached?(id)
+
+      member = bot.member(@id, id)
+      @members[id] = member
+    end
+
+    # @return [Array<Member>] an array of all the members on this server.
+    def members
+      return @members.values if @chunked
+
+      @bot.debug("Members for server #{@id} not chunked yet - initiating")
+      @bot.request_chunks(@id)
+      sleep 0.05 until @chunked
+      @members.values
+    end
+
+    alias_method :users, :members
+
     # Adds a role to the role cache
     # @note For internal use only
     # @!visibility private
@@ -908,9 +1186,9 @@ module Discordrb
     # @!visibility private
     def delete_role(role_id)
       @roles.reject! { |r| r.id == role_id }
-      @members.each do |user|
-        new_roles = user.roles[@id].reject { |r| r.id == role_id }
-        user.update_roles(self, new_roles)
+      @members.each do |_, member|
+        new_roles = member.roles.reject { |r| r.id == role_id }
+        member.update_roles(new_roles)
       end
       @channels.each do |channel|
         overwrites = channel.permission_overwrites.reject { |id, _| id == role_id }
@@ -918,26 +1196,40 @@ module Discordrb
       end
     end
 
-    # Adds a user to the user cache.
+    # Adds a member to the member cache.
     # @note For internal use only
     # @!visibility private
-    def add_user(user)
-      @members << user unless @members.include? user
+    def add_member(member)
+      @members[member.id] = member
       @member_count += 1
     end
 
-    # Removes a user from the user cache.
+    # Removes a member from the member cache.
     # @note For internal use only
     # @!visibility private
-    def delete_user(user_id)
-      @members.reject! { |member| member.id == user_id }.length
+    def delete_member(user_id)
+      @members.delete(user_id)
       @member_count -= 1
     end
 
+    # Checks whether a member is cached
+    # @note For internal use only
+    # @!visibility private
+    def member_cached?(user_id)
+      @members.include?(user_id)
+    end
+
+    # Adds a member to the cache
+    # @note For internal use only
+    # @!visibility private
+    def cache_member(member)
+      @members[member.id] = member
+    end
+
     # Creates a channel on this server with the given name.
     # @return [Channel] the created channel.
-    def create_channel(name)
-      response = API.create_channel(@bot.token, @id, name, 'text')
+    def create_channel(name, type = 'text')
+      response = API.create_channel(@bot.token, @id, name, type)
       Channel.new(JSON.parse(response), @bot)
     end
 
@@ -959,22 +1251,22 @@ module Discordrb
     end
 
     # Bans a user from this server.
-    # @param user [User] The user to ban.
+    # @param user [User, #resolve_id] The user to ban.
     # @param message_days [Integer] How many days worth of messages sent by the user should be deleted.
     def ban(user, message_days = 0)
-      API.ban_user(@bot.token, @id, user.id, message_days)
+      API.ban_user(@bot.token, @id, user.resolve_id, message_days)
     end
 
     # Unbans a previously banned user from this server.
-    # @param user [User] The user to unban.
+    # @param user [User, #resolve_id] The user to unban.
     def unban(user)
-      API.unban_user(@bot.token, @id, user.id)
+      API.unban_user(@bot.token, @id, user.resolve_id)
     end
 
     # Kicks a user from this server.
-    # @param user [User] The user to kick.
+    # @param user [User, #resolve_id] The user to kick.
     def kick(user)
-      API.kick_user(@bot.token, @id, user.id)
+      API.kick_user(@bot.token, @id, user.resolve_id)
     end
 
     # Forcibly moves a user into a different voice channel. Only works if the bot has the permission needed.
@@ -1013,10 +1305,15 @@ module Discordrb
     end
 
     # Sets the server's icon.
-    # @todo Make this behave in a similar way to User#avatar=.
-    # @param icon [String] The new icon, in base64-encoded JPG format.
+    # @param icon [String, #read] The new icon, in base64-encoded JPG format.
     def icon=(icon)
-      update_server_data(icon: icon)
+      if icon.respond_to? :read
+        icon_string = 'data:image/jpg;base64,'
+        icon_string += Base64.strict_encode64(icon.read)
+        update_server_data(icon: icon_string)
+      else
+        update_server_data(icon: icon)
+      end
     end
 
     # Sets the server's AFK channel.
@@ -1025,28 +1322,41 @@ module Discordrb
       update_server_data(afk_channel_id: afk_channel.resolve_id)
     end
 
-    # @deprecated Use #afk_channel= with the ID instead.
-    def afk_channel_id=(afk_channel_id)
-      update_server_data(afk_channel_id: afk_channel_id)
-    end
-
     # Sets the amount of time after which a user gets moved into the AFK channel.
     # @param afk_timeout [Integer] The AFK timeout, in seconds.
     def afk_timeout=(afk_timeout)
       update_server_data(afk_timeout: afk_timeout)
     end
 
+    # Processes a GUILD_MEMBERS_CHUNK packet, specifically the members field
+    # @note For internal use only
+    # @!visibility private
+    def process_chunk(members)
+      process_members(members)
+      @processed_chunk_members += members.length
+      LOGGER.debug("Processed one chunk on server #{@id} - length #{members.length}")
+
+      # Don't bother with the rest of the method if it's not truly the last packet
+      return unless @processed_chunk_members == @member_count
+
+      LOGGER.debug("Finished chunking server #{@id}")
+
+      # Reset everything to normal
+      @chunked = true
+      @processed_chunk_members = 0
+    end
+
     # Updates the cached data with new data
     # @note For internal use only
     # @!visibility private
     def update_data(new_data)
       @name = new_data[:name] || new_data['name'] || @name
       @region = new_data[:region] || new_data['region'] || @region
-      @icon = new_data[:icon] || new_data['icon'] || @icon
+      @icon_id = new_data[:icon] || new_data['icon'] || @icon_id
       @afk_timeout = new_data[:afk_timeout] || new_data['afk_timeout'].to_i || @afk_timeout
 
       @afk_channel_id = new_data[:afk_channel_id] || new_data['afk_channel_id'].to_i || @afk_channel.id
-      @afk_channel = @bot.channel(@afk_channel_id) if @afk_channel_id != 0 && (!@afk_channel || @afk_channel_id != @afk_channel.id)
+      @afk_channel = @bot.channel(@afk_channel_id, self) if @afk_channel_id != 0 && (!@afk_channel || @afk_channel_id != @afk_channel.id)
     end
 
     # The inspect method is overwritten to give more useful output
@@ -1060,7 +1370,7 @@ module Discordrb
       API.update_server(@bot.token, @id,
                         new_data[:name] || @name,
                         new_data[:region] || @region,
-                        new_data[:icon] || @icon,
+                        new_data[:icon_id] || @icon_id,
                         new_data[:afk_channel_id] || @afk_channel_id,
                         new_data[:afk_timeout] || @afk_timeout)
       update_data(new_data)
@@ -1080,20 +1390,10 @@ module Discordrb
     end
 
     def process_members(members)
-      @members = []
-      @members_by_id = {}
-
       return unless members
       members.each do |element|
-        user = User.new(element['user'], @bot)
-        @members << user
-        @members_by_id[user.id] = user
-        user_roles = []
-        element['roles'].each do |e|
-          role_id = e.to_i
-          user_roles << @roles_by_id[role_id]
-        end
-        user.update_roles(self, user_roles)
+        member = Member.new(element, self, @bot)
+        @members[member.id] = member
       end
     end
 
@@ -1103,7 +1403,7 @@ module Discordrb
       presences.each do |element|
         next unless element['user']
         user_id = element['user']['id'].to_i
-        user = @members_by_id[user_id]
+        user = @members[user_id]
         if user
           user.status = element['status'].to_sym
           user.game = element['game'] ? element['game']['name'] : nil
@@ -1127,15 +1427,17 @@ module Discordrb
       return unless voice_states
       voice_states.each do |element|
         user_id = element['user_id'].to_i
-        user = @members_by_id[user_id]
-        next unless user
-        user.server_mute = element['mute']
-        user.server_deaf = element['deaf']
-        user.self_mute = element['self_mute']
-        user.self_mute = element['self_mute']
+        member = @members[user_id]
+        next unless member
         channel_id = element['channel_id'].to_i
         channel = channel_id ? @channels_by_id[channel_id] : nil
-        user.move(channel)
+
+        member.update_voice_state(
+          channel,
+          element['mute'],
+          element['deaf'],
+          element['self_mute'],
+          element['self_deaf'])
       end
     end
   end