discorb 0.17.1 → 0.19.0

data/lib/discorb/interaction/response.rb

@@ -9,6 +9,8 @@ module Discorb
     # A module for response with source.
     #
     module SourceResponder
+      # @type instance: Discorb::Interaction
+
       #
       # Response with `DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE`(`5`).
       #
@@ -46,6 +48,8 @@ module Discorb
       # @param [Discorb::Embed] embed The embed to send.
       # @param [Array<Discorb::Embed>] embeds The embeds to send. (max: 10)
       # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions to send.
+      # @param [Discorb::Attachment] attachment The attachment to send.
+      # @param [Array<Discorb::Attachment>] attachments The attachments to send. (max: 10)
       # @param [Array<Discorb::Component>, Array<Array<Discorb::Component>>] components The components to send.
       # @param [Boolean] ephemeral Whether to make the response ephemeral.
       #
@@ -58,6 +62,8 @@ module Discorb
         embed: nil,
         embeds: nil,
         allowed_mentions: nil,
+        attachment: nil,
+        attachments: nil,
         components: nil,
         ephemeral: false
       )
@@ -70,23 +76,48 @@ module Discorb
             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)
+          attachments ||= attachment ? [attachment] : []
+
+          payload[:attachments] = attachments.map.with_index do |a, i|
+            {
+              id: i,
+              filename: a.filename,
+              description: a.description,
+            }
+          end
 
           ret = if @responded
-              _resp, data = @client.http.request(
-                Route.new("/webhooks/#{@application_id}/#{@token}", "//webhooks/:webhook_id/:token", :post), payload
+              _resp, data = @client.http.multipart_request(
+                Route.new(
+                  "/webhooks/#{@application_id}/#{@token}",
+                  "//webhooks/:webhook_id/:token",
+                  :post
+                ),
+                payload,
+                attachments
               ).wait
               webhook = Webhook::URLWebhook.new("/webhooks/#{@application_id}/#{@token}")
               Webhook::Message.new(webhook, data, @client)
             elsif @defered
-              @client.http.request(
-                Route.new("/webhooks/#{@application_id}/#{@token}/messages/@original",
-                          "//webhooks/:webhook_id/:token/messages/@original", :patch), payload
+              @client.http.multipart_request(
+                Route.new(
+                  "/webhooks/#{@application_id}/#{@token}/messages/@original",
+                  "//webhooks/:webhook_id/:token/messages/@original",
+                  :patch
+                ),
+                payload,
+                attachments
               ).wait
               CallbackMessage.new(@client, payload, @application_id, @token)
             else
-              @client.http.request(
-                Route.new("/interactions/#{@id}/#{@token}/callback", "//interactions/:interaction_id/:token/callback",
-                          :post), { type: 4, data: payload }
+              @client.http.multipart_request(
+                Route.new(
+                  "/interactions/#{@id}/#{@token}/callback",
+                  "//interactions/:interaction_id/:token/callback",
+                  :post
+                ),
+                { type: 4, data: payload },
+                attachments
               ).wait
               CallbackMessage.new(@client, payload, @application_id, @token)
             end
@@ -94,81 +125,86 @@ module Discorb
           ret
         end
       end
+    end
 
+    #
+    # Represents of a callback message of interaction.
+    #
+    class CallbackMessage
       #
-      # 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
-          @application_id = application_id
-          @token = token
-        end
+      # 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
+        @application_id = application_id
+        @token = token
+      end
 
-        #
-        # Edits the callback message.
-        # @async
-        # @macro edit
-        #
-        # @param [String] content The new content of the message.
-        # @param [Discorb::Embed] embed The new embed of the message.
-        # @param [Array<Discorb::Embed>] embeds The new embeds of the message.
-        # @param [Array<Discorb::Attachment>] attachments The attachments to remain.
-        # @param [Discorb::Attachment] file The file to send.
-        # @param [Array<Discorb::Attachment>] files The files to send.
-        #
-        # @return [Async::Task<void>] The task.
-        #
-        def edit(
-          content = Discorb::Unset,
-          embed: Discorb::Unset, embeds: Discorb::Unset,
-          file: Discorb::Unset, files: Discorb::Unset,
-          attachments: Discorb::Unset
-        )
-          Async do
-            payload = {}
-            payload[:content] = content if content != Discorb::Unset
-            payload[:embeds] = embed ? [embed.to_hash] : [] if embed != Discorb::Unset
-            payload[:embeds] = embeds.map(&:to_hash) if embeds != Discorb::Unset
-            payload[:attachments] = attachments.map(&:to_hash) if attachments != Discorb::Unset
-            files = [file] if file != Discorb::Unset
-            files = [] if files == Discorb::Unset
-            @client.http.multipart_request(
-              Route.new("/webhooks/#{@application_id}/#{@token}/messages/@original",
-                        "//webhooks/:webhook_id/:token/messages/@original", :patch), payload, files, headers: headers,
-            ).wait
-          end
+      #
+      # Edits the callback message.
+      # @async
+      # @macro edit
+      #
+      # @param [String] content The new content of the message.
+      # @param [Discorb::Embed] embed The new embed of the message.
+      # @param [Array<Discorb::Embed>] embeds The new embeds of the message.
+      # @param [Array<Discorb::Attachment>] attachments The attachments to remain.
+      # @param [Discorb::Attachment] file The file to send.
+      # @param [Array<Discorb::Attachment>] files The files to send.
+      #
+      # @return [Async::Task<void>] The task.
+      #
+      def edit(
+        content = Discorb::Unset,
+        embed: Discorb::Unset, embeds: Discorb::Unset,
+        file: Discorb::Unset, files: Discorb::Unset,
+        attachments: Discorb::Unset
+      )
+        Async do
+          payload = {}
+          payload[:content] = content if content != Discorb::Unset
+          payload[:embeds] = embed ? [embed.to_hash] : [] if embed != Discorb::Unset
+          payload[:embeds] = embeds.map(&:to_hash) if embeds != Discorb::Unset
+          payload[:attachments] = attachments.map(&:to_hash) if attachments != Discorb::Unset
+          files = [file] if file != Discorb::Unset
+          files = [] if files == Discorb::Unset
+          @client.http.multipart_request(
+            Route.new(
+              "/webhooks/#{@application_id}/#{@token}/messages/@original",
+              "//webhooks/:webhook_id/:token/messages/@original",
+              :patch
+            ),
+            payload,
+            files,
+          ).wait
         end
+      end
 
-        alias modify edit
+      alias modify edit
 
-        #
-        # Deletes the callback message.
-        # @async
-        # @note This will fail if the message is ephemeral.
-        #
-        # @return [Async::Task<void>] The task.
-        #
-        def delete!
-          Async do
-            @client.http.request(Route.new("/webhooks/#{@application_id}/#{@token}/messages/@original",
-                                           "//webhooks/:webhook_id/:token/messages/@original", :delete)).wait
-          end
+      #
+      # Deletes the callback message.
+      # @async
+      # @note This will fail if the message is ephemeral.
+      #
+      # @return [Async::Task<void>] The task.
+      #
+      def delete
+        Async do
+          @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
+      def inspect
+        "#<#{self.class.name} application_id=#{@application_id}"
       end
     end
 
@@ -176,6 +212,8 @@ module Discorb
     # A module for response with update.
     #
     module UpdateResponder
+      # @type instance: Discorb::Interaction
+
       #
       # Response with `DEFERRED_UPDATE_MESSAGE`(`6`).
       # @async
@@ -211,12 +249,24 @@ module Discorb
       # @param [Discorb::Embed] embed The embed to send.
       # @param [Array<Discorb::Embed>] embeds The embeds to send. (max: 10)
       # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions to send.
+      # @param [Discorb::Attachment] attachment The attachment to send.
+      # @param [Array<Discorb::Attachment>] attachments The attachments to send. (max: 10)
       # @param [Array<Discorb::Component>, Array<Array<Discorb::Component>>] components The components to send.
       # @param [Boolean] ephemeral Whether to make the response ephemeral.
       #
       # @return [Async::Task<void>] The task.
       #
-      def edit(content, tts: false, embed: nil, embeds: nil, allowed_mentions: nil, components: nil, ephemeral: false)
+      def edit(
+        content,
+        tts: false,
+        embed: nil,
+        embeds: nil,
+        allowed_mentions: nil,
+        attachment: nil,
+        attachments: nil,
+        components: nil,
+        ephemeral: false
+      )
         Async do
           payload = {}
           payload[:content] = content if content
@@ -231,9 +281,17 @@ module Discorb
             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)
-          @client.http.request(
+          attachments ||= [attachment] if attachment
+          payload[:attachments] = attachments.map.with_index do |a, i|
+            {
+              id: i,
+              filename: a.filename,
+              description: a.description,
+            }
+          end
+          @client.http.multipart_request(
             Route.new("/interactions/#{@id}/#{@token}/callback", "//interactions/:interaction_id/:token/callback",
-                      :post), { type: 7, data: payload }
+                      :post), { type: 7, data: payload }, attachments
           ).wait
         end
       end
@@ -243,6 +301,8 @@ module Discorb
     # A module for response with modal.
     #
     module ModalResponder
+      # @type instance: Discorb::Interaction
+
       #
       # Response with `MODAL`(`9`).
       #
@@ -253,17 +313,23 @@ module Discorb
       # @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
+        Async do
+          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
     end
 
     private
 
-    def _set_data(*)
+    def _set_data(_)
       nil
     end
   end

data/lib/discorb/interaction/root.rb

@@ -25,6 +25,8 @@ module Discorb
     # @return [Symbol] The locale of the guild that created the interaction.
     # @note This modifies the language code, `-` will be replaced with `_`.
     attr_reader :guild_locale
+    # @return [Discorb::Permission] The permissions of the bot.
+    attr_reader :app_permissions
 
     # @!attribute [r] guild
     #   @macro client_cache
@@ -62,6 +64,7 @@ module Discorb
       @token = data[:token]
       @locale = data[:locale].to_s.gsub("-", "_").to_sym
       @guild_locale = data[:guild_locale].to_s.gsub("-", "_").to_sym
+      @app_permissions = data[:app_permissions] && Permission.new(data[:app_permissions].to_i)
       @version = data[:version]
       @defered = false
       @responded = false
@@ -80,6 +83,142 @@ module Discorb
       "#<#{self.class} id=#{@id}>"
     end
 
+    #
+    # Send followup message.
+    #
+    # @async
+    #
+    # @param [String] content The content of the response.
+    # @param [Boolean] tts Whether to send the message as text-to-speech.
+    # @param [Discorb::Embed] embed The embed to send.
+    # @param [Array<Discorb::Embed>] embeds The embeds to send. (max: 10)
+    # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions to send.
+    # @param [Discorb::Attachment] attachment The attachment to send.
+    # @param [Array<Discorb::Attachment>] attachments The attachments to send. (max: 10)
+    # @param [Array<Discorb::Component>, Array<Array<Discorb::Component>>] components The components to send.
+    # @param [Boolean] ephemeral Whether to make the response ephemeral.
+    #
+    # @return [Discorb::Webhook::Message] The message.
+    #
+    def post(
+      content = nil,
+      tts: false,
+      embed: nil,
+      embeds: nil,
+      allowed_mentions: nil,
+      attachment: nil,
+      attachments: 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[: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)
+        attachments ||= attachment ? [attachment] : []
+
+        payload[:attachments] = attachments.map.with_index do |a, i|
+          {
+            id: i,
+            filename: a.filename,
+            description: a.description,
+          }
+        end
+
+        _resp, data = @client.http.multipart_request(
+          Route.new(
+            "/webhooks/#{@application_id}/#{@token}",
+            "//webhooks/:webhook_id/:token",
+            :post
+          ),
+          payload,
+          attachments
+        ).wait
+        webhook = Webhook::URLWebhook.new("/webhooks/#{@application_id}/#{@token}")
+        Webhook::Message.new(webhook, data, @client)
+        ret
+      end
+    end
+
+    #
+    # Edit the original response message.
+    # This method is low-level.
+    #
+    # @async
+    #
+    # @param [String] content The content of the response.
+    # @param [Discorb::Embed] embed The embed to send.
+    # @param [Array<Discorb::Embed>] embeds The embeds to send. (max: 10)
+    # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions to send.
+    # @param [Discorb::Attachment] attachment The attachment to send.
+    # @param [Array<Discorb::Attachment>] attachments The attachments to send. (max: 10)
+    # @param [Array<Discorb::Component>, Array<Array<Discorb::Component>>] components The components to send.
+    #
+    # @return [Async::Task<void>] The task.
+    #
+    # @see CallbackMessage#edit
+    #
+    def edit_original_message(
+      content = nil,
+      embed: nil,
+      embeds: nil,
+      attachment: nil,
+      attachments: nil,
+      components: nil
+    )
+      Async do
+        payload = {}
+        payload[:content] = content if content
+        payload[:embeds] = (embeds || [embed]).map { |e| e&.to_hash }.filter { _1 }.then { _1.empty? ? nil : _1 }
+        payload[:components] = Component.to_payload(components) if components
+        attachments ||= attachment && [attachment]
+
+        payload[:attachments] = attachments&.map&.with_index do |a, i|
+          {
+            id: i,
+            filename: a.filename,
+            description: a.description,
+          }
+        end
+        payload.compact!
+
+        @client.http.multipart_request(
+          Route.new(
+            "/webhooks/#{@application_id}/#{@token}/messages/@original",
+            "//webhooks/:webhook_id/:token/messages/@original",
+            :patch
+          ),
+          payload,
+          attachments
+        ).wait
+      end
+    end
+
+    #
+    # Delete the original response message.
+    # This method is low-level.
+    #
+    # @async
+    #
+    # @return [Async::Task<void>] The task.
+    #
+    def delete_original_message
+      Async do
+        @client.http.request(
+          Route.new(
+            "/webhooks/#{@application_id}/#{@token}/messages/@original",
+            "//webhooks/:webhook_id/:token/messages/@original",
+            :delete
+          )
+        ).wait
+      end
+    end
+
     class << self
       # @private
       attr_reader :interaction_type, :interaction_name, :event_name

data/lib/discorb/invite.rb

@@ -112,7 +112,7 @@ module Discorb
     # @async
     # @return [Async::Task<void>] The task.
     #
-    def delete!(reason: nil)
+    def delete(reason: nil)
       Async do
         @client.http.request(Route.new("/invites/#{@code}", "//invites/:code", :delete), {}, audit_log_reason: reason)
       end

data/lib/discorb/member.rb

@@ -52,10 +52,10 @@ module Discorb
     #   @return [Discorb::Presence] The presence of the member.
     # @!attribute [r] activity
     #   @macro client_cache
-    #   @return [Discorb::Activity] The activity of the member. It's from the {#presence}.
+    #   @return [Discorb::Presence::Activity] The activity of the member. It's from the {#presence}.
     # @!attribute [r] activities
     #   @macro client_cache
-    #   @return [Array<Discorb::Activity>] The activities of the member. It's from the {#presence}.
+    #   @return [Array<Discorb::Presence::Activity>] The activities of the member. It's from the {#presence}.
     # @!attribute [r] status
     #   @macro client_cache
     #   @return [Symbol] The status of the member. It's from the {#presence}.
@@ -303,7 +303,7 @@ module Discorb
       @deaf = member_data[:deaf]
       @custom_avatar = member_data[:avatar] && Asset.new(self, member_data[:avatar])
       super(user_data)
-      @display_avatar = @avatar || @custom_avatar
+      @display_avatar = @custom_avatar || @avatar
       @client.guilds[@guild_id].members[@id] = self unless @guild_id.nil? || @client.guilds[@guild_id].nil?
       @_member_data.update(member_data)
     end

data/lib/discorb/message.rb

@@ -7,7 +7,7 @@ module Discorb
   class Message < DiscordModel
     # @return [Discorb::Snowflake] The ID of the message.
     attr_reader :id
-    # @return [Discorb::User, Discorb::Member] The user that sent the message.
+    # @return [Discorb::User, Discorb::Member, Webhook::Message::Author] The user that sent the message.
     attr_reader :author
     # @return [String] The content of the message.
     attr_reader :content
@@ -217,8 +217,8 @@ module Discorb
       end
       if role
         ret.gsub!(/<@&(\d+)>/) do |_match|
-          role = guild&.roles&.[]($1)
-          role ? "@#{role.name}" : "@Unknown Role"
+          r = guild&.roles&.[]($1)
+          r ? "@#{r.name}" : "@Unknown Role"
         end
       end
       if emoji
@@ -282,9 +282,9 @@ module Discorb
     #
     # @return [Async::Task<void>] The task.
     #
-    def delete!(reason: nil)
+    def delete(reason: nil)
       Async do
-        channel.delete_message!(@id, reason: reason).wait
+        channel.delete_message(@id, reason: reason).wait
       end
     end
 
@@ -293,15 +293,17 @@ module Discorb
     #
     # @param [Boolean] fail_if_not_exists Whether to raise an error if the message does not exist.
     #
-    # @return [Hash] The reference object.
+    # @return [Discorb::Message::Reference] The reference object.
     #
     def to_reference(fail_if_not_exists: true)
-      {
-        message_id: @id,
-        channel_id: @channel_id,
-        guild_id: @guild_id,
-        fail_if_not_exists: fail_if_not_exists,
-      }
+      Reference.from_hash(
+        {
+          message_id: @id,
+          channel_id: @channel_id,
+          guild_id: @guild_id,
+          fail_if_not_exists: fail_if_not_exists,
+        }
+      )
     end
 
     def embed
@@ -400,16 +402,16 @@ module Discorb
     # Fetch reacted users of reaction.
     # @async
     #
-    # @param [Discorb::Emoji] emoji The emoji to fetch.
+    # @param [Discorb::Emoji, Discorb::PartialEmoji] emoji The emoji to fetch.
     # @param [Integer, nil] limit The maximum number of users to fetch. `nil` for no limit.
     # @param [Discorb::Snowflake, nil] after The ID of the user to start fetching from.
     #
     # @return [Async::Task<Array<Discorb::User>>] The users.
     #
-    def fetch_reacted_users(emoji, limit: nil, after: 0)
+    def fetch_reacted_users(emoji, limit: nil, after: Discorb::Snowflake.new("0"))
       Async do
         if limit.nil? || !limit.positive?
-          after = 0
+          after = Discorb::Snowflake.new("0")
           users = []
           loop do
             _resp, data = @client.http.request(

data/lib/discorb/message_meta.rb

@@ -76,8 +76,6 @@ module Discorb
         }
       end
 
-      alias to_reference to_hash
-
       #
       # Initialize a new reference from a hash.
       #
@@ -141,7 +139,8 @@ module Discorb
       def initialize(client, data)
         @id = Snowflake.new(data[:id])
         @name = data[:name]
-        @type = Discorb::Interaction.descendants.find { |c| c.interaction_type == data[:type] }
+        @type = (Discorb::Interaction.descendants.find { |c| c.interaction_type == data[:type] } or
+                 raise "Unknown interaction type: #{data[:type]}")
         @user = client.users[data[:user][:id]] || User.new(client, data[:user])
       end
 

data/lib/discorb/modules.rb

@@ -44,7 +44,7 @@ module Discorb
         payload[:embeds] = tmp_embed.map(&:to_hash) if tmp_embed
         payload[:allowed_mentions] =
           allowed_mentions ? allowed_mentions.to_hash(@client.allowed_mentions) : @client.allowed_mentions.to_hash
-        payload[:message_reference] = reference.to_reference if reference
+        payload[:message_reference] = reference.to_reference.to_hash if reference
         payload[:components] = Component.to_payload(components) if components
         attachments ||= attachment ? [attachment] : []
 
@@ -135,7 +135,7 @@ module Discorb
     #
     # @return [Async::Task<void>] The task.
     #
-    def delete_message!(message_id, reason: nil)
+    def delete_message(message_id, reason: nil)
       Async do
         @client.http.request(
           Route.new(
@@ -146,7 +146,7 @@ module Discorb
       end
     end
 
-    alias destroy_message! delete_message!
+    alias destroy_message delete_message
 
     #
     # Fetch a message from ID.
@@ -265,10 +265,11 @@ module Discorb
               sleep(5)
             end
           end
-          yield
+          ret = yield
         ensure
           post_task.stop
         end
+        ret
       else
         Async do |_task|
           @client.http.request(Route.new("/channels/#{@id}/typing", "//channels/:channel_id/typing", :post), {})

data/lib/discorb/permission.rb

@@ -202,7 +202,9 @@ module Discorb
     def +(other)
       result = to_hash
       self.class.bits.each_key do |field|
-        result[field] = other[field] unless other[field].nil?
+        unless other[field].nil?
+          result[field] = (other[field] || raise(KeyError, "field #{field} not found in #{other.inspect}"))
+        end
       end
       self.class.from_hash(result)
     end