discordrb 3.4.0 → 3.5.0

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
 

data/lib/discordrb/events/interactions.rb

@@ -0,0 +1,482 @@
+# frozen_string_literal: true
+
+require 'discordrb/events/generic'
+require 'discordrb/data'
+
+module Discordrb::Events
+  # Generic subclass for interaction events
+  class InteractionCreateEvent < Event
+    # @return [Interaction] The interaction for this event.
+    attr_reader :interaction
+
+    # @!attribute [r] type
+    #   @return [Integer]
+    #   @see Interaction#type
+    # @!attribute [r] server
+    #   @return [Server, nil]
+    #   @see Interaction#server
+    # @!attribute [r] server_id
+    #   @return [Integer]
+    #   @see Interaction#server_id
+    # @!attribute [r] channel
+    #   @return [Channel]
+    #   @see Interaction#channel
+    # @!attribute [r] channel_id
+    #   @return [Integer]
+    #   @see Interaction#channel_id
+    # @!attribute [r] user
+    #   @return [User]
+    #   @see Interaction#user
+    delegate :type, :server, :server_id, :channel, :channel_id, :user, to: :interaction
+
+    def initialize(data, bot)
+      @interaction = Discordrb::Interaction.new(data, bot)
+      @bot = bot
+    end
+
+    # (see Interaction#respond)
+    def respond(content: nil, tts: nil, embeds: nil, allowed_mentions: nil, flags: 0, ephemeral: nil, wait: false, components: nil, &block)
+      @interaction.respond(
+        content: content, tts: tts, embeds: embeds, allowed_mentions: allowed_mentions,
+        flags: flags, ephemeral: ephemeral, wait: wait, components: components, &block
+      )
+    end
+
+    # (see Interaction#defer)
+    def defer(flags: 0, ephemeral: true)
+      @interaction.defer(flags: flags, ephemeral: ephemeral)
+    end
+
+    # (see Interaction#update_message)
+    def update_message(content: nil, tts: nil, embeds: nil, allowed_mentions: nil, flags: 0, ephemeral: nil, wait: false, components: nil, &block)
+      @interaction.update_message(
+        content: content, tts: tts, embeds: embeds, allowed_mentions: allowed_mentions,
+        flags: flags, ephemeral: ephemeral, wait: wait, components: components, &block
+      )
+    end
+
+    # (see Interaction#show_modal)
+    def show_modal(title:, custom_id:, components: nil, &block)
+      @interaction.show_modal(title: title, custom_id: custom_id, components: components, &block)
+    end
+
+    # (see Interaction#edit_response)
+    def edit_response(content: nil, embeds: nil, allowed_mentions: nil, components: nil, &block)
+      @interaction.edit_response(content: content, embeds: embeds, allowed_mentions: allowed_mentions, components: components, &block)
+    end
+
+    # (see Interaction#delete_response)
+    def delete_response
+      @interaction.delete_response
+    end
+
+    # (see Interaction#send_message)
+    def send_message(content: nil, embeds: nil, tts: false, allowed_mentions: nil, flags: 0, ephemeral: nil, components: nil, &block)
+      @interaction.send_message(content: content, embeds: embeds, tts: tts, allowed_mentions: allowed_mentions, flags: flags, ephemeral: ephemeral, components: components, &block)
+    end
+
+    # (see Interaction#edit_message)
+    def edit_message(message, content: nil, embeds: nil, allowed_mentions: nil, &block)
+      @interaction.edit_message(message, content: content, embeds: embeds, allowed_mentions: allowed_mentions, &block)
+    end
+
+    # (see Interaction#delete_message)
+    def delete_message(message)
+      @interaction.delete_message(message)
+    end
+
+    # (see Interaction#defer_update)
+    def defer_update
+      @interaction.defer_update
+    end
+
+    # (see Interaction#get_component)
+    def get_component(custom_id)
+      @interaction.get_component(custom_id)
+    end
+  end
+
+  # Event handler for INTERACTION_CREATE events.
+  class InteractionCreateEventHandler < EventHandler
+    # @!visibility private
+    def matches?(event)
+      return false unless event.is_a? InteractionCreateEvent
+
+      [
+        matches_all(@attributes[:type], event.type) do |a, e|
+          a == case a
+               when String, Symbol
+                 Discordrb::Interactions::TYPES[e.to_sym]
+               else
+                 e
+               end
+        end,
+
+        matches_all(@attributes[:server], event.interaction) do |a, e|
+          a.resolve_id == e.server_id
+        end,
+
+        matches_all(@attributes[:channel], event.interaction) do |a, e|
+          a.resolve_id == e.channel_id
+        end,
+
+        matches_all(@attributes[:user], event.user) do |a, e|
+          a.resolve_id == e.id
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Event for ApplicationCommand interactions.
+  class ApplicationCommandEvent < InteractionCreateEvent
+    # Struct to allow accessing data via [] or methods.
+    Resolved = Struct.new('Resolved', :channels, :members, :messages, :roles, :users, :attachments) # rubocop:disable Lint/StructNewOverride
+
+    # @return [String] The name of the command.
+    attr_reader :command_name
+
+    # @return [Integer] The ID of the command.
+    attr_reader :command_id
+
+    # @return [String, nil] The name of the subcommand group relevant to this event.
+    attr_reader :subcommand_group
+
+    # @return [String, nil] The name of the subcommand relevant to this event.
+    attr_reader :subcommand
+
+    # @return [Resolved]
+    attr_reader :resolved
+
+    # @return [Hash<Symbol, Object>] Arguments provided to the command, mapped as `Name => Value`.
+    attr_reader :options
+
+    # @return [Integer, nil] The target of this command when it is a context command.
+    attr_reader :target_id
+
+    def initialize(data, bot)
+      super
+
+      command_data = data['data']
+
+      @command_id = command_data['id']
+      @command_name = command_data['name'].to_sym
+
+      @target_id = command_data['target_id']&.to_i
+      @resolved = Resolved.new({}, {}, {}, {}, {}, {})
+      process_resolved(command_data['resolved']) if command_data['resolved']
+
+      options = command_data['options'] || []
+
+      if options.empty?
+        @options = {}
+        return
+      end
+
+      case options[0]['type']
+      when 2
+        options = options[0]
+        @subcommand_group = options['name'].to_sym
+        @subcommand = options['options'][0]['name'].to_sym
+        options = options['options'][0]['options']
+      when 1
+        options = options[0]
+        @subcommand = options['name'].to_sym
+        options = options['options']
+      end
+
+      @options = transform_options_hash(options || {})
+    end
+
+    # @return [Message, User, nil] The target of this command, for context commands.
+    def target
+      return nil unless @target_id
+
+      @resolved.find { |data| data.key?(@target_id) }[@target_id]
+    end
+
+    private
+
+    def process_resolved(resolved_data)
+      resolved_data['users']&.each do |id, data|
+        @resolved[:users][id.to_i] = @bot.ensure_user(data)
+      end
+
+      resolved_data['roles']&.each do |id, data|
+        @resolved[:roles][id.to_i] = Discordrb::Role.new(data, @bot)
+      end
+
+      resolved_data['channels']&.each do |id, data|
+        data['guild_id'] = @interaction.server_id
+        @resolved[:channels][id.to_i] = Discordrb::Channel.new(data, @bot)
+      end
+
+      resolved_data['members']&.each do |id, data|
+        data['user'] = resolved_data['users'][id]
+        data['guild_id'] = @interaction.server_id
+        @resolved[:members][id.to_i] = Discordrb::Member.new(data, nil, @bot)
+      end
+
+      resolved_data['messages']&.each do |id, data|
+        @resolved[:messages][id.to_i] = Discordrb::Message.new(data, @bot)
+      end
+
+      resolved_data['attachments']&.each do |id, data|
+        @resolved[:attachments][id.to_i] = Discordrb::Attachment.new(data, nil, @bot)
+      end
+    end
+
+    def transform_options_hash(hash)
+      hash.to_h { |opt| [opt['name'], opt['options'] || opt['value']] }
+    end
+  end
+
+  # Event handler for ApplicationCommandEvents.
+  class ApplicationCommandEventHandler < EventHandler
+    # @return [Hash]
+    attr_reader :subcommands
+
+    # @!visibility private
+    def initialize(attributes, block)
+      super
+
+      @subcommands = {}
+    end
+
+    # @param name [Symbol, String]
+    # @yieldparam [SubcommandBuilder]
+    # @return [ApplicationCommandEventHandler]
+    def group(name)
+      raise ArgumentError, 'Unable to mix subcommands and groups' if @subcommands.any? { |_, v| v.is_a? Proc }
+
+      builder = SubcommandBuilder.new(name)
+      yield builder
+
+      @subcommands.merge!(builder.to_h)
+      self
+    end
+
+    # @param name [String, Symbol]
+    # @yieldparam [SubcommandBuilder]
+    # @return [ApplicationCommandEventHandler]
+    def subcommand(name, &block)
+      raise ArgumentError, 'Unable to mix subcommands and groups' if @subcommands.any? { |_, v| v.is_a? Hash }
+
+      @subcommands[name.to_sym] = block
+
+      self
+    end
+
+    # @!visibility private
+    # @param event [Event]
+    def call(event)
+      return unless matches?(event)
+
+      if event.subcommand_group
+        unless (cmd = @subcommands.dig(event.subcommand_group, event.subcommand))
+          Discordrb::LOGGER.debug("Received an event for an unhandled subcommand `#{event.command_name} #{event.subcommand_group} #{event.subcommand}'")
+          return
+        end
+
+        cmd.call(event)
+      elsif event.subcommand
+        unless (cmd = @subcommands[event.subcommand])
+          Discordrb::LOGGER.debug("Received an event for an unhandled subcommand `#{event.command_name} #{event.subcommand}'")
+          return
+        end
+
+        cmd.call(event)
+      else
+        @block.call(event)
+      end
+    end
+
+    # @!visibility private
+    def matches?(event)
+      return false unless event.is_a? ApplicationCommandEvent
+
+      [
+        matches_all(@attributes[:name], event.command_name) do |a, e|
+          a.to_sym == e.to_sym
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Builder for adding subcommands to an ApplicationCommandHandler
+  class SubcommandBuilder
+    # @!visibility private
+    # @param group [String, Symbol, nil]
+    def initialize(group = nil)
+      @group = group&.to_sym
+      @subcommands = {}
+    end
+
+    # @param name [Symbol, String]
+    # @yieldparam [ApplicationCommandEvent]
+    def subcommand(name, &block)
+      @subcommands[name.to_sym] = block
+    end
+
+    # @!visibility private
+    def to_h
+      @group ? { @group => @subcommands } : @subcommands
+    end
+  end
+
+  # An event for when a user interacts with a component.
+  class ComponentEvent < InteractionCreateEvent
+    # @return [String] User provided data for this button.
+    attr_reader :custom_id
+
+    # @return [Interactions::Message, nil] The message the button originates from.
+    attr_reader :message
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      @message = Discordrb::Interactions::Message.new(data['message'], bot, @interaction) if data['message']
+      @custom_id = data['data']['custom_id']
+    end
+  end
+
+  # Generic handler for component events.
+  class ComponentEventHandler < InteractionCreateEventHandler
+    def matches?(event)
+      return false unless super
+      return false unless event.is_a? ComponentEvent
+
+      [
+        matches_all(@attributes[:custom_id], event.custom_id) do |a, e|
+          # Match regexp and strings
+          case a
+          when Regexp
+            a.match?(e)
+          else
+            a == e
+          end
+        end,
+        matches_all(@attributes[:message], event.message) do |a, e|
+          case a
+          when String, Integer
+            a.resolve_id == e.id
+          else
+            a.id == e.id
+          end
+        end
+      ].reduce(&:&)
+    end
+  end
+
+  # An event for when a user interacts with a button component.
+  class ButtonEvent < ComponentEvent
+  end
+
+  # Event handler for a Button interaction event.
+  class ButtonEventHandler < ComponentEventHandler
+  end
+
+  # Event for when a user interacts with a select string component.
+  class StringSelectEvent < ComponentEvent
+    # @return [Array<String>] Selected values.
+    attr_reader :values
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      @values = data['data']['values']
+    end
+  end
+
+  # Event handler for a select string component.
+  class StringSelectEventHandler < ComponentEventHandler
+  end
+
+  # An event for when a user submits a modal.
+  class ModalSubmitEvent < ComponentEvent
+    # @return [Array<TextInputComponent>]
+    attr_reader :components
+
+    # Get the value of an input passed to the modal.
+    # @param custom_id [String] The custom ID of the component to look for.
+    # @return [String, nil]
+    def value(custom_id)
+      get_component(custom_id)&.value
+    end
+  end
+
+  # Event handler for a modal submission.
+  class ModalSubmitEventHandler < ComponentEventHandler
+  end
+
+  # Event for when a user interacts with a select user component.
+  class UserSelectEvent < ComponentEvent
+    # @return [Array<User>] Selected values.
+    attr_reader :values
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      @values = data['data']['values'].map { |e| bot.user(e) }
+    end
+  end
+
+  # Event handler for a select user component.
+  class UserSelectEventHandler < ComponentEventHandler
+  end
+
+  # Event for when a user interacts with a select role component.
+  class RoleSelectEvent < ComponentEvent
+    # @return [Array<Role>] Selected values.
+    attr_reader :values
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      @values = data['data']['values'].map { |e| bot.server(data['guild_id']).role(e) }
+    end
+  end
+
+  # Event handler for a select role component.
+  class RoleSelectEventHandler < ComponentEventHandler
+  end
+
+  # Event for when a user interacts with a select mentionable component.
+  class MentionableSelectEvent < ComponentEvent
+    # @return [Hash<Symbol => Array<User>, Symbol => Array<Role>>] Selected values.
+    attr_reader :values
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      users   = data['data']['resolved']['users'].keys.map { |e| bot.user(e) }
+      roles   = data['data']['resolved']['roles'] ? data['data']['resolved']['roles'].keys.map { |e| bot.server(data['guild_id']).role(e) } : []
+      @values = { users: users, roles: roles }
+    end
+  end
+
+  # Event handler for a select mentionable component.
+  class MentionableSelectEventHandler < ComponentEventHandler
+  end
+
+  # Event for when a user interacts with a select channel component.
+  class ChannelSelectEvent < ComponentEvent
+    # @return [Array<Channel>] Selected values.
+    attr_reader :values
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      @values = data['data']['values'].map { |e| bot.channel(e, bot.server(data['guild_id'])) }
+    end
+  end
+
+  # Event handler for a select channel component.
+  class ChannelSelectEventHandler < ComponentEventHandler
+  end
+end

data/lib/discordrb/events/message.rb

@@ -17,9 +17,10 @@ module Discordrb::Events
     # @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>, nil] A collection of components to attach to the message.
     # @return [Discordrb::Message] the message that was sent
-    def send_message(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 send_message(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
 
     # The same as {#send_message}, but yields a {Webhooks::Embed} for easy building of embedded content inside a block.
@@ -30,11 +31,12 @@ module Discordrb::Events
     # @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>, nil] A collection of components to attach to the message.
     # @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, &block)
-      channel.send_embed(message, embed, attachments, tts, allowed_mentions, message_reference, &block)
+    def send_embed(message = '', embed = nil, attachments = nil, tts = false, allowed_mentions = nil, message_reference = nil, components = nil, &block)
+      channel.send_embed(message, embed, attachments, tts, allowed_mentions, message_reference, components, &block)
     end
 
     # Sends a temporary message to the channel this message was sent in, right now.
@@ -44,8 +46,9 @@ module Discordrb::Events
     # @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
-    def send_temporary_message(content, timeout, tts = false, embed = nil, attachments = nil, allowed_mentions = nil)
-      channel.send_temporary_message(content, timeout, tts, embed, attachments, allowed_mentions)
+    # @param components [View, Array<Hash>, nil] A collection of components to attach to the message.
+    def send_temporary_message(content, timeout, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, components = nil)
+      channel.send_temporary_message(content, timeout, tts, embed, attachments, allowed_mentions, components)
     end
 
     # Adds a string to be sent after the event has finished execution. Avoids problems with rate limiting because only

data/lib/discordrb/events/presence.rb

@@ -65,28 +65,35 @@ module Discordrb::Events
     # @return [User] the user whose status got updated.
     attr_reader :user
 
-    # @return [String] the new game the user is playing.
-    attr_reader :game
+    # @return [Discordrb::Activity] The new activity
+    attr_reader :activity
 
-    # @return [String] the URL to the stream
-    attr_reader :url
+    # @!attribute [r] url
+    #   @return [String] the URL to the stream
 
-    # @return [String] what the player is currently doing (ex. game being streamed)
-    attr_reader :details
+    # @!attribute [r] details
+    #   @return [String] what the player is currently doing (ex. game being streamed)
 
-    # @return [Integer] the type of play. 0 = game, 1 = Twitch
-    attr_reader :type
+    # @!attribute [r] type
+    #   @return [Integer] the type of play. See {Discordrb::Activity}
+    delegate :url, :details, :type, to: :activity
 
-    def initialize(data, bot)
+    # @return [Hash<Symbol, Symbol>] the current online status (`:online`, `:idle` or `:dnd`) of the user
+    #   on various device types (`:desktop`, `:mobile`, or `:web`). The value will be `nil` if the user is offline or invisible.
+    attr_reader :client_status
+
+    def initialize(data, activity, bot)
       @bot = bot
+      @activity = activity
 
       @server = bot.server(data['guild_id'].to_i)
       @user = bot.user(data['user']['id'].to_i)
-      @game = data['game'] ? data['game']['name'] : nil
-      @type = data['game'] ? data['game']['type'].to_i : nil
-      # Handle optional 'game' fields safely
-      @url = data['game'] && data['game']['url'] ? data['game']['url'] : nil
-      @details = data['game'] && data['game']['details'] ? data['game']['details'] : nil
+      @client_status = @user.client_status
+    end
+
+    # @return [String] the name of the new game the user is playing.
+    def game
+      @activity.name
     end
   end
 

data/lib/discordrb/events/reactions.rb

@@ -137,7 +137,6 @@ module Discordrb::Events
       # Check for the proper event type
       return false unless event.is_a? ReactionRemoveAllEvent
 
-      # No attributes yet as there is no property available on the event that doesn't involve doing a resolution request
       [
         matches_all(@attributes[:message], event.message_id) do |a, e|
           a == e