discorb 0.13.1 → 0.14.0

data/examples/simple/ping_pong.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "discorb"
 
 client = Discorb::Client.new

data/examples/simple/rolepanel.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "discorb"
 intents = Discorb::Intents.new
 intents.members = true

data/examples/simple/wait_for_message.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "discorb"
 
 client = Discorb::Client.new
@@ -10,16 +11,16 @@ client.on :message do |message|
   next if message.author.bot?
   next unless message.content == "!quiz"
 
-  operator = [:+, :-, :*].sample
+  operator = %i[+ - *].sample
   num1 = rand(1..10)
   num2 = rand(1..10)
 
   val = num1.send(operator, num2)
   message.channel.post("Quiz: `#{num1} #{operator} #{num2}`")
   begin
-    msg = client.event_lock(:message, 30) { |m|
+    msg = client.event_lock(:message, 30) do |m|
       m.content == val.to_s && m.channel == message.channel
-    }.wait
+    end.wait
   rescue Discorb::TimeoutError
     message.channel.post("No one answered...")
   else

data/exe/discorb

@@ -1,24 +1,25 @@
 #! /usr/bin/env ruby
+# frozen_string_literal: true
 
 script = ARGV[0]
 
 if script.nil?
   puts "\e[94mThis is a tool for discorb. Currently these tools are available:\e[m"
 
-  discorb_path = $:.find { |path| File.directory?(path + "/discorb") }
+  discorb_path = $LOAD_PATH.find { |path| File.directory?(path + "/discorb") }
   scripts = {}
-  Dir.glob(discorb_path + "/discorb/exe/*.rb") do |script|
-    name = File.basename(script, ".rb")
-    description = File.read(script).match(/# description: (.+)/)&.[](1) || "No description"
+  Dir.glob(discorb_path + "/discorb/exe/*.rb") do |exe_script|
+    name = File.basename(exe_script, ".rb")
+    description = File.read(exe_script).match(/# description: (.+)/)&.[](1) || "No description"
     scripts[name] = description
   end
-  max_length = scripts.keys.map { |key| key.length }.max
+  max_length = scripts.keys.map(&:length).max
   scripts.sort.each do |name, description|
     puts "\e[90m#{name.rjust(max_length)}\e[m - #{description}"
   end
 
-  puts "\e[94m\nTo run a tool, type:\e[m\n" +
-         "\e[34m  discorb [script]\e[m"
+  puts "\e[94m\nTo run a tool, type:\e[m\n" \
+       "\e[34m  discorb [script]\e[m"
 
   exit 1
 end

data/lib/discorb/allowed_mentions.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+module Discorb
+  #
+  # Represents a allowed mentions in a message.
+  #
+  class AllowedMentions
+    # @return [Boolean] Whether to allow @everyone or @here.
+    attr_accessor :everyone
+    # @return [Boolean, Array<Discorb::Role>] The roles to allow, or false to disable.
+    attr_accessor :roles
+    # @return [Boolean, Array<Discorb::User>] The users to allow, or false to disable.
+    attr_accessor :users
+    # @return [Boolean] Whether to ping the user that sent the message to reply.
+    attr_accessor :replied_user
+
+    #
+    # Initializes a new instance of the AllowedMentions class.
+    #
+    # @param [Boolean] everyone Whether to allow @everyone or @here.
+    # @param [Boolean, Array<Discorb::Role>] roles The roles to allow, or false to disable.
+    # @param [Boolean, Array<Discorb::User>] users The users to allow, or false to disable.
+    # @param [Boolean] replied_user Whether to ping the user that sent the message to reply.
+    #
+    def initialize(everyone: nil, roles: nil, users: nil, replied_user: nil)
+      @everyone = everyone
+      @roles = roles
+      @users = users
+      @replied_user = replied_user
+    end
+
+    def inspect
+      "#<#{self.class} @everyone=#{@everyone} @roles=#{@roles} @users=#{@users} @replied_user=#{@replied_user}>"
+    end
+
+    # @private
+    def to_hash(other = nil)
+      payload = {
+        parse: %w[everyone roles users],
+      }
+      replied_user = nil_merge(@replied_user, other&.replied_user)
+      everyone = nil_merge(@everyone, other&.everyone)
+      roles = nil_merge(@roles, other&.roles)
+      users = nil_merge(@users, other&.users)
+      payload[:replied_user] = replied_user
+      payload[:parse].delete("everyone") if everyone == false
+      if (roles == false) || roles.is_a?(Array)
+        payload[:roles] = roles.map { |u| u.id.to_s } if roles.is_a? Array
+        payload[:parse].delete("roles")
+      end
+      if (users == false) || users.is_a?(Array)
+        payload[:users] = users.map { |u| u.id.to_s } if users.is_a? Array
+        payload[:parse].delete("users")
+      end
+      payload
+    end
+
+    def nil_merge(*args)
+      args.each do |a|
+        return a unless a.nil?
+      end
+      nil
+    end
+  end
+end

data/lib/discorb/app_command/command.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Handles application commands.
+  #
+  module ApplicationCommand
+    #
+    # Represents a application command.
+    # @abstract
+    #
+    class Command < DiscordModel
+      # @return [String] The name of the command.
+      attr_reader :name
+      # @return [Array<#to_s>] The guild ids that the command is enabled in.
+      attr_reader :guild_ids
+      # @return [Proc] The block of the command.
+      attr_reader :block
+      # @return [:chat_input, :user, :message] The type of the command.
+      attr_reader :type
+      # @return [Integer] The raw type of the command.
+      attr_reader :type_raw
+      # @return [Discorb::Dictionary{Discorb::Snowflake, :global => Discorb::Snowflake}] The ID mapping.
+      attr_reader :id_map
+
+      @types = {
+        1 => :chat_input,
+        2 => :user,
+        3 => :message,
+      }.freeze
+
+      # @private
+      def initialize(name, guild_ids, block, type)
+        @name = name
+        @guild_ids = guild_ids&.map(&:to_s)
+        @block = block
+        @raw_type = type
+        @type = Discorb::ApplicationCommand::Command.types[type]
+        @type_raw = type
+        @id_map = Discorb::Dictionary.new
+      end
+
+      # @private
+      def replace_block(instance)
+        current_block = @block.dup
+        @block = proc do |*args|
+          instance.instance_exec(*args, &current_block)
+        end
+      end
+
+      # @private
+      def to_hash
+        {
+          name: @name,
+          default_permission: @default_permission,
+          type: @type_raw,
+        }
+      end
+
+      #
+      # Represents the slash command.
+      #
+      class SlashCommand < Command
+        # @return [String] The description of the command.
+        attr_reader :description
+        # @return [Hash{String => Hash}] The options of the command.
+        attr_reader :options
+
+        # @private
+        def initialize(name, description, options, guild_ids, block, type, parent)
+          super(name, guild_ids, block, type)
+          @description = description
+          @options = options
+          @id = nil
+          @parent = parent
+          @id_map = Discorb::Dictionary.new
+        end
+
+        #
+        # Returns the commands name.
+        #
+        # @return [String] The name of the command.
+        #
+        def to_s
+          (@parent + " " + @name).strip
+        end
+
+        # @private
+        def to_hash
+          options_payload = options.map do |name, value|
+            ret = {
+              type: case value[:type]
+              when String, :string, :str
+                3
+              when Integer, :integer, :int
+                4
+              when TrueClass, FalseClass, :boolean, :bool
+                5
+              when Discorb::User, Discorb::Member, :user, :member
+                6
+              when Discorb::Channel, :channel
+                7
+              when Discorb::Role, :role
+                8
+              when :mentionable
+                9
+              when Float, :float
+                10
+              when :attachment
+                11
+              else
+                raise ArgumentError, "Invalid option type: #{value[:type]}"
+              end,
+              name: name,
+              description: value[:description],
+              required: value[:required].nil? ? !value[:optional] : value[:required],
+            }
+
+            ret[:choices] = value[:choices].map { |t| { name: t[0], value: t[1] } } if value[:choices]
+
+            ret[:channel_types] = value[:channel_types].map(&:channel_type) if value[:channel_types]
+
+            ret[:autocomplete] = !value[:autocomplete].nil? if value[:autocomplete]
+            if value[:range]
+              ret[:min_value] = value[:range].begin
+              ret[:max_value] = value[:range].end
+            end
+            ret
+          end
+          {
+            name: @name,
+            default_permission: true,
+            description: @description,
+            options: options_payload,
+          }
+        end
+      end
+
+      #
+      # Represents the command with subcommands.
+      #
+      class GroupCommand < Command
+        # @return [Array<Discorb::ApplicationCommand::Command::SlashCommand, Discorb::ApplicationCommand::Command::SubcommandGroup>] The subcommands of the command.
+        attr_reader :commands
+        # @return [String] The description of the command.
+        attr_reader :description
+
+        # @private
+        def initialize(name, description, guild_ids, type, client)
+          super(name, guild_ids, block, type)
+          @description = description
+          @commands = []
+          @client = client
+          @id_map = Discorb::Dictionary.new
+        end
+
+        #
+        # Add new subcommand.
+        #
+        # @param (see Discorb::ApplicationCommand::Handler#slash)
+        # @return [Discorb::ApplicationCommand::Command::SlashCommand] The added subcommand.
+        #
+        def slash(command_name, description, options = {}, &block)
+          command = Discorb::ApplicationCommand::Command::SlashCommand.new(command_name, description, options, [], block, 1, @name)
+          @client.bottom_commands << command
+          @commands << command
+          command
+        end
+
+        #
+        # Add new subcommand group.
+        #
+        # @param [String] command_name Group name.
+        # @param [String] description Group description.
+        #
+        # @yield Block to yield with the command.
+        # @yieldparam [Discorb::ApplicationCommand::Command::SubcommandGroup] group Group command.
+        #
+        # @return [Discorb::ApplicationCommand::Command::SubcommandGroup] Command object.
+        #
+        # @see file:docs/application_command.md Application Commands
+        #
+        def group(command_name, description, &block)
+          command = Discorb::ApplicationCommand::Command::SubcommandGroup.new(command_name, description, @name, @client)
+          command.yield_self(&block) if block_given?
+          @commands << command
+          command
+        end
+
+        #
+        # Returns the command name.
+        #
+        # @return [String] The command name.
+        #
+        def to_s
+          @name
+        end
+
+        # @private
+        def block_replace(instance)
+          super
+          @commands.each { |c| c.replace_block(instance) }
+        end
+
+        # @private
+        def to_hash
+          options_payload = @commands.map do |command|
+            if command.is_a?(SlashCommand)
+              {
+                name: command.name,
+                description: command.description,
+                default_permission: true,
+                type: 1,
+                options: command.to_hash[:options],
+              }
+            else
+              {
+                name: command.name,
+                description: command.description,
+                default_permission: true,
+                type: 2,
+                options: command.commands.map { |c| c.to_hash.merge(type: 1) },
+              }
+            end
+          end
+
+          {
+            name: @name,
+            default_permission: @enabled,
+            description: @description,
+            options: options_payload,
+          }
+        end
+      end
+
+      #
+      # Represents the subcommand group.
+      #
+      class SubcommandGroup < GroupCommand
+        # @return [Array<Discorb::ApplicationCommand::Command::SlashCommand>] The subcommands of the command.
+        attr_reader :commands
+
+        # @private
+        def initialize(name, description, parent, client)
+          super(name, description, [], 1, client)
+
+          @commands = []
+          @parent = parent
+        end
+
+        def to_s
+          @parent + " " + @name
+        end
+
+        #
+        # Add new subcommand.
+        # @param (see Discorb::ApplicationCommand::Handler#slash)
+        # @return [Discorb::ApplicationCommand::Command::SlashCommand] The added subcommand.
+        #
+        def slash(command_name, description, options = {}, &block)
+          command = Discorb::ApplicationCommand::Command::SlashCommand.new(command_name, description, options, [], block, 1, @parent + " " + @name)
+          @commands << command
+          @client.bottom_commands << command
+          command
+        end
+      end
+
+      class << self
+        # @private
+        attr_reader :types
+      end
+    end
+  end
+end

data/lib/discorb/app_command/handler.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Handles application commands.
+  #
+  module ApplicationCommand
+    #
+    # Module to handle application commands.
+    #
+    module Handler
+      #
+      # 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.
+      #   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. |
+      #   | `:type` | `Object` | Type of the option. |
+      #   | `:choice` | `Hash{String => String, Integer, Float}` | Type of the option. |
+      #   | `: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 [Proc] block Command block.
+      #
+      # @return [Discorb::ApplicationCommand::Command::SlashCommand] 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, "")
+        @commands << command
+        @bottom_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.
+      #
+      # @yield Block to yield with the command.
+      # @yieldparam [Discorb::ApplicationCommand::Command::GroupCommand] group Group command.
+      #
+      # @return [Discorb::ApplicationCommand::Command::GroupCommand] Command object.
+      #
+      # @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?
+        @commands << command
+        command
+      end
+
+      #
+      # 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 [Proc] block Command block.
+      # @yield [interaction, message] Block to execute.
+      # @yieldparam [Discorb::CommandInteraction::UserMenuCommand] interaction Interaction object.
+      # @yieldparam [Discorb::Message] message Message object.
+      #
+      # @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)
+        @commands << command
+        command
+      end
+
+      #
+      # 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 [Proc] block Command block.
+      # @yield [interaction, user] Block to execute.
+      # @yieldparam [Discorb::CommandInteraction::UserMenuCommand] interaction Interaction object.
+      # @yieldparam [Discorb::User] user User object.
+      #
+      # @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)
+        @commands << command
+        command
+      end
+
+      #
+      # Setup commands.
+      # @async
+      # @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.
+      #
+      # @note `token` parameter only required if you don't run client.
+      #
+      def setup_commands(token = nil, guild_ids: nil)
+        Async do
+          @token ||= token
+          @http = HTTP.new(self)
+          global_commands = @commands.select { |c| c.guild_ids == false or c.guild_ids == [] }
+          local_commands = @commands.select { |c| c.guild_ids.is_a?(Array) and c.guild_ids.any? }
+          default_commands = @commands.select { |c| c.guild_ids.nil? }
+          if guild_ids.is_a?(Array)
+            default_commands.each do |command|
+              command.instance_variable_set(:@guild_ids, guild_ids)
+            end
+            local_commands += default_commands
+          else
+            global_commands += default_commands
+          end
+          final_guild_ids = local_commands.map(&:guild_ids).flatten.map(&:to_s).uniq
+          app_info = fetch_application.wait
+          unless global_commands.empty?
+            @http.request(
+              Route.new(
+                "/applications/#{app_info.id}/commands",
+                "//applications/:application_id/commands",
+                :put
+              ),
+              global_commands.map(&:to_hash)
+            ).wait
+          end
+          if ENV["DISCORB_CLI_FLAG"] == "setup"
+            sputs "Registered commands for global:"
+            global_commands.each do |command|
+              iputs "- #{command.name}"
+            end
+          end
+          unless final_guild_ids.empty?
+            final_guild_ids.each do |guild_id|
+              commands = local_commands.select { |c| c.guild_ids.include?(guild_id) }
+              @http.request(
+                Route.new("/applications/#{app_info.id}/guilds/#{guild_id}/commands",
+                          "//applications/:application_id/guilds/:guild_id/commands",
+                          :put),
+                commands.map(&:to_hash)
+              ).wait
+              sputs "Registered commands for #{guild_id}:"
+              commands.each do |command|
+                iputs "- #{command.name}"
+              end
+            end
+          end
+          @log.info "Successfully setup commands"
+        end
+      end
+    end
+  end
+end