discordrb 3.4.3 → 3.6.0

data/lib/discordrb/data/avatar_decoration.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # A decoration displayed on a user's avatar.
+  class AvatarDecoration
+    # @return [Integer] ID of the avatar decoration's SKU.
+    attr_reader :sku_id
+
+    # @return [String] ID that can be used to generate an avatar decoration URL.
+    # @see #url
+    attr_reader :decoration_id
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+      @sku_id = data['sku_id']&.to_i
+      @decoration_id = data['asset']
+    end
+
+    # Utility method to get an avatar decoration URL.
+    # @return [String] the URL to the avatar decoration.
+    def url
+      API.avatar_decoration_url(@decoration_id)
+    end
+  end
+end

data/lib/discordrb/data/call.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # A call in a private channel.
+  class Call
+    # @return [Time, nil] the time at when the call ended.
+    attr_reader :ended_at
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+      @participant_ids = data['participants'] || []
+      @ended_at = Time.iso8601(data['ended_timestamp']) if data['ended_timestamp']
+    end
+
+    # Get the users that participated in this call.
+    # @return [Array<User>] the participants of this call.
+    def participants
+      @participants ||= @participant_ids.map { |participant| @bot.user(participant) }
+    end
+  end
+end

data/lib/discordrb/data/channel.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'discordrb/webhooks/view'
+require 'time'
+
 module Discordrb
   # A Discord channel, including data like the topic
   class Channel
@@ -13,23 +16,28 @@ module Discordrb
       group: 3,
       category: 4,
       news: 5,
-      store: 6
+      store: 6,
+      news_thread: 10,
+      public_thread: 11,
+      private_thread: 12,
+      stage_voice: 13,
+      directory: 14,
+      forum: 15
     }.freeze
 
     # @return [String] this channel's name.
     attr_reader :name
 
-    # @return [Server, nil] the server this channel is on. If this channel is a PM channel, it will be nil.
-    attr_reader :server
-
-    # @return [Integer, nil] the ID of the parent channel, if this channel is inside a category
+    # @return [Integer, nil] the ID of the parent channel, if this channel is inside a category. If this channel is a
+    #   thread, this is the text channel it is a child to.
     attr_reader :parent_id
 
     # @return [Integer] the type of this channel
     # @see TYPES
     attr_reader :type
 
-    # @return [Integer, nil] the ID of the owner of the group channel or nil if this is not a group channel.
+    # @return [Integer, nil] the ID of the owner of the group channel or nil if this is not a group channel. If this
+    #   channel is a thread, this is the member that started the thread.
     attr_reader :owner_id
 
     # @return [Array<Recipient>, nil] the array of recipients of the private messages, or nil if this is not a Private channel
@@ -56,6 +64,40 @@ module Discordrb
     attr_reader :rate_limit_per_user
     alias_method :slowmode_rate, :rate_limit_per_user
 
+    # @return [Integer, nil] An approximate count of messages sent in a thread, excluding deleted messages.
+    attr_reader :message_count
+
+    # @return [Integer, nil] An approximate count of members in a thread. Stops counting at 50.
+    attr_reader :member_count
+
+    # @return [true, false, nil] Whether or not this thread is archived.
+    attr_reader :archived
+    alias_method :archived?, :archived
+
+    # @return [Integer, nil] How long after the last message before a thread is automatically archived.
+    attr_reader :auto_archive_duration
+
+    # @return [Time, nil] The timestamp of when this threads status last changed.
+    attr_reader :archive_timestamp
+
+    # @return [true, false, nil] Whether this thread is locked or not.
+    attr_reader :locked
+    alias_method :locked?, :locked
+
+    # @return [Time, nil] When the current user joined this thread.
+    attr_reader :join_timestamp
+
+    # @return [Integer, nil] Member flags for this thread, used for notifications.
+    attr_reader :member_flags
+
+    # @return [true, false, nil] For private threads, determines whether non-moderators can add other non-moderators to
+    #   a thread.
+    attr_reader :invitable
+    alias_method :invitable?, :invitable
+
+    # @return [Time, nil] The time at when the last pinned message was pinned in this channel.
+    attr_reader :last_pin_timestamp
+
     # @return [true, false] whether or not this channel is a PM or group channel.
     def private?
       pm? || group?
@@ -99,15 +141,45 @@ module Discordrb
         end
       else
         @name = data['name']
-        @server = server || bot.server(data['guild_id'].to_i)
+        @server_id = server&.id || data['guild_id'].to_i
+        @server = server
       end
 
       @nsfw = data['nsfw'] || false
       @rate_limit_per_user = data['rate_limit_per_user'] || 0
+      @message_count = data['message_count']
+      @member_count = data['member_count']
+
+      if (metadata = data['thread_metadata'])
+        @archived = metadata['archived']
+        @auto_archive_duration = metadata['auto_archive_duration']
+        @archive_timestamp = Time.iso8601(metadata['archive_timestamp'])
+        @locked = metadata['locked']
+        @invitable = metadata['invitable']
+      end
 
+      if (member = data['member'])
+        @member_join = Time.iso8601(member['join_timestamp'])
+        @member_flags = member['flags']
+      end
+
+      process_last_pin_timestamp(data['last_pin_timestamp'])
       process_permission_overwrites(data['permission_overwrites'])
     end
 
+    # @return [Server, nil] the server this channel is on. If this channel is a PM channel, it will be nil.
+    # @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
+      return nil if private?
+
+      @server = @bot.server(@server_id)
+      raise Discordrb::Errors::NoPermission, 'The bot does not have access to this server' unless @server
+
+      @server
+    end
+
     # @return [true, false] whether or not this channel is a text channel
     def text?
       @type.zero?
@@ -143,6 +215,26 @@ module Discordrb
       @type == 6
     end
 
+    # @return [true, false] whether or not this channel is a news thread.
+    def news_thread?
+      @type == 10
+    end
+
+    # @return [true, false] whether or not this channel is a public thread.
+    def public_thread?
+      @type == 11
+    end
+
+    # @return [true, false] whether or not this channel is a private thread.
+    def private_thread?
+      @type == 12
+    end
+
+    # @return [true, false] whether or not this channel is a thread.
+    def thread?
+      news_thread? || public_thread? || private_thread?
+    end
+
     # @return [Channel, nil] the category channel, if this channel is in a category
     def category
       @bot.channel(@parent_id) if @parent_id
@@ -199,7 +291,7 @@ module Discordrb
       ids = if parent
               parent.children
             else
-              @server.channels.reject(&:parent_id).select { |c| c.type == @type }
+              server.channels.reject(&:parent_id).select { |c| c.type == @type }
             end.sort_by(&:position).map(&:id)
 
       # Move our channel ID after the target ID by deleting it,
@@ -225,7 +317,7 @@ module Discordrb
         move_argument << hash
       end
 
-      API::Server.update_channel_positions(@bot.token, @server.id, move_argument)
+      API::Server.update_channel_positions(@bot.token, @server_id, move_argument)
     end
 
     # Sets whether this channel is NSFW
@@ -262,9 +354,9 @@ module Discordrb
 
     # Sets the amount of time (in seconds) users have to wait in between sending messages.
     # @param rate [Integer]
-    # @raise [ArgumentError] if value isn't between 0 and 120
+    # @raise [ArgumentError] if value isn't between 0 and 21600
     def rate_limit_per_user=(rate)
-      raise ArgumentError, 'rate_limit_per_user must be between 0 and 120' unless rate.between?(0, 120)
+      raise ArgumentError, 'rate_limit_per_user must be between 0 and 21600' unless rate.between?(0, 21_600)
 
       update_channel_data(rate_limit_per_user: rate)
     end
@@ -341,9 +433,11 @@ module Discordrb
     # @param attachments [Array<File>] Files that can be referenced in embeds via `attachment://file.png`
     # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
     # @param message_reference [Message, String, Integer, nil] The message, or message ID, to reply to if any.
+    # @param components [View, Array<Hash>] Interaction components to associate with this message.
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2) and SUPPRESS_NOTIFICATIONS (1 << 12) can be set.
     # @return [Message] the message that was sent.
-    def send_message(content, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil)
-      @bot.send_message(@id, content, tts, embed, attachments, allowed_mentions, message_reference)
+    def send_message(content, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0)
+      @bot.send_message(@id, content, tts, embed, attachments, allowed_mentions, message_reference, components, flags)
     end
 
     alias_method :send, :send_message
@@ -356,8 +450,10 @@ module Discordrb
     # @param attachments [Array<File>] Files that can be referenced in embeds via `attachment://file.png`
     # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
     # @param message_reference [Message, String, Integer, nil] The message, or message ID, to reply to if any.
-    def send_temporary_message(content, timeout, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil)
-      @bot.send_temporary_message(@id, content, timeout, tts, embed, attachments, allowed_mentions, message_reference)
+    # @param components [View, Array<Hash>] Interaction components to associate with this message.
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2) and SUPPRESS_NOTIFICATIONS (1 << 12) can be set.
+    def send_temporary_message(content, timeout, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0)
+      @bot.send_temporary_message(@id, content, timeout, tts, embed, attachments, allowed_mentions, message_reference, components, flags)
     end
 
     # Convenience method to send a message with an embed.
@@ -372,19 +468,69 @@ module Discordrb
     # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
     # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
     # @param message_reference [Message, String, Integer, nil] The message, or message ID, to reply to if any.
+    # @param components [View, Array<Hash>] Interaction components to associate with this message.
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2) and SUPPRESS_NOTIFICATIONS (1 << 12) can be set.
     # @yield [embed] Yields the embed to allow for easy building inside a block.
     # @yieldparam embed [Discordrb::Webhooks::Embed] The embed from the parameters, or a new one.
     # @return [Message] The resulting message.
-    def send_embed(message = '', embed = nil, attachments = nil, tts = false, allowed_mentions = nil, message_reference = nil)
+    def send_embed(message = '', embed = nil, attachments = nil, tts = false, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0)
       embed ||= Discordrb::Webhooks::Embed.new
-      yield(embed) if block_given?
-      send_message(message, tts, embed, attachments, allowed_mentions, message_reference)
+      view = Discordrb::Webhooks::View.new
+
+      yield(embed, view) if block_given?
+
+      send_message(message, tts, embed, attachments, allowed_mentions, message_reference, components || view.to_a, flags)
+    end
+
+    # Send a message to this channel.
+    # @example This sends a silent message with an embed.
+    #   channel.send_message!(content: 'Hi <@171764626755813376>', flags: :suppress_notifications) do |builder|
+    #     builder.add_embed do |embed|
+    #       embed.title = 'The Ruby logo'
+    #       embed.image = Discordrb::Webhooks::EmbedImage.new(url: 'https://www.ruby-lang.org/images/header-ruby-logo.png')
+    #     end
+    #   end
+    # @param content [String] The content of the message. Should not be longer than 2000 characters or it will result in an error.
+    # @param timeout [Float, nil] The amount of time in seconds after which the message sent will be deleted, or `nil` if the message should not be deleted.
+    # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
+    # @param embeds [Array<Hash, Webhooks::Embed>] The embeds that should be attached to the message.
+    # @param attachments [Array<File>] Files that can be referenced in embeds and components via `attachment://file.png`.
+    # @param allowed_mentions [Hash, Discordrb::AllowedMentions, nil] Mentions that are allowed to ping on this message.
+    # @param reference [Message, String, Integer, Hash, nil] The optional message, or message ID, to reply to or forward.
+    # @param components [View, Array<#to_h>] Interaction components to associate with this message.
+    # @param flags [Integer, Symbol, Array<Symbol, Integer>] Flags for this message. Currently only `:suppress_embeds` (1 << 2), `:suppress_notifications` (1 << 12), and `:uikit_components` (1 << 15) can be set.
+    # @param has_components [true, false] Whether this message includes any V2 components. Enabling this disables sending content and embeds.
+    # @param nonce [nil, String, Integer, false] The 25 character nonce that should be used when sending this message.
+    # @param enforce_nonce [true, false] Whether the provided nonce should be enforced and used for message de-duplication.
+    # @yieldparam builder [Webhooks::Builder] An optional message builder. Arguments passed to the builder overwrite method data.
+    # @yieldparam view [Webhooks::View] An optional component builder. Arguments passed to the builder overwrite method data.
+    # @return [Message, nil] The resulting message that was created, or `nil` if the `timeout` parameter was set to a non `nil` value.
+    def send_message!(content: '', timeout: nil, tts: false, embeds: [], attachments: nil, allowed_mentions: nil, reference: nil, components: nil, flags: 0, has_components: false, nonce: nil, enforce_nonce: false)
+      builder = Discordrb::Webhooks::Builder.new
+      view = Discordrb::Webhooks::View.new
+
+      builder.tts = tts
+      builder.content = content
+      embeds&.each { |embed| builder << embed }
+      builder.allowed_mentions = allowed_mentions
+
+      yield(builder, view) if block_given?
+
+      flags = Array(flags).map { |flag| Discordrb::Message::FLAGS[flag] || flag }.reduce(&:|)
+      flags |= (1 << 15) if has_components
+      builder = builder.to_json_hash
+
+      if timeout
+        @bot.send_temporary_message(@id, builder[:content], timeout, builder[:tts], builder[:embeds], attachments, builder[:allowed_mentions], reference, components&.to_a || view.to_a, flags, nonce, enforce_nonce)
+      else
+        @bot.send_message(@id, builder[:content], builder[:tts], builder[:embeds], attachments, builder[:allowed_mentions], reference, components&.to_a || view.to_a, flags, nonce, enforce_nonce)
+      end
     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) }
+      content.each { |text| send_message!(content: text) }
     end
 
     # Splits a message into chunks whose length is at most the Discord character limit, then sends them individually.
@@ -502,6 +648,7 @@ module Discordrb
     # @!visibility private
     def update_from(other)
       @name = other.name
+      @type = other.type
       @position = other.position
       @topic = other.topic
       @recipients = other.recipients
@@ -511,6 +658,13 @@ module Discordrb
       @nsfw = other.nsfw
       @parent_id = other.parent_id
       @rate_limit_per_user = other.rate_limit_per_user
+      @archived = other.archived?
+      @auto_archive_duration = other.auto_archive_duration
+      @archive_timestamp = other.archive_timestamp
+      @locked = other.locked?
+      @invitable = other.invitable?
+      @message_count = other.message_count
+      @last_pin_timestamp = other.last_pin_timestamp
     end
 
     # The list of users currently in this channel. For a voice channel, it will return all the members currently
@@ -518,9 +672,9 @@ module Discordrb
     # @return [Array<Member>] the users in this channel
     def users
       if text?
-        @server.online_members(include_idle: true).select { |u| u.can_read_messages? self }
+        server.online_members(include_idle: true).select { |u| u.can_read_messages? self }
       elsif voice?
-        @server.voice_states.map { |id, voice_state| @server.member(id) if !voice_state.voice_channel.nil? && voice_state.voice_channel.id == @id }.compact
+        server.voice_states.filter_map { |id, voice_state| server.member(id) if !voice_state.voice_channel.nil? && voice_state.voice_channel.id == @id }
       end
     end
 
@@ -554,19 +708,37 @@ module Discordrb
     # @param message_id [Integer] The ID of the message to retrieve.
     # @return [Message, nil] the retrieved message, or `nil` if it couldn't be found.
     def load_message(message_id)
+      raise ArgumentError, 'message_id cannot be nil' if message_id.nil?
+
       response = API::Channel.message(@bot.token, @id, message_id)
       Message.new(JSON.parse(response), @bot)
-    rescue RestClient::ResourceNotFound
+    rescue Discordrb::Errors::UnknownMessage
       nil
     end
 
     alias_method :message, :load_message
 
-    # Requests all pinned messages in a channel.
-    # @return [Array<Message>] the received messages.
-    def pins
-      msgs = API::Channel.pinned_messages(@bot.token, @id)
-      JSON.parse(msgs).map { |msg| Message.new(msg, @bot) }
+    # Requests the pinned messages in a channel.
+    # @param limit [Integer, nil] the limit of how many pinned messages to retrieve. `nil` will return all the pinned messages.
+    # @return [Array<Message>] the messages pinned in the channel.
+    def pins(limit: 50)
+      get_pins = proc do |fetch_limit, before = nil|
+        resp = API::Channel.pinned_messages(@bot.token, @id, fetch_limit, before&.iso8601)
+        JSON.parse(resp)['items'].map { |pin| Message.new(pin['message'].merge({ 'pinned_at' => pin['pinned_at'] }), @bot) }
+      end
+
+      # Can be done without pagination.
+      return get_pins.call(limit) if limit && limit <= 50
+
+      paginator = Paginator.new(limit, :down) do |last_page|
+        if last_page && last_page.count < 50
+          []
+        else
+          get_pins.call(50, last_page&.last&.pinned_at)
+        end
+      end
+
+      paginator.to_a
     end
 
     # Delete the last N messages on this channel.
@@ -742,9 +914,96 @@ module Discordrb
       invites.map { |invite_data| Invite.new(invite_data, @bot) }
     end
 
+    # Start a thread.
+    # @param name [String] The name of the thread.
+    # @param auto_archive_duration [60, 1440, 4320, 10080] How long before a thread is automatically
+    #   archived.
+    # @param message [Message, Integer, String] The message to reference when starting this thread.
+    # @param type [Symbol, Integer] The type of thread to create. Can be a key from {TYPES} or the value.
+    # @return [Channel]
+    def start_thread(name, auto_archive_duration, message: nil, type: 11)
+      message_id = message&.id || message
+      type = TYPES[type] || type
+
+      data = if message
+               API::Channel.start_thread_with_message(@bot.token, @id, message_id, name, auto_archive_duration)
+             else
+               API::Channel.start_thread_without_message(@bot.token, @id, name, auto_archive_duration, type)
+             end
+
+      Channel.new(JSON.parse(data), @bot, @server)
+    end
+
+    # Start a thread in a forum or media channel.
+    # @param name [String] The name of the forum post to create.
+    # @param auto_archive_duration [Integer, nil] How long before the post is automatically archived.
+    # @param rate_limit_per_user [Integer, nil] The slowmode rate of the forum post to create.
+    # @param tags [Array<#resolve_id>, nil] The tags of the forum channel to apply onto the forum post.
+    # @param content [String, nil] The content of the forum post's starter message.
+    # @param embeds [Array<Hash, Webhooks::Embed>, nil] The embeds that should be attached to the forum post's starter message.
+    # @param allowed_mentions [Hash, Discordrb::AllowedMentions, nil] Mentions that are allowed to ping on this forum post's starter message.
+    # @param components [Webhooks::View, Array<#to_h>, nil] The interaction components to associate with this forum post's starter message.
+    # @param stickers [Array<#resolve_id>, nil] The stickers to include in the forum post's starter message.
+    # @param attachments [Array<File>, nil] Files that can be referenced in embeds and components via `attachment://file.png`.
+    # @param flags [Integer, Symbol, Array<Symbol, Integer>, nil] The flags to set on the forum post's starter message. Currently only `:suppress_embeds` (1 << 2), `:suppress_notifications` (1 << 12), and `:uikit_components` (1 << 15) can be set.
+    # @param has_components [true, false] Whether the starter message for this forum post includes any V2 components. Enabling this disables sending content and embeds.
+    # @param reason [String, nil] The reason for creating this forum post.
+    # @yieldparam builder [Webhooks::Builder] An optional message builder. Arguments passed to the builder overwrite method data.
+    # @yieldparam view [Webhooks::View] An optional component builder. Arguments passed to the builder overwrite method data.
+    # @return [Message] the starter message of the forum post. The forum post that was created can be accessed via {Message#thread}.
+    def start_forum_thread(name:, auto_archive_duration: nil, rate_limit_per_user: nil, tags: nil, content: nil, embeds: nil, allowed_mentions: nil, components: nil, stickers: nil, attachments: nil, flags: nil, has_components: false, reason: nil)
+      builder = Discordrb::Webhooks::Builder.new
+      view = Discordrb::Webhooks::View.new
+
+      builder.content = content
+      embeds&.each { |embed| builder << embed }
+      builder.allowed_mentions = allowed_mentions
+
+      yield(builder, view) if block_given?
+
+      flags = Array(flags).map { |flag| Discordrb::Message::FLAGS[flag] || flag }.reduce(&:|)
+      flags |= (1 << 15) if has_components
+      builder = builder.to_json_hash
+
+      message = { content: builder[:content], embeds: builder[:embeds], allowed_mentions: builder[:allowed_mentions], components: components&.to_a || view.to_a, sticker_ids: stickers&.map(&:resolve_id), flags: flags }
+      response = JSON.parse(API::Channel.start_thread_in_forum_or_media_channel(@bot.token, @id, name, message.compact, attachments, rate_limit_per_user, auto_archive_duration, tags&.map(&:resolve_id), reason))
+
+      Message.new(response['message'].merge!('channel_id' => response['id'], 'thread' => response), @bot)
+    end
+
+    # @!group Threads
+
+    # Join this thread.
+    def join_thread
+      @bot.join_thread(@id)
+    end
+
+    # Leave this thread
+    def leave_thread
+      @bot.leave_thread(@id)
+    end
+
+    # Members in the thread.
+    def members
+      @bot.thread_members[@id].collect { |id| @server_id ? @bot.member(@server_id, id) : @bot.user(id) }
+    end
+
+    # Add a member to the thread
+    # @param member [Member, Integer, String] The member, or ID of the member, to add to this thread.
+    def add_member(member)
+      @bot.add_thread_member(@id, member)
+    end
+
+    # @param member [Member, Integer, String] The member, or ID of the member, to remove from a thread.
+    def remove_member(member)
+      @bot.remove_thread_member(@id, member)
+    end
+
+    # @!endgroup
+
     # The default `inspect` method is overwritten to give more useful output.
     def inspect
-      "<Channel name=#{@name} id=#{@id} topic=\"#{@topic}\" type=#{@type} position=#{@position} server=#{@server}>"
+      "<Channel name=#{@name} id=#{@id} topic=\"#{@topic}\" type=#{@type} position=#{@position} server=#{@server || @server_id}>"
     end
 
     # Adds a recipient to a group channel.
@@ -771,6 +1030,14 @@ module Discordrb
       @recipients.delete(recipient)
     end
 
+    # Set the last pin timestamp of a channel.
+    # @param time [String, nil] the time of the last pinned message in the channel
+    # @note For internal use only
+    # @!visibility private
+    def process_last_pin_timestamp(time)
+      @last_pin_timestamp = time ? Time.parse(time) : time
+    end
+
     # Updates the cached data with new data
     # @note For internal use only
     # @!visibility private
@@ -790,15 +1057,17 @@ module Discordrb
 
     # @return [String] a URL that a user can use to navigate to this channel in the client
     def link
-      "https://discord.com/channels/#{@server&.id || '@me'}/#{@channel.id}"
+      "https://discord.com/channels/#{@server_id || '@me'}/#{@channel.id}"
     end
 
     alias_method :jump_link, :link
 
     private
 
+    # rubocop:disable Lint/UselessConstantScoping
     # For bulk_delete checking
     TWO_WEEKS = 86_400 * 14
+    # rubocop:enable Lint/UselessConstantScoping
 
     # Deletes a list of messages on this channel using bulk delete.
     def bulk_delete(ids, strict = false, reason = nil)
@@ -821,7 +1090,7 @@ module Discordrb
     def update_channel_data(new_data)
       new_nsfw = new_data[:nsfw].is_a?(TrueClass) || new_data[:nsfw].is_a?(FalseClass) ? new_data[:nsfw] : @nsfw
       # send permission_overwrite only when explicitly set
-      overwrites = new_data[:permission_overwrites] ? new_data[:permission_overwrites].map { |_, v| v.to_hash } : nil
+      overwrites = new_data[:permission_overwrites] ? new_data[:permission_overwrites].map(&:to_hash) : nil
       response = JSON.parse(API::Channel.update(@bot.token, @id,
                                                 new_data[:name] || @name,
                                                 new_data[:topic] || @topic,

data/lib/discordrb/data/collectibles.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # Collectibles are resources such as nameplates that can be collected by users.
+  class Collectibles
+    # @return [Nameplate, nil] the nameplate the user has collected or nil.
+    attr_reader :nameplate
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+      @nameplate = Nameplate.new(data['nameplate'], bot) if data['nameplate']
+    end
+
+    # Collectable background images shown on a user's name in the member's tab.
+    class Nameplate
+      # @return [Integer] ID of the nameplate's SKU.
+      attr_reader :sku_id
+
+      # @return [String] the path to the nameplate asset.
+      attr_reader :asset
+
+      # @return [String] the label of the nameplate.
+      attr_reader :label
+
+      # @return [Symbol] the background color of the nameplate.
+      attr_reader :palette
+
+      # @!visibility private
+      def initialize(data, bot)
+        @bot = bot
+        @sku_id = data['sku_id']&.to_i
+        @asset = data['asset']
+        @label = data['label']
+        @palette = data['palette'].to_sym
+      end
+
+      # Utility method to get the URL of this nameplate.
+      # @return [String] CDN url of this nameplate.
+      def url
+        API.nameplate_url(@asset)
+      end
+    end
+  end
+end