onyxcord 2.0.13 → 3.2.0

data/lib/onyxcord/core/bot/application_commands.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  class Bot
+    module ApplicationCommands
+      # Get all application commands.
+      # @param server_id [String, Integer, nil] The ID of the server to get the commands from. Global if `nil`.
+      # @return [Array<ApplicationCommand>]
+      def get_application_commands(server_id: nil)
+        resp = if server_id
+                 REST::Application.get_guild_commands(@token, profile.id, server_id)
+               else
+                 REST::Application.get_global_commands(@token, profile.id)
+               end
+
+        JSON.parse(resp).map do |command_data|
+          ApplicationCommand.new(command_data, self, server_id)
+        end
+      end
+
+      # Get an application command by ID.
+      # @param command_id [String, Integer]
+      # @param server_id [String, Integer, nil] The ID of the server to get the command from. Global if `nil`.
+      def get_application_command(command_id, server_id: nil)
+        resp = if server_id
+                 REST::Application.get_guild_command(@token, profile.id, server_id, command_id)
+               else
+                 REST::Application.get_global_command(@token, profile.id, command_id)
+               end
+        ApplicationCommand.new(JSON.parse(resp), self, server_id)
+      end
+
+      # @return [OnyxCord::Interactions::Registry]
+      def commands
+        @commands ||= ApplicationCommands::Registry.new(self)
+      end
+
+      def slash(name, description: nil, **attributes, &block)
+        commands.slash(name, description: description, **attributes, &block)
+      end
+
+      def user_command(name, **attributes, &block)
+        commands.user(name, **attributes, &block)
+      end
+
+      def message_command(name, **attributes, &block)
+        commands.message(name, **attributes, &block)
+      end
+
+      def sync_application_commands!(server_id: nil, delete_unknown: false)
+        commands.sync!(server_id: server_id, delete_unknown: delete_unknown)
+      end
+
+      def bulk_overwrite_global_application_commands(commands)
+        response = REST::Application.bulk_overwrite_global_commands(@token, profile.id, commands)
+        JSON.parse(response).map { |data| ApplicationCommand.new(data, self) }
+      end
+
+      def bulk_overwrite_guild_application_commands(server_id, commands)
+        response = REST::Application.bulk_overwrite_guild_commands(@token, profile.id, server_id.resolve_id, commands)
+        JSON.parse(response).map { |data| ApplicationCommand.new(data, self, server_id) }
+      end
+
+      # @yieldparam [OptionBuilder]
+      # @yieldparam [PermissionBuilder]
+      # @example
+      #   bot.register_application_command(:reddit, 'Reddit Commands') do |cmd|
+      #     cmd.subcommand_group(:subreddit, 'Subreddit Commands') do |group|
+      #       group.subcommand(:hot, "What's trending") do |sub|
+      #         sub.string(:subreddit, 'Subreddit to search')
+      #       end
+      #       group.subcommand(:new, "What's new") do |sub|
+      #         sub.string(:since, 'How long ago', choices: ['this hour', 'today', 'this week', 'this month', 'this year', 'all time'])
+      #         sub.string(:subreddit, 'Subreddit to search')
+      #       end
+      #     end
+      #   end
+      def register_application_command(name, description, server_id: nil, default_permission: nil, type: :chat_input, default_member_permissions: nil, contexts: nil, nsfw: false, integration_types: nil)
+        type = ApplicationCommand::TYPES[type] || type
+
+        contexts = contexts&.map { |context| Interaction::CONTEXTS[context] || context }
+        integration_types = integration_types&.map { |type| Interaction::INTEGRATION_TYPES[type] || type }
+        default_member_permissions = Permissions.bits(default_member_permissions) if default_member_permissions.is_a?(Array)
+
+        builder = Interactions::OptionBuilder.new
+        permission_builder = Interactions::PermissionBuilder.new
+        yield(builder, permission_builder) if block_given?
+
+        resp = if server_id
+                 REST::Application.create_guild_command(@token, profile.id, server_id, name, description, builder.to_a, default_permission, type, default_member_permissions&.to_s, contexts, nsfw)
+               else
+                 REST::Application.create_global_command(@token, profile.id, name, description, builder.to_a, default_permission, type, default_member_permissions&.to_s, contexts, nsfw, integration_types)
+               end
+        cmd = ApplicationCommand.new(JSON.parse(resp), self, server_id)
+
+        if permission_builder.to_a.any?
+          raise ArgumentError, 'Permissions can only be set for guild commands' unless server_id
+
+          edit_application_command_permissions(cmd.id, server_id, permission_builder.to_a)
+        end
+
+        cmd
+      end
+
+      # @yieldparam [OptionBuilder]
+      # @yieldparam [PermissionBuilder]
+      def edit_application_command(command_id, server_id: nil, name: nil, description: nil, default_permission: nil, type: :chat_input, default_member_permissions: nil, contexts: nil, nsfw: nil, integration_types: nil)
+        type = ApplicationCommand::TYPES[type] || type
+
+        contexts = contexts&.map { |context| Interaction::CONTEXTS[context] || context }
+        integration_types = integration_types&.map { |type| Interaction::INTEGRATION_TYPES[type] || type }
+        default_member_permissions = Permissions.bits(default_member_permissions) if default_member_permissions.is_a?(Array)
+
+        builder = Interactions::OptionBuilder.new
+        permission_builder = Interactions::PermissionBuilder.new
+
+        yield(builder, permission_builder) if block_given?
+
+        resp = if server_id
+                 REST::Application.edit_guild_command(@token, profile.id, server_id, command_id, name, description, builder.to_a, default_permission, type, default_member_permissions&.to_s, contexts, nsfw)
+               else
+                 REST::Application.edit_global_command(@token, profile.id, command_id, name, description, builder.to_a, default_permission, type, default_member_permissions&.to_s, contexts, nsfw, integration_types)
+               end
+        cmd = ApplicationCommand.new(JSON.parse(resp), self, server_id)
+
+        if permission_builder.to_a.any?
+          raise ArgumentError, 'Permissions can only be set for guild commands' unless server_id
+
+          edit_application_command_permissions(cmd.id, server_id, permission_builder.to_a)
+        end
+
+        cmd
+      end
+
+      # Remove an application command from the commands registered with discord.
+      # @param command_id [String, Integer] The ID of the command to remove.
+      # @param server_id [String, Integer] The ID of the server to delete this command from, global if `nil`.
+      def delete_application_command(command_id, server_id: nil)
+        if server_id
+          REST::Application.delete_guild_command(@token, profile.id, server_id, command_id)
+        else
+          REST::Application.delete_global_command(@token, profile.id, command_id)
+        end
+      end
+
+      # @param command_id [Integer, String]
+      # @param server_id [Integer, String]
+      # @param permissions [Array<Hash>] An array of objects formatted as `{ id: ENTITY_ID, type: 1 or 2, permission: true or false }`
+      # @param bearer_token [String] A valid bearer token that has permission to manage the server and its roles.
+      def edit_application_command_permissions(command_id, server_id, permissions = [], bearer_token = nil)
+        builder = Interactions::PermissionBuilder.new
+        yield builder if block_given?
+
+        raise ArgumentError, 'This method requires a valid bearer token to be provided' unless bearer_token
+
+        permissions += builder.to_a
+        bearer_token = "Bearer #{bearer_token.delete_prefix('Bearer ')}"
+        REST::Application.edit_guild_command_permissions(bearer_token, profile.id, server_id, command_id, permissions)
+      end
+
+      # Get the permissions for all of the application commands in a specific server.
+      # @param server_id [Integer, String, nil] The ID of the server to fetch application command permissions for.
+      # @return [Array<ApplicationCommand::Permission>] The permissions for all of the application commands in the given server.
+      def application_command_permissions(server_id:)
+        response = REST::Application.get_guild_application_command_permissions(@token, profile.id, server_id.resolve_id)
+        JSON.parse(response).flat_map { |data| data['permissions'].map { |inner| ApplicationCommand::Permission.new(inner, data, self) } }
+      end
+
+      # Fetches all the application emojis that the bot can use.
+      # @return [Array<Emoji>] Returns an array of emoji objects.
+      def application_emojis
+        response = REST::Application.list_application_emojis(@token, profile.id)
+        JSON.parse(response)['items'].map { |emoji| Emoji.new(emoji, self) }
+      end
+
+      # Fetches a single application emoji from its ID.
+      # @param emoji_id [Integer, String] ID of the application emoji.
+      # @return [Emoji] The application emoji.
+      def application_emoji(emoji_id)
+        response = REST::Application.get_application_emoji(@token, profile.id, emoji_id.resolve_id)
+        Emoji.new(JSON.parse(response), self)
+      end
+
+      # Creates a new custom emoji that can be used by this application.
+      # @param name [String] The name of emoji to create.
+      # @param image [String, #read] Base64 string with the image data, or an object that responds to #read.
+      # @return [Emoji] The emoji that has been created.
+      def create_application_emoji(name:, image:)
+        image = image.respond_to?(:read) ? OnyxCord.encode64(image) : image
+        response = REST::Application.create_application_emoji(@token, profile.id, name, image)
+        Emoji.new(JSON.parse(response), self)
+      end
+
+      # Edits an existing application emoji.
+      # @param emoji_id [Integer, String, Emoji] ID of the application emoji to edit.
+      # @param name [String] The new name of the emoji.
+      # @return [Emoji] Returns the updated emoji object on success.
+      def edit_application_emoji(emoji_id, name:)
+        response = REST::Application.edit_application_emoji(@token, profile.id, emoji_id.resolve_id, name)
+        Emoji.new(JSON.parse(response), self)
+      end
+
+      # Deletes an existing application emoji.
+      # @param emoji_id [Integer, String, Emoji] ID of the application emoji to delete.
+      def delete_application_emoji(emoji_id)
+        REST::Application.delete_application_emoji(@token, profile.id, emoji_id.resolve_id)
+      end
+    end
+  end
+end

data/lib/onyxcord/core/bot/awaits.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  class Bot
+    module Awaits
+      # Add an await the bot should listen to. For information on awaits, see {Await}.
+      # @param key [Symbol] The key that uniquely identifies the await for {AwaitEvent}s to listen to (see {#await}).
+      # @param type [Class] The event class that should be listened for.
+      # @param attributes [Hash] The attributes the event should check for. The block will only be executed if all attributes match.
+      # @yield Is executed when the await is triggered.
+      # @yieldparam event [Event] The event object that was triggered.
+      # @return [Await] The await that was created.
+      # @deprecated Will be changed to blocking behavior in v4.0. Use {#add_await!} instead.
+      def add_await(key, type, attributes = {}, &block)
+        raise "You can't await an AwaitEvent!" if type == OnyxCord::Events::AwaitEvent
+
+        await = Await.new(self, key, type, attributes, block)
+        @awaits ||= {}
+        @awaits[key] = await
+      end
+
+      # Awaits an event, blocking the current thread until a response is received.
+      # @param type [Class] The event class that should be listened for.
+      # @option attributes [Numeric] :timeout the amount of time (in seconds) to wait for a response before returning `nil`. Waits forever if omitted.
+      # @yield Executed when a matching event is received.
+      # @yieldparam event [Event] The event object that was triggered.
+      # @yieldreturn [true, false] Whether the event matches extra await criteria described by the block
+      # @return [Event, nil] The event object that was triggered, or `nil` if a `timeout` was set and no event was raised in time.
+      # @raise [ArgumentError] if `timeout` is given and is not a positive numeric value
+      def add_await!(type, attributes = {})
+        raise "You can't await an AwaitEvent!" if type == OnyxCord::Events::AwaitEvent
+
+        timeout = attributes[:timeout]
+        raise ArgumentError, 'Timeout must be a number > 0' if timeout.is_a?(Numeric) && !timeout.positive?
+
+        mutex = Mutex.new
+        cv = ConditionVariable.new
+        response = nil
+        block = lambda do |event|
+          mutex.synchronize do
+            response = event
+            if block_given?
+              result = yield(event)
+              cv.signal if result.is_a?(TrueClass)
+            else
+              cv.signal
+            end
+          end
+        end
+
+        handler = register_event(type, attributes, block)
+
+        if timeout
+          Thread.new do
+            sleep timeout
+            mutex.synchronize { cv.signal }
+          end
+        end
+
+        mutex.synchronize { cv.wait(mutex) }
+
+        remove_handler(handler)
+        raise 'ConditionVariable was signaled without returning an event!' if response.nil? && timeout.nil?
+
+        response
+      end
+
+      # Add a user to the list of ignored users. Those users will be ignored in message events at event processing level.
+      # @note Ignoring a user only prevents any message events (including mentions, commands etc.) from them! Typing and
+      #   presence and any other events will still be received.
+      # @param user [User, String, Integer] The user, or its ID, to be ignored.
+      def ignore_user(user)
+        @ignored_ids << user.resolve_id
+      end
+
+      # Remove a user from the ignore list.
+      # @param user [User, String, Integer] The user, or its ID, to be unignored.
+      def unignore_user(user)
+        @ignored_ids.delete(user.resolve_id)
+      end
+
+      # Checks whether a user is being ignored.
+      # @param user [User, String, Integer] The user, or its ID, to check.
+      # @return [true, false] whether or not the user is ignored.
+      def ignored?(user)
+        @ignored_ids.include?(user.resolve_id)
+      end
+
+      # @see Logger#debug
+      def debug(message)
+        LOGGER.debug(message)
+      end
+
+      # @see Logger#log_exception
+      def log_exception(e)
+        LOGGER.log_exception(e)
+      end
+
+      # Dispatches an event to this bot. Called by the gateway connection handler used internally.
+      def dispatch(type, data = nil)
+        return dispatch_packet(type) if data.nil? && type.is_a?(Hash)
+
+        handle_dispatch(type, data)
+      end
+
+      # Raises a heartbeat event. Called by the gateway connection handler used internally.
+      def raise_heartbeat_event
+        raise_event(HeartbeatEvent.new(self))
+      end
+    end
+  end
+end

data/lib/onyxcord/core/bot/invites.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  class Bot
+    module Invites
+      # Makes the bot join an invite to a server.
+      # @param invite [String, Invite] The invite to join. For possible formats see {#resolve_invite_code}.
+      def accept_invite(invite)
+        resolved = invite(invite).code
+        REST::Invite.accept(token, resolved)
+      end
+
+      # Creates an OAuth invite URL that can be used to invite this bot to a particular server.
+      # @param server [Server, nil] The server the bot should be invited to, or nil if a general invite should be created.
+      # @param permission_bits [String, Integer] Permission bits that should be appended to invite url.
+      # @param redirect_uri [String] Redirect URI that should be appended to invite url.
+      # @param scopes [Array<String>] Scopes that should be appended to invite url.
+      # @return [String] the OAuth invite URL.
+      def invite_url(server: nil, permission_bits: nil, redirect_uri: nil, scopes: ['bot'])
+        @client_id ||= bot_application.id
+
+        query = URI.encode_www_form({
+          client_id: @client_id,
+          guild_id: server&.id,
+          permissions: permission_bits,
+          redirect_uri: redirect_uri,
+          scope: scopes.join(' ')
+        }.compact)
+
+        "https://discord.com/oauth2/authorize?#{query}"
+      end
+
+      # Revokes an invite to a server. Will fail unless you have the *Manage Server* permission.
+      # It is recommended that you use {Invite#delete} instead.
+      # @param code [String, Invite] The invite to revoke. For possible formats see {#resolve_invite_code}.
+      def delete_invite(code)
+        invite = resolve_invite_code(code)
+        REST::Invite.delete(token, invite)
+      end
+    end
+  end
+end

data/lib/onyxcord/core/bot/messaging.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  class Bot
+    module Messaging
+      # Sends a text message to a channel given its ID and the message's content.
+      # @param channel [Channel, String, Integer] The channel, or its ID, to send something to.
+      # @param content [String] The text that should be sent as a message. It is limited to 2000 characters (Discord imposed).
+      # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
+      # @param embeds [Hash, OnyxCord::Webhooks::Embed, Array<Hash>, Array<OnyxCord::Webhooks::Embed> nil] The rich embed(s) to append to this message.
+      # @param allowed_mentions [Hash, OnyxCord::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
+      # @param message_reference [Message, String, Integer, Hash, 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), SUPPRESS_NOTIFICATIONS (1 << 12), and IS_COMPONENTS_V2 (1 << 15) can be set.
+      # @param nonce [String, nil] A optional nonce in order to verify that a message was sent. Maximum of twenty-five characters.
+      # @param enforce_nonce [true, false] Whether the nonce should be enforced and used for message de-duplication.
+      # @param poll [Hash, Poll::Builder, Poll, nil] The poll that should be attached to this message.
+      # @return [Message] The message that was sent.
+      def send_message(channel, content, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0, nonce = nil, enforce_nonce = false, poll = nil)
+        channel = channel.resolve_id
+        debug("Sending message to #{channel} with content '#{content}'")
+        allowed_mentions = { parse: [] } if allowed_mentions == false
+        message_reference = { message_id: message_reference.resolve_id } if message_reference.respond_to?(:resolve_id)
+        embeds = (embeds.instance_of?(Array) ? embeds.map(&:to_hash) : [embeds&.to_hash]).compact
+        flags = OnyxCord::MessageComponents.apply_v2_flag(flags, components)
+
+        response = REST::Channel.create_message(token, channel, content, tts, embeds, nonce, attachments, allowed_mentions&.to_hash, message_reference, components, flags, enforce_nonce, poll&.to_h)
+        Message.new(JSON.parse(response), self)
+      end
+
+      # Sends a text message to a channel given its ID and the message's content,
+      # then deletes it after the specified timeout in seconds.
+      # @param channel [Channel, String, Integer] The channel, or its ID, to send something to.
+      # @param content [String] The text that should be sent as a message. It is limited to 2000 characters (Discord imposed).
+      # @param timeout [Float] The amount of time in seconds after which the message sent will be deleted.
+      # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
+      # @param embeds [Hash, OnyxCord::Webhooks::Embed, Array<Hash>, Array<OnyxCord::Webhooks::Embed> nil] The rich embed(s) to append to this message.
+      # @param attachments [Array<File>] Files that can be referenced in embeds via `attachment://file.png`
+      # @param allowed_mentions [Hash, OnyxCord::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), SUPPRESS_NOTIFICATIONS (1 << 12), and IS_COMPONENTS_V2 (1 << 15) can be set.
+      # @param nonce [String, nil] A optional nonce in order to verify that a message was sent. Maximum of twenty-five characters.
+      # @param enforce_nonce [true, false] Whether the nonce should be enforced and used for message de-duplication.
+      # @param poll [Hash, Poll::Builder, Poll, nil] The poll that should be attached to this message.
+      def send_temporary_message(channel, content, timeout, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0, nonce = nil, enforce_nonce = false, poll = nil)
+        Internal::AsyncRuntime.async do
+          message = send_message(channel, content, tts, embeds, attachments, allowed_mentions, message_reference, components, flags, nonce, enforce_nonce, poll)
+          Internal::AsyncRuntime.sleep(timeout)
+          message.delete
+        end
+
+        nil
+      end
+
+      # Sends a file to a channel. If it is an image, it will automatically be embedded.
+      # @note This executes in a blocking way, so if you're sending long files, be wary of delays.
+      # @param channel [Channel, String, Integer] The channel, or its ID, to send something to.
+      # @param file [File] The file that should be sent.
+      # @param caption [string] The caption for the file.
+      # @param tts [true, false] Whether or not this file's caption should be sent using Discord text-to-speech.
+      # @param filename [String] Overrides the filename of the uploaded file
+      # @param spoiler [true, false] Whether or not this file should appear as a spoiler.
+      # @example Send a file from disk
+      #   bot.send_file(83281822225530880, File.open('rubytaco.png', 'r'))
+      def send_file(channel, file, caption: nil, tts: false, filename: nil, spoiler: nil)
+        if file.respond_to?(:read)
+          if spoiler
+            filename ||= File.basename(file.path)
+            filename = "SPOILER_#{filename}" unless filename.start_with? 'SPOILER_'
+          end
+          file.define_singleton_method(:original_filename) { filename } if filename
+          file.define_singleton_method(:path) { filename } if filename
+        end
+
+        channel = channel.resolve_id
+        response = REST::Channel.upload_file(token, channel, file, caption: caption, tts: tts)
+        Message.new(JSON.parse(response), self)
+      end
+
+      # Gets the users, channels, roles and emoji from a string.
+      # @param mentions [String] The mentions, which should look like `<@12314873129>`, `<#123456789>`, `<@&123456789>` or `<:name:126328:>`.
+      # @param server [Server, nil] The server of the associated mentions. (recommended for role parsing, to speed things up)
+      # @return [Array<User, Channel, Role, Emoji>] The array of users, channels, roles and emoji identified by the mentions, or `nil` if none exists.
+      def parse_mentions(mentions, server = nil)
+        array_to_return = []
+        # While possible mentions may be in message
+        while mentions.include?('<') && mentions.include?('>')
+          # Removing all content before the next possible mention
+          mentions = mentions.split('<', 2)[1]
+          # Locate the first valid mention enclosed in `<...>`, otherwise advance to the next open `<`
+          next unless mentions.split('>', 2).first.length < mentions.split('<', 2).first.length
+
+          # Store the possible mention value to be validated with RegEx
+          mention = mentions.split('>', 2).first
+          if /@!?(?<id>\d+)/ =~ mention
+            array_to_return << user(id) unless user(id).nil?
+          elsif /#(?<id>\d+)/ =~ mention
+            array_to_return << channel(id, server) unless channel(id, server).nil?
+          elsif /@&(?<id>\d+)/ =~ mention
+            if server
+              array_to_return << server.role(id) unless server.role(id).nil?
+            else
+              @servers.each_value do |element|
+                array_to_return << element.role(id) unless element.role(id).nil?
+              end
+            end
+          elsif /(?<animated>^a|^${0}):(?<name>\w+):(?<id>\d+)/ =~ mention
+            array_to_return << (emoji(id) || Emoji.new({ 'animated' => animated != '', 'name' => name, 'id' => id }, self, nil))
+          end
+        end
+        array_to_return
+      end
+
+      # Gets the user, channel, role or emoji from a string.
+      # @param mention [String] The mention, which should look like `<@12314873129>`, `<#123456789>`, `<@&123456789>` or `<:name:126328:>`.
+      # @param server [Server, nil] The server of the associated mention. (recommended for role parsing, to speed things up)
+      # @return [User, Channel, Role, Emoji] The user, channel, role or emoji identified by the mention, or `nil` if none exists.
+      def parse_mention(mention, server = nil)
+        parse_mentions(mention, server).first
+      end
+
+      # Join a thread
+      # @param channel [Channel, Integer, String]
+      def join_thread(channel)
+        REST::Channel.join_thread(@token, channel.resolve_id)
+        nil
+      end
+
+      # Leave a thread
+      # @param channel [Channel, Integer, String]
+      def leave_thread(channel)
+        REST::Channel.leave_thread(@token, channel.resolve_id)
+        nil
+      end
+
+      # Add a member to a thread
+      # @param channel [Channel, Integer, String]
+      # @param member [Member, Integer, String]
+      def add_thread_member(channel, member)
+        REST::Channel.add_thread_member(@token, channel.resolve_id, member.resolve_id)
+        nil
+      end
+
+      # Remove a member from a thread
+      # @param channel [Channel, Integer, String]
+      # @param member [Member, Integer, String]
+      def remove_thread_member(channel, member)
+        REST::Channel.remove_thread_member(@token, channel.resolve_id, member.resolve_id)
+        nil
+      end
+
+      # Makes the bot leave any groups with no recipients remaining
+      def prune_empty_groups
+        @channels.each_value do |channel|
+          channel.leave_group if channel.group? && channel.recipients.empty?
+        end
+      end
+    end
+  end
+end

data/lib/onyxcord/core/bot/oauth.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  class Bot
+    module OAuth
+      # Creates a new application to do OAuth authorization with. This allows you to use OAuth to authorize users using
+      # Discord. For information how to use this, see the docs: https://discord.com/developers/docs/topics/oauth2
+      # @param name [String] What your application should be called.
+      # @param redirect_uris [Array<String>] URIs that Discord should redirect your users to after authorizing.
+      # @return [Array(String, String)] your applications' client ID and client secret to be used in OAuth authorization.
+      def create_oauth_application(name, redirect_uris)
+        response = JSON.parse(REST.create_oauth_application(@token, name, redirect_uris))
+        [response['id'], response['secret']]
+      end
+
+      # Changes information about your OAuth application
+      # @param name [String] What your application should be called.
+      # @param redirect_uris [Array<String>] URIs that Discord should redirect your users to after authorizing.
+      # @param description [String] A string that describes what your application does.
+      # @param icon [String, nil] A data URI for your icon image (for example a base 64 encoded image), or nil if no icon
+      #   should be set or changed.
+      def update_oauth_application(name, redirect_uris, description = '', icon = nil)
+        REST.update_oauth_application(@token, name, redirect_uris, description, icon)
+      end
+    end
+  end
+end

data/lib/onyxcord/core/bot/presence.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  class Bot
+    module Presence
+      # Updates presence status.
+      # @param status [String] The status the bot should show up as. Can be `online`, `dnd`, `idle`, or `invisible`
+      # @param activity [String, nil] The name of the activity to be played/watched/listened to/stream name on the stream.
+      # @param url [String, nil] The Twitch URL to display as a stream. nil for no stream.
+      # @param since [Integer] When this status was set.
+      # @param afk [true, false] Whether the bot is AFK.
+      # @param activity_type [Integer] The type of activity status to display.
+      #   Can be 0 (Playing), 1 (Streaming), 2 (Listening), 3 (Watching), or 5 (Competing).
+      # @see Gateway#send_status_update
+      def update_status(status, activity, url, since = 0, afk = false, activity_type = 0)
+        gateway_check
+
+        @activity = activity
+        @status = status
+        @streamurl = url
+        type = url ? 1 : activity_type
+
+        activity_obj = activity || url ? { 'name' => activity, 'url' => url, 'type' => type } : nil
+        @gateway.send_status_update(status, since, activity_obj, afk)
+
+        # Update the status in the cache
+        profile.update_presence('status' => status.to_s, 'activities' => [activity_obj].compact)
+      end
+
+      # Sets the currently playing game to the specified game.
+      # @param name [String] The name of the game to be played.
+      # @return [String] The game that is being played now.
+      def game=(name)
+        gateway_check
+        update_status(@status, name, nil)
+      end
+
+      alias_method :playing=, :game=
+
+      # Sets the current listening status to the specified name.
+      # @param name [String] The thing to be listened to.
+      # @return [String] The thing that is now being listened to.
+      def listening=(name)
+        gateway_check
+        update_status(@status, name, nil, nil, nil, 2)
+      end
+
+      # Sets the current watching status to the specified name.
+      # @param name [String] The thing to be watched.
+      # @return [String] The thing that is now being watched.
+      def watching=(name)
+        gateway_check
+        update_status(@status, name, nil, nil, nil, 3)
+      end
+
+      # Sets the currently online stream to the specified name and Twitch URL.
+      # @param name [String] The name of the stream to display.
+      # @param url [String] The url of the current Twitch stream.
+      # @return [String] The stream name that is being displayed now.
+      def stream(name, url)
+        gateway_check
+        update_status(@status, name, url)
+        name
+      end
+
+      # Sets the currently competing status to the specified name.
+      # @param name [String] The name of the game to be competing in.
+      # @return [String] The game that is being competed in now.
+      def competing=(name)
+        gateway_check
+        update_status(@status, name, nil, nil, nil, 5)
+      end
+
+      # Sets status to online.
+      def online
+        gateway_check
+        update_status(:online, @activity, @streamurl)
+      end
+
+      alias_method :on, :online
+
+      # Sets status to idle.
+      def idle
+        gateway_check
+        update_status(:idle, @activity, nil)
+      end
+
+      alias_method :away, :idle
+
+      # Sets the bot's status to DnD (red icon).
+      def dnd
+        gateway_check
+        update_status(:dnd, @activity, nil)
+      end
+
+      # Sets the bot's status to invisible (appears offline).
+      def invisible
+        gateway_check
+        update_status(:invisible, @activity, nil)
+      end
+    end
+  end
+end