discordrb 3.4.3 → 3.5.0

data/lib/discordrb/data/server.rb

@@ -66,28 +66,15 @@ module Discordrb
       @bot = bot
       @owner_id = data['owner_id'].to_i
       @id = data['id'].to_i
-
-      process_channels(data['channels'])
-      update_data(data)
-
-      @large = data['large']
-      @member_count = data['member_count']
-      @splash_id = nil
-      @banner_id = nil
-      @features = data['features'].map { |element| element.downcase.to_sym }
       @members = {}
       @voice_states = {}
       @emoji = {}
 
-      process_roles(data['roles'])
-      process_emoji(data['emojis'])
-      process_members(data['members'])
-      process_presences(data['presences'])
-      process_voice_states(data['voice_states'])
+      process_channels(data['channels'])
+      update_data(data)
 
       # Whether this server's members have been chunked (resolved using op 8 and GUILD_MEMBERS_CHUNK) yet
       @chunked = false
-      @processed_chunk_members = 0
 
       @booster_count = data['premium_subscription_count'] || 0
       @boost_level = data['premium_tier']
@@ -143,10 +130,15 @@ module Discordrb
     end
 
     # @return [Array<Member>] an array of all the members on this server.
+    # @raise [RuntimeError] if the bot was not started with the :server_member intent
     def members
       return @members.values if @chunked
 
       @bot.debug("Members for server #{@id} not chunked yet - initiating")
+
+      # If the SERVER_MEMBERS intent flag isn't set, the gateway won't respond when we ask for members.
+      raise 'The :server_members intent is required to get server members' if (@bot.gateway.intents & INTENTS[:server_members]).zero?
+
       @bot.request_chunks(@id)
       sleep 0.05 until @chunked
       @members.values
@@ -189,78 +181,73 @@ module Discordrb
       AuditLogs.new(self, @bot, JSON.parse(API::Server.audit_logs(@bot.token, @id, limit, user, action, before)))
     end
 
-    # Cache @embed
+    # Cache @widget
     # @note For internal use only
     # @!visibility private
-    def cache_embed_data
-      data = JSON.parse(API::Server.embed(@bot.token, @id))
-      @embed_enabled = data['enabled']
-      @embed_channel_id = data['channel_id']
+    def cache_widget_data
+      data = JSON.parse(API::Server.widget(@bot.token, @id))
+      @widget_enabled = data['enabled']
+      @widget_channel_id = data['channel_id']
     end
 
     # @return [true, false] whether or not the server has widget enabled
-    def embed_enabled?
-      cache_embed_data if @embed_enabled.nil?
-      @embed_enabled
+    def widget_enabled?
+      cache_widget_data if @widget_enabled.nil?
+      @widget_enabled
     end
-    alias_method :widget_enabled, :embed_enabled?
-    alias_method :widget?, :embed_enabled?
-    alias_method :embed?, :embed_enabled?
+    alias_method :widget?, :widget_enabled?
+    alias_method :embed_enabled, :widget_enabled?
+    alias_method :embed?, :widget_enabled?
 
-    # @return [Channel, nil] the channel the server embed will make an invite for.
-    def embed_channel
-      cache_embed_data if @embed_enabled.nil?
-      @bot.channel(@embed_channel_id) if @embed_channel_id
+    # @return [Channel, nil] the channel the server widget will make an invite for.
+    def widget_channel
+      cache_widget_data if @widget_enabled.nil?
+      @bot.channel(@widget_channel_id) if @widget_channel_id
     end
-    alias_method :widget_channel, :embed_channel
+    alias_method :embed_channel, :widget_channel
 
-    # Sets whether this server's embed (widget) is enabled
+    # Sets whether this server's widget is enabled
     # @param value [true, false]
-    def embed_enabled=(value)
-      modify_embed(value, embed_channel)
+    def widget_enabled=(value)
+      modify_widget(value, widget_channel)
     end
+    alias_method :embed_enabled=, :widget_enabled=
 
-    alias_method :widget_enabled=, :embed_enabled=
-
-    # Sets whether this server's embed (widget) is enabled
+    # Sets whether this server's widget is enabled
     # @param value [true, false]
     # @param reason [String, nil] the reason to be shown in the audit log for this action
-    def set_embed_enabled(value, reason = nil)
-      modify_embed(value, embed_channel, reason)
+    def set_widget_enabled(value, reason = nil)
+      modify_widget(value, widget_channel, reason)
     end
+    alias_method :set_embed_enabled, :set_widget_enabled
 
-    alias_method :set_widget_enabled, :set_embed_enabled
-
-    # Changes the channel on the server's embed (widget)
-    # @param channel [Channel, String, Integer] the channel, or its ID, to be referenced by the embed
-    def embed_channel=(channel)
-      modify_embed(embed?, channel)
+    # Changes the channel on the server's widget
+    # @param channel [Channel, String, Integer] the channel, or its ID, to be referenced by the widget
+    def widget_channel=(channel)
+      modify_widget(widget?, channel)
     end
+    alias_method :embed_channel=, :widget_channel=
 
-    alias_method :widget_channel=, :embed_channel=
-
-    # Changes the channel on the server's embed (widget)
-    # @param channel [Channel, String, Integer] the channel, or its ID, to be referenced by the embed
+    # Changes the channel on the server's widget
+    # @param channel [Channel, String, Integer] the channel, or its ID, to be referenced by the widget
     # @param reason [String, nil] the reason to be shown in the audit log for this action
-    def set_embed_channel(channel, reason = nil)
-      modify_embed(embed?, channel, reason)
+    def set_widget_channel(channel, reason = nil)
+      modify_widget(widget?, channel, reason)
     end
+    alias_method :set_embed_channel, :set_widget_channel
 
-    alias_method :set_widget_channel, :set_embed_channel
-
-    # Changes the channel on the server's embed (widget), and sets whether it is enabled.
-    # @param enabled [true, false] whether the embed (widget) is enabled
-    # @param channel [Channel, String, Integer] the channel, or its ID, to be referenced by the embed
+    # Changes the channel on the server's widget, and sets whether it is enabled.
+    # @param enabled [true, false] whether the widget is enabled
+    # @param channel [Channel, String, Integer] the channel, or its ID, to be referenced by the widget
     # @param reason [String, nil] the reason to be shown in the audit log for this action
-    def modify_embed(enabled, channel, reason = nil)
-      cache_embed_data if @embed_enabled.nil?
-      channel_id = channel ? channel.resolve_id : @embed_channel_id
-      response = JSON.parse(API::Server.modify_embed(@bot.token, @id, enabled, channel_id, reason))
-      @embed_enabled = response['enabled']
-      @embed_channel_id = response['channel_id']
+    def modify_widget(enabled, channel, reason = nil)
+      cache_widget_data if @widget_enabled.nil?
+      channel_id = channel ? channel.resolve_id : @widget_channel_id
+      response = JSON.parse(API::Server.modify_widget(@bot.token, @id, enabled, channel_id, reason))
+      @widget_enabled = response['enabled']
+      @widget_channel_id = response['channel_id']
     end
-
-    alias_method :modify_widget, :modify_embed
+    alias_method :modify_embed, :modify_widget
 
     # @param include_idle [true, false] Whether to count idle members as online.
     # @param include_bots [true, false] Whether to include bot accounts in the count.
@@ -444,7 +431,7 @@ module Discordrb
     # @!visibility private
     def delete_member(user_id)
       @members.delete(user_id)
-      @member_count -= 1
+      @member_count -= 1 unless @member_count <= 0
     end
 
     # Checks whether a member is cached
@@ -586,7 +573,7 @@ module Discordrb
     # The amount of emoji the server can have, based on its current Nitro Boost Level.
     # @return [Integer] the max amount of emoji
     def max_emoji
-      case @level
+      case @boost_level
       when 1
         100
       when 2
@@ -598,9 +585,13 @@ module Discordrb
       end
     end
 
+    # Retrieve banned users from this server.
+    # @param limit [Integer] Number of users to return (up to maximum 1000, default 1000).
+    # @param before_id [Integer] Consider only users before given user id.
+    # @param after_id [Integer] Consider only users after given user id.
     # @return [Array<ServerBan>] a list of banned users on this server and the reason they were banned.
-    def bans
-      response = JSON.parse(API::Server.bans(@bot.token, @id))
+    def bans(limit: nil, before_id: nil, after_id: nil)
+      response = JSON.parse(API::Server.bans(@bot.token, @id, limit, before_id, after_id))
       response.map do |e|
         ServerBan.new(self, User.new(e['user'], @bot), e['reason'])
       end
@@ -628,11 +619,12 @@ module Discordrb
       API::Server.remove_member(@bot.token, @id, user.resolve_id, reason)
     end
 
-    # Forcibly moves a user into a different voice channel. Only works if the bot has the permission needed.
+    # Forcibly moves a user into a different voice channel.
+    # Only works if the bot has the permission needed and if the user is already connected to some voice channel on this server.
     # @param user [User, String, Integer] The user to move.
-    # @param channel [Channel, String, Integer] The voice channel to move into.
+    # @param channel [Channel, String, Integer, nil] The voice channel to move into. (If nil, the user is disconnected from the voice channel)
     def move(user, channel)
-      API::Server.update_member(@bot.token, @id, user.resolve_id, channel_id: channel.resolve_id)
+      API::Server.update_member(@bot.token, @id, user.resolve_id, channel_id: channel&.resolve_id)
     end
 
     # Deletes this server. Be aware that this is permanent and impossible to undo, so be careful!
@@ -805,19 +797,16 @@ module Discordrb
     # Processes a GUILD_MEMBERS_CHUNK packet, specifically the members field
     # @note For internal use only
     # @!visibility private
-    def process_chunk(members)
+    def process_chunk(members, chunk_index, chunk_count)
       process_members(members)
-      @processed_chunk_members += members.length
-      LOGGER.debug("Processed one chunk on server #{@id} - length #{members.length}")
+      LOGGER.debug("Processed chunk #{chunk_index + 1}/#{chunk_count} server #{@id} - index #{chunk_index} - 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
+      return if chunk_index + 1 < chunk_count
 
       LOGGER.debug("Finished chunking server #{@id}")
 
       # Reset everything to normal
       @chunked = true
-      @processed_chunk_members = 0
     end
 
     # @return [Channel, nil] the AFK voice channel of this server, or `nil` if none is set.
@@ -842,17 +831,30 @@ module Discordrb
 
       afk_channel_id = new_data[:afk_channel_id] || new_data['afk_channel_id'] || @afk_channel
       @afk_channel_id = afk_channel_id.nil? ? nil : afk_channel_id.resolve_id
-      embed_channel_id = new_data[:embed_channel_id] || new_data['embed_channel_id'] || @embed_channel
-      @embed_channel_id = embed_channel_id.nil? ? nil : embed_channel_id.resolve_id
+      widget_channel_id = new_data[:widget_channel_id] || new_data['widget_channel_id'] || @widget_channel
+      @widget_channel_id = widget_channel_id.nil? ? nil : widget_channel_id.resolve_id
       system_channel_id = new_data[:system_channel_id] || new_data['system_channel_id'] || @system_channel
       @system_channel_id = system_channel_id.nil? ? nil : system_channel_id.resolve_id
 
-      @embed_enabled = new_data[:embed_enabled] || new_data['embed_enabled']
+      @widget_enabled = new_data[:widget_enabled] || new_data['widget_enabled']
       @splash = new_data[:splash_id] || new_data['splash_id'] || @splash_id
 
       @verification_level = new_data[:verification_level] || new_data['verification_level'] || @verification_level
       @explicit_content_filter = new_data[:explicit_content_filter] || new_data['explicit_content_filter'] || @explicit_content_filter
       @default_message_notifications = new_data[:default_message_notifications] || new_data['default_message_notifications'] || @default_message_notifications
+
+      @large = new_data.key?('large') ? new_data['large'] : @large
+      @member_count = new_data['member_count'] || @member_count || 0
+      @splash_id = new_data['splash'] || @splash_id
+      @banner_id = new_data['banner'] || @banner_id
+      @features = new_data['features'] ? new_data['features'].map { |element| element.downcase.to_sym } : @features || []
+
+      process_channels(new_data['channels']) if new_data['channels']
+      process_roles(new_data['roles']) if new_data['roles']
+      process_emoji(new_data['emojis']) if new_data['emojis']
+      process_members(new_data['members']) if new_data['members']
+      process_presences(new_data['presences']) if new_data['presences']
+      process_voice_states(new_data['voice_states']) if new_data['voice_states']
     end
 
     # Adds a channel to this server's cache

data/lib/discordrb/data/user.rb

@@ -3,10 +3,33 @@
 module Discordrb
   # Mixin for the attributes users should have
   module UserAttributes
+    # rubocop:disable Naming/VariableNumber
+    FLAGS = {
+      staff: 1 << 0,
+      partner: 1 << 1,
+      hypesquad: 1 << 2,
+      bug_hunter_level_1: 1 << 3,
+      hypesquad_online_house_1: 1 << 6,
+      hypesquad_online_house_2: 1 << 7,
+      hypesquad_online_house_3: 1 << 8,
+      premium_early_supporter: 1 << 9,
+      team_pseudo_user: 1 << 10,
+      bug_hunter_level_2: 1 << 14,
+      verified_bot: 1 << 16,
+      verified_developer: 1 << 17,
+      certified_moderator: 1 << 18,
+      bot_http_interactions: 1 << 19,
+      active_developer: 1 << 22
+    }.freeze
+    # rubocop:enable Naming/VariableNumber
+
     # @return [String] this user's username
     attr_reader :username
     alias_method :name, :username
 
+    # @return [String, nil] this user's global name
+    attr_reader :global_name
+
     # @return [String] this user's discriminator which is used internally to identify users with identical usernames.
     attr_reader :discriminator
     alias_method :discrim, :discriminator
@@ -17,10 +40,21 @@ module Discordrb
     attr_reader :bot_account
     alias_method :bot_account?, :bot_account
 
+    # @return [true, false] whether this is fake user for a webhook message
+    attr_reader :webhook_account
+    alias_method :webhook_account?, :webhook_account
+    alias_method :webhook?, :webhook_account
+
     # @return [String] the ID of this user's current avatar, can be used to generate an avatar URL.
     # @see #avatar_url
     attr_accessor :avatar_id
 
+    # Utility function to get Discord's display name of a user not in server
+    # @return [String] the name the user displays as (global_name if they have one, username otherwise)
+    def display_name
+      global_name || username
+    end
+
     # Utility function to mention users in messages
     # @return [String] the mention code in the form of <@id>
     def mention
@@ -29,18 +63,37 @@ module Discordrb
 
     # Utility function to get Discord's distinct representation of a user, i.e. username + discriminator
     # @return [String] distinct representation of user
+    # TODO: Maybe change this method again after discriminator removal ?
     def distinct
-      "#{@username}##{@discriminator}"
+      if @discriminator && @discriminator != '0'
+        "#{@username}##{@discriminator}"
+      else
+        @username.to_s
+      end
     end
 
     # Utility function to get a user's avatar URL.
     # @param format [String, nil] If `nil`, the URL will default to `webp` for static avatars, and will detect if the user has a `gif` avatar. You can otherwise specify one of `webp`, `jpg`, `png`, or `gif` to override this. Will always be PNG for default avatars.
     # @return [String] the URL to the avatar image.
+    # TODO: Maybe change this method again after discriminator removal ?
     def avatar_url(format = nil)
-      return API::User.default_avatar(@discriminator) unless @avatar_id
+      unless @avatar_id
+        return API::User.default_avatar(@discriminator, legacy: true) if @discriminator && @discriminator != '0'
+
+        return API::User.default_avatar(@id)
+      end
 
       API::User.avatar_url(@id, @avatar_id, format)
     end
+
+    # @return [Integer] the public flags on a user's account
+    attr_reader :public_flags
+
+    FLAGS.each do |name, value|
+      define_method("#{name}?") do
+        (@public_flags & value).positive?
+      end
+    end
   end
 
   # User on Discord, including internal data like discriminators
@@ -63,15 +116,20 @@ module Discordrb
       @bot = bot
 
       @username = data['username']
+      @global_name = data['global_name']
       @id = data['id'].to_i
       @discriminator = data['discriminator']
       @avatar_id = data['avatar']
       @roles = {}
       @activities = Discordrb::ActivitySet.new
+      @public_flags = data['public_flags'] || 0
 
       @bot_account = false
       @bot_account = true if data['bot']
 
+      @webhook_account = false
+      @webhook_account = true if data['_webhook']
+
       @status = :offline
       @client_status = process_client_status(data['client_status'])
     end
@@ -109,13 +167,20 @@ module Discordrb
       pm.send_file(file, caption: caption, filename: filename, spoiler: spoiler)
     end
 
-    # Set the user's name
+    # Set the user's username
     # @note for internal use only
     # @!visibility private
     def update_username(username)
       @username = username
     end
 
+    # Set the user's global_name
+    # @note For internal use only.
+    # @!visibility private
+    def update_global_name(global_name)
+      @global_name = global_name
+    end
+
     # Set the user's presence data
     # @note for internal use only
     # @!visibility private
@@ -154,14 +219,9 @@ module Discordrb
       @bot.profile.id == @id
     end
 
-    # @return [true, false] whether this user is a fake user for a webhook message
-    def webhook?
-      @discriminator == Message::ZERO_DISCRIM
-    end
-
     # @!visibility private
     def process_client_status(client_status)
-      (client_status || {}).map { |k, v| [k.to_sym, v.to_sym] }.to_h
+      (client_status || {}).to_h { |k, v| [k.to_sym, v.to_sym] }
     end
 
     # @!method offline?

data/lib/discordrb/data/webhook.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'discordrb/webhooks/builder'
+require 'discordrb/webhooks/view'
+
 module Discordrb
   # A webhook on a server channel
   class Webhook
@@ -81,13 +84,13 @@ module Discordrb
     def update(data)
       # Only pass a value for avatar if the key is defined as sending nil will delete the
       data[:avatar] = avatarise(data[:avatar]) if data.key?(:avatar)
-      data[:channel_id] = data[:channel].resolve_id
+      data[:channel_id] = data[:channel]&.resolve_id
       data.delete(:channel)
-      update_webhook(data)
+      update_webhook(**data)
     end
 
     # Deletes the webhook.
-    # @param reason [String] The reason the invite is being deleted.
+    # @param reason [String] The reason the webhook is being deleted.
     def delete(reason = nil)
       if token?
         API::Webhook.token_delete_webhook(@token, @id, reason)
@@ -96,10 +99,100 @@ module Discordrb
       end
     end
 
+    # Execute a webhook.
+    # @param content [String] The content of the message. May be 2000 characters long at most.
+    # @param username [String] The username the webhook will display as. If this is not set, the default username set in the webhook's settings.
+    # @param avatar_url [String] The URL of an image file to be used as an avatar. If this is not set, the default avatar from the webhook's
+    # @param tts [true, false] Whether this message should use TTS or not. By default, it doesn't.
+    # @param file [File] File to be sent together with the message. Mutually exclusive with embeds; a webhook message can contain
+    #   either a file to be sent or embeds.
+    # @param embeds [Array<Webhooks::Embed, Hash>] Embeds to attach to this message.
+    # @param allowed_mentions [AllowedMentions, Hash] Mentions that are allowed to ping in the `content`.
+    # @param wait [true, false] Whether Discord should wait for the message to be successfully received by clients, or
+    #   whether it should return immediately after sending the message. If `true` a {Message} object will be returned.
+    # @yield [builder] Gives the builder to the block to add additional steps, or to do the entire building process.
+    # @yieldparam builder [Builder] The builder given as a parameter which is used as the initial step to start from.
+    # @example Execute the webhook with kwargs
+    #   client.execute(
+    #     content: 'Testing',
+    #     username: 'discordrb',
+    #     embeds: [
+    #       { timestamp: Time.now.iso8601, title: 'testing', image: { url: 'https://i.imgur.com/PcMltU7.jpg' } }
+    #     ])
+    # @example Execute the webhook with an already existing builder
+    #   builder = Discordrb::Webhooks::Builder.new # ...
+    #   client.execute(builder)
+    # @example Execute the webhook by building a new message
+    #   client.execute do |builder|
+    #     builder.content = 'Testing'
+    #     builder.username = 'discordrb'
+    #     builder.add_embed do |embed|
+    #       embed.timestamp = Time.now
+    #       embed.title = 'Testing'
+    #       embed.image = Discordrb::Webhooks::EmbedImage.new(url: 'https://i.imgur.com/PcMltU7.jpg')
+    #     end
+    #   end
+    # @return [Message, nil] If `wait` is `true`, a {Message} will be returned. Otherwise this method will return `nil`.
+    # @note This is only available to webhooks with publically exposed tokens. This excludes channel follow webhooks and webhooks retrieved
+    #   via the audit log.
+    def execute(content: nil, username: nil, avatar_url: nil, tts: nil, file: nil, embeds: nil, allowed_mentions: nil, wait: true, builder: nil, components: nil)
+      raise Discordrb::Errors::UnauthorizedWebhook unless @token
+
+      params = { content: content, username: username, avatar_url: avatar_url, tts: tts, file: file, embeds: embeds, allowed_mentions: allowed_mentions }
+
+      builder ||= Webhooks::Builder.new
+      view = Webhooks::View.new
+
+      yield(builder, view) if block_given?
+
+      data = builder.to_json_hash.merge(params.compact)
+      components ||= view
+
+      resp = API::Webhook.token_execute_webhook(@token, @id, wait, data[:content], data[:username], data[:avatar_url], data[:tts], data[:file], data[:embeds], data[:allowed_mentions], nil, components.to_a)
+
+      Message.new(JSON.parse(resp), @bot) if wait
+    end
+
+    # Delete a message created by this webhook.
+    # @param message [Message, String, Integer] The ID of the message to delete.
+    def delete_message(message)
+      raise Discordrb::Errors::UnauthorizedWebhook unless @token
+
+      API::Webhook.token_delete_message(@token, @id, message.resolve_id)
+    end
+
+    # Edit a message created by this webhook.
+    # @param message [Message, String, Integer] The ID of the message to edit.
+    # @param content [String] The content of the message. May be 2000 characters long at most.
+    # @param embeds [Array<Webhooks::Embed, Hash>] Embeds to be attached to the message.
+    # @param allowed_mentions [AllowedMentions, Hash] Mentions that are allowed to ping in the `content`.
+    # @param builder [Builder, nil] The builder to start out with, or nil if one should be created anew.
+    # @yield [builder] Gives the builder to the block to add additional steps, or to do the entire building process.
+    # @yieldparam builder [Webhooks::Builder] The builder given as a parameter which is used as the initial step to start from.
+    # @return [Message] The updated message.
+    # @param components [View, Array<Hash>] Interaction components to associate with this message.
+    # @note When editing `allowed_mentions`, it will update visually in the client but not alert the user with a notification.
+    def edit_message(message, content: nil, embeds: nil, allowed_mentions: nil, builder: nil, components: nil)
+      raise Discordrb::Errors::UnauthorizedWebhook unless @token
+
+      params = { content: content, embeds: embeds, allowed_mentions: allowed_mentions }.compact
+
+      builder ||= Webhooks::Builder.new
+      view ||= Webhooks::View.new
+
+      yield(builder, view) if block_given?
+
+      data = builder.to_json_hash.merge(params.compact)
+      components ||= view
+
+      resp = API::Webhook.token_edit_message(@token, @id, message.resolve_id, data[:content], data[:embeds], data[:allowed_mentions], components.to_a)
+      Message.new(JSON.parse(resp), @bot)
+    end
+
     # Utility function to get a webhook's avatar URL.
     # @return [String] the URL to the avatar image
     def avatar_url
-      return API::User.default_avatar unless @avatar
+      return API::User.default_avatar(@id) unless @avatar
 
       API::User.avatar_url(@id, @avatar)
     end

data/lib/discordrb/data.rb

@@ -12,6 +12,7 @@ require 'discordrb/api/invite'
 require 'discordrb/api/user'
 require 'discordrb/api/webhook'
 require 'discordrb/webhooks/embeds'
+require 'discordrb/webhooks/view'
 require 'discordrb/paginator'
 require 'time'
 require 'base64'
@@ -37,3 +38,5 @@ require 'discordrb/data/integration'
 require 'discordrb/data/server'
 require 'discordrb/data/webhook'
 require 'discordrb/data/audit_logs'
+require 'discordrb/data/interaction'
+require 'discordrb/data/component'

data/lib/discordrb/errors.rb

@@ -20,6 +20,9 @@ module Discordrb
     # Raised when the bot gets a HTTP 502 error, which is usually caused by Cloudflare.
     class CloudflareError < RuntimeError; end
 
+    # Raised when using a webhook method without an associated token.
+    class UnauthorizedWebhook < RuntimeError; end
+
     # Generic class for errors denoted by API error codes
     class CodeError < RuntimeError
       class << self
@@ -29,8 +32,11 @@ module Discordrb
 
       # Create a new error with a particular message (the code should be defined by the class instance variable)
       # @param message [String] the message to use
-      def initialize(message)
+      # @param errors [Hash] API errors
+      def initialize(message, errors = nil)
         @message = message
+
+        @errors = errors ? flatten_errors(errors) : []
       end
 
       # @return [Integer] The error code represented by this error.
@@ -38,15 +44,50 @@ module Discordrb
         self.class.code
       end
 
+      # @return [String] A message including the message and flattened errors.
+      def full_message(*)
+        error_list = @errors.collect { |err| "\t- #{err}" }
+
+        "#{@message}\n#{error_list.join("\n")}"
+      end
+
       # @return [String] This error's represented message
       attr_reader :message
+
+      # @return [Hash] More precise errors
+      attr_reader :errors
+
+      private
+
+      # @!visibility hidden
+      # Flattens errors into a more easily read format.
+      # @example Flattening errors of a bad field
+      #   flatten_errors(data['errors'])
+      #   # => ["embed.fields[0].name: This field is required", "embed.fields[0].value: This field is required"]
+      def flatten_errors(err, prev_key = nil)
+        err.collect do |key, sub_err|
+          if prev_key
+            key = /\A\d+\Z/.match?(key) ? "#{prev_key}[#{key}]" : "#{prev_key}.#{key}"
+          end
+
+          if (errs = sub_err['_errors'])
+            "#{key}: #{errs.map { |e| e['message'] }.join(' ')}"
+          elsif sub_err['message'] || sub_err['code']
+            "#{sub_err['code'] ? "#{sub_err['code']}: " : nil}#{err_msg}"
+          elsif sub_err.is_a? String
+            sub_err
+          else
+            flatten_errors(sub_err, key)
+          end
+        end.flatten
+      end
     end
 
     # Create a new code error class
     # rubocop:disable Naming/MethodName
     def self.Code(code)
       classy = Class.new(CodeError)
-      classy.instance_variable_set('@code', code)
+      classy.instance_variable_set(:@code, code)
 
       @code_classes ||= {}
       @code_classes[code] = classy
@@ -58,7 +99,7 @@ module Discordrb
     # @param code [Integer] The code to check
     # @return [Class] the error class for the given code
     def self.error_class_for(code)
-      @code_classes[code]
+      @code_classes[code] || UnknownError
     end
 
     # Used when Discord doesn't provide a more specific code

data/lib/discordrb/events/channels.rb

@@ -31,7 +31,7 @@ module Discordrb::Events
 
     def initialize(data, bot)
       @bot = bot
-      @channel = bot.channel(data['id'].to_i)
+      @channel = data.is_a?(Discordrb::Channel) ? data : bot.channel(data['id'].to_i)
     end
   end