discorb 0.0.6 → 0.2.0

data/examples/extension/message_expander.rb

@@ -8,7 +8,7 @@ module MessageExpander
     "(?<guild>[0-9]{18})/(?<channel>[0-9]{18})/(?<message>[0-9]{18})(?!>)"
   )
 
-  event :message do |_task, message|
+  event :message do |message|
     next if message.author.bot?
 
     message.content.to_enum(:scan, @message_regex).map { Regexp.last_match }.each do |match|

data/examples/simple/eval.rb

@@ -2,11 +2,11 @@ require "discorb"
 
 client = Discorb::Client.new
 
-client.once :ready do |_task|
+client.once :ready do
   puts "Logged in as #{client.user}"
 end
 
-client.on :message do |_task, message|
+client.on :message do |message|
   next if message.author.bot?
   next unless message.content.start_with?("eval ")
 

data/examples/simple/ping_pong.rb

@@ -6,7 +6,7 @@ client.once :ready do
   puts "Logged in as #{client.user}"
 end
 
-client.on :message do |_task, message|
+client.on :message do |message|
   next if message.author.bot?
   next unless message.content == "ping"
 

data/examples/simple/rolepanel.rb

@@ -13,7 +13,7 @@ client.once :ready do
   puts "Logged in as #{client.user}"
 end
 
-client.on :reaction_add do |_task, event|
+client.on :reaction_add do |event|
   next unless event.emoji.value.end_with?(0x0000fe0f.chr("utf-8") + 0x000020e3.chr("utf-8"))
   next if event.member.bot?
 
@@ -28,7 +28,7 @@ client.on :reaction_add do |_task, event|
   end
 end
 
-client.on :reaction_remove do |_task, event|
+client.on :reaction_remove do |event|
   next unless event.emoji.value.end_with?(0x0000fe0f.chr("utf-8") + 0x000020e3.chr("utf-8"))
   next if event.member.bot?
 
@@ -43,7 +43,7 @@ client.on :reaction_remove do |_task, event|
   end
 end
 
-client.on :message do |_task, message|
+client.on :message do |message|
   next unless message.content.start_with?("/rp ")
   next if message.author.bot?
 

data/examples/simple/wait_for_message.rb

@@ -6,7 +6,7 @@ client.once :ready do
   puts "Logged in as #{client.user}"
 end
 
-client.on :message do |_task, message|
+client.on :message do |message|
   next if message.author.bot?
   next unless message.content == "!quiz"
 

data/exe/discord-irb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+require "io/console"
+require "discorb"
+require "optparse"
+
+intents_value = Discorb::Intents.all.value
+token_file = "token"
+
+opt = OptionParser.new
+opt.on("-i", "--intents", "intents to use, default to all") { |v| intents_value = v }
+opt.on("-t", "--token-file", "token file to load, default to \"token\"") { |v| token_file = v }
+opt.parse(ARGV)
+
+client = Discorb::Client.new(intents: Discorb::Intents.from_value(intents_value))
+$messages = []
+
+client.on :ready do
+  puts "\e[96mLogged in as #{client.user}\e[m"
+
+  def message
+    $messages.last
+  end
+
+  def dirb_help
+    puts <<~EOS
+           \e[96mDiscord-IRB\e[m
+           This is a debug client for Discord.
+           \e[90mmessage\e[m to get latest message.
+
+           \e[36mhttps://rubydoc.info/gems/discorb/file/docs/discord_irb.md\e[m for more information.
+         EOS
+  end
+
+  puts <<~FIRST_MESSAGE
+         Running on \e[31mRuby #{RUBY_VERSION}\e[m, disco\e[31mrb #{Discorb::VERSION}\e[m
+         Type \e[90mdirb_help\e[m to help.
+       FIRST_MESSAGE
+
+  binding.irb
+
+  client.close!
+end
+
+client.on :message do |message|
+  $messages << message
+end
+
+token = ENV["DISCORD_BOT_TOKEN"] || ENV["DISCORD_TOKEN"]
+if token.nil?
+  if File.exists?(token_file)
+    token = File.read(token_file)
+  else
+    print "\e[90mToken?\e[m : "
+    token = $stdin.noecho(&:gets).chomp
+    puts
+  end
+end
+
+client.run token

data/lib/discorb/asset.rb

@@ -54,4 +54,38 @@ module Discorb
       end
     end
   end
+
+  #
+  # Represents a default avatar.
+  #
+  class DefaultAvatar < DiscordModel
+
+    # @!attribute [r] animated?
+    #   @return [false] For compatibility with {Asset}, always `false`.
+
+    # @!visibility private
+    def initialize(discriminator)
+      @discriminator = discriminator.to_s.rjust(4, "0")
+    end
+
+    def animated?
+      false
+    end
+
+    #
+    # Returns the URL of the avatar.
+    #
+    # @param [String] image_format The image format. This is compatible with {Asset#url}, will be ignored.
+    # @param [Integer] size The size of the image. This is compatible with {Asset#url}, will be ignored.
+    #
+    # @return [String] URL of the avatar.
+    #
+    def url(image_format: nil, size: 1024)
+      "https://cdn.discordapp.com/embed/avatars/#{@discriminator.to_i % 5}.png"
+    end
+
+    def inspect
+      "#<#{self.class} #{@discriminator}>"
+    end
+  end
 end

data/lib/discorb/channel.rb

@@ -68,9 +68,9 @@ module Discorb
     end
 
     # @!visibility private
-    def base_url
+    def channel_id
       Async do
-        "/channels/#{@id}"
+        @id
       end
     end
 
@@ -1090,9 +1090,9 @@ module Discorb
     include Messageable
 
     # @!visibility private
-    def base_url
+    def channel_id
       Async do
-        "/channels/#{@id}"
+        @id
       end
     end
 

data/lib/discorb/client.rb

@@ -41,6 +41,14 @@ module Discorb
     attr_reader :messages
     # @return [Discorb::Logger] The logger.
     attr_reader :log
+    # @return [Array<Discorb::Command::Command>] The commands that the client is using.
+    attr_reader :commands
+    # @return [Float] The ping of the client.
+    #   @note This will be calculated from heartbeat and heartbeat_ack.
+    # @return [nil] If not connected to the gateway.
+    attr_reader :ping
+    # @return [:initialized, :running, :closed] The status of the client.
+    attr_reader :status
 
     #
     # Initializes a new client.
@@ -52,8 +60,13 @@ module Discorb
     # @param [Boolean] colorize_log Whether to colorize the log.
     # @param [:debug, :info, :warn, :error, :critical] log_level The log level.
     # @param [Boolean] wait_until_ready Whether to delay event dispatch until ready.
+    # @param [Boolean] overwrite_application_commands Whether to overwrite application commands on ready.
     #
-    def initialize(allowed_mentions: nil, intents: nil, message_caches: 1000, log: nil, colorize_log: false, log_level: :info, wait_until_ready: true)
+    def initialize(
+      allowed_mentions: nil, intents: nil, message_caches: 1000,
+      log: nil, colorize_log: false, log_level: :info,
+      wait_until_ready: true, overwrite_application_commands: true
+    )
       @allowed_mentions = allowed_mentions || AllowedMentions.new(everyone: true, roles: true, users: true)
       @intents = (intents or Intents.default)
       @events = {}
@@ -72,6 +85,9 @@ module Discorb
       @ready = false
       @tasks = []
       @conditions = {}
+      @commands = []
+      @overwrite_application_commands = overwrite_application_commands
+      @status = :initialized
     end
 
     #
@@ -124,7 +140,7 @@ module Discorb
     # @param [Object] args The arguments to pass to the event.
     #
     def dispatch(event_name, *args)
-      Async do |_task|
+      Async do
         if (conditions = @conditions[event_name])
           ids = Set[*conditions.map(&:first).map(&:object_id)]
           conditions.delete_if do |condition|
@@ -148,7 +164,7 @@ module Discorb
           lambda { |event_args|
             Async(annotation: "Discorb event: #{event_name}") do |task|
               @events[event_name].delete(block) if block.discriminator[:once]
-              block.call(task, *event_args)
+              block.call(*event_args)
               @log.debug "Dispatched proc with ID #{block.id.inspect}"
             rescue StandardError, ScriptError => e
               message = "An error occurred while dispatching proc with ID #{block.id.inspect}\n#{e.full_message}"
@@ -164,16 +180,6 @@ module Discorb
       end
     end
 
-    #
-    # Starts the client.
-    #
-    # @param [String] token The token to use.
-    #
-    def run(token)
-      @token = token.to_s
-      connect_gateway(true)
-    end
-
     #
     # Fetch user from ID.
     # @macro async
@@ -293,7 +299,7 @@ module Discorb
       end
       payload[:status] = status unless status.nil?
       if @connection
-        Async do |_task|
+        Async do
           send_gateway(3, **payload)
         end
       else
@@ -306,7 +312,7 @@ module Discorb
     #
     # Method to wait for a event.
     #
-    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] event The name of the event.
     # @param [Integer] timeout The timeout in seconds.
     # @param [Proc] check The check to use.
     #
@@ -347,6 +353,9 @@ module Discorb
     #
     def extend(mod)
       if mod.respond_to?(:events)
+        @events.each_value do |event|
+          event.delete_if { |c| c.discriminator[:extension] == mod.name }
+        end
         mod.events.each do |name, events|
           @events[name] = [] if @events[name].nil?
           events.each do |event|
@@ -358,6 +367,39 @@ module Discorb
       super(mod)
     end
 
-    include Discorb::GatewayHandler
+    include Discorb::Gateway::Handler
+    include Discorb::Command::Handler
+
+    #
+    # Starts the client.
+    #
+    # @param [String] token The token to use.
+    #
+    def run(token)
+      Async do |task|
+        @token = token.to_s
+        @close_condition = Async::Condition.new
+        main_task = Async do
+          @status = :running
+          connect_gateway(true).wait
+        rescue
+          @status = :stopped
+          @close_condition.signal
+          raise
+        end
+        @close_condition.wait
+        main_task.stop
+      end
+    end
+
+    #
+    # Stops the client.
+    #
+    def close!
+      @connection.send_close
+      @tasks.each(&:stop)
+      @status = :closed
+      @close_condition.signal
+    end
   end
 end

data/lib/discorb/command.rb

@@ -0,0 +1,393 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Handles application commands.
+  #
+  module Command
+    #
+    # Module to handle 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. |
+      #   | `:optional` | `Boolean` | Whether the option is optional or not. |
+      #   | `:type` | `Object` | Type of the option. |
+      #   | `:choice` | `Hash{String => String, Integer, Float}` | Type of the option. |
+      #
+      # @param [Array<#to_s>] guild_ids Guild IDs to restrict the command to.
+      # @param [Proc] block Command block.
+      #
+      # @return [Discorb::Command::Command::SlashCommand]
+      #
+      # @see file:docs/application_command.md#register-slash-command
+      #
+      def slash(command_name, description, options = {}, guild_ids: [], &block)
+        command = Discorb::Command::Command::SlashCommand.new(command_name, description, options, guild_ids, block, 1, "")
+        @commands << command
+        command
+      end
+
+      #
+      # Add new command with group.
+      #
+      # @param [String] command_name Command name.
+      # @param [String] description Command description.
+      # @param [Array<#to_s>] guild_ids Guild IDs to restrict the command to.
+      #
+      # @return [Discorb::Command::Command::GroupCommand] Command object.
+      #
+      # @see file:docs/slash_command.md
+      #
+      def slash_group(command_name, description, guild_ids: [])
+        command = Discorb::Command::Command::GroupCommand.new(command_name, description, guild_ids, nil)
+        @commands << command
+        command
+      end
+
+      #
+      # Add message context menu command.
+      #
+      # @param [String] command_name Command name.
+      # @param [Array<#to_s>] guild_ids Guild IDs to restrict the command to.
+      # @param [Proc] block Command block.
+      # @yield [interaction, message] Block to execute.
+      # @yieldparam [Discorb::CommandInteraction::UserMenuCommand] Interaction object.
+      # @yieldparam [Discorb::Message] user Message object.
+      #
+      # @return [Discorb::Command::Command] Command object.
+      #
+      def message_command(command_name, guild_ids: [], &block)
+        command = Discorb::Command::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>] guild_ids Guild IDs to restrict the command to.
+      # @param [Proc] block Command block.
+      # @yield [interaction, user] Block to execute.
+      # @yieldparam [Discorb::CommandInteraction::UserMenuCommand] Interaction object.
+      # @yieldparam [Discorb::User] user User object.
+      #
+      # @return [Discorb::Command::Command] Command object.
+      #
+      def user_command(command_name, guild_ids: [], &block)
+        command = Discorb::Command::Command.new(command_name, guild_ids, block, 2)
+        @commands << command
+        command
+      end
+
+      #
+      # Setup commands.
+      # @note This method is called automatically if overwrite_application_commands is set to true.
+      # @see Client#initialize
+      #
+      # @param [String] token Bot token.
+      # @note `token` parameter only required if you don't run client.
+      #
+      def setup_commands(token = nil)
+        Async do
+          @token ||= token
+          @http = HTTP.new(self)
+          global_commands = @commands.select { |c| c.guild_ids.empty? }
+          guild_ids = Set[*@commands.map(&:guild_ids).flatten]
+          app_info = fetch_application.wait
+          http.put("/applications/#{app_info.id}/commands", global_commands.map(&:to_hash)).wait unless global_commands.empty?
+          guild_ids.each do |guild_id|
+            commands = @commands.select { |c| c.guild_ids.include?(guild_id) }
+            http.put("/applications/#{app_info.id}/guilds/#{guild_id}/commands", commands.map(&:to_hash)).wait
+          end unless guild_ids.empty?
+          @log.info "Successfully setup commands"
+        end
+      end
+    end
+
+    #
+    # 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
+
+      # @!visibility private
+      def initialize(name, guild_ids, block, type)
+        @name = name
+        @guild_ids = guild_ids.map(&:to_s)
+        @block = block
+        @raw_type = type
+        @type = Discorb::Command::Command.types[type]
+        @type_raw = type
+        @id_map = Discorb::Dictionary.new
+      end
+
+      # @!visibility 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
+
+        # @!visibility private
+        def initialize(name, description, options, guild_ids, block, type, parent)
+          @description = description
+          @name = name
+          @guild_ids = guild_ids.map(&:to_s)
+          @block = block
+          @type = Discorb::Command::Command.types[type]
+          @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
+
+        # @!visibility 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
+              else
+                raise ArgumentError, "Invalid option type: #{value[:type]}"
+              end,
+              name: name,
+              description: value[:description],
+              required: !value[:optional],
+            }
+            if value[:choices]
+              ret[:choices] = value[:choices].map { |t| { name: t[0], value: t[1] } }
+            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::Command::Command::SlashCommand, Discorb::Command::Command::SubcommandGroup>] The subcommands of the command.
+        attr_reader :commands
+        # @return [String] The description of the command.
+        attr_reader :description
+
+        # @!visibility private
+        def initialize(name, description, guild_ids, type)
+          super(name, guild_ids, block, type)
+          @description = description
+          @commands = []
+          @id_map = Discorb::Dictionary.new
+        end
+
+        #
+        # Add new subcommand.
+        #
+        # @param (see Discorb::Command::Handler#slash)
+        # @return [Discorb::Command::Command::SlashCommand] The added subcommand.
+        #
+        def slash(command_name, description, options = {}, &block)
+          command = Discorb::Command::Command::SlashCommand.new(command_name, description, options, [], block, 1, @name)
+          options_payload = options.map do |name, value|
+            ret = {
+              type: case (value[:type].is_a?(Array) ? value[:type].first : value[:type])
+              when String, :string
+                3
+              when Integer
+                4
+              when TrueClass, FalseClass, :boolean
+                5
+              when Discorb::User, Discorb::Member, :user, :member
+                6
+              when Discorb::Channel, :channel
+                7
+              when Discorb::Role, :role
+                8
+              when :mentionable
+                9
+              when Float
+                10
+              end,
+              name: name,
+              description: value[:description],
+              required: !value[:optional],
+            }
+            if value[:type].is_a?(Array)
+              ret[:choices] = value[:type]
+            end
+
+            ret
+          end
+          {
+            name: @name,
+            default_permission: true,
+            description: @description,
+            options: options_payload,
+          }
+          @commands << command
+          command
+        end
+
+        #
+        # Add new subcommand group.
+        #
+        # @param [String] command_name Group name.
+        # @param [String] description Group description.
+        #
+        # @return [Discorb::Command::Command::SubcommandGroup] Command object.
+        #
+        # @see file:docs/slash_command.md
+        #
+        def group(command_name, description)
+          command = Discorb::Command::Command::SubcommandGroup.new(command_name, description, @name)
+          @commands << command
+          command
+        end
+
+        #
+        # Returns the command name.
+        #
+        # @return [String] The command name.
+        #
+        def to_s
+          @name
+        end
+
+        # @!visibility private
+        def to_hash
+          options_payload = @commands.map do |command|
+            if command.is_a?(SlashCommand)
+              {
+                name: command.name,
+                description: command.description,
+                default_permission: command.enabled,
+                type: 1,
+                options: command.to_hash[:options],
+              }
+            else
+              {
+                name: command.name,
+                description: command.description,
+                default_permission: command.enabled,
+                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::Command::Command::SlashCommand>] The subcommands of the command.
+        attr_reader :commands
+
+        # @!visibility private
+        def initialize(name, description, enabled, parent)
+          super(name, description, [], enabled, 1)
+
+          @commands = []
+          @parent = parent
+        end
+
+        def to_s
+          @parent + " " + @name
+        end
+
+        #
+        # Add new subcommand.
+        # @param (see Discorb::Command::Handler#slash)
+        # @return [Discorb::Command::Command::SlashCommand] The added subcommand.
+        #
+        def slash(command_name, description, options = {}, enabled: true, &block)
+          command = Discorb::Command::Command::SlashCommand.new(command_name, description, options, [], enabled, block, 1, @parent + " " + @name)
+          @commands << command
+          command
+        end
+      end
+
+      class << self
+        # @!visibility private
+        attr_reader :types
+      end
+    end
+  end
+end