discordrb 3.4.3 → 3.5.0

data/lib/discordrb/data/invite.rb

@@ -100,7 +100,7 @@ module Discordrb
                 end
 
       @uses = data['uses']
-      @inviter = data['inviter'] ? (@bot.user(data['inviter']['id'].to_i) || User.new(data['inviter'], bot)) : nil
+      @inviter = data['inviter'] ? bot.ensure_user(data['inviter']) : nil
       @temporary = data['temporary']
       @revoked = data['revoked']
       @online_member_count = data['approximate_presence_count']

data/lib/discordrb/data/member.rb

@@ -18,6 +18,10 @@ module Discordrb
 
     # @return [Server] the server this member is on.
     attr_reader :server
+
+    # @return [Time] When the user's timeout will expire.
+    attr_reader :communication_disabled_until
+    alias_method :timeout, :communication_disabled_until
   end
 
   # A member is a user on a server. It differs from regular users in that it has roles, voice statuses and things like
@@ -62,17 +66,39 @@ module Discordrb
       @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)
+      @server = server
+      @server_id = server&.id || data['guild_id'].to_i
 
-      # Initialize the roles by getting the roles from the server one-by-one
-      update_roles(data['roles'])
+      @role_ids = data['roles']&.map(&:to_i) || []
 
       @nick = data['nick']
       @joined_at = data['joined_at'] ? Time.parse(data['joined_at']) : nil
       @boosting_since = data['premium_since'] ? Time.parse(data['premium_since']) : nil
+      timeout_until = data['communication_disabled_until']
+      @communication_disabled_until = timeout_until ? Time.parse(timeout_until) : nil
+      @permissions = Permissions.new(data['permissions']) if data['permissions']
+    end
+
+    # @return [Server] the server this member is on.
+    # @raise [Discordrb::Errors::NoPermission] This can happen when receiving interactions for servers in which the bot is not
+    #   authorized with the `bot` scope.
+    def server
+      return @server if @server
+
+      @server = @bot.server(@server_id)
+      raise Discordrb::Errors::NoPermission, 'The bot does not have access to this server' unless @server
+
+      @server
+    end
+
+    # @return [Array<Role>] the roles this member has.
+    # @raise [Discordrb::Errors::NoPermission] This can happen when receiving interactions for servers in which the bot is not
+    #   authorized with the `bot` scope.
+    def roles
+      return @roles if @roles
+
+      update_roles(@role_ids)
+      @roles
     end
 
     # @return [true, false] if this user is a Nitro Booster of this server.
@@ -82,14 +108,14 @@ module Discordrb
 
     # @return [true, false] whether this member is the server owner.
     def owner?
-      @server.owner == self
+      server.owner == self
     end
 
     # @param role [Role, String, Integer] the role to check or its ID.
     # @return [true, false] whether this member has the specified role.
     def role?(role)
       role = role.resolve_id
-      @roles.any? { |e| e.id == role }
+      roles.any?(role)
     end
 
     # @see Member#set_roles
@@ -97,12 +123,30 @@ module Discordrb
       set_roles(role)
     end
 
+    # Check if the current user has communication disabled.
+    # @return [true, false]
+    def communication_disabled?
+      !@communication_disabled_until.nil? && @communication_disabled_until > Time.now
+    end
+
+    alias_method :timeout?, :communication_disabled?
+
+    # Set a user's timeout duration, or remove it by setting the timeout to `nil`.
+    # @param timeout_until [Time, nil] When the timeout will end.
+    def communication_disabled_until=(timeout_until)
+      raise ArgumentError, 'A time out cannot exceed 28 days' if timeout_until && timeout_until > (Time.now + 2_419_200)
+
+      API::Server.update_member(@bot.token, @server_id, @user.id, communication_disabled_until: timeout_until.iso8601)
+    end
+
+    alias_method :timeout=, :communication_disabled_until=
+
     # Bulk sets a member's roles.
     # @param role [Role, Array<Role>] The role(s) to set.
     # @param reason [String] The reason the user's roles are being changed.
     def set_roles(role, reason = nil)
       role_ids = role_id_array(role)
-      API::Server.update_member(@bot.token, @server.id, @user.id, roles: role_ids, reason: reason)
+      API::Server.update_member(@bot.token, @server_id, @user.id, roles: role_ids, reason: reason)
     end
 
     # Adds and removes roles from a member.
@@ -116,10 +160,10 @@ module Discordrb
     def modify_roles(add, remove, reason = nil)
       add_role_ids = role_id_array(add)
       remove_role_ids = role_id_array(remove)
-      old_role_ids = @roles.map(&:id)
+      old_role_ids = resolve_role_ids
       new_role_ids = (old_role_ids - remove_role_ids + add_role_ids).uniq
 
-      API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids, reason: reason)
+      API::Server.update_member(@bot.token, @server_id, @user.id, roles: new_role_ids, reason: reason)
     end
 
     # Adds one or more roles to this member.
@@ -129,11 +173,11 @@ module Discordrb
       role_ids = role_id_array(role)
 
       if role_ids.count == 1
-        API::Server.add_member_role(@bot.token, @server.id, @user.id, role_ids[0], reason)
+        API::Server.add_member_role(@bot.token, @server_id, @user.id, role_ids[0], reason)
       else
-        old_role_ids = @roles.map(&:id)
+        old_role_ids = resolve_role_ids
         new_role_ids = (old_role_ids + role_ids).uniq
-        API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids, reason: reason)
+        API::Server.update_member(@bot.token, @server_id, @user.id, roles: new_role_ids, reason: reason)
       end
     end
 
@@ -144,22 +188,22 @@ module Discordrb
       role_ids = role_id_array(role)
 
       if role_ids.count == 1
-        API::Server.remove_member_role(@bot.token, @server.id, @user.id, role_ids[0], reason)
+        API::Server.remove_member_role(@bot.token, @server_id, @user.id, role_ids[0], reason)
       else
-        old_role_ids = @roles.map(&:id)
+        old_role_ids = resolve_role_ids
         new_role_ids = old_role_ids.reject { |i| role_ids.include?(i) }
-        API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids, reason: reason)
+        API::Server.update_member(@bot.token, @server_id, @user.id, roles: new_role_ids, reason: reason)
       end
     end
 
     # @return [Role] the highest role this member has.
     def highest_role
-      @roles.max_by(&:position)
+      roles.max_by(&:position)
     end
 
     # @return [Role, nil] the role this member is being hoisted with.
     def hoist_role
-      hoisted_roles = @roles.select(&:hoist)
+      hoisted_roles = roles.select(&:hoist)
       return nil if hoisted_roles.empty?
 
       hoisted_roles.max_by(&:position)
@@ -167,7 +211,7 @@ module Discordrb
 
     # @return [Role, nil] the role this member is basing their colour on.
     def colour_role
-      coloured_roles = @roles.select { |v| v.colour.combined.nonzero? }
+      coloured_roles = roles.select { |v| v.colour.combined.nonzero? }
       return nil if coloured_roles.empty?
 
       coloured_roles.max_by(&:position)
@@ -184,22 +228,41 @@ module Discordrb
 
     # Server deafens this member.
     def server_deafen
-      API::Server.update_member(@bot.token, @server.id, @user.id, deaf: true)
+      API::Server.update_member(@bot.token, @server_id, @user.id, deaf: true)
     end
 
     # Server undeafens this member.
     def server_undeafen
-      API::Server.update_member(@bot.token, @server.id, @user.id, deaf: false)
+      API::Server.update_member(@bot.token, @server_id, @user.id, deaf: false)
     end
 
     # Server mutes this member.
     def server_mute
-      API::Server.update_member(@bot.token, @server.id, @user.id, mute: true)
+      API::Server.update_member(@bot.token, @server_id, @user.id, mute: true)
     end
 
     # Server unmutes this member.
     def server_unmute
-      API::Server.update_member(@bot.token, @server.id, @user.id, mute: false)
+      API::Server.update_member(@bot.token, @server_id, @user.id, mute: false)
+    end
+
+    # Bans this member from the server.
+    # @param message_days [Integer] How many days worth of messages sent by the member should be deleted.
+    # @param reason [String] The reason this member is being banned.
+    def ban(message_days = 0, reason: nil)
+      server.ban(@user, message_days, reason: reason)
+    end
+
+    # Unbans this member from the server.
+    # @param reason [String] The reason this member is being unbanned.
+    def unban(reason = nil)
+      server.unban(@user, reason)
+    end
+
+    # Kicks this member from the server.
+    # @param reason [String] The reason this member is being kicked.
+    def kick(reason = nil)
+      server.kick(@user, reason)
     end
 
     # @see Member#set_nick
@@ -218,28 +281,28 @@ module Discordrb
       nick ||= ''
 
       if @user.current_bot?
-        API::User.change_own_nickname(@bot.token, @server.id, nick, reason)
+        API::User.change_own_nickname(@bot.token, @server_id, nick, reason)
       else
-        API::Server.update_member(@bot.token, @server.id, @user.id, nick: nick, reason: nil)
+        API::Server.update_member(@bot.token, @server_id, @user.id, nick: nick, reason: nil)
       end
     end
 
     alias_method :set_nickname, :set_nick
 
-    # @return [String] the name the user displays as (nickname if they have one, username otherwise)
+    # @return [String] the name the user displays as (nickname if they have one, global_name if they have one, username otherwise)
     def display_name
-      nickname || username
+      nickname || global_name || username
     end
 
     # Update this member's roles
     # @note For internal use only.
     # @!visibility private
     def update_roles(role_ids)
-      @roles = [@server.role(@server.id)]
+      @roles = [server.role(@server_id)]
       role_ids.each do |id|
         # It is possible for members to have roles that do not exist
-        # on the server any longer. See https://github.com/shardlab/discordrb/issues/371
-        role = @server.role(id)
+        # on the server any longer. See https://github.com/discordrb/discordrb/issues/371
+        role = server.role(id)
         @roles << role if role
       end
     end
@@ -258,6 +321,12 @@ module Discordrb
       @boosting_since = time
     end
 
+    # @!visibility private
+    def update_communication_disabled_until(time)
+      time = time ? Time.parse(time) : nil
+      @communication_disabled_until = time
+    end
+
     # Update this member
     # @note For internal use only.
     # @!visibility private
@@ -268,13 +337,15 @@ module Discordrb
       @deaf = data['deaf'] if data.key?('deaf')
 
       @joined_at = Time.parse(data['joined_at']) if data['joined_at']
+      timeout_until = data['communication_disabled_until']
+      @communication_disabled_until = timeout_until ? Time.parse(timeout_until) : nil
     end
 
     include PermissionCalculator
 
     # Overwriting inspect for debug purposes
     def inspect
-      "<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}>"
+      "<Member user=#{@user.inspect} server=#{@server&.inspect || @server_id} joined_at=#{@joined_at} roles=#{@roles&.inspect || @role_ids} voice_channel=#{@voice_channel.inspect} mute=#{@mute} deaf=#{@deaf} self_mute=#{@self_mute} self_deaf=#{@self_deaf}>"
     end
 
     private
@@ -290,8 +361,12 @@ module Discordrb
 
     # Utility method to get data out of this member's voice state
     def voice_state_attribute(name)
-      voice_state = @server.voice_states[@user.id]
+      voice_state = server.voice_states[@user.id]
       voice_state&.send name
     end
+
+    def resolve_role_ids
+      @roles ? @roles.collect(&:id) : @role_ids
+    end
   end
 end

data/lib/discordrb/data/message.rb

@@ -61,14 +61,17 @@ module Discordrb
     attr_reader :pinned
     alias_method :pinned?, :pinned
 
+    # @return [Integer] what the type of the message is
+    attr_reader :type
+
     # @return [Server, nil] the server in which this message was sent.
     attr_reader :server
 
     # @return [Integer, nil] the webhook ID that sent this message, or `nil` if it wasn't sent through a webhook.
     attr_reader :webhook_id
 
-    # The discriminator that webhook user accounts have.
-    ZERO_DISCRIM = '0000'
+    # @return [Array<Component>]
+    attr_reader :components
 
     # @!visibility private
     def initialize(data, bot)
@@ -76,6 +79,7 @@ module Discordrb
       @content = data['content']
       @channel = bot.channel(data['channel_id'].to_i)
       @pinned = data['pinned']
+      @type = data['type']
       @tts = data['tts']
       @nonce = data['nonce']
       @mention_everyone = data['mention_everyone']
@@ -85,12 +89,14 @@ module Discordrb
 
       @server = @channel.server
 
+      @webhook_id = data['webhook_id']&.to_i
+
       @author = if data['author']
-                  if data['author']['discriminator'] == ZERO_DISCRIM
+                  if @webhook_id
                     # This is a webhook user! It would be pointless to try to resolve a member here, so we just create
                     # a User and return that instead.
                     Discordrb::LOGGER.debug("Webhook user: #{data['author']['id']}")
-                    User.new(data['author'], @bot)
+                    User.new(data['author'].merge({ '_webhook' => true }), @bot)
                   elsif @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
@@ -100,11 +106,12 @@ module Discordrb
 
                     if member
                       member.update_data(data['member']) if data['member']
+                      member.update_global_name(data['author']['global_name']) if data['author']['global_name']
                     else
                       Discordrb::LOGGER.debug("Member with ID #{data['author']['id']} not cached (possibly left the server).")
                       member = if data['member']
                                  member_data = data['author'].merge(data['member'])
-                                 Member.new(member_data, bot)
+                                 Member.new(member_data, @server, bot)
                                else
                                  @bot.ensure_user(data['author'])
                                end
@@ -114,8 +121,6 @@ module Discordrb
                   end
                 end
 
-      @webhook_id = data['webhook_id'].to_i if data['webhook_id']
-
       @timestamp = Time.parse(data['timestamp']) if data['timestamp']
       @edited_timestamp = data['edited_timestamp'].nil? ? nil : Time.parse(data['edited_timestamp'])
       @edited = !@edited_timestamp.nil?
@@ -149,43 +154,53 @@ module Discordrb
 
       @embeds = []
       @embeds = data['embeds'].map { |e| Embed.new(e, self) } if data['embeds']
+
+      @components = []
+      @components = data['components'].map { |component_data| Components.from_data(component_data, @bot) } if data['components']
     end
 
     # Replies to this message with the specified content.
     # @deprecated Please use {#respond}.
+    # @param content [String] The content to send. Should not be longer than 2000 characters or it will result in an error.
+    # @return (see #respond)
     # @see Channel#send_message
     def reply(content)
       @channel.send_message(content)
     end
 
-    # Sends a message to this channel.
+    # Responds to this message as an inline reply.
     # @param content [String] The content to send. Should not be longer than 2000 characters or it will result in an error.
     # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
     # @param embed [Hash, Discordrb::Webhooks::Embed, nil] The rich embed to append to this message.
     # @param attachments [Array<File>] Files that can be referenced in embeds via `attachment://file.png`
     # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
     # @param mention_user [true, false] Whether the user that is being replied to should be pinged by the reply.
-    # @return [Message] the message that was sent.
-    def reply!(content, tts: false, embed: nil, attachments: nil, allowed_mentions: {}, mention_user: false)
+    # @param components [View, Array<Hash>] Interaction components to associate with this message.
+    # @return (see #respond)
+    def reply!(content, tts: false, embed: nil, attachments: nil, allowed_mentions: {}, mention_user: false, components: nil)
       allowed_mentions = { parse: [] } if allowed_mentions == false
       allowed_mentions = allowed_mentions.to_hash.transform_keys(&:to_sym)
       allowed_mentions[:replied_user] = mention_user
 
-      respond(content, tts, embed, attachments, allowed_mentions, self)
+      respond(content, tts, embed, attachments, allowed_mentions, self, components)
     end
 
     # (see Channel#send_message)
-    def respond(content, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil)
-      @channel.send_message(content, tts, embed, attachments, allowed_mentions, message_reference)
+    def respond(content, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil)
+      @channel.send_message(content, tts, embed, attachments, allowed_mentions, message_reference, components)
     end
 
     # Edits this message to have the specified content instead.
     # You can only edit your own messages.
     # @param new_content [String] the new content the message should have.
-    # @param new_embed [Hash, Discordrb::Webhooks::Embed, nil] The new embed the message should have. If `nil` the message will be changed to have no embed.
+    # @param new_embeds [Hash, Discordrb::Webhooks::Embed, Array<Hash>, Array<Discordrb::Webhooks::Embed>, nil] The new embeds the message should have. If `nil` the message will be changed to have no embeds.
+    # @param new_components [View, Array<Hash>] The new components the message should have. If `nil` the message will be changed to have no components.
     # @return [Message] the resulting message.
-    def edit(new_content, new_embed = nil)
-      response = API::Channel.edit_message(@bot.token, @channel.id, @id, new_content, [], new_embed ? new_embed.to_hash : nil)
+    def edit(new_content, new_embeds = nil, new_components = nil)
+      new_embeds = (new_embeds.instance_of?(Array) ? new_embeds.map(&:to_hash) : [new_embeds&.to_hash]).compact
+      new_components = new_components&.to_a || []
+
+      response = API::Channel.edit_message(@bot.token, @channel.id, @id, new_content, [], new_embeds, new_components)
       Message.new(JSON.parse(response), @bot)
     end
 
@@ -222,6 +237,19 @@ module Discordrb
       @bot.add_await!(Discordrb::Events::MessageEvent, { from: @author.id, in: @channel.id }.merge(attributes), &block)
     end
 
+    # Add an {Await} for a reaction to be added on this message.
+    # @see Bot#add_await
+    # @deprecated Will be changed to blocking behavior in v4.0. Use {#await_reaction!} instead.
+    def await_reaction(key, attributes = {}, &block)
+      @bot.add_await(key, Discordrb::Events::ReactionAddEvent, { message: @id }.merge(attributes), &block)
+    end
+
+    # Add a blocking {Await} for a reaction to be added on this message.
+    # @see Bot#add_await!
+    def await_reaction!(attributes = {}, &block)
+      @bot.add_await!(Discordrb::Events::ReactionAddEvent, { message: @id }.merge(attributes), &block)
+    end
+
     # @return [true, false] whether this message was sent by the current {Bot}.
     def from_bot?
       @author&.current_bot?
@@ -276,14 +304,38 @@ module Discordrb
     # @return [Array<User>] the users who used this reaction
     def reacted_with(reaction, limit: 100)
       reaction = reaction.to_reaction if reaction.respond_to?(:to_reaction)
+      reaction = reaction.to_s if reaction.respond_to?(:to_s)
+
+      get_reactions = proc do |fetch_limit, after_id = nil|
+        resp = API::Channel.get_reactions(@bot.token, @channel.id, @id, reaction, nil, after_id, fetch_limit)
+        return JSON.parse(resp).map { |d| User.new(d, @bot) }
+      end
+
+      # Can be done without pagination
+      return get_reactions.call(limit) if limit && limit <= 100
+
       paginator = Paginator.new(limit, :down) do |last_page|
-        after_id = last_page.last.id if last_page
-        last_page = JSON.parse(API::Channel.get_reactions(@bot.token, @channel.id, @id, reaction, nil, after_id, limit))
-        last_page.map { |d| User.new(d, @bot) }
+        if last_page && last_page.count < 100
+          []
+        else
+          get_reactions.call(100, last_page&.last&.id)
+        end
       end
+
       paginator.to_a
     end
 
+    # Returns a hash of all reactions to a message as keys and the users that reacted to it as values.
+    # @param limit [Integer] the limit of how many users to retrieve per distinct reaction emoji. `nil` will return all users
+    # @example Get all the users that reacted to a message for a giveaway.
+    #   giveaway_participants = message.all_reaction_users
+    # @return [Hash<String => Array<User>>] A hash mapping the string representation of a
+    #   reaction to an array of users.
+    def all_reaction_users(limit: 100)
+      all_reactions = @reactions.map { |r| { r.to_s => reacted_with(r, limit: limit) } }
+      all_reactions.reduce({}, :merge)
+    end
+
     # Deletes a reaction made by a user on this message.
     # @param user [User, String, Integer] the user or user ID who used this reaction
     # @param reaction [String, #to_reaction] the reaction to remove
@@ -322,6 +374,12 @@ module Discordrb
       !@referenced_message.nil?
     end
 
+    # Whether or not this message was of type "CHAT_INPUT_COMMAND"
+    # @return [true, false]
+    def chat_input_command?
+      @type == 20
+    end
+
     # @return [Message, nil] the Message this Message was sent in reply to.
     def referenced_message
       return @referenced_message if @referenced_message
@@ -330,5 +388,27 @@ module Discordrb
       referenced_channel = @bot.channel(@message_reference['channel_id'])
       @referenced_message = referenced_channel.message(@message_reference['message_id'])
     end
+
+    # @return [Array<Components::Button>]
+    def buttons
+      results = @components.collect do |component|
+        case component
+        when Components::Button
+          component
+        when Components::ActionRow
+          component.buttons
+        end
+      end
+
+      results.flatten.compact
+    end
+
+    # to_message -> self or message
+    # @return [Discordrb::Message]
+    def to_message
+      self
+    end
+
+    alias_method :message, :to_message
   end
 end

data/lib/discordrb/data/overwrite.rb

@@ -4,6 +4,12 @@ module Discordrb
   # A permissions overwrite, when applied to channels describes additional
   # permissions a member needs to perform certain actions in context.
   class Overwrite
+    # Types of overwrites mapped to their API value.
+    TYPES = {
+      role: 0,
+      member: 1
+    }.freeze
+
     # @return [Integer] ID of the thing associated with this overwrite type
     attr_accessor :id
 
@@ -32,14 +38,14 @@ module Discordrb
     # @example Create an overwrite by ID and permissions bits
     #   Overwrite.new(120571255635181568, type: 'member', allow: 1024, deny: 0)
     # @param object [Integer, #id] the ID or object this overwrite is for
-    # @param type [String] the type of object this overwrite is for (only required if object is an Integer)
-    # @param allow [Integer, Permissions] allowed permissions for this overwrite, by bits or a Permissions object
-    # @param deny [Integer, Permissions] denied permissions for this overwrite, by bits or a Permissions object
+    # @param type [String, Symbol, Integer] the type of object this overwrite is for (only required if object is an Integer)
+    # @param allow [String, Integer, Permissions] allowed permissions for this overwrite, by bits or a Permissions object
+    # @param deny [String, Integer, Permissions] denied permissions for this overwrite, by bits or a Permissions object
     # @raise [ArgumentError] if type is not :member or :role
     def initialize(object = nil, type: nil, allow: 0, deny: 0)
       if type
-        type = type.to_sym
-        raise ArgumentError, 'Overwrite type must be :member or :role' unless (type != :member) || (type != :role)
+        type = TYPES.value?(type) ? TYPES.key(type) : type.to_sym
+        raise ArgumentError, 'Overwrite type must be :member or :role' unless type
       end
 
       @id = object.respond_to?(:id) ? object.id : object
@@ -71,7 +77,7 @@ module Discordrb
     def self.from_hash(data)
       new(
         data['id'].to_i,
-        type: data['type'],
+        type: TYPES.key(data['type']),
         allow: Permissions.new(data['allow']),
         deny: Permissions.new(data['deny'])
       )
@@ -93,7 +99,7 @@ module Discordrb
     def to_hash
       {
         id: id,
-        type: type,
+        type: TYPES[type],
         allow: allow.bits,
         deny: deny.bits
       }

data/lib/discordrb/data/role.rb

@@ -32,6 +32,42 @@ module Discordrb
     # @return [Integer] the position of this role in the hierarchy
     attr_reader :position
 
+    # @return [String, nil] The icon hash for this role.
+    attr_reader :icon
+
+    # @return [Tags, nil] The role tags
+    attr_reader :tags
+
+    # Wrapper for the role tags
+    class Tags
+      # @return [Integer, nil] The ID of the bot this role belongs to
+      attr_reader :bot_id
+
+      # @return [Integer, nil] The ID of the integration this role belongs to
+      attr_reader :integration_id
+
+      # @return [true, false] Whether this is the guild's Booster role
+      attr_reader :premium_subscriber
+
+      # @return [Integer, nil] The id of this role's subscription sku and listing
+      attr_reader :subscription_listing_id
+
+      # @return [true, false] Whether this role is available for purchase
+      attr_reader :available_for_purchase
+
+      # @return [true, false] Whether this role is a guild's linked role
+      attr_reader :guild_connections
+
+      def initialize(data)
+        @bot_id = data['bot_id']&.resolve_id
+        @integration_id = data['integration_id']&.resolve_id
+        @premium_subscriber = data.key?('premium_subscriber')
+        @subscription_listing_id = data['subscription_listing_id']&.resolve_id
+        @available_for_purchase = data.key?('available_for_purchase')
+        @guild_connections = data.key?('guild_connections')
+      end
+    end
+
     # This class is used internally as a wrapper to a Role object that allows easy writing of permission data.
     class RoleWriter
       # @!visibility private
@@ -67,6 +103,10 @@ module Discordrb
       @managed = data['managed']
 
       @colour = ColourRGB.new(data['color'])
+
+      @icon = data['icon']
+
+      @tags = Tags.new(data['tags']) if data['tags']
     end
 
     # @return [String] a string that will mention this role, if it is mentionable.
@@ -92,6 +132,7 @@ module Discordrb
       @colour = other.colour
       @position = other.position
       @managed = other.managed
+      @icon = other.icon
     end
 
     # Updates the data cache from a hash containing data
@@ -128,6 +169,20 @@ module Discordrb
       update_role_data(colour: colour)
     end
 
+    # Upload a role icon for servers with the ROLE_ICONS feature.
+    # @param file [File]
+    def icon=(file)
+      update_role_data(icon: file)
+    end
+
+    # @param format ['webp', 'png', 'jpeg']
+    # @return [String] URL to the icon on Discord's CDN.
+    def icon_url(format = 'webp')
+      return nil unless @icon
+
+      Discordrb::API.role_icon_url(@id, @icon, format)
+    end
+
     alias_method :color=, :colour=
 
     # Changes this role's permissions to a fixed bitfield. This allows setting multiple permissions at once with just
@@ -184,7 +239,9 @@ module Discordrb
                               (new_data[:colour] || @colour).combined,
                               new_data[:hoist].nil? ? @hoist : new_data[:hoist],
                               new_data[:mentionable].nil? ? @mentionable : new_data[:mentionable],
-                              new_data[:permissions] || @permissions.bits)
+                              new_data[:permissions] || @permissions.bits,
+                              nil,
+                              new_data.key?(:icon) ? new_data[:icon] : :undef)
       update_data(new_data)
     end
   end