discorb 0.15.0 → 0.17.0

data/examples/extension/message_expander.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 require "discorb"
 
+#
+# Class for expanding message URL.
+#
 class MessageExpander
   include Discorb::Extension
 
-  @@message_regex = Regexp.new(
+  MESSAGE_PATTERN = Regexp.new(
     '(?!<)https://(?:ptb\.|canary\.)?discord(?:app)?\.com/channels/' \
     "(?<guild>[0-9]{18})/(?<channel>[0-9]{18})/(?<message>[0-9]{18})(?!>)"
   )
@@ -12,7 +15,7 @@ class MessageExpander
   event :message do |message|
     next if message.author.bot?
 
-    message.content.to_enum(:scan, @@message_regex).map { Regexp.last_match }.each do |match|
+    message.content.to_enum(:scan, MESSAGE_PATTERN).map { Regexp.last_match }.each do |match|
       ch = @client.channels[match[:channel]]
       next if ch.nil?
 

data/examples/simple/eval.rb

@@ -25,9 +25,9 @@ client.on :message do |message|
     res = res.wait if res.is_a? Async::Task
     message.channel.post("```rb\n#{res.inspect[...1990]}\n```")
   end
-rescue Exception => e
+rescue Exception => e # rubocop:disable Lint/RescueException
   message.reply embed: Discorb::Embed.new("Error!", "```rb\n#{e.full_message(highlight: false)[...1990]}\n```",
                                           color: Discorb::Color[:red])
 end
 
-client.run(ENV["discord_bot_token"])
+client.run(ENV.fetch("discord_bot_token", nil))

data/examples/simple/ping_pong.rb

@@ -14,4 +14,4 @@ client.on :message do |message|
   message.channel.post("Pong!")
 end
 
-client.run(ENV["DISCORD_BOT_TOKEN"])
+client.run(ENV.fetch("DISCORD_BOT_TOKEN", nil))

data/examples/simple/rolepanel.rb

@@ -2,7 +2,7 @@
 require "discorb"
 intents = Discorb::Intents.new
 intents.members = true
-client = Discorb::Client.new(intents: intents, log: $stdout, colorize_log: true)
+client = Discorb::Client.new(intents: intents)
 
 def convert_role(guild, string)
   guild.roles.find do |role|
@@ -63,4 +63,4 @@ client.on :message do |message|
   end
 end
 
-client.run(ENV["DISCORD_BOT_TOKEN"])
+client.run(ENV.fetch("DISCORD_BOT_TOKEN", nil))

data/examples/simple/shard.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require "discorb"
+
+client = Discorb::Client.new(log: Logger.new($stdout))
+
+client.once :standby do
+  puts "Logged in as #{client.user}"
+end
+
+client.on :message do |message|
+  next if message.author.bot?
+  next unless message.content == "!inspect"
+
+  message.channel.post("I'm #{client.user}, running on shard #{client.shard_id}!")
+end
+
+client.run(ENV.fetch("DISCORD_BOT_TOKEN", nil), shards: [0, 1], shard_count: 2)

data/examples/simple/wait_for_message.rb

@@ -28,4 +28,4 @@ client.on :message do |message|
   end
 end
 
-client.run(ENV["DISCORD_BOT_TOKEN"])
+client.run(ENV.fetch("DISCORD_BOT_TOKEN", nil))

data/exe/discorb

@@ -1,32 +1,47 @@
 #! /usr/bin/env ruby
 # frozen_string_literal: true
 
-script = ARGV[0]
+require "optparse"
 
-if script.nil?
-  puts "\e[94mThis is a tool for discorb. Currently these tools are available:\e[m"
-
-  discorb_path = $LOAD_PATH.find { |path| File.directory?(path + "/discorb") }
-  scripts = {}
+options = {
+  bundler: true,
+}
+discorb_paths = $LOAD_PATH.filter { |path| File.directory?(path + "/discorb") }
+scripts = {}
+discorb_paths.each do |discorb_path|
   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(&:length).max
-  scripts.sort.each do |name, description|
-    puts "\e[90m#{name.rjust(max_length)}\e[m - #{description}"
+end
+max_length = scripts.keys.map(&:length).max
+global = OptionParser.new do |opts|
+  opts.banner = "Usage: discorb [options] [subcommand [options]]"
+  opts.on("-b", "--[no-]bundler", "Whether to use bundler.") do |v|
+    options[:bundler] = v
   end
+  opts.separator ""
+  commands = +"Subcommands:\n"
+  commands << scripts.sort.map do |name, description|
+    "  #{name.rjust(max_length)} - #{description}"
+  end.join("\n")
+  commands << "\n\nYou can run `discorb [subcommand] --help` for more information."
+  opts.separator commands
+end
+global.order!(ARGV)
 
-  puts "\e[94m\nTo run a tool, type:\e[m\n" \
-       "\e[34m  discorb [script]\e[m"
-
-  exit 1
+if ARGV.empty?
+  puts global
+  abort
 end
 
+require "bundler/setup" if options[:bundler]
+
+command = ARGV.shift
+
 begin
-  require "discorb/exe/#{script}"
+  require "discorb/exe/#{command}"
 rescue LoadError
-  puts "\e[91mThis tool is not available: \e[90m#{script}\e[m"
-  exit 1
+  warn "Unknown subcommand: #{command}"
 end

data/lefthook.yml

@@ -0,0 +1,45 @@
+# EXAMPLE USAGE
+# Refer for explanation to following link:
+# https://github.com/evilmartians/lefthook/blob/master/docs/full_guide.md
+#
+# pre-push:
+#   commands:
+#     packages-audit:
+#       tags: frontend security
+#       run: yarn audit
+#     gems-audit:
+#       tags: backend security
+#       run: bundle audit
+#
+# pre-commit:
+#   parallel: true
+#   commands:
+#     eslint:
+#       glob: "*.{js,ts}"
+#       run: yarn eslint {staged_files}
+#     rubocop:
+#       tags: backend style
+#       glob: "*.rb"
+#       exclude: "application.rb|routes.rb"
+#       run: bundle exec rubocop --force-exclusion {all_files}
+#     govet:
+#       tags: backend style
+#       files: git ls-files -m
+#       glob: "*.go"
+#       run: go vet {files}
+#   scripts:
+#     "hello.js":
+#       runner: node
+#     "any.go":
+#       runner: go run
+pre-commit:
+  parallel: true
+  commands:
+    linting:
+      glob: "*.rb"
+      run: rubocop {staged_files}
+
+commit-msg:
+  scripts:
+    "validator.rb":
+      runner: ruby

data/lib/discorb/allowed_mentions.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Discorb
   #
   # Represents a allowed mentions in a message.
@@ -32,7 +33,14 @@ module Discorb
       "#<#{self.class} @everyone=#{@everyone} @roles=#{@roles} @users=#{@users} @replied_user=#{@replied_user}>"
     end
 
+    #
+    # Converts the object to a hash.
     # @private
+    #
+    # @param [Discorb::AllowedMentions, nil] other The object to merge.
+    #
+    # @return [Hash] The hash.
+    #
     def to_hash(other = nil)
       payload = {
         parse: %w[everyone roles users],

data/lib/discorb/app_command/command.rb

@@ -1,16 +1,13 @@
 # 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.
+      # @return [Hash{Symbol => 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
@@ -20,27 +17,46 @@ module Discorb
       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
+      # @return [Discorb::Permission] The default permissions for this command.
+      attr_reader :default_permission
+      # @return [Boolean] Whether the command is enabled in DMs.
+      attr_reader :dm_permission
 
-      @types = {
+      # @private
+      # @return [{Integer => Symbol}] The mapping of raw types to types.
+      TYPES = {
         1 => :chat_input,
         2 => :user,
         3 => :message,
       }.freeze
 
+      #
+      # Initialize a new command.
       # @private
-      def initialize(name, guild_ids, block, type)
-        @name = name
+      #
+      # @param [String, Hash{Symbol => String}] name The name of the command.
+      # @param [Array<#to_s>] guild_ids The guild ids that the command is enabled in.
+      # @param [Proc] block The block of the command.
+      # @param [:chat_input, :user, :message] type The type of the command.
+      # @param [Boolean] dm_permission Whether the command is enabled in DMs.
+      # @param [Discorb::Permission] default_permission The default permission of the command.
+      #
+      def initialize(name, guild_ids, block, type, dm_permission = nil, default_permission = nil)
+        @name = name.is_a?(String) ? { "default" => name } : ApplicationCommand.modify_localization_hash(name)
         @guild_ids = guild_ids&.map(&:to_s)
         @block = block
-        @raw_type = type
-        @type = Discorb::ApplicationCommand::Command.types[type]
+        @type = Discorb::ApplicationCommand::Command::TYPES[type]
         @type_raw = type
-        @id_map = Discorb::Dictionary.new
+        @dm_permission = dm_permission
+        @default_permission = default_permission
       end
 
+      #
+      # Changes the self pointer of block to the given object.
       # @private
+      #
+      # @param [Object] instance The object to change the self pointer to.
+      #
       def replace_block(instance)
         current_block = @block.dup
         @block = proc do |*args|
@@ -48,32 +64,58 @@ module Discorb
         end
       end
 
+      #
+      # Converts the object to a hash.
       # @private
+      #
+      # @return [Hash] The hash represents the object.
+      #
       def to_hash
         {
-          name: @name,
-          default_permission: @default_permission,
+          name: @name["default"],
+          name_localizations: @name.except("default"),
           type: @type_raw,
+          dm_permission: @dm_permission,
+          default_member_permissions: @default_permission&.value&.to_s,
         }
       end
 
       #
       # Represents the slash command.
       #
-      class SlashCommand < Command
-        # @return [String] The description of the command.
+      class ChatInputCommand < Command
+        # @return [Hash{String => String}] The description of the command.
         attr_reader :description
         # @return [Hash{String => Hash}] The options of the command.
         attr_reader :options
 
+        #
+        # Initialize a new slash command.
         # @private
-        def initialize(name, description, options, guild_ids, block, type, parent)
-          super(name, guild_ids, block, type)
-          @description = description
+        #
+        # @param [String, Hash{Symbol => String}] name The name of the command.
+        #   The hash should have `default`, and language keys.
+        # @param [String, Hash{Symbol => String}] description The description of the command.
+        #   The hash should have `default`, and language keys.
+        # @param [Hash{String => Hash}] options The options of the command.
+        # @param [Array<#to_s>] guild_ids The guild ids that the command is enabled in.
+        # @param [Proc] block The block of the command.
+        # @param [:chat_input, :user, :message] type The type of the command.
+        # @param [Discorb::ApplicationCommand::Command, nil] parent The parent command.
+        # @param [Boolean] dm_permission Whether the command is enabled in DMs.
+        # @param [Discorb::Permission] default_permission The default permission of the command.
+        #
+        def initialize(name, description, options, guild_ids, block, type, parent, dm_permission, default_permission)
+          super(name, guild_ids, block, type, dm_permission, default_permission)
+          @description = if description.is_a?(String)
+              {
+                "default" => description,
+              }
+            else
+              ApplicationCommand.modify_localization_hash(description)
+            end
           @options = options
-          @id = nil
           @parent = parent
-          @id_map = Discorb::Dictionary.new
         end
 
         #
@@ -82,10 +124,15 @@ module Discorb
         # @return [String] The name of the command.
         #
         def to_s
-          (@parent + " " + @name).strip
+          "#{@parent} #{@name["default"]}".strip
         end
 
+        #
+        # Converts the object to a hash.
         # @private
+        #
+        # @return [Hash] The hash represents the object.
+        #
         def to_hash
           options_payload = options.map do |name, value|
             ret = {
@@ -112,11 +159,34 @@ module Discorb
                 raise ArgumentError, "Invalid option type: #{value[:type]}"
               end,
               name: name,
-              description: value[:description],
+              name_localizations: ApplicationCommand.modify_localization_hash(value[:name_localizations]),
               required: value[:required].nil? ? !value[:optional] : value[:required],
             }
 
-            ret[:choices] = value[:choices].map { |t| { name: t[0], value: t[1] } } if value[:choices]
+            if value[:description].is_a?(String)
+              ret[:description] = value[:description]
+            else
+              description = ApplicationCommand.modify_localization_hash(value[:description])
+              ret[:description] = description["default"]
+              ret[:description_localizations] = description.except("default")
+            end
+            if value[:choices]
+              ret[:choices] = value[:choices].map do |k, v|
+                r = {
+                  name: k, value: v,
+                }
+                if choices_localizations = value[:choices_localizations].clone
+                  name_localizations = ApplicationCommand.modify_localization_hash(choices_localizations.delete(k) do
+                    warn "Missing localization for #{k}"
+                    {}
+                  end)
+                  r[:name_localizations] = name_localizations.except("default")
+                  r[:name] = name_localizations["default"]
+                  r.delete(:name_localizations) if r[:name_localizations].nil?
+                end
+                r
+              end
+            end
 
             ret[:channel_types] = value[:channel_types].map(&:channel_type) if value[:channel_types]
 
@@ -128,10 +198,13 @@ module Discorb
             ret
           end
           {
-            name: @name,
-            default_permission: true,
-            description: @description,
+            name: @name["default"],
+            name_localizations: @name.except("default"),
+            description: @description["default"],
+            description_localizations: @description.except("default"),
             options: options_payload,
+            dm_permission: @dm_permission,
+            default_member_permissions: @default_permission&.value&.to_s,
           }
         end
       end
@@ -140,29 +213,58 @@ module Discorb
       # Represents the command with subcommands.
       #
       class GroupCommand < Command
-        # @return [Array<Discorb::ApplicationCommand::Command::SlashCommand, Discorb::ApplicationCommand::Command::SubcommandGroup>] The subcommands of the command.
+        # @return [Array<
+        #     Discorb::ApplicationCommand::Command::ChatInputCommand,
+        #     Discorb::ApplicationCommand::Command::SubcommandGroup
+        #   >] The subcommands of the command.
         attr_reader :commands
         # @return [String] The description of the command.
         attr_reader :description
 
+        #
+        # Initialize a new group command.
         # @private
-        def initialize(name, description, guild_ids, type, client)
-          super(name, guild_ids, block, type)
-          @description = description
+        #
+        # @param [String, Hash{Symbol => String}] name The name of the command.
+        # @param [String, Hash{Symbol => String}] description The description of the command.
+        # @param [Array<#to_s>] guild_ids The guild ids that the command is enabled in.
+        # @param [:chat_input, :user, :message] type The type of the command.
+        # @param [Discorb::Client] client The client of the command.
+        # @param [Boolean] dm_permission Whether the command is enabled in DMs.
+        # @param [Discorb::Permission] default_permission The default permission of the command.
+        #
+        def initialize(name, description, guild_ids, type, client, dm_permission, default_permission)
+          super(name, guild_ids, block, type, dm_permission, default_permission)
+          @description = if description.is_a?(String)
+              {
+                "default" => description,
+              }
+            else
+              ApplicationCommand.modify_localization_hash(description)
+            end
           @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.
+        # @return [Discorb::ApplicationCommand::Command::ChatInputCommand] 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
+        def slash(command_name, description, options = {}, dm_permission: true, default_permission: nil, &block)
+          command = Discorb::ApplicationCommand::Command::ChatInputCommand.new(
+            command_name,
+            description,
+            options,
+            [],
+            block,
+            1,
+            self,
+            dm_permission,
+            default_permission
+          )
+          @client.callable_commands << command
           @commands << command
           command
         end
@@ -182,7 +284,7 @@ module Discorb
         #
         def group(command_name, description, &block)
           command = Discorb::ApplicationCommand::Command::SubcommandGroup.new(command_name, description, @name, @client)
-          command.yield_self(&block) if block_given?
+          command.then(&block) if block_given?
           @commands << command
           command
         end
@@ -193,41 +295,58 @@ module Discorb
         # @return [String] The command name.
         #
         def to_s
-          @name
+          @name["default"]
         end
 
+        #
+        # Changes the self pointer to the given object.
         # @private
+        #
+        # @param [Object] instance The object to change to.
+        #
         def block_replace(instance)
           super
           @commands.each { |c| c.replace_block(instance) }
         end
 
+        #
+        # Converts the object to a hash.
         # @private
+        #
+        # @return [Hash] The hash represents the object.
+        #
         def to_hash
           options_payload = @commands.map do |command|
-            if command.is_a?(SlashCommand)
+            if command.is_a?(ChatInputCommand)
               {
-                name: command.name,
-                description: command.description,
-                default_permission: true,
+                name: command.name["default"],
+                name_localizations: command.name.except("default"),
+                description: command.description["default"],
+                description_localizations: command.description.except("default"),
                 type: 1,
                 options: command.to_hash[:options],
               }
             else
               {
-                name: command.name,
-                description: command.description,
-                default_permission: true,
+                name: command.name["default"],
+                name_localizations: command.name.except("default"),
+                description: command.description["default"],
+                description_localizations: command.description.except("default"),
                 type: 2,
-                options: command.commands.map { |c| c.to_hash.merge(type: 1) },
+                options: command.commands.map do |c|
+                  c.to_hash.merge(type: 1).except(:dm_permission, :default_member_permissions)
+                end,
               }
             end
           end
 
           {
-            name: @name,
-            default_permission: @enabled,
-            description: @description,
+            name: @name["default"],
+            name_localizations: @name.except("default"),
+            description: @description["default"],
+            description_localizations: @description.except("default"),
+            dm_permission: @dm_permission,
+            default_member_permissions: @default_permission&.value&.to_s,
             options: options_payload,
           }
         end
@@ -237,38 +356,43 @@ module Discorb
       # Represents the subcommand group.
       #
       class SubcommandGroup < GroupCommand
-        # @return [Array<Discorb::ApplicationCommand::Command::SlashCommand>] The subcommands of the command.
+        # @return [Array<Discorb::ApplicationCommand::Command::ChatInputCommand>] The subcommands of the command.
         attr_reader :commands
 
+        #
+        # Initialize a new subcommand group.
         # @private
+        #
+        # @param [String] name The name of the command.
+        # @param [String] description The description of the command.
+        # @param [Discorb::ApplicationCommand::Command::GroupCommand] parent The parent command.
+        # @param [Discorb::Client] client The client.
         def initialize(name, description, parent, client)
-          super(name, description, [], 1, client)
+          super(name, description, [], 1, client, nil, nil)
 
           @commands = []
           @parent = parent
         end
 
         def to_s
-          @parent + " " + @name
+          "#{@parent} #{@name}"
         end
 
         #
         # Add new subcommand.
         # @param (see Discorb::ApplicationCommand::Handler#slash)
-        # @return [Discorb::ApplicationCommand::Command::SlashCommand] The added subcommand.
+        # @return [Discorb::ApplicationCommand::Command::ChatInputCommand] The added subcommand.
         #
         def slash(command_name, description, options = {}, &block)
-          command = Discorb::ApplicationCommand::Command::SlashCommand.new(command_name, description, options, [], block, 1, @parent + " " + @name)
+          command = Discorb::ApplicationCommand::Command::ChatInputCommand.new(
+            command_name, description, options, [],
+            block, 1, self, nil, nil
+          )
           @commands << command
-          @client.bottom_commands << command
+          @client.callable_commands << command
           command
         end
       end
-
-      class << self
-        # @private
-        attr_reader :types
-      end
     end
   end
 end

data/lib/discorb/app_command/common.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Handles application commands.
+  #
+  module ApplicationCommand
+    # @return [Array<String>] List of valid locales.
+    VALID_LOCALES = %w[da de en-GB en-US es-ES fr hr it lt hu nl no pl pt-BR ro fi sv-SE vi tr cs el bg ru uk hi th
+                       zh-CN ja zh-TW ko].freeze
+
+    module_function
+
+    def modify_localization_hash(hash)
+      hash.to_h do |rkey, value|
+        key = rkey.to_s.gsub("_", "-")
+        raise ArgumentError, "Invalid locale: #{key}" if VALID_LOCALES.none? do |valid|
+                                                           valid.downcase == key.downcase
+                                                         end && key != "default"
+
+        [key == "default" ? "default" : VALID_LOCALES.find { |valid| valid.downcase == key.downcase }, value]
+      end
+    end
+  end
+end