discorb 0.13.4 → 0.15.1

data/lib/discorb/message_meta.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+module Discorb
+  #
+  # Represents a message in Discord.
+  #
+  class Message < DiscordModel
+    #
+    # 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
+
+      def inspect
+        "#<#{self.class.name} #{@channel_id}/#{@message_id}>"
+      end
+    end
+
+    #
+    # Represents a sticker.
+    #
+    class Sticker
+      # @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
+
+      def inspect
+        "#<#{self.class.name} #{@id}: #{@name} format=#{@format}>"
+      end
+    end
+
+    #
+    # Represents a interaction of message.
+    #
+    class Interaction < DiscordModel
+      # @return [Discorb::Snowflake] The interaction 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
+
+      #
+      # 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
+
+    #
+    # 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
+
+      # @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 = TYPES[data[:type]]
+      end
+
+      def inspect
+        "<#{self.class.name} #{@name} type=#{@type}>"
+      end
+    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
 
@@ -204,7 +228,7 @@ module Discorb
           post_task.stop
         end
       else
-        Async do |task|
+        Async do |_task|
           @client.http.request(Route.new("/channels/#{@id}/typing", "//channels/:channel_id/typing", :post), {})
         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
@@ -174,13 +180,16 @@ module Discorb
     # @return [Hash] The permission overwrite as a hash.
     #
     def to_hash
-      self.class.bits.keys.map do |field|
-        [field, if @allow & self.class.bits[field] != 0
-          true
-        elsif @deny & self.class.bits[method] != 0
-          false
-        end]
-      end.to_h
+      self.class.bits.keys.to_h do |field|
+        [
+          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])
@@ -105,7 +118,7 @@ module Discorb
         @party = data[:party] && Party.new(data[:party])
         @assets = data[:assets] && Asset.new(data[:assets])
         @instance = data[:instance]
-        @buttons = data[:buttons] && data[:buttons].map { |b| Button.new(b) }
+        @buttons = data[:buttons]&.map { |b| Button.new(b) }
         @flags = data[:flags] && Flag.new(data[:flags])
       end
 
@@ -140,13 +153,21 @@ 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])
         end
       end
 
+      #
+      # Represents the party of an activity.
+      #
       class Party < DiscordModel
         # @return [String] The id of the party.
         attr_reader :id
@@ -156,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]
@@ -226,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]
@@ -244,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
 
     #
@@ -275,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

data/lib/discorb/rate_limit.rb

@@ -6,7 +6,12 @@ module Discorb
   # @private
   #
   class RatelimitHandler
+    #
+    # Initialize a rate limit handler.
     # @private
+    #
+    # @param [Discorb::Client] client The client.
+    #
     def initialize(client)
       @client = client
       @path_ratelimit_bucket = {}
@@ -40,7 +45,7 @@ module Discorb
         @path_ratelimit_bucket.delete(path.identifier + path.major_param)
         return
       end
-      return if bucket[:remaining] > 0
+      return if (bucket[:remaining]).positive?
 
       time = bucket[:reset_at] - Time.now.to_f
       @client.log.info("rate limit for #{path.identifier} with #{path.major_param} reached, waiting #{time.round(4)} seconds")
@@ -54,9 +59,7 @@ module Discorb
     # @param [Net::HTTPResponse] resp The response.
     #
     def save(path, resp)
-      if resp["X-Ratelimit-Global"] == "true"
-        @global = Time.now.to_f + JSON.parse(resp.body, symbolize_names: true)[:retry_after]
-      end
+      @global = Time.now.to_f + JSON.parse(resp.body, symbolize_names: true)[:retry_after] if resp["X-Ratelimit-Global"] == "true"
       return unless resp["X-RateLimit-Remaining"]
       @path_ratelimit_hash[path.identifier] = resp["X-Ratelimit-Bucket"]
       @path_ratelimit_bucket[resp["X-Ratelimit-Bucket"] + path.major_param] = {

data/lib/discorb/reaction.rb

@@ -16,7 +16,13 @@ module Discorb
     alias me? me
     alias reacted? me
 
+    #
+    # Initialize a new reaction.
     # @private
+    #
+    # @param [Discorb::Message] message The message that this reaction is on.
+    # @param [Hash] data The data of the reaction.
+    #
     def initialize(message, data)
       @message = message
       _set_data(data)

data/lib/discorb/role.rb

@@ -42,7 +42,14 @@ module Discorb
 
     include Comparable
 
+    #
+    # Initializes a new role.
     # @private
+    #
+    # @param [Discorb::Client] client The client.
+    # @param [Discorb::Guild] guild The guild the role belongs to.
+    # @param [Hash] data The data of the role.
+    #
     def initialize(client, guild, data)
       @client = client
       @guild = guild
@@ -176,7 +183,12 @@ module Discorb
       # @!attribute [r] integration?
       #   @return [Boolean] Whether the role is an integration role.
 
+      #
+      # Initializes a new tag.
       # @private
+      #
+      # @param [Hash] data The data of the tag.
+      #
       def initialize(data)
         @bot_id = Snowflake.new(data[:bot_id])
         @integration_id = Snowflake.new(data[:integration_id])

data/lib/discorb/sticker.rb

@@ -29,16 +29,27 @@ module Discorb
     attr_reader :available
     alias available? available
 
-    @sticker_type = {
+    # @private
+    # @return [{Integer => Symbol}] The mapping of sticker types.
+    STICKER_TYPE = {
       1 => :official,
       2 => :guild,
     }.freeze
-    @sticker_format = {
+
+    # @private
+    # @return [{Integer => Symbol}] The mapping of sticker format.
+    STICKER_FORMAT = {
       1 => :png,
       2 => :apng,
       3 => :lottie,
-    }
+    }.freeze
+    #
+    # Initialize a new sticker.
     # @private
+    #
+    # @param [Discorb::Client] client The client.
+    # @param [Hash] data The sticker data.
+    #
     def initialize(client, data)
       @client = client
       _set_data(data)
@@ -51,15 +62,6 @@ module Discorb
       # @!attribute [r] guild
       #   @macro client_cache
       #   @return [Discorb::Guild] The guild the sticker is in.
-      @sticker_type = {
-        1 => :official,
-        2 => :guild,
-      }.freeze
-      @sticker_format = {
-        1 => :png,
-        2 => :apng,
-        3 => :lottie,
-      }
 
       def guild
         @client.guilds[@guild_id]
@@ -121,7 +123,13 @@ module Discorb
       # @return [Discorb::Asset] The banner of the pack.
       attr_reader :banner
 
+      #
+      # Initialize a new sticker pack.
       # @private
+      #
+      # @param [Discorb::Client] client The client.
+      # @param [Hash] data The sticker pack data.
+      #
       def initialize(client, data)
         @client = client
         @id = Snowflake.new(data[:id])
@@ -141,8 +149,8 @@ module Discorb
       @id = Snowflake.new(data[:id])
       @name = data[:name]
       @tags = data[:tags].split(",")
-      @type = self.class.sticker_type[data[:type]]
-      @format = self.class.sticker_format[data[:format]]
+      @type = STICKER_TYPE[data[:type]]
+      @format = STICKER_FORMAT[data[:format]]
       @description = data[:description]
       @available = data[:available]
       if @type == :official

data/lib/discorb/user.rb

@@ -29,7 +29,13 @@ module Discorb
     # @!attribute [r] mention
     #   @return [String] The user's mention.
 
+    #
+    # Initializes a new user.
     # @private
+    #
+    # @param [Discorb::Client] client The client.
+    # @param [Hash] data The user data.
+    #
     def initialize(client, data)
       @client = client
       @data = {}
@@ -79,7 +85,12 @@ module Discorb
 
     alias app_owner? bot_owner?
 
+    #
+    # Returns the dm channel id of the user.
     # @private
+    #
+    # @return [Async::Task<Discorb::Snowflake>] A task that resolves to the channel id.
+    #
     def channel_id
       Async do
         next @dm_channel_id if @dm_channel_id
@@ -137,7 +148,7 @@ module Discorb
       @avatar = data[:avatar] ? Asset.new(self, data[:avatar]) : DefaultAvatar.new(data[:discriminator])
       @bot = data[:bot]
       @raw_data = data
-      @client.users[@id] = self if !data[:no_cache]
+      @client.users[@id] = self unless data[:no_cache]
       @created_at = @id.timestamp
       @data.update(data)
     end

data/lib/discorb/utils/colored_puts.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # @private
 def sputs(text)
   puts "\e[92m#{text}\e[m"