discordrb 3.5.0 → 3.6.0

data/lib/discordrb/data/message.rb

@@ -5,17 +5,80 @@ module Discordrb
   class Message
     include IDObject
 
+    # Map of message flags.
+    FLAGS = {
+      crossposted: 1 << 0,
+      crosspost: 1 << 1,
+      suppress_embeds: 1 << 2,
+      source_message_deleted: 1 << 3,
+      urgent: 1 << 4,
+      thread: 1 << 5,
+      ephemeral: 1 << 6,
+      loading: 1 << 7,
+      failed_to_mention_roles: 1 << 8,
+      suppress_notifications: 1 << 12,
+      voice_message: 1 << 13,
+      snapshot: 1 << 14,
+      uikit_components: 1 << 15
+    }.freeze
+
+    # Map of message types.
+    TYPES = {
+      default: 0,
+      recipient_add: 1,
+      recipient_remove: 2,
+      call: 3,
+      channel_name_change: 4,
+      channel_icon_change: 5,
+      channel_pinned_message: 6,
+      server_member_join: 7,
+      server_boost: 8,
+      server_boost_tier_one: 9,
+      server_boost_tier_two: 10,
+      server_boost_tier_three: 11,
+      channel_follow_add: 12,
+      server_discovery_disqualified: 14,
+      server_discovery_requalified: 15,
+      server_discovery_grace_period_initial_warning: 16,
+      server_discovery_grace_period_final_warning: 17,
+      thread_created: 18,
+      reply: 19,
+      chat_input_command: 20,
+      thread_starter_message: 21,
+      server_invite_reminder: 22,
+      context_menu_command: 23,
+      automod_action: 24,
+      role_subscription_purchase: 25,
+      interaction_premium_upsell: 26,
+      stage_start: 27,
+      stage_end: 28,
+      stage_speaker: 29,
+      stage_raise_hand: 30,
+      stage_topic: 31,
+      server_application_premium_subscription: 32,
+      server_incident_alert_mode_enabled: 36,
+      server_incident_alert_mode_disabled: 37,
+      server_incident_report_raid: 38,
+      server_incident_report_false_alarm: 39,
+      purchase_notification: 44,
+      poll_result: 46,
+      changelog: 47,
+      server_join_request_accepted: 52,
+      server_join_request_rejected: 53,
+      server_join_request_withdrawn: 54,
+      report_to_mod_deleted_message: 58,
+      report_to_mod_timeout_user: 59,
+      report_to_mod_kick_user: 60,
+      report_to_mod_ban_user: 61,
+      report_to_mod_closed_report: 62,
+      server_emoji_added: 63
+    }.freeze
+
     # @return [String] the content of this message.
     attr_reader :content
     alias_method :text, :content
     alias_method :to_s, :content
 
-    # @return [Member, User] the user that sent this message. (Will be a {Member} most of the time, it should only be a
-    #   {User} for old messages when the author has left the server since then)
-    attr_reader :author
-    alias_method :user, :author
-    alias_method :writer, :author
-
     # @return [Channel] the channel in which this message was sent.
     attr_reader :channel
 
@@ -70,9 +133,24 @@ module Discordrb
     # @return [Integer, nil] the webhook ID that sent this message, or `nil` if it wasn't sent through a webhook.
     attr_reader :webhook_id
 
-    # @return [Array<Component>]
+    # @return [Array<Component>] Interaction components for this message.
     attr_reader :components
 
+    # @return [Integer] flags set on the message.
+    attr_reader :flags
+
+    # @return [Channel, nil] The thread that was started from this message, or nil.
+    attr_reader :thread
+
+    # @return [Time, nil] the time at when this message was pinned. Only present on messages fetched via {Channel#pins}.
+    attr_reader :pinned_at
+
+    # @return [Call, nil] the call in a private channel that prompted this message.
+    attr_reader :call
+
+    # @return [Array<Snapshot>] the message snapshots included in this message.
+    attr_reader :snapshots
+
     # @!visibility private
     def initialize(data, bot)
       @bot = bot
@@ -91,35 +169,21 @@ module Discordrb
 
       @webhook_id = data['webhook_id']&.to_i
 
-      @author = if data['author']
-                  if @webhook_id
-                    # This is a webhook user! It would be pointless to try to resolve a member here, so we just create
-                    # a User and return that instead.
-                    Discordrb::LOGGER.debug("Webhook user: #{data['author']['id']}")
-                    User.new(data['author'].merge({ '_webhook' => true }), @bot)
-                  elsif @channel.private?
-                    # Turn the message user into a recipient - we can't use the channel recipient
-                    # directly because the bot may also send messages to the channel
-                    Recipient.new(bot.user(data['author']['id'].to_i), @channel, bot)
-                  else
-                    member = @channel.server.member(data['author']['id'].to_i)
-
-                    if member
-                      member.update_data(data['member']) if data['member']
-                      member.update_global_name(data['author']['global_name']) if data['author']['global_name']
-                    else
-                      Discordrb::LOGGER.debug("Member with ID #{data['author']['id']} not cached (possibly left the server).")
-                      member = if data['member']
-                                 member_data = data['author'].merge(data['member'])
-                                 Member.new(member_data, @server, bot)
-                               else
-                                 @bot.ensure_user(data['author'])
-                               end
-                    end
-
-                    member
-                  end
-                end
+      if data['author']
+        if @webhook_id
+          # This is a webhook user! It would be pointless to try to resolve a member here, so we just create
+          # a User and return that instead.
+          Discordrb::LOGGER.debug("Webhook user: #{data['author']['id']}")
+          @author = User.new(data['author'].merge({ '_webhook' => true }), @bot)
+        elsif @channel.private?
+
+          # Turn the message user into a recipient - we can't use the channel recipient
+          # directly because the bot may also send messages to the channel
+          @author = Recipient.new(bot.user(data['author']['id'].to_i), @channel, bot)
+        else
+          @author_id = data['author']['id'].to_i
+        end
+      end
 
       @timestamp = Time.parse(data['timestamp']) if data['timestamp']
       @edited_timestamp = data['edited_timestamp'].nil? ? nil : Time.parse(data['edited_timestamp'])
@@ -157,8 +221,34 @@ module Discordrb
 
       @components = []
       @components = data['components'].map { |component_data| Components.from_data(component_data, @bot) } if data['components']
+
+      @flags = data['flags'] || 0
+
+      @thread = data['thread'] ? @bot.ensure_channel(data['thread'], @server) : nil
+
+      @pinned_at = data['pinned_at'] ? Time.parse(data['pinned_at']) : nil
+
+      @call = data['call'] ? Call.new(data['call'], @bot) : nil
+
+      @snapshots = data['message_snapshots']&.map { |snapshot| Snapshot.new(snapshot['message'], @bot) } || []
     end
 
+    # @return [Member, User] the user that sent this message. (Will be a {Member} most of the time, it should only be a
+    #   {User} for old messages when the author has left the server since then)
+    def author
+      return @author if @author
+
+      if @channel.server
+        @author = @channel.server.member(@author_id)
+        Discordrb::LOGGER.debug("Member with ID #{@author_id} not cached (possibly left the server).") if @author.nil?
+      end
+
+      @author ||= @bot.user(@author_id)
+    end
+
+    alias_method :user, :author
+    alias_method :writer, :author
+
     # Replies to this message with the specified content.
     # @deprecated Please use {#respond}.
     # @param content [String] The content to send. Should not be longer than 2000 characters or it will result in an error.
@@ -176,18 +266,19 @@ module Discordrb
     # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
     # @param mention_user [true, false] Whether the user that is being replied to should be pinged by the reply.
     # @param components [View, Array<Hash>] Interaction components to associate with this message.
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2) and SUPPRESS_NOTIFICATIONS (1 << 12) can be set.
     # @return (see #respond)
-    def reply!(content, tts: false, embed: nil, attachments: nil, allowed_mentions: {}, mention_user: false, components: nil)
+    def reply!(content, tts: false, embed: nil, attachments: nil, allowed_mentions: {}, mention_user: false, components: nil, flags: 0)
       allowed_mentions = { parse: [] } if allowed_mentions == false
       allowed_mentions = allowed_mentions.to_hash.transform_keys(&:to_sym)
       allowed_mentions[:replied_user] = mention_user
 
-      respond(content, tts, embed, attachments, allowed_mentions, self, components)
+      respond(content, tts, embed, attachments, allowed_mentions, self, components, flags)
     end
 
     # (see Channel#send_message)
-    def respond(content, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil)
-      @channel.send_message(content, tts, embed, attachments, allowed_mentions, message_reference, components)
+    def respond(content, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0)
+      @channel.send_message(content, tts, embed, attachments, allowed_mentions, message_reference, components, flags)
     end
 
     # Edits this message to have the specified content instead.
@@ -195,12 +286,13 @@ module Discordrb
     # @param new_content [String] the new content the message should have.
     # @param new_embeds [Hash, Discordrb::Webhooks::Embed, Array<Hash>, Array<Discordrb::Webhooks::Embed>, nil] The new embeds the message should have. If `nil` the message will be changed to have no embeds.
     # @param new_components [View, Array<Hash>] The new components the message should have. If `nil` the message will be changed to have no components.
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2) can be edited.
     # @return [Message] the resulting message.
-    def edit(new_content, new_embeds = nil, new_components = nil)
+    def edit(new_content, new_embeds = nil, new_components = nil, flags = 0)
       new_embeds = (new_embeds.instance_of?(Array) ? new_embeds.map(&:to_hash) : [new_embeds&.to_hash]).compact
-      new_components = new_components&.to_a || []
+      new_components = new_components.to_a
 
-      response = API::Channel.edit_message(@bot.token, @channel.id, @id, new_content, [], new_embeds, new_components)
+      response = API::Channel.edit_message(@bot.token, @channel.id, @id, new_content, [], new_embeds, new_components, flags)
       Message.new(JSON.parse(response), @bot)
     end
 
@@ -224,6 +316,12 @@ module Discordrb
       nil
     end
 
+    # Crossposts a message in a news channel.
+    def crosspost
+      response = API::Channel.crosspost_message(@bot.token, @channel.id, @id)
+      Message.new(JSON.parse(response), @bot)
+    end
+
     # Add an {Await} for a message with the same user and channel.
     # @see Bot#add_await
     # @deprecated Will be changed to blocking behavior in v4.0. Use {#await!} instead.
@@ -286,6 +384,25 @@ module Discordrb
       @reactions.select(&:me)
     end
 
+    # Removes embeds from the message
+    # @return [Message] the resulting message.
+    def suppress_embeds
+      flags = @flags | (1 << 2)
+      response = API::Channel.edit_message(@bot.token, @channel.id, @id, :undef, :undef, :undef, :undef, flags)
+      Message.new(JSON.parse(response), @bot)
+    end
+
+    # Check if this message mentions a specific user or role.
+    # @param target [Role, User, Member, Integer, String] The mention to match against.
+    # @return [true, false] whether or not this message mentions the target.
+    def mentions?(target)
+      mentions = (@mentions + role_mentions)
+
+      mentions << server if @mention_everyone
+
+      mentions.any?(target.resolve_id)
+    end
+
     # Reacts to a message.
     # @param reaction [String, #to_reaction] the unicode emoji or {Emoji}
     def create_reaction(reaction)
@@ -308,7 +425,7 @@ module Discordrb
 
       get_reactions = proc do |fetch_limit, after_id = nil|
         resp = API::Channel.get_reactions(@bot.token, @channel.id, @id, reaction, nil, after_id, fetch_limit)
-        return JSON.parse(resp).map { |d| User.new(d, @bot) }
+        JSON.parse(resp).map { |d| User.new(d, @bot) }
       end
 
       # Can be done without pagination
@@ -374,19 +491,13 @@ module Discordrb
       !@referenced_message.nil?
     end
 
-    # Whether or not this message was of type "CHAT_INPUT_COMMAND"
-    # @return [true, false]
-    def chat_input_command?
-      @type == 20
-    end
-
     # @return [Message, nil] the Message this Message was sent in reply to.
     def referenced_message
       return @referenced_message if @referenced_message
       return nil unless @message_reference
 
       referenced_channel = @bot.channel(@message_reference['channel_id'])
-      @referenced_message = referenced_channel.message(@message_reference['message_id'])
+      @referenced_message = referenced_channel&.message(@message_reference['message_id'])
     end
 
     # @return [Array<Components::Button>]
@@ -410,5 +521,41 @@ module Discordrb
     end
 
     alias_method :message, :to_message
+
+    FLAGS.each do |name, value|
+      define_method("#{name}?") do
+        @flags.anybits?(value)
+      end
+    end
+
+    TYPES.each do |name, value|
+      define_method("#{name}?") do
+        @type == value
+      end
+    end
+
+    # Convert this message to a hash that can be used to reference this message in a forward or a reply.
+    # @param type [Integer, Symbol] The reference type to set. Can either be one of `:reply` or `:forward`.
+    # @param must_exist [true, false] Whether to raise an error if this message was deleted when sending it.
+    # @return [Hash] the message as a hash representation that can be used in a forwarded message or a reply.
+    def to_reference(type: :reply, must_exist: true)
+      type = (type == :reply ? 0 : 1) if type.is_a?(Symbol)
+
+      { type: type, message_id: @id, channel_id: @channel.id, fail_if_not_exists: must_exist }
+    end
+
+    # Forward this message to another channel.
+    # @param channel [Integer, String, Channel] The target channel to forward this message to.
+    # @param must_exist [true, false] Whether to raise an error if this message was deleted when sending it.
+    # @param timeout [Float, nil] The amount of time in seconds after which the message sent will be deleted.
+    # @param flags [Integer, Symbol, Array<Integer, Symbol>] The message flags to set on the forwarded message.
+    # @param nonce [String, Integer, nil] The 25 character optional nonce that should be used when forwarding this message.
+    # @param enforce_nonce [true, false] Whether the provided nonce should be enforced and used for message de-duplication.
+    # @return [Message, nil] the message that was created from forwarding this one, or `nil` if this is a temporary message.
+    def forward(channel, must_exist: true, timeout: nil, flags: 0, nonce: nil, enforce_nonce: false)
+      reference = to_reference(type: :forward, must_exist: must_exist)
+
+      @bot.channel(channel).send_message!(reference: reference, timeout: timeout, flags: flags, nonce: nonce, enforce_nonce: enforce_nonce)
+    end
   end
 end

data/lib/discordrb/data/overwrite.rb

@@ -65,7 +65,9 @@ module Discordrb
 
     # Comparison by attributes [:id, :type, :allow, :deny]
     def ==(other)
+      # rubocop:disable Lint/Void
       false unless other.is_a? Discordrb::Overwrite
+      # rubocop:enable Lint/Void
       id == other.id &&
         type == other.type &&
         allow == other.allow &&

data/lib/discordrb/data/primary_server.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # A server tag that a user has chosen to display on their profile.
+  class PrimaryServer
+    # @return [Integer] the ID of the server this primary server is for.
+    attr_reader :server_id
+
+    # @return [Boolean] if the user is displaying the primary server's tag.
+    attr_reader :enabled
+    alias_method :enabled?, :enabled
+
+    # @return [String] the text of the primary server's tag. Limited to four characters.
+    attr_reader :name
+    alias_method :text, :name
+
+    # @return [String] the ID of the server tag's badge. can be used to generate a badge URL.
+    # @see #badge_url
+    attr_reader :badge_id
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+      @server_id = data['identity_guild_id']&.to_i
+      @enabled = data['identity_enabled']
+      @name = data['tag']
+      @badge_id = data['badge']
+    end
+
+    # Get the server associated with this primary server.
+    # @return [Server] the server associated with this primary server.
+    # @raise [Discordrb::Errors::NoPermission] this can happen when the bot is not in the associated server.
+    def server
+      @bot.server(@server_id)
+    end
+
+    # Get the server preview associated with this primary server.
+    # @return [ServerPreview, nil] the server preview associated with this primary server, or `nil` if it can't be accessed.
+    def server_preview
+      @bot.server_preview(@server_id)
+    end
+
+    # Utility method to get a server tag's badge URL.
+    # @param format [String] the URL will default to `webp`. You can otherwise specify one of `jpg` or `png` to override this.
+    # @return [String] the URL to the server tag's badge image.
+    def badge_url(format = 'webp')
+      API.server_tag_badge_url(@server_id, @badge_id, format)
+    end
+
+    # Comparison based off of server ID.
+    # @return [true, false] if the other object is equal to this primary server.
+    def ==(other)
+      return false unless other.is_a?(PrimaryServer)
+
+      Discordrb.id_compare(other.server_id, @server_id)
+    end
+
+    alias_method :eql?, :==
+  end
+end

data/lib/discordrb/data/profile.rb

@@ -22,13 +22,8 @@ module Discordrb
     # @param avatar [String, #read] A JPG file to be used as the avatar, either
     #  something readable (e.g. File Object) or as a data URL.
     def avatar=(avatar)
-      if avatar.respond_to? :read
-        # Set the file to binary mode if supported, so we don't get problems with Windows
-        avatar.binmode if avatar.respond_to?(:binmode)
-
-        avatar_string = 'data:image/jpg;base64,'
-        avatar_string += Base64.strict_encode64(avatar.read)
-        update_profile_data(avatar: avatar_string)
+      if avatar.respond_to?(:read)
+        update_profile_data(avatar: Discordrb.encode64(avatar))
       else
         update_profile_data(avatar: avatar)
       end

data/lib/discordrb/data/reaction.rb

@@ -16,10 +16,11 @@ module Discordrb
     # @return [String] the name or unicode representation of the emoji
     attr_reader :name
 
+    # @!visibility private
     def initialize(data)
       @count = data['count']
       @me = data['me']
-      @id = data['emoji']['id'].nil? ? nil : data['emoji']['id'].to_i
+      @id = data['emoji']['id']&.to_i
       @name = data['emoji']['name']
     end
 

data/lib/discordrb/data/recipient.rb

@@ -16,7 +16,7 @@ module Discordrb
       raise ArgumentError, 'Tried to create a recipient for a public channel!' unless @channel.private?
 
       @user = user
-      super @user
+      super(@user)
 
       # Member attributes
       @mute = @deaf = @self_mute = @self_deaf = false