discordrb 3.3.0 → 3.4.3

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

data/lib/discordrb/id_object.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # Mixin for objects that have IDs
+  module IDObject
+    # @return [Integer] the ID which uniquely identifies this object across Discord.
+    attr_reader :id
+    alias_method :resolve_id, :id
+    alias_method :hash, :id
+
+    # ID based comparison
+    def ==(other)
+      Discordrb.id_compare(@id, other)
+    end
+
+    alias_method :eql?, :==
+
+    # Estimates the time this object was generated on based on the beginning of the ID. This is fairly accurate but
+    # shouldn't be relied on as Discord might change its algorithm at any time
+    # @return [Time] when this object was created at
+    def creation_time
+      # Milliseconds
+      ms = (@id >> 22) + DISCORD_EPOCH
+      Time.at(ms / 1000.0)
+    end
+
+    # Creates an artificial snowflake at the given point in time. Useful for comparing against.
+    # @param time [Time] The time the snowflake should represent.
+    # @return [Integer] a snowflake with the timestamp data as the given time
+    def self.synthesise(time)
+      ms = (time.to_f * 1000).to_i
+      (ms - DISCORD_EPOCH) << 22
+    end
+
+    class << self
+      alias_method :synthesize, :synthesise
+    end
+  end
+end

data/lib/discordrb/light/integrations.rb

@@ -49,7 +49,7 @@ module Discordrb::Light
     #   Twitch account connection of the server owner).
     attr_reader :server_connection
 
-    # @return [Connection] the connection integrated with the server (i. e. your connection)
+    # @return [Connection] the connection integrated with the server (i.e. your connection)
     attr_reader :integrated_connection
 
     # @!visibility private

data/lib/discordrb/light/light_bot.rb

@@ -6,7 +6,7 @@ require 'discordrb/api/user'
 require 'discordrb/light/data'
 require 'discordrb/light/integrations'
 
-# This module contains classes to allow connections to bots without a connection to the gateway socket, i. e. bots
+# This module contains classes to allow connections to bots without a connection to the gateway socket, i.e. bots
 # that only use the REST part of the API.
 module Discordrb::Light
   # A bot that only uses the REST part of the API. Hierarchically unrelated to the regular {Discordrb::Bot}. Useful to

data/lib/discordrb/logger.rb

@@ -2,7 +2,7 @@
 
 module Discordrb
   # The format log timestamps should be in, in strftime format
-  LOG_TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S.%L'.freeze
+  LOG_TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S.%L'
 
   # Logs debug messages
   class Logger
@@ -18,7 +18,7 @@ module Discordrb
     # Creates a new logger.
     # @param fancy [true, false] Whether this logger uses fancy mode (ANSI escape codes to make the output colourful)
     # @param streams [Array<IO>, Array<#puts & #flush>] the streams the logger should write to.
-    def initialize(fancy = false, streams = [STDOUT])
+    def initialize(fancy = false, streams = [$stdout])
       @fancy = fancy
       self.mode = :normal
 
@@ -38,10 +38,10 @@ module Discordrb
     }.freeze
 
     # The ANSI format code that resets formatting
-    FORMAT_RESET = "\u001B[0m".freeze
+    FORMAT_RESET = "\u001B[0m"
 
     # The ANSI format code that makes something bold
-    FORMAT_BOLD = "\u001B[1m".freeze
+    FORMAT_BOLD = "\u001B[1m"
 
     MODES.each do |mode, hash|
       define_method(mode) do |message|

data/lib/discordrb/paginator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # Utility class for wrapping paginated endpoints. It is [Enumerable](https://ruby-doc.org/core-2.5.1/Enumerable.html),
+  # similar to an `Array`, so most of the same methods can be used to filter the results of the request
+  # that it wraps. If you simply want an array of all of the results, `#to_a` can be called.
+  class Paginator
+    include Enumerable
+
+    # Creates a new {Paginator}
+    # @param limit [Integer] the maximum number of items to request before stopping
+    # @param direction [:up, :down] the order in which results are returned in
+    # @yield [Array, nil] the last page of results, or nil if this is the first iteration.
+    #   This should be used to request the next page of results.
+    # @yieldreturn [Array] the next page of results
+    def initialize(limit, direction, &block)
+      @count = 0
+      @limit = limit
+      @direction = direction
+      @block = block
+    end
+
+    # Yields every item produced by the wrapped request, until it returns
+    # no more results or the configured `limit` is reached.
+    def each
+      last_page = nil
+      until limit_check
+        page = @block.call(last_page)
+        return if page.empty?
+
+        enumerator = case @direction
+                     when :down
+                       page.each
+                     when :up
+                       page.reverse_each
+                     end
+
+        enumerator.each do |item|
+          yield item
+          @count += 1
+          break if limit_check
+        end
+
+        last_page = page
+      end
+    end
+
+    private
+
+    # Whether the paginator limit has been exceeded
+    def limit_check
+      return false if @limit.nil?
+
+      @count >= @limit
+    end
+  end
+end