discorb 0.13.4 → 0.15.1

data/lib/discorb/interaction/response.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
 module Discorb
+  #
+  # Represents an interaction of Discord.
+  #
   class Interaction
     #
     # A module for response with source.
     #
-    module SourceResponse
+    module SourceResponder
       #
       # Response with `DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE`(`5`).
       #
@@ -38,14 +42,14 @@ module Discorb
       # @param [Array<Discorb::Component>, Array<Array<Discorb::Component>>] components The components to send.
       # @param [Boolean] ephemeral Whether to make the response ephemeral.
       #
-      # @return [Discorb::Interaction::SourceResponse::CallbackMessage, Discorb::Webhook::Message] The callback message.
+      # @return [Discorb::Interaction::SourceResponder::CallbackMessage, Discorb::Webhook::Message] The callback message.
       #
       def post(content = nil, tts: false, embed: nil, embeds: nil, allowed_mentions: nil, components: nil, ephemeral: false)
         Async do
           payload = {}
           payload[:content] = content if content
           payload[:tts] = tts
-          payload[:embeds] = (embeds || [embed])&.map { |e| e&.to_hash }.filter { _1 }
+          payload[:embeds] = (embeds || [embed]).map { |e| e&.to_hash }.filter { _1 }
           payload[:allowed_mentions] = allowed_mentions&.to_hash(@client.allowed_mentions) || @client.allowed_mentions.to_hash
           payload[:components] = Component.to_payload(components) if components
           payload[:flags] = (ephemeral ? 1 << 6 : 0)
@@ -66,8 +70,19 @@ module Discorb
         end
       end
 
+      #
+      # Represents of a callback message of interaction.
+      #
       class CallbackMessage
+        #
+        # Initializes a new instance of CallbackMessage.
         # @private
+        #
+        # @param [Client] client The client.
+        # @param [Hash] data The payload.
+        # @param [String] application_id The application ID.
+        # @param [String] token The token.
+        #
         def initialize(client, data, application_id, token)
           @client = client
           @data = data
@@ -121,13 +136,17 @@ module Discorb
             @client.http.request(Route.new("/webhooks/#{@application_id}/#{@token}/messages/@original", "//webhooks/:webhook_id/:token/messages/@original", :delete)).wait
           end
         end
+
+        def inspect
+          "#<#{self.class.name} application_id=#{@application_id}"
+        end
       end
     end
 
     #
     # A module for response with update.
     #
-    module UpdateResponse
+    module UpdateResponder
       #
       # Response with `DEFERRED_UPDATE_MESSAGE`(`6`).
       # @async
@@ -181,6 +200,28 @@ module Discorb
       end
     end
 
+    #
+    # A module for response with modal.
+    #
+    module ModalResponder
+      #
+      # Response with `MODAL`(`9`).
+      #
+      # @param [String] title The title of the modal.
+      # @param [String] custom_id The custom id of the modal.
+      # @param [Array<Discorb::TextInput>] components The text inputs to send.
+      #
+      # @return [Async::Task<void>] The task.
+      #
+      def show_modal(title, custom_id, components)
+        payload = { title: title, custom_id: custom_id, components: Component.to_payload(components) }
+        @client.http.request(
+          Route.new("/interactions/#{@id}/#{@token}/callback", "//interactions/:interaction_id/:token/callback", :post),
+          { type: 9, data: payload }
+        ).wait
+      end
+    end
+
     private
 
     def _set_data(*)

data/lib/discorb/interaction/root.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Discorb
   #
   # Represents a user interaction with the bot.
@@ -37,7 +38,13 @@ module Discorb
     @interaction_type = nil
     @interaction_name = nil
 
+    #
+    # Initialize a new interaction.
     # @private
+    #
+    # @param [Discorb::Client] client The client this interaction belongs to.
+    # @param [Hash] data The data of the interaction.
+    #
     def initialize(client, data)
       @client = client
       @id = Snowflake.new(data[:id])
@@ -80,7 +87,13 @@ module Discorb
       # @private
       attr_reader :interaction_type, :interaction_name, :event_name
 
+      #
+      # Create a new Interaction instance from the data.
       # @private
+      #
+      # @param [Discorb::Client] client The client this interaction belongs to.
+      # @param [Hash] data The data of the interaction.
+      #
       def make_interaction(client, data)
         interaction = nil
         descendants.each do |klass|
@@ -93,7 +106,10 @@ module Discorb
         interaction
       end
 
+      #
+      # Returns the descendants of the class.
       # @private
+      #
       def descendants
         ObjectSpace.each_object(Class).select { |klass| klass < self }
       end

data/lib/discorb/interaction.rb

@@ -1,3 +1,4 @@
-%w[root response command components autocomplete].each do |file|
+# frozen_string_literal: true
+%w[root response command components autocomplete modal].each do |file|
   require_relative "interaction/#{file}.rb"
 end

data/lib/discorb/invite.rb

@@ -66,13 +66,22 @@ module Discorb
     #   Whether the invite is temporary.
     #   @return [Boolean]
 
-    @target_types = {
+    # @private
+    # @return [{Integer => Symbol}] The mapping of target types.
+    TARGET_TYPES = {
       nil => :voice,
       1 => :stream,
       2 => :guild,
     }.freeze
 
+    #
+    # Initialize a new invite.
     # @private
+    #
+    # @param [Discorb::Client] client The client.
+    # @param [Hash] data The data of invite.
+    # @param [Boolean] gateway Whether the data is from gateway.
+    #
     def initialize(client, data, gateway)
       @client = client
       @data = data[:data]
@@ -124,7 +133,7 @@ module Discorb
         @expires_at = data[:expires_at] && Time.iso8601(data[:expires_at])
       end
       @inviter_data = data[:inviter]
-      @target_type = self.class.target_types[data[:target_type]]
+      @target_type = TARGET_TYPES[data[:target_type]]
       @target_user = @client.users[data[:target_user][:id]] || User.new(@client, data[:target_user]) if data[:target_user]
       # @target_application = nil
 
@@ -137,10 +146,5 @@ module Discorb
       @temporary = data[:temporary]
       @created_at = Time.iso8601(data[:created_at])
     end
-
-    class << self
-      # @private
-      attr_reader :target_types
-    end
   end
 end

data/lib/discorb/log.rb

@@ -5,11 +5,11 @@ module Discorb
   class Logger
     attr_accessor :out, :colorize_log
 
-    @levels = %i[debug info warn error fatal].freeze
+    LEVELS = %i[debug info warn error fatal].freeze
 
     def initialize(out, colorize_log, level)
       @out = out
-      @level = self.class.levels.index(level)
+      @level = LEVELS.index(level)
       @colorize_log = colorize_log
     end
 
@@ -18,11 +18,11 @@ module Discorb
     end
 
     def level
-      self.class.levels[@level]
+      LEVELS[@level]
     end
 
     def level=(level)
-      @level = self.class.levels.index(level)
+      @level = LEVELS.index(level)
       raise ArgumentError, "Invalid log level: #{level}" unless @level
     end
 
@@ -64,7 +64,7 @@ module Discorb
 
     def write_output(name, color, message, fallback)
       unless @out
-        fallback.puts(message) if fallback
+        fallback&.puts(message)
 
         return
       end

data/lib/discorb/member.rb

@@ -62,7 +62,15 @@ module Discorb
     # @!attribute [r] owner?
     #   @return [Boolean] Whether the member is the owner of the guild.
 
+    #
+    # Initialize a new instance of the member.
     # @private
+    #
+    # @param [Discorb::Client] client The client.
+    # @param [Discorb::Snowflake] guild_id The ID of the guild.
+    # @param [Hash] user_data The data of the user.
+    # @param [Hash] member_data The data of the member.
+    #
     def initialize(client, guild_id, user_data, member_data)
       @guild_id = guild_id
       @client = client
@@ -105,9 +113,7 @@ module Discorb
     end
 
     def permissions
-      if owner?
-        return Permission.new((1 << 38) - 1)
-      end
+      return Permission.new((1 << 38) - 1) if owner?
       roles.map(&:permissions).sum(Permission.new(0))
     end
 
@@ -250,6 +256,19 @@ module Discorb
       end
     end
 
+    #
+    # Checks if the member can manage the given role.
+    #
+    # @param [Discorb::Role] role The role.
+    #
+    # @return [Boolean] `true` if the member can manage the role.
+    #
+    def can_manage?(role)
+      return true if owner?
+      top_role = roles.max_by(&:position)
+      top_role.position > role.position
+    end
+
     private
 
     def _set_data(user_data, member_data)

data/lib/discorb/message.rb

@@ -1,68 +1,6 @@
 # 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
-
   #
   # Represents a message.
   #
@@ -214,7 +152,14 @@ module Discorb
       !@guild_id.nil?
     end
 
+    #
+    # Initialize a new message.
     # @private
+    #
+    # @param [Discorb::Client] client The client.
+    # @param [Hash] data The data of the welcome screen.
+    # @param [Boolean] no_cache Whether to disable caching.
+    #
     def initialize(client, data, no_cache: false)
       @client = client
       @data = {}
@@ -257,38 +202,44 @@ module Discorb
     #
     def clean_content(user: true, channel: true, role: true, emoji: true, everyone: true, codeblock: false)
       ret = @content.dup
-      ret.gsub!(/<@!?(\d+)>/) do |match|
-        member = guild&.members&.[]($1)
-        member ||= @client.users[$1]
-        member ? "@#{member.name}" : "@Unknown User"
-      end if user
-      ret.gsub!(/<#(\d+)>/) do |match|
+      if user
+        ret.gsub!(/<@!?(\d+)>/) do |_match|
+          member = guild&.members&.[]($1)
+          member ||= @client.users[$1]
+          member ? "@#{member.name}" : "@Unknown User"
+        end
+      end
+      ret.gsub!(/<#(\d+)>/) do |_match|
         channel = @client.channels[$1]
         channel ? "<##{channel.id}>" : "#Unknown Channel"
       end
-      ret.gsub!(/<@&(\d+)>/) do |match|
-        role = guild&.roles&.[]($1)
-        role ? "@#{role.name}" : "@Unknown Role"
-      end if role
-      ret.gsub!(/<a?:([a-zA-Z0-9_]+):\d+>/) do |match|
-        $1
-      end if emoji
+      if role
+        ret.gsub!(/<@&(\d+)>/) do |_match|
+          role = guild&.roles&.[]($1)
+          role ? "@#{role.name}" : "@Unknown Role"
+        end
+      end
+      if emoji
+        ret.gsub!(/<a?:([a-zA-Z0-9_]+):\d+>/) do |_match|
+          $1
+        end
+      end
       ret.gsub!(/@(everyone|here)/, "@\u200b\\1") if everyone
-      unless codeblock
+      if codeblock
+        ret
+      else
         codeblocks = ret.split("```", -1)
         original_codeblocks = @content.scan(/```(.+?)```/m)
         res = []
         max = codeblocks.length
-        codeblocks.each_with_index do |codeblock, i|
-          if max % 2 == 0 && i == max - 1 or i.even?
-            res << codeblock
+        codeblocks.each_with_index do |single_codeblock, i|
+          res << if max.even? && i == max - 1 || i.even?
+            single_codeblock
           else
-            res << original_codeblocks[i / 2]
+            original_codeblocks[i / 2]
           end
         end
         res.join("```")
-      else
-        ret
       end
     end
 
@@ -300,16 +251,17 @@ module Discorb
     # @param [Discorb::Embed] embed The embed to send.
     # @param [Array<Discorb::Embed>] embeds The embeds to send.
     # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions.
+    # @param [Array<Discorb::Attachment>] attachments The new attachments.
     # @param [Array<Discorb::Component>, Array<Array<Discorb::Component>>] components The components to send.
     # @param [Boolean] supress Whether to supress embeds.
     #
     # @return [Async::Task<void>] The task.
     #
-    def edit(content = nil, embed: nil, embeds: nil, allowed_mentions: nil,
-                            components: nil, supress: nil)
+    def edit(content = Discorb::Unset, embed: Discorb::Unset, embeds: Discorb::Unset, allowed_mentions: Discorb::Unset,
+                                       attachments: Discorb::Unset, components: Discorb::Unset, supress: Discorb::Unset)
       Async do
         channel.edit_message(@id, content, embed: embed, embeds: embeds, allowed_mentions: allowed_mentions,
-                                           components: components, supress: supress).wait
+                                           attachments: attachments, components: components, supress: supress).wait
       end
     end
 
@@ -501,102 +453,6 @@ module Discorb
       "#<#{self.class} #{@content.inspect} id=#{@id}>"
     end
 
-    #
-    # Represents message flag.
-    # ## Flag fields
-    # |Field|Value|
-    # |-|-|
-    # |`1 << 0`|`:crossposted`|
-    # |`1 << 1`|`:crosspost`|
-    # |`1 << 2`|`:supress_embeds`|
-    # |`1 << 3`|`:source_message_deleted`|
-    # |`1 << 4`|`:urgent`|
-    # |`1 << 5`|`:has_thread`|
-    # |`1 << 6`|`:ephemeral`|
-    # |`1 << 7`|`:loading`|
-    #
-    class Flag < Discorb::Flag
-      @bits = {
-        crossposted: 0,
-        crosspost: 1,
-        supress_embeds: 2,
-        source_message_deleted: 3,
-        urgent: 4,
-        has_thread: 5,
-        ephemeral: 6,
-        loading: 7,
-      }.freeze
-    end
-
-    #
-    # Represents reference of message.
-    #
-    class Reference
-      # @return [Discorb::Snowflake] The guild ID.
-      attr_accessor :guild_id
-      # @return [Discorb::Snowflake] The channel ID.
-      attr_accessor :channel_id
-      # @return [Discorb::Snowflake] The message ID.
-      attr_accessor :message_id
-      # @return [Boolean] Whether fail the request if the message is not found.
-      attr_accessor :fail_if_not_exists
-
-      alias fail_if_not_exists? fail_if_not_exists
-
-      #
-      # Initialize a new reference.
-      #
-      # @param [Discorb::Snowflake] guild_id The guild ID.
-      # @param [Discorb::Snowflake] channel_id The channel ID.
-      # @param [Discorb::Snowflake] message_id The message ID.
-      # @param [Boolean] fail_if_not_exists Whether fail the request if the message is not found.
-      #
-      def initialize(guild_id, channel_id, message_id, fail_if_not_exists: true)
-        @guild_id = guild_id
-        @channel_id = channel_id
-        @message_id = message_id
-        @fail_if_not_exists = fail_if_not_exists
-      end
-
-      #
-      # Convert the reference to a hash.
-      #
-      # @return [Hash] The hash.
-      #
-      def to_hash
-        {
-          message_id: @message_id,
-          channel_id: @channel_id,
-          guild_id: @guild_id,
-          fail_if_not_exists: @fail_if_not_exists,
-        }
-      end
-
-      alias to_reference to_hash
-
-      #
-      # Initialize a new reference from a hash.
-      #
-      # @param [Hash] data The hash.
-      #
-      # @return [Discorb::Message::Reference] The reference.
-      # @see https://discord.com/developers/docs/resources/channel#message-reference-object
-      #
-      def self.from_hash(data)
-        new(data[:guild_id], data[:channel_id], data[:message_id], fail_if_not_exists: data[:fail_if_not_exists])
-      end
-    end
-
-    class Sticker
-      attr_reader :id, :name, :format
-
-      def initialize(data)
-        @id = Snowflake.new(data[:id])
-        @name = data[:name]
-        @format = Discorb::Sticker.sticker_format[data[:format]]
-      end
-    end
-
     private
 
     def _set_data(data)
@@ -627,8 +483,8 @@ module Discorb
       @tts = data[:tts]
       @mention_everyone = data[:mention_everyone]
       @mention_roles = data[:mention_roles].map { |r| guild.roles[r] }
-      @attachments = data[:attachments].map { |a| Attachment.new(a) }
-      @embeds = data[:embeds] ? data[:embeds].map { |e| Embed.new(data: e) } : []
+      @attachments = data[:attachments].map { |a| Attachment.from_hash(a) }
+      @embeds = data[:embeds] ? data[:embeds].map { |e| Embed.from_hash(e) } : []
       @reactions = data[:reactions] ? data[:reactions].map { |r| Reaction.new(self, r) } : []
       @pinned = data[:pinned]
       @type = self.class.message_type[data[:type]]
@@ -645,57 +501,6 @@ module Discorb
       @deleted = false
     end
 
-    #
-    # Represents a interaction of message.
-    #
-    class Interaction < DiscordModel
-      # @return [Discorb::Snowflake] The user ID.
-      attr_reader :id
-      # @return [String] The name of command.
-      # @return [nil] If the message is not a command.
-      attr_reader :name
-      # @return [Class] The type of interaction.
-      attr_reader :type
-      # @return [Discorb::User] The user.
-      attr_reader :user
-
-      # @private
-      def initialize(client, data)
-        @id = Snowflake.new(data[:id])
-        @name = data[:name]
-        @type = Discorb::Interaction.descendants.find { |c| c.interaction_type == data[:type] }
-        @user = client.users[data[:user][:id]] || User.new(client, data[:user])
-      end
-    end
-
-    #
-    # Represents a activity of message.
-    #
-    class Activity < DiscordModel
-      # @return [String] The name of activity.
-      attr_reader :name
-      # @return [Symbol] The type of activity.
-      attr_reader :type
-
-      @type = {
-        1 => :join,
-        2 => :spectate,
-        3 => :listen,
-        5 => :join_request,
-      }
-
-      # @private
-      def initialize(data)
-        @name = data[:name]
-        @type = self.class.type(data[:type])
-      end
-
-      class << self
-        # @private
-        attr_reader :type
-      end
-    end
-
     class << self
       # @private
       attr_reader :message_type