discorb 0.16.0 → 0.17.0

data/lib/discorb/app_command/handler.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 module Discorb
-  #
-  # Handles application commands.
-  #
   module ApplicationCommand
     #
     # Module to handle application commands.
@@ -12,44 +9,83 @@ module Discorb
       #
       # Add new top-level command.
       #
-      # @param [String] command_name Command name.
-      # @param [String] description Command description.
-      # @param [Hash{String => Hash{:description => String, :optional => Boolean, :type => Object}}] options Command options.
+      # @param [String, Hash{Symbol => String}] command_name Command name.
+      #  If hash is passed, it must be a pair of Language code and Command name, and `:default` key is required.
+      #  You can use `_` instead of `-` in language code.
+      # @param [String, Hash{Symbol => String}] description Command description.
+      #   If hash is passed, it must be a pair of Language code and Command description, and `:default` key is required.
+      #  You can use `_` instead of `-` in language code.
+      # @param [Hash{String => Hash{:description => String, :optional => Boolean, :type => Object}}] options
+      #  Command options.
       #   The key is the option name, the value is a hash with the following keys:
       #
       #   | Key | Type | Description |
       #   | --- | --- | --- |
-      #   | `:description` | `String` | Description of the option. |
-      #   | `:required` | Whether the argument is required. `optional` will be used if not specified. |
-      #   | `:optional` | Whether the argument is optional. `required` will be used if not specified. |
+      #   | `:description` | `String` \| `Hash{Symbol => String}` |
+      #     Description of the option. If hash is passed, it must be a pair of Language code and description,
+      #     and `:default` key is required. You can use `_` instead of `-` in language code. |
+      #   | `:required` | Boolean(true | false) |
+      #     Whether the argument is required. `optional` will be used if not specified. |
+      #   | `:optional` | Boolean(true | false) |
+      #     Whether the argument is optional. `required` will be used if not specified. |
       #   | `:type` | `Object` | Type of the option. |
-      #   | `:choice` | `Hash{String => String, Integer, Float}` | Type of the option. |
+      #   | `:choices` | `Hash{String => String, Integer, Float}` | Type of the option. |
+      #   | `:choices_localizations` | `Hash{String => Hash{Symbol => String}}` |
+      #      Localization of the choice. Key must be the name of a choice. |
       #   | `:default` | `Object` | Default value of the option. |
       #   | `:channel_types` | `Array<Class<Discorb::Channel>>` | Type of the channel option. |
       #   | `:autocomplete` | `Proc` | Autocomplete function. |
       #   | `:range` | `Range` | Range of the option. Only valid for numeric options. (`:int`, `:float`) |
       #
-      # @param [Array<#to_s>, false, nil] guild_ids Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [Array<#to_s>, false, nil] guild_ids
+      #  Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [Boolean] dm_permission Whether the command is available in DM.
+      # @param [Discorb::Permission] default_permission The default permission of the command.
       # @param [Proc] block Command block.
       #
-      # @return [Discorb::ApplicationCommand::Command::SlashCommand] Command object.
+      # @return [Discorb::ApplicationCommand::Command::ChatInputCommand] Command object.
       #
       # @see file:docs/application_command.md#register-slash-command Application Comamnds: Register Slash Command
       # @see file:docs/cli/setup.md CLI: setup
       #
-      def slash(command_name, description, options = {}, guild_ids: nil, &block)
-        command = Discorb::ApplicationCommand::Command::SlashCommand.new(command_name, description, options, guild_ids, block, 1, "")
+      def slash(
+        command_name,
+        description,
+        options = {},
+        guild_ids: nil,
+        dm_permission: true,
+        default_permission: nil,
+        &block
+      )
+        command_name = { default: command_name } if command_name.is_a?(String)
+        description = { default: description } if description.is_a?(String)
+        command_name = ApplicationCommand.modify_localization_hash(command_name)
+        description = ApplicationCommand.modify_localization_hash(description)
+        command = Discorb::ApplicationCommand::Command::ChatInputCommand.new(
+          command_name,
+          description,
+          options,
+          guild_ids,
+          block,
+          1,
+          nil,
+          dm_permission,
+          default_permission
+        )
         @commands << command
-        @bottom_commands << command
+        @callable_commands << command
         command
       end
 
       #
       # Add new command with group.
       #
-      # @param [String] command_name Command name.
-      # @param [String] description Command description.
-      # @param [Array<#to_s>, false, nil] guild_ids Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [String, Hash{Symbol => String}] command_name Command name.
+      # @param [String, Hash{Symbol => String}] description Command description.
+      # @param [Array<#to_s>, false, nil] guild_ids
+      #  Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [Boolean] dm_permission Whether the command is available in DM.
+      # @param [Discorb::Permission] default_permission The default permission of the command.
       #
       # @yield Block to yield with the command.
       # @yieldparam [Discorb::ApplicationCommand::Command::GroupCommand] group Group command.
@@ -59,9 +95,14 @@ module Discorb
       # @see file:docs/application_command.md Application Commands
       # @see file:docs/cli/setup.md CLI: setup
       #
-      def slash_group(command_name, description, guild_ids: nil, &block)
-        command = Discorb::ApplicationCommand::Command::GroupCommand.new(command_name, description, guild_ids, nil, self)
-        command.yield_self(&block) if block_given?
+      def slash_group(command_name, description, guild_ids: nil, dm_permission: true, default_permission: nil, &block)
+        command_name = { default: command_name } if command_name.is_a?(String)
+        description = { default: description } if description.is_a?(String)
+        command_name = ApplicationCommand.modify_localization_hash(command_name)
+        description = ApplicationCommand.modify_localization_hash(description)
+        command = Discorb::ApplicationCommand::Command::GroupCommand.new(command_name, description, guild_ids, nil,
+                                                                         self, dm_permission, default_permission)
+        command.then(&block) if block_given?
         @commands << command
         command
       end
@@ -69,8 +110,11 @@ module Discorb
       #
       # Add message context menu command.
       #
-      # @param [String] command_name Command name.
-      # @param [Array<#to_s>, false, nil] guild_ids Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [String, Hash{Symbol => String}] command_name Command name.
+      # @param [Array<#to_s>, false, nil] guild_ids
+      #  Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [Boolean] dm_permission Whether the command is available in DM.
+      # @param [Discorb::Permission] default_permission The default permission of the command.
       # @param [Proc] block Command block.
       # @yield [interaction, message] Block to execute.
       # @yieldparam [Discorb::CommandInteraction::UserMenuCommand] interaction Interaction object.
@@ -78,8 +122,11 @@ module Discorb
       #
       # @return [Discorb::ApplicationCommand::Command] Command object.
       #
-      def message_command(command_name, guild_ids: nil, &block)
-        command = Discorb::ApplicationCommand::Command.new(command_name, guild_ids, block, 3)
+      def message_command(command_name, guild_ids: nil, dm_permission: true, default_permission: nil, &block)
+        command_name = { default: command_name } if command_name.is_a?(String)
+        command_name = ApplicationCommand.modify_localization_hash(command_name)
+        command = Discorb::ApplicationCommand::Command.new(command_name, guild_ids, block, 3, dm_permission,
+                                                           default_permission)
         @commands << command
         command
       end
@@ -87,8 +134,11 @@ module Discorb
       #
       # Add user context menu command.
       #
-      # @param [String] command_name Command name.
-      # @param [Array<#to_s>, false, nil] guild_ids Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [String, Hash{Symbol => String}] command_name Command name.
+      # @param [Array<#to_s>, false, nil] guild_ids
+      #  Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [Boolean] dm_permission Whether the command is available in DM.
+      # @param [Discorb::Permission] default_permission The default permission of the command.
       # @param [Proc] block Command block.
       # @yield [interaction, user] Block to execute.
       # @yieldparam [Discorb::CommandInteraction::UserMenuCommand] interaction Interaction object.
@@ -96,8 +146,11 @@ module Discorb
       #
       # @return [Discorb::ApplicationCommand::Command] Command object.
       #
-      def user_command(command_name, guild_ids: nil, &block)
-        command = Discorb::ApplicationCommand::Command.new(command_name, guild_ids, block, 2)
+      def user_command(command_name, guild_ids: nil, dm_permission: true, default_permission: nil, &block)
+        command_name = { default: command_name } if command_name.is_a?(String)
+        command_name = ApplicationCommand.modify_localization_hash(command_name)
+        command = Discorb::ApplicationCommand::Command.new(command_name, guild_ids, block, 2, dm_permission,
+                                                           default_permission)
         @commands << command
         command
       end
@@ -108,7 +161,8 @@ module Discorb
       # @see Client#initialize
       #
       # @param [String] token Bot token.
-      # @param [Array<#to_s>, false, nil] guild_ids Guild IDs to use as default. If `false` is given, it will be global command.
+      # @param [Array<#to_s>, false, nil] guild_ids
+      #  Guild IDs to use as default. If `false` is given, it will be global command.
       #
       # @note `token` parameter only required if you don't run client.
       #
@@ -139,10 +193,10 @@ module Discorb
               global_commands.map(&:to_hash)
             ).wait
           end
-          if ENV["DISCORB_CLI_FLAG"] == "setup"
+          if ENV.fetch("DISCORB_CLI_FLAG", nil) == "setup"
             sputs "Registered commands for global:"
             global_commands.each do |command|
-              iputs "- #{command.name}"
+              iputs "- #{command.name["default"]}"
             end
           end
           unless final_guild_ids.empty?
@@ -156,13 +210,41 @@ module Discorb
               ).wait
               sputs "Registered commands for #{guild_id}:"
               commands.each do |command|
-                iputs "- #{command.name}"
+                iputs "- #{command.name["default"]}"
               end
             end
           end
           @logger.info "Successfully setup commands"
         end
       end
+
+      #
+      # Claer commands in specified guilds.
+      # @async
+      # @see Client#initialize
+      #
+      # @param [String] token Bot token.
+      # @param [Array<#to_s>, false, nil] guild_ids Guild IDs to clear.
+      #
+      # @note `token` parameter only required if you don't run client.
+      #
+      def clear_commands(token, guild_ids)
+        Async do
+          @token ||= token
+          @http = HTTP.new(self)
+          app_info = fetch_application.wait
+
+          guild_ids.each do |guild_id|
+            @http.request(
+              Route.new("/applications/#{app_info.id}/guilds/#{guild_id}/commands",
+                        "//applications/:application_id/guilds/:guild_id/commands",
+                        :put),
+              []
+            ).wait
+          end
+          sputs "Cleared commands for #{guild_ids.length} guilds." if ENV.fetch("DISCORB_CLI_FLAG", nil) == "setup"
+        end
+      end
     end
   end
 end

data/lib/discorb/app_command.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
-%w[command handler].each do |file|
+
+%w[common command handler].each do |file|
   require_relative "app_command/#{file}.rb"
 end

data/lib/discorb/application.rb

@@ -29,6 +29,7 @@ module Discorb
     alias bot_require_code_grant? bot_require_code_grant
     # @return [Discorb::Application::Flag] The application's flags.
     attr_reader :flags
+
     #
     # Initializes a new instance of the Application class.
     # @private

data/lib/discorb/asset.rb

@@ -51,7 +51,7 @@ module Discorb
       case @target
       when User, Member, Webhook
         "avatars"
-      when Guild, IncomingWebhook::Guild
+      when Guild, Webhook::FollowerWebhook::Guild
         "icons"
       when Application, Integration::Application
         "app-icons"
@@ -65,7 +65,6 @@ module Discorb
   # Represents a default avatar.
   #
   class DefaultAvatar < DiscordModel
-
     # @!attribute [r] animated?
     #   @return [false] For compatibility with {Asset}, always `false`.
 

data/lib/discorb/attachment.rb

@@ -70,7 +70,7 @@ module Discorb
     def initialize_hash(data)
       @id = Snowflake.new(data[:id])
       @filename = data[:filename]
-      @content_type = data[:content_type]
+      @content_type = data[:content_type] || "application/octet-stream"
       @size = data[:size]
       @url = data[:url]
       @proxy_url = data[:proxy_url]

data/lib/discorb/audit_logs.rb

@@ -21,9 +21,11 @@ module Discorb
     def initialize(client, data, guild)
       @client = client
       @guild = guild
-      @webhooks = data[:webhooks].map { |webhook| Webhook.new([@client, webhook]) }
+      @webhooks = data[:webhooks].map { |webhook| Webhook.from_data(@client, webhook) }
       @users = data[:users].map { |user| client.users[user[:id]] || User.new(@client, user) }
-      @threads = data[:threads].map { |thread| client.channels[thread[:id]] || Channel.make_channel(@client, thread, no_cache: true) }
+      @threads = data[:threads].map do |thread|
+        client.channels[thread[:id]] || Channel.make_channel(@client, thread, no_cache: true)
+      end
       @entries = data[:audit_log_entries].map { |entry| AuditLog::Entry.new(@client, entry, guild.id) }
     end
 
@@ -106,7 +108,8 @@ module Discorb
       attr_reader :type
       # @return [Discorb::AuditLog::Entry::Changes] The changes in this entry.
       attr_reader :changes
-      # @return [Discorb::Channel, Discorb::Role, Discorb::Member, Discorb::Guild, Discorb::Message] The target of the entry.
+      # @return [Discorb::Channel, Discorb::Role, Discorb::Member, Discorb::Guild, Discorb::Message]
+      #   The target of the entry.
       attr_reader :target
       # @return [Hash{Symbol => Object}] The optional data for this entry.
       # @note You can use dot notation to access the data.
@@ -193,7 +196,7 @@ module Discorb
         @user_id = Snowflake.new(data[:user_id])
         @target_id = Snowflake.new(data[:target_id])
         @type = EVENTS[data[:action_type]]
-        @target = self.class.converts[@type.to_s.split("_")[0].to_sym]&.call(client, @target_id, @gui)
+        @target = CONVERTERS[@type.to_s.split("_")[0].to_sym]&.call(client, @target_id, @gui)
         @target ||= Snowflake.new(data[:target_id])
         @changes = data[:changes] && Changes.new(data[:changes])
         @reason = data[:reason]
@@ -201,7 +204,7 @@ module Discorb
           define_singleton_method(option) { value }
           if option.end_with?("_id")
             define_singleton_method(option.to_s.sub("_id", "")) do
-              self.class.converts[option.to_s.split("_")[0].to_sym]&.call(client, value, @guild_id)
+              CONVERTERS[option.to_s.split("_")[0].to_sym]&.call(client, value, @guild_id)
             end
           end
         end
@@ -304,11 +307,11 @@ module Discorb
             when "permissions"
               ->(v) { Discorb::Permission.new(v.to_i) }
             when "status"
-              ->(v) { Discorb::ScheduledEvent.status[v] }
+              ->(v) { Discorb::ScheduledEvent::STATUS[v] }
             when "entity_type"
-              ->(v) { Discorb::ScheduledEvent.entity_type[v] }
+              ->(v) { Discorb::ScheduledEvent::ENTITY_TYPE[v] }
             when "privacy_level"
-              ->(v) { Discorb::StageInstance.privacy_level[v] || Discorb::ScheduledEvent.privacy_level[v] }
+              ->(v) { Discorb::StageInstance::PRIVACY_LEVEL[v] || Discorb::ScheduledEvent::PRIVACY_LEVEL[v] }
             else
               ->(v) { v }
             end

data/lib/discorb/channel/base.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a channel of Discord.
+  # @abstract
+  #
+  class Channel < DiscordModel
+    # @return [Discorb::Snowflake] The ID of the channel.
+    attr_reader :id
+    # @return [String] The name of the channel.
+    attr_reader :name
+
+    # @!attribute [r] type
+    #   @return [Integer] The type of the channel as integer.
+
+    @channel_type = nil
+    @subclasses = []
+
+    #
+    # Initializes a new instance of the Channel class.
+    # @private
+    #
+    def initialize(client, data, no_cache: false)
+      @client = client
+      @data = {}
+      @no_cache = no_cache
+      _set_data(data)
+    end
+
+    #
+    # Checks if the channel is other channel.
+    #
+    # @param [Discorb::Channel] other The channel to check.
+    #
+    # @return [Boolean] True if the channel is other channel.
+    #
+    def ==(other)
+      return false unless other.respond_to?(:id)
+
+      @id == other.id
+    end
+
+    def inspect
+      "#<#{self.class} \"##{@name}\" id=#{@id}>"
+    end
+
+    #
+    # Returns the descendants of the Channel class.
+    # @private
+    #
+    def self.descendants
+      ObjectSpace.each_object(Class).select { |klass| klass < self }
+    end
+
+    #
+    # Creates a new instance of the Channel class or instance of its descendants.
+    # @private
+    #
+    # @param [Discorb::Client] client The client that instantiated the object.
+    # @param [Hash] data The data of the object.
+    # @param [Boolean] no_cache Whether to disable cache the object.
+    #
+    def self.make_channel(client, data, no_cache: false)
+      descendants.each do |klass|
+        if !klass.channel_type.nil? && klass.channel_type == data[:type]
+          return klass.new(client, data,
+                           no_cache: no_cache)
+        end
+      end
+      client.logger.warn("Unknown channel type #{data[:type]}, initialized GuildChannel")
+      GuildChannel.new(client, data)
+    end
+
+    class << self
+      #
+      # @private
+      # @return [Integer] The type of the channel.
+      #
+      attr_reader :channel_type
+    end
+
+    def type
+      self.class.channel_type
+    end
+
+    #
+    # Returns the channel id to request.
+    # @private
+    #
+    # @return [Async::Task<Discorb::Snowflake>] A task that resolves to the channel id.
+    #
+    def channel_id
+      Async do
+        @id
+      end
+    end
+
+    private
+
+    def _set_data(data)
+      @id = Snowflake.new(data[:id])
+      @name = data[:name]
+      @client.channels[@id] = self if !@no_cache && !(data[:no_cache])
+      @data.update(data)
+    end
+  end
+end

data/lib/discorb/channel/category.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a category in a guild.
+  #
+  class CategoryChannel < GuildChannel
+    @channel_type = 4
+
+    include Discorb::ChannelContainer
+
+    def channels
+      @client.channels.values.filter { |channel| channel.parent == self }
+    end
+
+    def create_text_channel(*args, **kwargs)
+      guild.create_text_channel(*args, parent: self, **kwargs)
+    end
+
+    def create_voice_channel(*args, **kwargs)
+      guild.create_voice_channel(*args, parent: self, **kwargs)
+    end
+
+    def create_news_channel(*args, **kwargs)
+      guild.create_news_channel(*args, parent: self, **kwargs)
+    end
+
+    def create_stage_channel(*args, **kwargs)
+      guild.create_stage_channel(*args, parent: self, **kwargs)
+    end
+  end
+end

data/lib/discorb/channel/container.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Module for container of channels.
+  #
+  module ChannelContainer
+    #
+    # Returns text channels.
+    #
+    # @return [Array<Discorb::TextChannel>] The text channels.
+    #
+    def text_channels
+      channels.filter { |c| c.instance_of? TextChannel }
+    end
+
+    #
+    # Returns voice channels.
+    #
+    # @return [Array<Discorb::VoiceChannel>] The voice channels.
+    #
+    def voice_channels
+      channels.filter { |c| c.instance_of? VoiceChannel }
+    end
+
+    #
+    # Returns news channels.
+    #
+    # @return [Array<Discorb::NewsChannel>] The news channels.
+    #
+    def news_channels
+      channels.filter { |c| c.instance_of? NewsChannel }
+    end
+
+    #
+    # Returns stage channels.
+    #
+    # @return [Array<Discorb::StageChannel>] The stage channels.
+    #
+    def stage_channels
+      channels.filter { |c| c.instance_of? StageChannel }
+    end
+  end
+end

data/lib/discorb/channel/dm.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a DM channel.
+  #
+  class DMChannel < Channel
+    include Messageable
+
+    #
+    # Returns the channel id to request.
+    # @private
+    #
+    # @return [Async::Task<Discorb::Snowflake>] A task that resolves to the channel id.
+    #
+    def channel_id
+      Async do
+        @id
+      end
+    end
+
+    private
+
+    def _set_data(data)
+      @id = Snowflake.new(data)
+    end
+  end
+end