discordrb 3.3.0 → 3.4.0

data/lib/discordrb/events/presence.rb

@@ -15,11 +15,16 @@ module Discordrb::Events
     # @return [Symbol] the new status.
     attr_reader :status
 
+    # @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
+
     def initialize(data, bot)
       @bot = bot
 
       @user = bot.user(data['user']['id'].to_i)
       @status = data['status'].to_sym
+      @client_status = user.client_status
       @server = bot.server(data['guild_id'].to_i)
     end
   end
@@ -32,9 +37,10 @@ module Discordrb::Events
 
       [
         matches_all(@attributes[:from], event.user) do |a, e|
-          a == if a.is_a? String
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e
@@ -92,9 +98,10 @@ module Discordrb::Events
 
       [
         matches_all(@attributes[:from], event.user) do |a, e|
-          a == if a.is_a? String
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e
@@ -105,6 +112,9 @@ module Discordrb::Events
         end,
         matches_all(@attributes[:type], event.type) do |a, e|
           a == e
+        end,
+        matches_all(@attributes[:client_status], event.client_status) do |a, e|
+          e.slice(a.keys) == a
         end
       ].reduce(true, &:&)
     end

data/lib/discordrb/events/raw.rb

@@ -30,9 +30,7 @@ module Discordrb::Events
       [
         matches_all(@attributes[:type] || @attributes[:t], event.type) do |a, e|
           if a.is_a? Regexp
-            # 24: update to matches?
-            match = a.match(e)
-            match ? (e == match[0]) : false
+            a.match?(e)
           else
             e.to_s.casecmp(a.to_s).zero?
           end

data/lib/discordrb/events/reactions.rb

@@ -11,6 +11,9 @@ module Discordrb::Events
     # @return [Emoji] the emoji that was reacted with.
     attr_reader :emoji
 
+    # @!visibility private
+    attr_reader :message_id
+
     def initialize(data, bot)
       @bot = bot
 
@@ -54,13 +57,38 @@ module Discordrb::Events
 
       [
         matches_all(@attributes[:emoji], event.emoji) do |a, e|
-          if a.is_a? Integer
+          case a
+          when Integer
             e.id == a
-          elsif a.is_a? String
+          when String
             e.name == a || e.name == a.delete(':') || e.id == a.resolve_id
           else
             e == a
           end
+        end,
+        matches_all(@attributes[:message], event.message_id) do |a, e|
+          a == e
+        end,
+        matches_all(@attributes[:in], event.channel) do |a, e|
+          case a
+          when String
+            # Make sure to remove the "#" from channel names in case it was specified
+            a.delete('#') == e.name
+          when Integer
+            a == e.id
+          else
+            a == e
+          end
+        end,
+        matches_all(@attributes[:from], event.user) do |a, e|
+          case a
+          when String
+            a == e.name
+          when :bot
+            e.current_bot?
+          else
+            a == e
+          end
         end
       ].reduce(true, &:&)
     end
@@ -82,6 +110,9 @@ module Discordrb::Events
   class ReactionRemoveAllEvent < Event
     include Respondable
 
+    # @!visibility private
+    attr_reader :message_id
+
     def initialize(data, bot)
       @bot = bot
 
@@ -107,7 +138,22 @@ module Discordrb::Events
       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
-      [].reduce(true, &:&)
+      [
+        matches_all(@attributes[:message], event.message_id) do |a, e|
+          a == e
+        end,
+        matches_all(@attributes[:in], event.channel) do |a, e|
+          case a
+          when String
+            # Make sure to remove the "#" from channel names in case it was specified
+            a.delete('#') == e.name
+          when Integer
+            a == e.id
+          else
+            a == e
+          end
+        end
+      ].reduce(true, &:&)
     end
   end
 end

data/lib/discordrb/events/typing.rb

@@ -45,18 +45,20 @@ module Discordrb::Events
 
       [
         matches_all(@attributes[:in], event.channel) do |a, e|
-          if a.is_a? String
+          case a
+          when String
             a.delete('#') == e.name
-          elsif a.is_a? Integer
+          when Integer
             a == e.id
           else
             a == e
           end
         end,
         matches_all(@attributes[:from], event.user) do |a, e|
-          a == if a.is_a? String
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e

data/lib/discordrb/events/voice_server_update.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'discordrb/events/generic'
+require 'discordrb/data'
+
+module Discordrb::Events
+  # Event raised when a server's voice server is updating.
+  # Sent when initially connecting to voice and when a voice instance fails
+  # over to a new server.
+  # This event is exposed for use with library agnostic interfaces like telecom and
+  # lavalink.
+  class VoiceServerUpdateEvent < Event
+    # @return [String] The voice connection token
+    attr_reader :token
+
+    # @return [Server] The server this update is for.
+    attr_reader :server
+
+    # @return [String] The voice server host.
+    attr_reader :endpoint
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @token = data['token']
+      @endpoint = data['endpoint']
+      @server = bot.server(data['guild_id'])
+    end
+  end
+
+  # Event handler for VoiceServerUpdateEvent
+  class VoiceServerUpdateEventHandler < EventHandler
+    def matches?(event)
+      return false unless event.is_a? VoiceServerUpdateEvent
+
+      [
+        matches_all(@attributes[:from], event.server) do |a, e|
+          a == if a.is_a? String
+                 e.name
+               else
+                 e
+               end
+        end
+      ]
+    end
+  end
+end

data/lib/discordrb/events/voice_state_update.rb

@@ -38,37 +38,38 @@ module Discordrb::Events
 
       [
         matches_all(@attributes[:from], event.user) do |a, e|
-          a == if a.is_a? String
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e
                end
         end,
         matches_all(@attributes[:mute], event.mute) do |a, e|
-          a == if a.is_a?(TrueClass) || a.is_a?(FalseClass)
+          a == if a.is_a? String
                  e.to_s
                else
                  e
                end
         end,
         matches_all(@attributes[:deaf], event.deaf) do |a, e|
-          a == if a.is_a?(TrueClass) || a.is_a?(FalseClass)
+          a == if a.is_a? String
                  e.to_s
                else
                  e
                end
         end,
         matches_all(@attributes[:self_mute], event.self_mute) do |a, e|
-          a == if a.is_a?(TrueClass) || a.is_a?(FalseClass)
+          a == if a.is_a? String
                  e.to_s
                else
                  e
                end
         end,
         matches_all(@attributes[:self_deaf], event.self_deaf) do |a, e|
-          a == if a.is_a?(TrueClass) || a.is_a?(FalseClass)
+          a == if a.is_a? String
                  e.to_s
                else
                  e
@@ -76,9 +77,11 @@ module Discordrb::Events
         end,
         matches_all(@attributes[:channel], event.channel) do |a, e|
           next unless e # Don't bother if the channel is nil
-          a == if a.is_a? String
+
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e
@@ -86,9 +89,11 @@ module Discordrb::Events
         end,
         matches_all(@attributes[:old_channel], event.old_channel) do |a, e|
           next unless e # Don't bother if the channel is nil
-          a == if a.is_a? String
+
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e

data/lib/discordrb/events/webhooks.rb

@@ -28,28 +28,31 @@ module Discordrb::Events
 
       [
         matches_all(@attributes[:server], event.server) do |a, e|
-          a == if a.is_a? String
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e
                end
         end,
         matches_all(@attributes[:channel], event.channel) do |a, e|
-          if a.is_a? String
+          case a
+          when String
             # Make sure to remove the "#" from channel names in case it was specified
             a.delete('#') == e.name
-          elsif a.is_a? Integer
+          when Integer
             a == e.id
           else
             a == e
           end
         end,
         matches_all(@attributes[:webhook], event) do |a, e|
-          a == if a.is_a? String
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e

data/lib/discordrb/gateway.rb

@@ -25,8 +25,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require 'thread'
-
 module Discordrb
   # Gateway packet opcodes
   module Opcodes
@@ -145,20 +143,19 @@ 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)
+    def initialize(bot, token, shard_key = nil, compress_mode = :stream, intents = nil)
       @token = token
       @bot = bot
 
       @shard_key = shard_key
 
-      @getc_mutex = Mutex.new
-
       # Whether the connection to the gateway has succeeded yet
       @ws_success = false
 
       @check_heartbeat_acks = true
 
       @compress_mode = compress_mode
+      @intents = intents
     end
 
     # Connect to the gateway server in a separate thread
@@ -170,8 +167,19 @@ module Discordrb
       end
 
       LOGGER.debug('WS thread created! Now waiting for confirmation that everything worked')
-      sleep(0.5) until @ws_success
-      LOGGER.debug('Confirmation received! Exiting run.')
+      loop do
+        sleep(0.5)
+
+        if @ws_success
+          LOGGER.debug('Confirmation received! Exiting run.')
+          break
+        end
+
+        if @should_reconnect == false
+          LOGGER.debug('Reconnection flag was unset. Exiting run.')
+          break
+        end
+      end
     end
 
     # Prevents all further execution until the websocket thread stops (e.g. through a closed connection).
@@ -181,16 +189,16 @@ module Discordrb
 
     # Whether the WebSocket connection to the gateway is currently open
     def open?
-      @handshake && @handshake.finished? && !@closed
+      @handshake&.finished? && !@closed
     end
 
     # Stops the bot gracefully, disconnecting the websocket without immediately killing the thread. This means that
     # Discord is immediately aware of the closed connection and makes the bot appear offline instantly.
     #
     # If this method doesn't work or you're looking for something more drastic, use {#kill} instead.
-    def stop(no_sync = false)
+    def stop
       @should_reconnect = false
-      close(no_sync)
+      close
 
       # Return nil so command bots don't send a message
       nil
@@ -241,7 +249,7 @@ module Discordrb
     def heartbeat
       if check_heartbeat_acks
         unless @last_heartbeat_acked
-          # We're in a bad situation - apparently the last heartbeat wasn't acked, which means the connection is likely
+          # We're in a bad situation - apparently the last heartbeat wasn't ACK'd, which means the connection is likely
           # a zombie. Reconnect
           LOGGER.warn('Last heartbeat was not acked, so this is a zombie connection! Reconnecting')
 
@@ -303,6 +311,7 @@ module Discordrb
         compress: compress,
         large_threshold: large_threshold
       }
+      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
@@ -312,7 +321,7 @@ module Discordrb
 
     # Sends a status update packet (op 3). This sets the bot user's status (online/idle/...) and game playing/streaming.
     # @param status [String] The status that should be set (`online`, `idle`, `dnd`, `invisible`).
-    # @param since [Integer] The unix timestamp in milliseconds when the status was set. Should only be provided when
+    # @param since [Integer] The Unix timestamp in milliseconds when the status was set. Should only be provided when
     #   `afk` is true.
     # @param game [Hash<Symbol => Object>, nil] `nil` if no game should be played, or a hash of `:game => "name"` if a
     #   game should be played. The hash can also contain additional attributes for streaming statuses.
@@ -360,7 +369,7 @@ module Discordrb
       @instant_reconnect = true
       @should_reconnect = true
 
-      close
+      close(4000)
     end
 
     # Sends a resume packet (op 6). This replays all events from a previous point specified by its packet sequence. This
@@ -402,12 +411,12 @@ module Discordrb
 
     # Sends a custom packet over the connection. This can be useful to implement future yet unimplemented functionality
     # or for testing. You probably shouldn't use this unless you know what you're doing.
-    # @param op [Integer] The opcode the packet should be sent as. Can be one of {Opcodes} or a custom value if
+    # @param opcode [Integer] The opcode the packet should be sent as. Can be one of {Opcodes} or a custom value if
     #   necessary.
-    # @param packet [Object] Some arbitrary JSON-serialisable data that should be sent as the `d` field.
-    def send_packet(op, packet)
+    # @param packet [Object] Some arbitrary JSON-serializable data that should be sent as the `d` field.
+    def send_packet(opcode, packet)
       data = {
-        op: op,
+        op: opcode,
         d: packet
       }
 
@@ -436,20 +445,18 @@ module Discordrb
       @heartbeat_thread = Thread.new do
         Thread.current[:discordrb_name] = 'heartbeat'
         loop do
-          begin
-            # Send a heartbeat if heartbeats are active and either no session exists yet, or an existing session is
-            # suspended (e.g. after op7)
-            if (@session && !@session.suspended?) || !@session
-              sleep @heartbeat_interval
-              @bot.raise_heartbeat_event
-              heartbeat
-            else
-              sleep 1
-            end
-          rescue => e
-            LOGGER.error('An error occurred while heartbeating!')
-            LOGGER.log_exception(e)
+          # Send a heartbeat if heartbeats are active and either no session exists yet, or an existing session is
+          # suspended (e.g. after op7)
+          if (@session && !@session.suspended?) || !@session
+            sleep @heartbeat_interval
+            @bot.raise_heartbeat_event
+            heartbeat
+          else
+            sleep 1
           end
+        rescue StandardError => e
+          LOGGER.error('An error occurred while heartbeating!')
+          LOGGER.log_exception(e)
         end
       end
     end
@@ -502,7 +509,7 @@ module Discordrb
           cert_store.set_default_paths
           ctx.cert_store = cert_store
         else
-          ctx.set_params ssl_version: :TLSv1_2
+          ctx.set_params ssl_version: :TLSv1_2 # rubocop:disable Naming/VariableNumber
         end
 
         socket = OpenSSL::SSL::SSLSocket.new(socket, ctx)
@@ -567,7 +574,7 @@ module Discordrb
 
       # We're done! Delegate to the websocket loop
       websocket_loop
-    rescue => e
+    rescue StandardError => e
       LOGGER.error('An error occurred while connecting to the websocket!')
       LOGGER.log_exception(e)
     end
@@ -584,13 +591,17 @@ module Discordrb
           unless @socket
             LOGGER.warn('Socket is nil in websocket_loop! Reconnecting')
             handle_internal_close('Socket is nil in websocket_loop')
+            next
           end
 
-          recv_data = nil
-
-          # Get some data from the socket, synchronised so the socket can't be closed during this
-          # 24: remove locking
-          @getc_mutex.synchronize { recv_data = @socket.getc }
+          # Get some data from the socket
+          begin
+            recv_data = @socket.readpartial(4096)
+          rescue EOFError
+            @pipe_broken = true
+            handle_internal_close('Socket EOF in websocket_loop')
+            next
+          end
 
           # Check if we actually got data
           unless recv_data
@@ -621,7 +632,7 @@ module Discordrb
             # If the handshake hasn't finished, handle it
             handle_handshake_data(recv_data)
           end
-        rescue => e
+        rescue StandardError => e
           handle_error(e)
         end
       end
@@ -645,12 +656,13 @@ module Discordrb
     ZLIB_SUFFIX = "\x00\x00\xFF\xFF".b.freeze
 
     def handle_message(msg)
-      if @compress_mode == :large
+      case @compress_mode
+      when :large
         if msg.byteslice(0) == 'x'
           # The message is compressed, inflate it
           msg = Zlib::Inflate.inflate(msg)
         end
-      elsif @compress_mode == :stream
+      when :stream
         # Write deflated string to buffer
         @zlib_reader << msg
 
@@ -703,6 +715,7 @@ module Discordrb
 
         @session = Session.new(data['session_id'])
         @session.sequence = 0
+        @bot.__send__(:notify_ready) if @intents && (@intents & INTENTS[:servers]).zero?
       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
@@ -750,7 +763,7 @@ module Discordrb
       LOGGER.debug("Trace: #{packet['d']['_trace']}")
       LOGGER.debug("Session: #{@session.inspect}")
 
-      if @session && @session.should_resume?
+      if @session&.should_resume?
         # Make sure we're sending heartbeats again
         @session.resume
 
@@ -773,22 +786,31 @@ 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))
+
       if e.respond_to? :code
         # It is a proper close frame we're dealing with, print reason and message to console
         LOGGER.error('Websocket close frame received!')
         LOGGER.error("Code: #{e.code}")
         LOGGER.error("Message: #{e.data}")
+        @should_reconnect = false if FATAL_CLOSE_CODES.include?(e.code)
       elsif e.is_a? Exception
         # Log the exception
         LOGGER.error('The websocket connection has closed due to an error!')
         LOGGER.log_exception(e)
       else
-        LOGGER.error("The websocket connection has closed: #{e.inspect}")
+        LOGGER.error("The websocket connection has closed: #{e&.inspect || '(no information)'}")
       end
     end
 
-    def send(data, type = :text)
+    def send(data, type = :text, code = nil)
       LOGGER.out(data)
 
       unless @handshaked && !@closed
@@ -797,40 +819,33 @@ module Discordrb
       end
 
       # Create the frame we're going to send
-      frame = ::WebSocket::Frame::Outgoing::Client.new(data: data, type: type, version: @handshake.version)
+      frame = ::WebSocket::Frame::Outgoing::Client.new(data: data, type: type, version: @handshake.version, code: code)
 
       # Try to send it
       begin
         @socket.write frame.to_s
-      rescue => e
+      rescue StandardError => e
         # There has been an error!
         @pipe_broken = true
         handle_internal_close(e)
       end
     end
 
-    def close(no_sync = false)
+    def close(code = 1000)
       # If we're already closed, there's no need to do anything - return
       return if @closed
 
       # Suspend the session so we don't send heartbeats
-      @session.suspend if @session
+      @session&.suspend
 
       # Send a close frame (if we can)
-      send nil, :close unless @pipe_broken
+      send nil, :close, code unless @pipe_broken
 
       # We're officially closed, notify the main loop.
-      # This needs to be synchronised with the getc mutex, so the notification, and especially the actual
-      # close afterwards, don't coincide with the main loop reading something from the SSL socket.
-      # This would cause a segfault due to (I suspect) Ruby bug #12292: https://bugs.ruby-lang.org/issues/12292
-      if no_sync
-        @closed = true
-      else
-        @getc_mutex.synchronize { @closed = true }
-      end
+      @closed = true
 
       # Close the socket if possible
-      @socket.close if @socket
+      @socket&.close
       @socket = nil
 
       # Make sure we do necessary things as soon as we're closed