onyxcord 1.1.0

data/lib/onyxcord/api/user.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+# API calls for User object
+module OnyxCord::API::User
+  module_function
+
+  # Get user data
+  # https://discord.com/developers/docs/resources/user#get-user
+  def resolve(token, user_id)
+    OnyxCord::API.request(
+      :users_uid,
+      nil,
+      :get,
+      "#{OnyxCord::API.api_base}/users/#{user_id}",
+      Authorization: token
+    )
+  end
+
+  # Get profile data
+  # https://discord.com/developers/docs/resources/user#get-current-user
+  def profile(token)
+    OnyxCord::API.request(
+      :users_me,
+      nil,
+      :get,
+      "#{OnyxCord::API.api_base}/users/@me",
+      Authorization: token
+    )
+  end
+
+  # @deprecated Please use {OnyxCord::API::Server.update_current_member} instead.
+  # https://discord.com/developers/docs/resources/user#modify-current-user-nick
+  def change_own_nickname(token, server_id, nick, reason = nil)
+    OnyxCord::API.request(
+      :guilds_sid_members_me_nick,
+      server_id, # This is technically a guild endpoint
+      :patch,
+      "#{OnyxCord::API.api_base}/guilds/#{server_id}/members/@me/nick",
+      { nick: nick }.to_json,
+      Authorization: token,
+      content_type: :json,
+      'X-Audit-Log-Reason': reason
+    )
+  end
+
+  # @deprecated Please use {update_current_user} instead.
+  # https://discord.com/developers/docs/resources/user#modify-current-user
+  def update_profile(token, _email, _password, new_username, avatar, _new_password = nil)
+    update_current_user(token, new_username, avatar)
+  end
+
+  # Update the properties of the user for the current bot.
+  # https://discord.com/developers/docs/resources/user#modify-current-user
+  def update_current_user(token, username = :undef, avatar = :undef, banner = :undef)
+    OnyxCord::API.request(
+      :users_me,
+      nil,
+      :patch,
+      "#{OnyxCord::API.api_base}/users/@me",
+      { username: username, avatar: avatar, banner: banner }.reject { |_, value| value == :undef }.to_json,
+      Authorization: token,
+      content_type: :json
+    )
+  end
+
+  # Get the servers a user is connected to
+  # https://discord.com/developers/docs/resources/user#get-current-user-guilds
+  def servers(token)
+    OnyxCord::API.request(
+      :users_me_guilds,
+      nil,
+      :get,
+      "#{OnyxCord::API.api_base}/users/@me/guilds",
+      Authorization: token
+    )
+  end
+
+  # Leave a server
+  # https://discord.com/developers/docs/resources/user#leave-guild
+  def leave_server(token, server_id)
+    OnyxCord::API.request(
+      :users_me_guilds_sid,
+      nil,
+      :delete,
+      "#{OnyxCord::API.api_base}/users/@me/guilds/#{server_id}",
+      Authorization: token
+    )
+  end
+
+  # Get the DMs for the current user
+  # https://discord.com/developers/docs/resources/user#get-user-dms
+  def user_dms(token)
+    OnyxCord::API.request(
+      :users_me_channels,
+      nil,
+      :get,
+      "#{OnyxCord::API.api_base}/users/@me/channels",
+      Authorization: token
+    )
+  end
+
+  # Create a DM to another user
+  # https://discord.com/developers/docs/resources/user#create-dm
+  def create_pm(token, recipient_id)
+    OnyxCord::API.request(
+      :users_me_channels,
+      nil,
+      :post,
+      "#{OnyxCord::API.api_base}/users/@me/channels",
+      { recipient_id: recipient_id }.to_json,
+      Authorization: token,
+      content_type: :json
+    )
+  end
+
+  # Get information about a user's connections
+  # https://discord.com/developers/docs/resources/user#get-users-connections
+  def connections(token)
+    OnyxCord::API.request(
+      :users_me_connections,
+      nil,
+      :get,
+      "#{OnyxCord::API.api_base}/users/@me/connections",
+      Authorization: token
+    )
+  end
+
+  # Returns one of the "default" discord avatars from the CDN given a discriminator or id since new usernames
+  # TODO: Maybe change this method again after discriminator removal ?
+  def default_avatar(discrim_id = 0, legacy: false)
+    index = if legacy
+              discrim_id.to_i % 5
+            else
+              (discrim_id.to_i >> 22) % 5
+            end
+    "#{OnyxCord::API.cdn_url}/embed/avatars/#{index}.png"
+  end
+
+  # Make an avatar URL from the user and avatar IDs
+  def avatar_url(user_id, avatar_id, format = nil)
+    format ||= if avatar_id.start_with?('a_')
+                 'gif'
+               else
+                 'webp'
+               end
+    "#{OnyxCord::API.cdn_url}/avatars/#{user_id}/#{avatar_id}.#{format}"
+  end
+
+  # Make a banner URL from the user and banner IDs
+  def banner_url(user_id, banner_id, format = nil)
+    format ||= if banner_id.start_with?('a_')
+                 'gif'
+               else
+                 'png'
+               end
+    "#{OnyxCord::API.cdn_url}/banners/#{user_id}/#{banner_id}.#{format}"
+  end
+end

data/lib/onyxcord/api/webhook.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'onyxcord/message_components'
+
+# API calls for Webhook object
+module OnyxCord::API::Webhook
+  module_function
+
+  # Get a webhook
+  # https://discord.com/developers/docs/resources/webhook#get-webhook
+  def webhook(token, webhook_id)
+    OnyxCord::API.request(
+      :webhooks_wid,
+      nil,
+      :get,
+      "#{OnyxCord::API.api_base}/webhooks/#{webhook_id}",
+      Authorization: token
+    )
+  end
+
+  # Get a webhook via webhook token
+  # https://discord.com/developers/docs/resources/webhook#get-webhook-with-token
+  def token_webhook(webhook_token, webhook_id)
+    OnyxCord::API.request(
+      :webhooks_wid,
+      nil,
+      :get,
+      "#{OnyxCord::API.api_base}/webhooks/#{webhook_id}/#{webhook_token}"
+    )
+  end
+
+  # Execute a webhook via token.
+  # https://discord.com/developers/docs/resources/webhook#execute-webhook
+  def token_execute_webhook(webhook_token, webhook_id, wait = false, content = nil, username = nil, avatar_url = nil, tts = nil, file = nil, embeds = nil, allowed_mentions = nil, flags = nil, components = nil, attachments = nil, poll = nil)
+    components = OnyxCord::MessageComponents.payload(components) unless components.nil?
+    flags = OnyxCord::MessageComponents.apply_v2_flag(flags, components)
+    body = { content: content, username: username, avatar_url: avatar_url, tts: tts, embeds: embeds&.map(&:to_hash),  allowed_mentions: allowed_mentions, flags: flags, components: components, poll: poll }
+
+    body = if file
+             { file: file, payload_json: body.to_json }
+           elsif attachments
+             files = [*0...attachments.size].zip(attachments).to_h
+             { **files, payload_json: body.to_json }
+           else
+             body.to_json
+           end
+
+    headers = { content_type: :json } unless file || attachments
+    with_components = components&.any? ? true : nil
+    query = URI.encode_www_form({ wait: wait, with_components: with_components }.compact)
+
+    OnyxCord::API.request(
+      :webhooks_wid,
+      webhook_id,
+      :post,
+      "#{OnyxCord::API.api_base}/webhooks/#{webhook_id}/#{webhook_token}?#{query}",
+      body,
+      headers
+    )
+  end
+
+  # Update a webhook
+  # https://discord.com/developers/docs/resources/webhook#modify-webhook
+  def update_webhook(token, webhook_id, data, reason = nil)
+    OnyxCord::API.request(
+      :webhooks_wid,
+      webhook_id,
+      :patch,
+      "#{OnyxCord::API.api_base}/webhooks/#{webhook_id}",
+      data.to_json,
+      Authorization: token,
+      content_type: :json,
+      'X-Audit-Log-Reason': reason
+    )
+  end
+
+  # Update a webhook via webhook token
+  # https://discord.com/developers/docs/resources/webhook#modify-webhook-with-token
+  def token_update_webhook(webhook_token, webhook_id, data, reason = nil)
+    OnyxCord::API.request(
+      :webhooks_wid,
+      webhook_id,
+      :patch,
+      "#{OnyxCord::API.api_base}/webhooks/#{webhook_id}/#{webhook_token}",
+      data.to_json,
+      content_type: :json,
+      'X-Audit-Log-Reason': reason
+    )
+  end
+
+  # Deletes a webhook
+  # https://discord.com/developers/docs/resources/webhook#delete-webhook
+  def delete_webhook(token, webhook_id, reason = nil)
+    OnyxCord::API.request(
+      :webhooks_wid,
+      webhook_id,
+      :delete,
+      "#{OnyxCord::API.api_base}/webhooks/#{webhook_id}",
+      Authorization: token,
+      'X-Audit-Log-Reason': reason
+    )
+  end
+
+  # Deletes a webhook via webhook token
+  # https://discord.com/developers/docs/resources/webhook#delete-webhook-with-token
+  def token_delete_webhook(webhook_token, webhook_id, reason = nil)
+    OnyxCord::API.request(
+      :webhooks_wid,
+      webhook_id,
+      :delete,
+      "#{OnyxCord::API.api_base}/webhooks/#{webhook_id}/#{webhook_token}",
+      'X-Audit-Log-Reason': reason
+    )
+  end
+
+  # Get a message that was created by the webhook corresponding to the provided token.
+  # https://discord.com/developers/docs/resources/webhook#get-webhook-message
+  def token_get_message(webhook_token, webhook_id, message_id)
+    OnyxCord::API.request(
+      :webhooks_wid_messages_mid,
+      webhook_id,
+      :get,
+      "#{OnyxCord::API.api_base}/webhooks/#{webhook_id}/#{webhook_token}/messages/#{message_id}"
+    )
+  end
+
+  # Edit a webhook message via webhook token
+  # https://discord.com/developers/docs/resources/webhook#edit-webhook-message
+  def token_edit_message(webhook_token, webhook_id, message_id, content = nil, embeds = nil, allowed_mentions = nil, components = nil, attachments = nil, flags = nil, poll = nil)
+    components = OnyxCord::MessageComponents.payload(components) unless components.nil?
+    flags = OnyxCord::MessageComponents.apply_v2_flag(flags, components)
+    body = { content: content, embeds: embeds, allowed_mentions: allowed_mentions, components: components, flags: flags, poll: poll }
+
+    body = if attachments
+             files = [*0...attachments.size].zip(attachments).to_h
+             { **files, payload_json: body.to_json }
+           else
+             body.to_json
+           end
+
+    headers = { content_type: :json } unless attachments
+
+    OnyxCord::API.request(
+      :webhooks_wid_messages,
+      webhook_id,
+      :patch,
+      "#{OnyxCord::API.api_base}/webhooks/#{webhook_id}/#{webhook_token}/messages/#{message_id}",
+      body,
+      headers
+    )
+  end
+
+  # Delete a webhook message via webhook token.
+  # https://discord.com/developers/docs/resources/webhook#delete-webhook-message
+  def token_delete_message(webhook_token, webhook_id, message_id)
+    OnyxCord::API.request(
+      :webhooks_wid_messages,
+      webhook_id,
+      :delete,
+      "#{OnyxCord::API.api_base}/webhooks/#{webhook_id}/#{webhook_token}/messages/#{message_id}"
+    )
+  end
+end

data/lib/onyxcord/api.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+require 'rest-client'
+require 'json'
+require 'time'
+
+require 'onyxcord/errors'
+require 'onyxcord/rate_limiter/rest'
+
+# List of methods representing endpoints in Discord's API
+module OnyxCord::API
+  # The base URL of the Discord REST API.
+  APIBASE = 'https://discord.com/api/v9'
+
+  # The URL of Discord's CDN
+  CDN_URL = 'https://cdn.discordapp.com'
+
+  module_function
+
+  # @return [String] the currently used API base URL.
+  def api_base
+    @api_base || APIBASE
+  end
+
+  # Sets the API base URL to something.
+  def api_base=(value)
+    @api_base = value
+  end
+
+  # @return [String] the currently used CDN url
+  def cdn_url
+    @cdn_url || CDN_URL
+  end
+
+  # @return [String] the bot name, previously specified using {.bot_name=}.
+  def bot_name
+    @bot_name
+  end
+
+  # Sets the bot name to something. Used in {.user_agent}. For the bot's username, see {Profile#username=}.
+  def bot_name=(value)
+    @bot_name = value
+  end
+
+  # Changes the rate limit tracing behaviour. If rate limit tracing is on, a full backtrace will be logged on every RL
+  # hit.
+  # @param value [true, false] whether or not to enable rate limit tracing
+  def trace=(value)
+    @trace = value
+  end
+
+  # Generate a user agent identifying this requester as onyxcord.
+  def user_agent
+    # This particular string is required by the Discord devs.
+    required = "DiscordBot (https://github.com/kruldevb/OnyxCord, v#{OnyxCord::VERSION})"
+    @bot_name ||= ''
+
+    "#{required} rest-client/#{RestClient::VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION}p#{RUBY_PATCHLEVEL} onyxcord/#{OnyxCord::VERSION} #{@bot_name}"
+  end
+
+  # Resets all rate limit mutexes
+  def reset_mutexes
+    @rate_limiter = OnyxCord::RateLimiter::Rest.new
+  end
+
+  def rate_limiter
+    @rate_limiter ||= OnyxCord::RateLimiter::Rest.new
+  end
+
+  # Wait a specified amount of time synchronised with the specified mutex.
+  def sync_wait(time, mutex)
+    mutex.synchronize { sleep time }
+  end
+
+  # Wait for a specified mutex to unlock and do nothing with it afterwards.
+  def mutex_wait(mutex)
+    mutex.lock
+    mutex.unlock
+  end
+
+  # Performs a RestClient request.
+  # @param type [Symbol] The type of HTTP request to use.
+  # @param attributes [Array] The attributes for the request.
+  def raw_request(type, attributes)
+    RestClient.send(type, *attributes)
+  rescue RestClient::Forbidden => e
+    # HACK: for #request, dynamically inject restclient's response into NoPermission - this allows us to rate limit
+    noprm = OnyxCord::Errors::NoPermission.new
+    noprm.define_singleton_method(:_rc_response) { e.response }
+    raise noprm, "The bot doesn't have the required permission to do this!"
+  rescue RestClient::BadGateway
+    OnyxCord::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')
+    retry
+  end
+
+  # Make an API request, including rate limit handling.
+  def request(key, major_parameter, type, *attributes)
+    # Add a custom user agent
+    attributes.last[:user_agent] = user_agent if attributes.last.is_a? Hash
+
+    begin
+      rate_limiter.before_request(key, major_parameter)
+
+      response = nil
+      begin
+        response = raw_request(type, attributes)
+      rescue RestClient::Exception => e
+        response = e.response
+
+        if response.body && !e.is_a?(RestClient::TooManyRequests)
+          data = JSON.parse(response.body)
+          err_klass = OnyxCord::Errors.error_class_for(data['code'] || 0)
+          e = err_klass.new(data['message'], data['errors'])
+
+          OnyxCord::LOGGER.error(e.full_message)
+        end
+
+        raise e
+      rescue OnyxCord::Errors::NoPermission => e
+        if e.respond_to?(:_rc_response)
+          response = e._rc_response
+        else
+          OnyxCord::LOGGER.warn("NoPermission doesn't respond_to? _rc_response!")
+        end
+
+        raise e
+      ensure
+        if response
+          rate_limiter.record_response(key, major_parameter, response.headers)
+        else
+          OnyxCord::LOGGER.ratelimit('Response was nil before trying to preemptively rate limit!')
+        end
+      end
+    rescue RestClient::TooManyRequests => e
+      trace("429 #{key} #{major_parameter}")
+      rate_limiter.handle_rate_limit(key, major_parameter, e.response)
+
+      retry
+    end
+
+    # Endpoints that use Elasticsearch can return a 202 when the index isn't ready yet. Wait the
+    # amount of time indicated by the response body, and then recursively retry and return the request.
+    if response&.code == 202 && response&.body
+      body = JSON.parse(response.body)
+
+      if body['code'] == 110_000
+        case body['retry_after']
+        when 0, 1, nil
+          sleep(rand(4.5..5.0))
+        else
+          sleep(body['retry_after'])
+        end
+
+        return request(*key, type, *attributes)
+      end
+    end
+
+    response
+  end
+
+  # Handles pre-emptive rate limiting by waiting the given mutex by the difference of the Date header to the
+  # X-Ratelimit-Reset header, thus making sure we don't get 429'd in any subsequent requests.
+  def handle_preemptive_rl(headers, mutex, key)
+    OnyxCord::LOGGER.ratelimit "RL bucket depletion detected! Date: #{headers[:date]} Reset: #{headers[:x_ratelimit_reset]}"
+    delta = headers[:x_ratelimit_reset_after].to_f
+    OnyxCord::LOGGER.warn("Locking RL mutex (key: #{key}) for #{delta} seconds pre-emptively")
+    sync_wait(delta, mutex)
+  end
+
+  # Perform rate limit tracing. All this method does is log the current backtrace to the console with the `:ratelimit`
+  # level.
+  # @param reason [String] the reason to include with the backtrace.
+  def trace(reason)
+    unless @trace
+      OnyxCord::LOGGER.debug("trace was called with reason #{reason}, but tracing is not enabled")
+      return
+    end
+
+    OnyxCord::LOGGER.ratelimit("Trace (#{reason}):")
+
+    caller.each do |str|
+      OnyxCord::LOGGER.ratelimit(" #{str}")
+    end
+  end
+
+  # Make an icon URL from server and icon IDs
+  def icon_url(server_id, icon_id, format = 'webp')
+    "#{cdn_url}/icons/#{server_id}/#{icon_id}.#{format}"
+  end
+
+  # Make an icon URL from application and icon IDs
+  def app_icon_url(app_id, icon_id, format = 'webp')
+    "#{cdn_url}/app-icons/#{app_id}/#{icon_id}.#{format}"
+  end
+
+  # Make a widget picture URL from server ID
+  def widget_url(server_id, style = 'shield')
+    "#{api_base}/guilds/#{server_id}/widget.png?style=#{style}"
+  end
+
+  # Make a splash URL from server and splash IDs
+  def splash_url(server_id, splash_id, format = 'webp')
+    "#{cdn_url}/splashes/#{server_id}/#{splash_id}.#{format}"
+  end
+
+  # Make a discovery splash URL from server and splash IDs
+  def discovery_splash_url(server_id, splash_id, format = 'webp')
+    "#{cdn_url}/discovery-splashes/#{server_id}/#{splash_id}.#{format}"
+  end
+
+  # Make a banner URL from server and banner IDs
+  def banner_url(server_id, banner_id, format = 'webp')
+    "#{cdn_url}/banners/#{server_id}/#{banner_id}.#{format}"
+  end
+
+  # Make an emoji icon URL from emoji ID
+  def emoji_icon_url(emoji_id, format = 'webp')
+    "#{cdn_url}/emojis/#{emoji_id}.#{format}"
+  end
+
+  # Make an asset URL from application and asset IDs
+  def asset_url(application_id, asset_id, format = 'webp')
+    "#{cdn_url}/app-assets/#{application_id}/#{asset_id}.#{format}"
+  end
+
+  # Make an achievement icon URL from application ID, achievement ID, and icon hash
+  def achievement_icon_url(application_id, achievement_id, icon_hash, format = 'webp')
+    "#{cdn_url}/app-assets/#{application_id}/achievements/#{achievement_id}/icons/#{icon_hash}.#{format}"
+  end
+
+  # @param role_id [String, Integer]
+  # @param icon_hash [String]
+  # @param format ['webp', 'png', 'jpeg']
+  # @return [String]
+  def role_icon_url(role_id, icon_hash, format = 'webp')
+    "#{cdn_url}/role-icons/#{role_id}/#{icon_hash}.#{format}"
+  end
+
+  # make an avatar decoration URL from an avatar decoration ID.
+  def avatar_decoration_url(avatar_decoration_id, format = 'png')
+    "#{cdn_url}/avatar-decoration-presets/#{avatar_decoration_id}.#{format}"
+  end
+
+  # make a static nameplate URL from the nameplate asset.
+  def static_nameplate_url(nameplate_asset, format = 'png')
+    "#{cdn_url}/assets/collectibles/#{nameplate_asset.delete_suffix('/')}/static.#{format}"
+  end
+
+  # make a nameplate URL from the nameplate asset.
+  def nameplate_url(nameplate_asset, format = 'webm')
+    "#{cdn_url}/assets/collectibles/#{nameplate_asset.delete_suffix('/')}/asset.#{format}"
+  end
+
+  # make a server tag badge URL from a server ID and badge ID.
+  def server_tag_badge_url(server_id, badge_id, format = 'webp')
+    "#{cdn_url}/guild-tag-badges/#{server_id}/#{badge_id}.#{format}"
+  end
+
+  # make a scheduled event cover URL from a scheduled event ID and a cover ID.
+  def scheduled_event_cover_url(scheduled_event_id, cover_id, format = 'webp', size = nil)
+    "#{cdn_url}/guild-events/#{scheduled_event_id}/#{cover_id}.#{format}#{"?size=#{size}" if size}"
+  end
+
+  # make a cover image URL from application and cover IDs.
+  def app_cover_url(app_id, cover_id, format = 'webp')
+    "#{cdn_url}/app-icons/#{app_id}/#{cover_id}.#{format}"
+  end
+
+  # make a team icon URL from team and icon IDs.
+  def team_icon_url(team_id, icon_id, format = 'webp')
+    "#{cdn_url}/team-icons/#{team_id}/#{icon_id}.#{format}"
+  end
+
+  # Change an OAuth application's properties
+  # @deprecated Please use {Application#update_current_application} instead.
+  def update_oauth_application(token, name, redirect_uris, description = '', icon = nil)
+    request(
+      :oauth2_applications,
+      nil,
+      :put,
+      "#{api_base}/oauth2/applications",
+      { name: name, redirect_uris: redirect_uris, description: description, icon: icon }.to_json,
+      Authorization: token,
+      content_type: :json
+    )
+  end
+
+  # Get the bot's OAuth application's information
+  def oauth_application(token)
+    request(
+      :oauth2_applications_me,
+      nil,
+      :get,
+      "#{api_base}/applications/@me",
+      Authorization: token
+    )
+  end
+
+  # Get the gateway to be used
+  def gateway(token)
+    request(
+      :gateway,
+      nil,
+      :get,
+      "#{api_base}/gateway",
+      Authorization: token
+    )
+  end
+
+  # Get the gateway to be used, with additional information for sharding and
+  # session start limits
+  def gateway_bot(token)
+    request(
+      :gateway_bot,
+      nil,
+      :get,
+      "#{api_base}/gateway/bot",
+      Authorization: token
+    )
+  end
+
+  # Get a list of available voice regions
+  def voice_regions(token)
+    request(
+      :voice_regions,
+      nil,
+      :get,
+      "#{api_base}/voice/regions",
+      Authorization: token,
+      content_type: :json
+    )
+  end
+end
+
+OnyxCord::API.reset_mutexes

data/lib/onyxcord/await.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  # Awaits are a way to register new, temporary event handlers on the fly. Awaits can be
+  # registered using {Bot#add_await}, {User#await}, {Message#await} and {Channel#await}.
+  #
+  # Awaits contain a block that will be called before the await event will be triggered.
+  # If this block returns anything that is not `false` exactly, the await will be deleted.
+  # If no block is present, the await will also be deleted. This is an easy way to make
+  # temporary events that are only temporary under certain conditions.
+  #
+  # Besides the given block, an {OnyxCord::Events::AwaitEvent} will also be executed with the key and
+  # the type of the await that was triggered. It's possible to register multiple events
+  # that trigger on the same await.
+  class Await
+    # The key that uniquely identifies this await.
+    # @return [Symbol] The unique key.
+    attr_reader :key
+
+    # The class of the event that this await listens for.
+    # @return [Class] The event class.
+    attr_reader :type
+
+    # The attributes of the event that will be listened for.
+    # @return [Hash] A hash of attributes.
+    attr_reader :attributes
+
+    # Makes a new await. For internal use only.
+    # @!visibility private
+    def initialize(bot, key, type, attributes, block = nil)
+      @bot = bot
+      @key = key
+      @type = type
+      @attributes = attributes
+      @block = block
+    end
+
+    # Checks whether the await can be triggered by the given event, and if it can, execute the block
+    # and return its result along with this await's key.
+    # @param event [Event] An event to check for.
+    # @return [Array] This await's key and whether or not it should be deleted. If there was no match, both are nil.
+    def match(event)
+      dummy_handler = EventContainer.handler_class(@type).new(@attributes, @bot)
+      return [nil, nil] unless event.instance_of?(@type) && dummy_handler.matches?(event)
+
+      should_delete = true if (@block && @block.call(event) != false) || !@block
+
+      [@key, should_delete]
+    end
+  end
+end