discordrb 3.4.3 → 3.6.0

data/lib/discordrb/events/message.rb

@@ -17,9 +17,11 @@ module Discordrb::Events
     # @param attachments [Array<File>] Files that can be referenced in embeds via `attachment://file.png`
     # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
     # @param message_reference [Message, String, Integer, nil] The message, or message ID, to reply to if any.
+    # @param components [View, Array<Hash>, nil] A collection of components to attach to the message.
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2) and SUPPRESS_NOTIFICATIONS (1 << 12) can be set.
     # @return [Discordrb::Message] the message that was sent
-    def send_message(content, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil)
-      channel.send_message(content, tts, embed, attachments, allowed_mentions, message_reference)
+    def send_message(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
 
     # The same as {#send_message}, but yields a {Webhooks::Embed} for easy building of embedded content inside a block.
@@ -30,11 +32,13 @@ module Discordrb::Events
     # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
     # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
     # @param message_reference [Message, String, Integer, nil] The message, or message ID, to reply to if any.
+    # @param components [View, Array<Hash>, nil] A collection of components to attach to the message.
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2) and SUPPRESS_NOTIFICATIONS (1 << 12) can be set.
     # @yield [embed] Yields the embed to allow for easy building inside a block.
     # @yieldparam embed [Discordrb::Webhooks::Embed] The embed from the parameters, or a new one.
     # @return [Message] The resulting message.
-    def send_embed(message = '', embed = nil, attachments = nil, tts = false, allowed_mentions = nil, message_reference = nil, &block)
-      channel.send_embed(message, embed, attachments, tts, allowed_mentions, message_reference, &block)
+    def send_embed(message = '', embed = nil, attachments = nil, tts = false, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0, &block)
+      channel.send_embed(message, embed, attachments, tts, allowed_mentions, message_reference, components, flags, &block)
     end
 
     # Sends a temporary message to the channel this message was sent in, right now.
@@ -44,8 +48,16 @@ module Discordrb::Events
     # @param embed [Hash, Discordrb::Webhooks::Embed, nil] The rich embed to append to this message.
     # @param attachments [Array<File>] Files that can be referenced in embeds via `attachment://file.png`
     # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
-    def send_temporary_message(content, timeout, tts = false, embed = nil, attachments = nil, allowed_mentions = nil)
-      channel.send_temporary_message(content, timeout, tts, embed, attachments, allowed_mentions)
+    # @param components [View, Array<Hash>, nil] A collection of components to attach to the message.
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2) and SUPPRESS_NOTIFICATIONS (1 << 12) can be set.
+    def send_temporary_message(content, timeout, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, components = nil, flags = 0)
+      channel.send_temporary_message(content, timeout, tts, embed, attachments, allowed_mentions, components, flags)
+    end
+
+    # Sends a message to the channel this message was sent in, right now.
+    # @see Channel#send_message!
+    def send_message!(...)
+      channel.send_message!(...)
     end
 
     # Adds a string to be sent after the event has finished execution. Avoids problems with rate limiting because only
@@ -81,6 +93,9 @@ module Discordrb::Events
     alias_method :send, :send_message
     alias_method :respond, :send_message
     alias_method :send_temp, :send_temporary_message
+
+    alias_method :send!, :send_message!
+    alias_method :respond!, :send_message!
   end
 
   # Event raised when a text message is sent to a channel
@@ -121,6 +136,7 @@ module Discordrb::Events
     #   @see Channel#server
     delegate :server, to: :channel
 
+    # @!visibility private
     def initialize(message, bot)
       @bot = bot
       @message = message
@@ -223,7 +239,9 @@ module Discordrb::Events
             a == e
           end
         end,
-        matches_all(@attributes[:from], event.author) do |a, e|
+        matches_all(@attributes[:from], event.message) do |a, e|
+          # Resolve the author in the block in order to prevent resolving the author even when the attribute is `nil`
+          e = e.author
           case a
           when String
             a == e.name
@@ -244,9 +262,18 @@ module Discordrb::Events
             match ? (e == match[0]) : false
           end
         end,
+        matches_all(@attributes[:type] || @attributes[:message_type], event.message.type) do |a, e|
+          case a
+          when String, Symbol
+            Discordrb::Message::TYPES[a.to_sym] == e
+          when Integer
+            a == e
+          end
+        end,
         matches_all(@attributes[:after], event.timestamp) { |a, e| a > e },
         matches_all(@attributes[:before], event.timestamp) { |a, e| a < e },
-        matches_all(@attributes[:private], event.channel.private?) { |a, e| !e == !a }
+        matches_all(@attributes[:private], event.channel.private?) { |a, e| !e == !a },
+        matches_all(@attributes[:server], event.server) { |a, e| a&.resolve_id == e&.resolve_id }
       ].reduce(true, &:&)
     end
 
@@ -279,10 +306,14 @@ module Discordrb::Events
     # @return [Integer] the ID associated with this event
     attr_reader :id
 
+    # @return [Server, nil] the server associated with this event
+    attr_reader :server
+
     # @!visibility private
     def initialize(data, bot)
       @id = data['id'].to_i
       @channel = bot.channel(data['channel_id'].to_i)
+      @server = @channel.server
       @saved_message = ''
       @bot = bot
     end
@@ -308,6 +339,9 @@ module Discordrb::Events
           else
             a == e
           end
+        end,
+        matches_all(@attributes[:server], event.server) do |a, e|
+          a&.resolve_id == e&.resolve_id
         end
       ].reduce(true, &:&)
     end

data/lib/discordrb/events/presence.rb

@@ -19,6 +19,7 @@ module Discordrb::Events
     #   on various device types (`:desktop`, `:mobile`, or `:web`). The value will be `nil` if the user is offline or invisible.
     attr_reader :client_status
 
+    # @!visibility private
     def initialize(data, bot)
       @bot = bot
 
@@ -65,28 +66,36 @@ module Discordrb::Events
     # @return [User] the user whose status got updated.
     attr_reader :user
 
-    # @return [String] the new game the user is playing.
-    attr_reader :game
+    # @return [Discordrb::Activity] The new activity
+    attr_reader :activity
 
-    # @return [String] the URL to the stream
-    attr_reader :url
+    # @!attribute [r] url
+    #   @return [String] the URL to the stream
 
-    # @return [String] what the player is currently doing (ex. game being streamed)
-    attr_reader :details
+    # @!attribute [r] details
+    #   @return [String] what the player is currently doing (ex. game being streamed)
 
-    # @return [Integer] the type of play. 0 = game, 1 = Twitch
-    attr_reader :type
+    # @!attribute [r] type
+    #   @return [Integer] the type of play. See {Discordrb::Activity}
+    delegate :url, :details, :type, to: :activity
 
-    def initialize(data, bot)
+    # @return [Hash<Symbol, Symbol>] the current online status (`:online`, `:idle` or `:dnd`) of the user
+    #   on various device types (`:desktop`, `:mobile`, or `:web`). The value will be `nil` if the user is offline or invisible.
+    attr_reader :client_status
+
+    # @!visibility private
+    def initialize(data, activity, bot)
       @bot = bot
+      @activity = activity
 
       @server = bot.server(data['guild_id'].to_i)
       @user = bot.user(data['user']['id'].to_i)
-      @game = data['game'] ? data['game']['name'] : nil
-      @type = data['game'] ? data['game']['type'].to_i : nil
-      # Handle optional 'game' fields safely
-      @url = data['game'] && data['game']['url'] ? data['game']['url'] : nil
-      @details = data['game'] && data['game']['details'] ? data['game']['details'] : nil
+      @client_status = @user.client_status
+    end
+
+    # @return [String] the name of the new game the user is playing.
+    def game
+      @activity.name
     end
   end
 

data/lib/discordrb/events/raw.rb

@@ -14,6 +14,7 @@ module Discordrb::Events
     attr_reader :data
     alias_method :d, :data
 
+    # @!visibility private
     def initialize(type, data, bot)
       @type = type
       @data = data

data/lib/discordrb/events/reactions.rb

@@ -14,6 +14,7 @@ module Discordrb::Events
     # @!visibility private
     attr_reader :message_id
 
+    # @!visibility private
     def initialize(data, bot)
       @bot = bot
 
@@ -113,6 +114,7 @@ module Discordrb::Events
     # @!visibility private
     attr_reader :message_id
 
+    # @!visibility private
     def initialize(data, bot)
       @bot = bot
 
@@ -137,7 +139,6 @@ module Discordrb::Events
       # Check for the proper event type
       return false unless event.is_a? ReactionRemoveAllEvent
 
-      # No attributes yet as there is no property available on the event that doesn't involve doing a resolution request
       [
         matches_all(@attributes[:message], event.message_id) do |a, e|
           a == e

data/lib/discordrb/events/roles.rb

@@ -17,6 +17,7 @@ module Discordrb::Events
     #   @see Role#name
     delegate :name, to: :role
 
+    # @!visibility private
     def initialize(data, bot)
       @bot = bot
 
@@ -54,6 +55,7 @@ module Discordrb::Events
     # @return [Server] the server on which a role got deleted.
     attr_reader :server
 
+    # @!visibility private
     def initialize(data, bot)
       @bot = bot
 

data/lib/discordrb/events/threads.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# Generic subclass for threads
+module Discordrb::Events
+  # Raised when a thread is created
+  class ThreadCreateEvent < Event
+    # @return [Channel] the thread in question.
+    attr_reader :thread
+
+    delegate :name, :server, :owner, :parent_channel, :thread_metadata, to: :thread
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+      @thread = data.is_a?(Discordrb::Channel) ? data : bot.channel(data['id'].to_i)
+    end
+  end
+
+  # Event handler for ChannelCreateEvent
+  class ThreadCreateEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ThreadCreateEvent
+
+      [
+        matches_all(@attributes[:name], event.name) do |a, e|
+          a == if a.is_a? String
+                 e.to_s
+               else
+                 e
+               end
+        end,
+        matches_all(@attributes[:server], event.server) do |a, e|
+          a.resolve_id == e.resolve_id
+        end,
+        matches_all(@attributes[:invitable], event.thread.invitable) do |a, e|
+          a == e
+        end,
+        matches_all(@attributes[:owner], event.thread.owner) do |a, e|
+          a.resolve_id == e.resolve_id
+        end,
+        matches_all(@attributes[:channel], event.thread.parent) do |a, e|
+          a.resolve_id == e.resolve_id
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Raised when a thread is updated (e.g. name changes)
+  class ThreadUpdateEvent < ThreadCreateEvent; end
+
+  # Event handler for ThreadUpdateEvent
+  class ThreadUpdateEventHandler < ThreadCreateEventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ThreadUpdateEvent
+
+      super
+    end
+  end
+
+  # Raised when members are added or removed from a thread.
+  class ThreadMembersUpdateEvent < Event
+    # @return [Channel]
+    attr_reader :thread
+
+    # @return [Array<Integer>]
+    attr_reader :removed_member_ids
+
+    # @return [Integer]
+    attr_reader :member_count
+
+    delegate :name, :server, :owner, :parent_channel, :thread_metadata, to: :thread
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+      @server = bot.server(data['guild_id'].to_i) if data['guild_id']
+      @thread = data.is_a?(Discordrb::Channel) ? data : bot.channel(data['id'].to_i)
+      @added_member_ids = data['added_members']&.map { |m| m['user_id']&.to_i } || []
+      @removed_member_ids = data['removed_member_ids']&.map(&:resolve_id) || []
+      @member_count = data['member_count']
+    end
+  end
+
+  # @return [Array<Member, User>] the members that were added to the thread
+  def added_members
+    @added_members ||= @added_member_ids&.map { |id| @server&.member(id) || @bot.user(id) }
+  end
+
+  # Event handler for ThreadMembersUpdateEvent
+  class ThreadMembersUpdateEventHandler < ThreadCreateEventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ThreadMembersUpdateEvent
+
+      super
+    end
+  end
+end

data/lib/discordrb/events/typing.rb

@@ -17,6 +17,7 @@ module Discordrb::Events
     # @return [Time] when the typing happened.
     attr_reader :timestamp
 
+    # @!visibility private
     def initialize(data, bot)
       @bot = bot
 

data/lib/discordrb/events/voice_server_update.rb

@@ -19,6 +19,7 @@ module Discordrb::Events
     # @return [String] The voice server host.
     attr_reader :endpoint
 
+    # @!visibility private
     def initialize(data, bot)
       @bot = bot
 

data/lib/discordrb/events/voice_state_update.rb

@@ -11,6 +11,7 @@ module Discordrb::Events
     # @return [Channel, nil] the old channel this user was on, or nil if the user is newly joining voice.
     attr_reader :old_channel
 
+    # @!visibility private
     def initialize(data, old_channel_id, bot)
       @bot = bot
 

data/lib/discordrb/events/webhooks.rb

@@ -12,6 +12,7 @@ module Discordrb::Events
     # @return [Channel] the channel the webhook is associated to
     attr_reader :channel
 
+    # @!visibility private
     def initialize(data, bot)
       @bot = bot
 

data/lib/discordrb/gateway.rb

@@ -90,14 +90,22 @@ module Discordrb
   # This class stores the data of an active gateway session. Note that this is different from a websocket connection -
   # there may be multiple sessions per connection or one session may persist over multiple connections.
   class Session
+    # @return [String] Used to uniquely identify this session. Mostly used when resuming connections.
     attr_reader :session_id
+
+    # @return [Integer] Incrementing integer used to determine the most recent event reccived from Discord.
     attr_accessor :sequence
 
-    def initialize(session_id)
+    # @return [String] Gateway URL used to reconnect to the gateway node that Discord wants this session to use.
+    attr_reader :resume_gateway_url
+
+    # @!visibility private
+    def initialize(session_id, resume_gateway_url)
       @session_id = session_id
       @sequence = 0
       @suspended = false
       @invalid = false
+      @resume_gateway_url = resume_gateway_url
     end
 
     # Flags this session as suspended, so we know not to try and send heartbeats, etc. to the gateway until we've reconnected
@@ -117,6 +125,7 @@ module Discordrb
     # Flags this session as being invalid
     def invalidate
       @invalid = true
+      @resume_gateway_url = nil
     end
 
     def invalid?
@@ -134,7 +143,14 @@ module Discordrb
     LARGE_THRESHOLD = 100
 
     # The version of the gateway that's supposed to be used.
-    GATEWAY_VERSION = 6
+    GATEWAY_VERSION = 9
+
+    # Close codes that are unrecoverable, after which we should not try to reconnect.
+    # - 4003: Not authenticated. How did this happen?
+    # - 4004: Authentication failed. Token was wrong, nothing we can do.
+    # - 4011: Sharding required. Currently requires developer intervention.
+    # - 4014: Use of disabled privileged intents.
+    FATAL_CLOSE_CODES = [4003, 4004, 4011, 4014].freeze
 
     # Heartbeat ACKs are Discord's way of verifying on the client side whether the connection is still alive. If this is
     # set to true (default value) the gateway client will use that functionality to detect zombie connections and
@@ -143,7 +159,10 @@ module Discordrb
     # @return [true, false] whether or not this gateway should check for heartbeat ACKs.
     attr_accessor :check_heartbeat_acks
 
-    def initialize(bot, token, shard_key = nil, compress_mode = :stream, intents = nil)
+    # @return [Integer] the intent parameter sent to the gateway server.
+    attr_reader :intents
+
+    def initialize(bot, token, shard_key = nil, compress_mode = :stream, intents = ALL_INTENTS)
       @token = token
       @bot = bot
 
@@ -277,12 +296,12 @@ module Discordrb
     def identify
       compress = @compress_mode == :large
       send_identify(@token, {
-                      '$os': RUBY_PLATFORM,
-                      '$browser': 'discordrb',
-                      '$device': 'discordrb',
-                      '$referrer': '',
-                      '$referring_domain': ''
-                    }, compress, 100, @shard_key)
+                      os: RUBY_PLATFORM,
+                      browser: 'discordrb',
+                      device: 'discordrb',
+                      referrer: '',
+                      referring_domain: ''
+                    }, compress, LARGE_THRESHOLD, @shard_key, @intents)
     end
 
     # Sends an identify packet (op 2). This starts a new session on the current connection and tells Discord who we are.
@@ -292,26 +311,26 @@ module Discordrb
     # @param properties [Hash<Symbol => String>] A list of properties for Discord to use in analytics. The following
     #   keys are recognised:
     #
-    #    - "$os" (recommended value: the operating system the bot is running on)
-    #    - "$browser" (recommended value: library name)
-    #    - "$device" (recommended value: library name)
-    #    - "$referrer" (recommended value: empty)
-    #    - "$referring_domain" (recommended value: empty)
+    #    - "os" (recommended value: the operating system the bot is running on)
+    #    - "browser" (recommended value: library name)
+    #    - "device" (recommended value: library name)
+    #    - "referrer" (recommended value: empty)
+    #    - "referring_domain" (recommended value: empty)
     #
     # @param compress [true, false] Whether certain large packets should be compressed using zlib.
     # @param large_threshold [Integer] The member threshold after which a server counts as large and will have to have
     #   its member list chunked.
     # @param shard_key [Array(Integer, Integer), nil] The shard key to use for sharding, represented as
     #   [shard_id, num_shards], or nil if the bot should not be sharded.
-    def send_identify(token, properties, compress, large_threshold, shard_key = nil)
+    def send_identify(token, properties, compress, large_threshold, shard_key = nil, intents = ALL_INTENTS)
       data = {
         # Don't send a v anymore as it's entirely determined by the URL now
         token: token,
         properties: properties,
         compress: compress,
-        large_threshold: large_threshold
+        large_threshold: large_threshold,
+        intents: intents
       }
-      data[:intents] = @intents unless @intents.nil?
 
       # Don't include the shard key at all if it is nil as Discord checks for its mere existence
       data[:shard] = shard_key if shard_key
@@ -449,8 +468,13 @@ module Discordrb
           # suspended (e.g. after op7)
           if (@session && !@session.suspended?) || !@session
             sleep @heartbeat_interval
-            @bot.raise_heartbeat_event
-            heartbeat
+            # Check if we're connected here, since we could possibly be waiting for a reconnect to occur.
+            if @handshaked && !@closed
+              @bot.raise_heartbeat_event
+              heartbeat
+            else
+              LOGGER.debug('Tried to send a heartbeat without being connected! Ignoring, we should be fine.')
+            end
           else
             sleep 1
           end
@@ -535,7 +559,7 @@ module Discordrb
     end
 
     def process_gateway
-      raw_url = find_gateway
+      raw_url = @session&.resume_gateway_url || find_gateway
 
       # Append a slash in case it's not there (I'm not sure how well WSCS handles it otherwise)
       raw_url += '/' unless raw_url.end_with? '/'
@@ -653,7 +677,9 @@ module Discordrb
       LOGGER.log_exception(e)
     end
 
+    # rubocop:disable Lint/UselessConstantScoping
     ZLIB_SUFFIX = "\x00\x00\xFF\xFF".b.freeze
+    # rubocop:enable Lint/UselessConstantScoping
 
     def handle_message(msg)
       case @compress_mode
@@ -713,9 +739,9 @@ module Discordrb
       when :READY
         LOGGER.info("Discord using gateway protocol version: #{data['v']}, requested: #{GATEWAY_VERSION}")
 
-        @session = Session.new(data['session_id'])
+        @session = Session.new(data['session_id'], data['resume_gateway_url'])
         @session.sequence = 0
-        @bot.__send__(:notify_ready) if @intents && (@intents & INTENTS[:servers]).zero?
+        @bot.__send__(:notify_ready) if @intents && @intents.nobits?(INTENTS[:servers])
       when :RESUMED
         # The RESUMED event is received after a successful op 6 (resume). It does nothing except tell the bot the
         # connection is initiated (like READY would). Starting with v5, it doesn't set a new heartbeat interval anymore
@@ -786,12 +812,6 @@ module Discordrb
       handle_close(e)
     end
 
-    # Close codes that are unrecoverable, after which we should not try to reconnect.
-    # - 4003: Not authenticated. How did this happen?
-    # - 4004: Authentication failed. Token was wrong, nothing we can do.
-    # - 4011: Sharding required. Currently requires developer intervention.
-    FATAL_CLOSE_CODES = [4003, 4004, 4011].freeze
-
     def handle_close(e)
       @bot.__send__(:raise_event, Events::DisconnectEvent.new(@bot))
 
@@ -800,6 +820,15 @@ module Discordrb
         LOGGER.error('Websocket close frame received!')
         LOGGER.error("Code: #{e.code}")
         LOGGER.error("Message: #{e.data}")
+
+        if e.code == 4014
+          LOGGER.error(<<~ERROR)
+            You attempted to identify with privileged intents that your bot is not authorized to use
+            Please enable the privileged intents on the bot page of your application on the discord developer page.
+            Read more here https://discord.com/developers/docs/topics/gateway#privileged-intents
+          ERROR
+        end
+
         @should_reconnect = false if FATAL_CLOSE_CODES.include?(e.code)
       elsif e.is_a? Exception
         # Log the exception

data/lib/discordrb/paginator.rb

@@ -24,7 +24,7 @@ module Discordrb
     # no more results or the configured `limit` is reached.
     def each
       last_page = nil
-      until limit_check
+      until limit_exceeded?
         page = @block.call(last_page)
         return if page.empty?
 
@@ -38,7 +38,7 @@ module Discordrb
         enumerator.each do |item|
           yield item
           @count += 1
-          break if limit_check
+          break if limit_exceeded?
         end
 
         last_page = page
@@ -48,7 +48,7 @@ module Discordrb
     private
 
     # Whether the paginator limit has been exceeded
-    def limit_check
+    def limit_exceeded?
       return false if @limit.nil?
 
       @count >= @limit