discorb 0.14.0 → 0.16.0

data/lib/discorb/interaction/components.rb

@@ -18,26 +18,39 @@ module Discorb
     @interaction_type = 3
     @interaction_name = :message_component
 
+    #
+    # Initialize a new message component interaction.
     # @private
+    #
+    # @param [Discorb::Client] client The client.
+    # @param [Hash] data The data.
+    #
     def initialize(client, data)
       super
-      @message = Message.new(@client, data[:message].merge({ member: data[:member] }))
+      @message = Message.new(@client, data[:message].merge({ member: data[:member], guild_id: data[:guild_id] }))
     end
 
     class << self
       # @private
+      # @return [Integer] The component type.
       attr_reader :component_type
 
+      #
+      # Create a MessageComponentInteraction instance for the given data.
       # @private
+      #
       def make_interaction(client, data)
         nested_classes.each do |klass|
           return klass.new(client, data) if !klass.component_type.nil? && klass.component_type == data[:data][:component_type]
         end
-        client.log.warn("Unknown component type #{data[:component_type]}, initialized Interaction")
+        client.logger.warn("Unknown component type #{data[:component_type]}, initialized Interaction")
         MessageComponentInteraction.new(client, data)
       end
 
+      #
+      # Returns the classes under this class.
       # @private
+      #
       def nested_classes
         constants.select { |c| const_get(c).is_a? Class }.map { |c| const_get(c) }
       end

data/lib/discorb/interaction/response.rb

@@ -74,7 +74,15 @@ module Discorb
       # 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
@@ -128,6 +136,10 @@ 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
 

data/lib/discorb/interaction/root.rb

@@ -38,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])
@@ -81,20 +87,29 @@ 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|
           interaction = klass.make_interaction(client, data) if !klass.interaction_type.nil? && klass.interaction_type == data[:type]
         end
         if interaction.nil?
-          client.log.warn("Unknown interaction type #{data[:type]}, initialized Interaction")
+          client.logger.warn("Unknown interaction type #{data[:type]}, initialized Interaction")
           interaction = Interaction.new(client, data)
         end
         interaction
       end
 
+      #
+      # Returns the descendants of the class.
       # @private
+      #
       def descendants
         ObjectSpace.each_object(Class).select { |klass| klass < self }
       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/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
@@ -248,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

@@ -152,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 = {}
@@ -244,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
 
@@ -445,6 +453,54 @@ module Discorb
       "#<#{self.class} #{@content.inspect} id=#{@id}>"
     end
 
+    private
+
+    def _set_data(data)
+      @id = Snowflake.new(data[:id])
+      @channel_id = data[:channel_id]
+
+      if data[:guild_id]
+        @guild_id = data[:guild_id]
+        @dm = nil
+      else
+        @dm = Discorb::DMChannel.new(@client, data[:channel_id])
+        @guild_id = nil
+      end
+
+      if data[:member].nil? && data[:webhook_id]
+        @webhook_id = Snowflake.new(data[:webhook_id])
+        @author = Webhook::Message::Author.new(data[:author])
+      elsif data[:guild_id].nil? || data[:guild_id].empty? || data[:member].nil?
+        @author = @client.users[data[:author][:id]] || User.new(@client, data[:author])
+      else
+        @author = guild&.members&.get(data[:author][:id]) || Member.new(@client,
+                                                                        @guild_id, data[:author], data[:member])
+      end
+      @content = data[:content]
+      @created_at = Time.iso8601(data[:timestamp])
+      @updated_at = data[:edited_timestamp].nil? ? nil : Time.iso8601(data[:edited_timestamp])
+
+      @tts = data[:tts]
+      @mention_everyone = data[:mention_everyone]
+      @mention_roles = data[:mention_roles].map { |r| guild.roles[r] }
+      @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]]
+      @activity = data[:activity] && Activity.new(data[:activity])
+      @application_id = data[:application_id]
+      @message_reference = data[:message_reference] && Reference.from_hash(data[:message_reference])
+      @flag = Flag.new(0b111 - data[:flags])
+      @sticker_items = data[:sticker_items] ? data[:sticker_items].map { |s| Message::Sticker.new(s) } : []
+      # @referenced_message = data[:referenced_message] && Message.new(@client, data[:referenced_message])
+      @interaction = data[:interaction] && Message::Interaction.new(@client, data[:interaction])
+      @thread = data[:thread] && Channel.make_channel(@client, data[:thread])
+      @components = data[:components].map { |c| c[:components].map { |co| Component.from_hash(co) } }
+      @data.update(data)
+      @deleted = false
+    end
+
     class << self
       # @private
       attr_reader :message_type

data/lib/discorb/message_meta.rb

@@ -88,74 +88,39 @@ module Discorb
       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
+
+      def inspect
+        "#<#{self.class.name} #{@channel_id}/#{@message_id}>"
+      end
     end
 
     #
     # Represents a sticker.
     #
     class Sticker
-      attr_reader :id, :name, :format
+      # @return [Discorb::Snowflake] The sticker ID.
+      attr_reader :id
+      # @return [String] The sticker name.
+      attr_reader :name
+      # @return [Symbol] The sticker format.
+      attr_reader :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)
-      @id = Snowflake.new(data[:id])
-      @channel_id = data[:channel_id]
-
-      if data[:guild_id]
-        @guild_id = data[:guild_id]
-        @dm = nil
-      else
-        @dm = Discorb::DMChannel.new(@client, data[:channel_id])
-        @guild_id = nil
+        @format = Discorb::Sticker::STICKER_FORMAT[data[:format]]
       end
 
-      if data[:member].nil? && data[:webhook_id]
-        @webhook_id = Snowflake.new(data[:webhook_id])
-        @author = Webhook::Message::Author.new(data[:author])
-      elsif data[:guild_id].nil? || data[:guild_id].empty? || data[:member].nil?
-        @author = @client.users[data[:author][:id]] || User.new(@client, data[:author])
-      else
-        @author = guild&.members&.get(data[:author][:id]) || Member.new(@client,
-                                                                        @guild_id, data[:author], data[:member])
+      def inspect
+        "#<#{self.class.name} #{@id}: #{@name} format=#{@format}>"
       end
-      @content = data[:content]
-      @created_at = Time.iso8601(data[:timestamp])
-      @updated_at = data[:edited_timestamp].nil? ? nil : Time.iso8601(data[:edited_timestamp])
-
-      @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) } : []
-      @reactions = data[:reactions] ? data[:reactions].map { |r| Reaction.new(self, r) } : []
-      @pinned = data[:pinned]
-      @type = self.class.message_type[data[:type]]
-      @activity = data[:activity] && Activity.new(data[:activity])
-      @application_id = data[:application_id]
-      @message_reference = data[:message_reference] && Reference.from_hash(data[:message_reference])
-      @flag = Flag.new(0b111 - data[:flags])
-      @sticker_items = data[:sticker_items] ? data[:sticker_items].map { |s| Message::Sticker.new(s) } : []
-      # @referenced_message = data[:referenced_message] && Message.new(@client, data[:referenced_message])
-      @interaction = data[:interaction] && Message::Interaction.new(@client, data[:interaction])
-      @thread = data[:thread] && Channel.make_channel(@client, data[:thread])
-      @components = data[:components].map { |c| c[:components].map { |co| Component.from_hash(co) } }
-      @data.update(data)
-      @deleted = false
     end
 
     #
     # Represents a interaction of message.
     #
     class Interaction < DiscordModel
-      # @return [Discorb::Snowflake] The user ID.
+      # @return [Discorb::Snowflake] The interaction ID.
       attr_reader :id
       # @return [String] The name of command.
       # @return [nil] If the message is not a command.
@@ -165,13 +130,23 @@ module Discorb
       # @return [Discorb::User] The user.
       attr_reader :user
 
+      #
+      # Initialize a new interaction.
       # @private
+      #
+      # @param [Discorb::Client] client The client.
+      # @param [Hash] data The interaction data.
+      #
       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
+
+      def inspect
+        "<#{self.class.name} #{@id}: #{@name} type=#{@type} #{@user}>"
+      end
     end
 
     #
@@ -183,22 +158,28 @@ module Discorb
       # @return [Symbol] The type of activity.
       attr_reader :type
 
-      @type = {
+      # @private
+      # @return [{Integer => Symbol}] The mapping of activity type.
+      TYPES = {
         1 => :join,
         2 => :spectate,
         3 => :listen,
         5 => :join_request,
-      }
+      }.freeze
 
+      #
+      # Initialize a new activity.
       # @private
+      #
+      # @param [Hash] data The activity data.
+      #
       def initialize(data)
         @name = data[:name]
-        @type = self.class.type(data[:type])
+        @type = TYPES[data[:type]]
       end
 
-      class << self
-        # @private
-        attr_reader :type
+      def inspect
+        "<#{self.class.name} #{@name} type=#{@type}>"
       end
     end
   end

data/lib/discorb/modules.rb

@@ -16,13 +16,13 @@ module Discorb
     # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions.
     # @param [Discorb::Message, Discorb::Message::Reference] reference The message to reply to.
     # @param [Array<Discorb::Component>, Array<Array<Discorb::Component>>] components The components to send.
-    # @param [Discorb::File] file The file to send.
-    # @param [Array<Discorb::File>] files The files to send.
+    # @param [Discorb::Attachment] attachment The attachment to send.
+    # @param [Array<Discorb::Attachment>] attachments The attachments to send.
     #
     # @return [Async::Task<Discorb::Message>] The message sent.
     #
     def post(content = nil, tts: false, embed: nil, embeds: nil, allowed_mentions: nil,
-                            reference: nil, components: nil, file: nil, files: nil)
+                            reference: nil, components: nil, attachment: nil, attachments: nil)
       Async do
         payload = {}
         payload[:content] = content if content
@@ -37,8 +37,17 @@ module Discorb
           allowed_mentions ? allowed_mentions.to_hash(@client.allowed_mentions) : @client.allowed_mentions.to_hash
         payload[:message_reference] = reference.to_reference if reference
         payload[:components] = Component.to_payload(components) if components
-        files = [file]
-        _resp, data = @client.http.multipart_request(Route.new("/channels/#{channel_id.wait}/messages", "//channels/:channel_id/messages", :post), payload, files).wait
+        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("/channels/#{channel_id.wait}/messages", "//channels/:channel_id/messages", :post), payload, attachments).wait
         Message.new(@client, data.merge({ guild_id: @guild_id.to_s }))
       end
     end
@@ -48,33 +57,48 @@ module Discorb
     #
     # Edit a message.
     # @async
+    # @!macro edit
     #
     # @param [#to_s] message_id The message id.
     # @param [String] content The message content.
     # @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_message(message_id, content = nil, embed: nil, embeds: nil, allowed_mentions: nil,
-                                                components: nil, supress: nil)
+    def edit_message(message_id, content = Discorb::Unset, embed: Discorb::Unset, embeds: Discorb::Unset, allowed_mentions: Discorb::Unset,
+                                                           attachments: Discorb::Unset, components: Discorb::Unset, supress: Discorb::Unset)
       Async do
         payload = {}
-        payload[:content] = content if content
-        tmp_embed = if embed
+        payload[:content] = content if content != Discorb::Unset
+        tmp_embed = if embed != Discorb::Unset
             [embed]
-          elsif embeds
+          elsif embeds != Discorb::Unset
             embeds
           end
         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[:components] = Component.to_payload(components) if components
-        payload[:flags] = (supress ? 1 << 2 : 0) unless supress.nil?
-        @client.http.request(Route.new("/channels/#{channel_id.wait}/messages/#{message_id}", "//channels/:channel_id/messages/:message_id", :patch), payload).wait
+          allowed_mentions == Discorb::Unset ? @client.allowed_mentions.to_hash : allowed_mentions.to_hash(@client.allowed_mentions)
+        payload[:components] = Component.to_payload(components) if components != Discorb::Unset
+        payload[:flags] = (supress ? 1 << 2 : 0) if supress != Discorb::Unset
+        if attachments != Discorb::Unset
+          payload[:attachments] = attachments.map.with_index do |a, i|
+            {
+              id: i,
+              filename: a.filename,
+              description: a.description,
+            }
+          end
+        end
+        @client.http.multipart_request(
+          Route.new("/channels/#{channel_id.wait}/messages/#{message_id}", "//channels/:channel_id/messages/:message_id", :patch),
+          payload,
+          attachments == Discorb::Unset ? [] : attachments
+        ).wait
       end
     end
 

data/lib/discorb/permission.rb

@@ -138,7 +138,13 @@ module Discorb
     }.freeze
     @bits = @raw_bits.transform_values { |v| 1 << v }.freeze
 
+    #
+    # Initializes a new PermissionOverwrite.
     # @private
+    #
+    # @param allow [Integer] The allowed permissions.
+    # @param deny [Integer] The denied permissions.
+    #
     def initialize(allow, deny)
       @allow = allow
       @deny = deny
@@ -175,11 +181,14 @@ module Discorb
     #
     def to_hash
       self.class.bits.keys.to_h do |field|
-        [field, if @allow & self.class.bits[field] != 0
-          true
-        elsif @deny & self.class.bits[method] != 0
-          false
-        end]
+        [
+          field,
+          if @allow & self.class.bits[field] != 0
+            true
+          elsif @deny & self.class.bits[field] != 0
+            false
+          end,
+        ]
       end
     end
 

data/lib/discorb/presence.rb

@@ -19,7 +19,13 @@ module Discorb
     # @!attribute [r] activity
     #   @return [Discorb::Presence::Activity] The activity of the presence.
 
+    #
+    # Initialize a presence.
     # @private
+    #
+    # @param [Discorb::Client] client The client.
+    # @param [Hash] data The data of the presence.
+    #
     def initialize(client, data)
       @client = client
       @data = data
@@ -80,19 +86,26 @@ module Discorb
       # @return [Discorb::Presence::Activity::Flag] The flags of the activity.
       attr_reader :flags
 
-      @activity_types = {
+      # @private
+      # @return [{Integer => Symbol}] The mapping of activity types.
+      ACTIVITY_TYPES = {
         0 => :game,
         1 => :streaming,
         2 => :listening,
         3 => :watching,
         4 => :custom,
         5 => :competing,
-      }
+      }.freeze
 
+      #
+      # Initialize the activity.
       # @private
+      #
+      # @param [Hash] data The activity data.
+      #
       def initialize(data)
         @name = data[:name]
-        @type = self.class.activity_types[data[:type]]
+        @type = ACTIVITY_TYPES[data[:type]]
         @url = data[:url]
         @created_at = Time.at(data[:created_at])
         @timestamps = data[:timestamps] && Timestamps.new(data[:timestamps])
@@ -140,7 +153,12 @@ module Discorb
         # @return [Time] The end time of the activity.
         attr_reader :end
 
+        #
+        # Initialize the timestamps.
         # @private
+        #
+        # @param [Hash] data The timestamps data.
+        #
         def initialize(data)
           @start = data[:start] && Time.at(data[:start])
           @end = data[:end] && Time.at(data[:end])
@@ -159,7 +177,12 @@ module Discorb
         # @!attribute [r] max_size
         #   @return [Integer] The max size of the party.
 
+        #
+        # Initialize the party.
         # @private
+        #
+        # @param [Hash] data The party data.
+        #
         def initialize(data)
           @id = data[:id]
           @size = data[:size]
@@ -229,7 +252,12 @@ module Discorb
         # @return [String] The match secret of the activity.
         attr_reader :match
 
+        #
+        # Initialize the secrets.
         # @private
+        #
+        # @param [Hash] data The secrets data.
+        #
         def initialize(data)
           @join = data[:join]
           @spectate = data[:spectate]
@@ -247,17 +275,17 @@ module Discorb
         attr_reader :url
         alias text label
 
+        #
+        # Initialize the button.
         # @private
+        #
+        # @param [Hash] data The button data.
+        #
         def initialize(data)
           @label = data[0]
           @url = data[1]
         end
       end
-
-      class << self
-        # @private
-        attr_reader :activity_types
-      end
     end
 
     #
@@ -278,7 +306,12 @@ module Discorb
       # @!attribute [r] web?
       #   @return [Boolean] Whether the user is not offline on web.
 
+      #
+      # Initialize the client status.
       # @private
+      #
+      # @param [Hash] data The client status data.
+      #
       def initialize(data)
         @desktop = data[:desktop]&.to_sym || :offline
         @mobile = data[:mobile]&.to_sym || :offline