discordrb 3.1.1 → 3.4.0

data/lib/discordrb/commands/container.rb

@@ -9,20 +9,26 @@ module Discordrb::Commands
   module CommandContainer
     include RateLimiter
 
-    # @return [Hash<Symbol, Command>] hash of command names and commands this container has.
+    # @return [Hash<Symbol, Command, CommandAlias>] hash of command names and commands this container has.
     attr_reader :commands
 
     # Adds a new command to the container.
-    # @param name [Symbol, Array<Symbol>] The name of the command to add, or an array of multiple names for the command
+    # @param name [Symbol] The name of the command to add.
     # @param attributes [Hash] The attributes to initialize the command with.
+    # @option attributes [Array<Symbol>] :aliases A list of additional names for this command. This in effect
+    #   creates {CommandAlias} objects in the container ({#commands}) that refer to the newly created command.
+    #   Additionally, the default help command will identify these command names as an alias where applicable.
     # @option attributes [Integer] :permission_level The minimum permission level that can use this command, inclusive.
     #   See {CommandBot#set_user_permission} and {CommandBot#set_role_permission}.
     # @option attributes [String, false] :permission_message Message to display when a user does not have sufficient
     #   permissions to execute a command. %name% in the message will be replaced with the name of the command. Disable
     #   the message by setting this option to false.
     # @option attributes [Array<Symbol>] :required_permissions Discord action permissions (e.g. `:kick_members`) that
-    #   should be required to use this command. See {Discordrb::Permissions::Flags} for a list.
-    # @option attributes [Array<Role>, Array<#resolve_id>] :required_roles Roles that user should have to use this command.
+    #   should be required to use this command. See {Discordrb::Permissions::FLAGS} for a list.
+    # @option attributes [Array<Role>, Array<String, Integer>] :required_roles Roles, or their IDs, that user must have to use this command
+    #   (user must have all of them).
+    # @option attributes [Array<Role>, Array<String, Integer>] :allowed_roles Roles, or their IDs, that user should have to use this command
+    #   (user should have at least one of them).
     # @option attributes [Array<String, Integer, Channel>] :channels The channels that this command can be used on. An
     #   empty array indicates it can be used on any channel. Supersedes the command bot attribute.
     # @option attributes [true, false] :chain_usable Whether this command is able to be used inside of a command chain
@@ -33,6 +39,9 @@ module Discordrb::Commands
     #   command if the user asks for it.
     # @option attributes [String] :usage A short description of how this command should be used. Will be displayed in
     #   the help command or if the user uses it wrong.
+    # @option attributes [Array<Class>] :arg_types An array of argument classes which will be used for type-checking.
+    #   Hard-coded for some native classes, but can be used with any class that implements static
+    #   method `from_argument`.
     # @option attributes [Integer] :min_args The minimum number of arguments this command should have. If a user
     #   attempts to call the command with fewer arguments, the usage information will be displayed, if it exists.
     # @option attributes [Integer] :max_args The maximum number of arguments the command should have.
@@ -41,23 +50,30 @@ module Discordrb::Commands
     #   command will be available again.
     # @option attributes [Symbol] :bucket The rate limit bucket that should be used for rate limiting. No rate limiting
     #   will be done if unspecified or nil.
+    # @option attributes [String, #call] :rescue A string to respond with, or a block to be called in the event an exception
+    #   is raised internally. If given a String, `%exception%` will be substituted with the exception's `#message`. If given
+    #   a `Proc`, it will be passed the `CommandEvent` along with the `Exception`.
     # @yield The block is executed when the command is executed.
     # @yieldparam event [CommandEvent] The event of the message that contained the command.
+    # @note `LocalJumpError`s are rescued from internally, giving bots the opportunity to use `return` or `break` in
+    #   their blocks without propagating an exception.
     # @return [Command] The command that was added.
     def command(name, attributes = {}, &block)
       @commands ||= {}
-      if name.is_a? Array
-        new_command = nil
 
-        name.each do |e|
-          new_command = Command.new(e, attributes, &block)
-          @commands[e] = new_command
-        end
+      # TODO: Remove in 4.0
+      if name.is_a?(Array)
+        name, *aliases = name
+        attributes[:aliases] = aliases if attributes[:aliases].nil?
+        Discordrb::LOGGER.warn("While registering command #{name.inspect}")
+        Discordrb::LOGGER.warn('Arrays for command aliases is removed. Please use `aliases` argument instead.')
+      end
 
-        new_command
-      else
-        @commands[name] = Command.new(name, attributes, &block)
+      new_command = Command.new(name, attributes, &block)
+      new_command.attributes[:aliases].each do |aliased_name|
+        @commands[aliased_name] = CommandAlias.new(aliased_name, new_command)
       end
+      @commands[name] = new_command
     end
 
     # Removes a specific command from this container.
@@ -83,9 +99,7 @@ module Discordrb::Commands
       container_modules = container.singleton_class.included_modules
 
       # If the container is an EventContainer and we can include it, then do that
-      if container_modules.include?(Discordrb::EventContainer) && respond_to?(:include_events)
-        include_events(container)
-      end
+      include_events(container) if container_modules.include?(Discordrb::EventContainer) && respond_to?(:include_events)
 
       if container_modules.include? Discordrb::Commands::CommandContainer
         include_commands(container)

data/lib/discordrb/commands/parser.rb

@@ -22,9 +22,12 @@ module Discordrb::Commands
         # Discord action permissions required to use this command
         required_permissions: attributes[:required_permissions] || [],
 
-        # Roles required to use this command
+        # Roles required to use this command (all? comparison)
         required_roles: attributes[:required_roles] || [],
 
+        # Roles allowed to use this command (any? comparison)
+        allowed_roles: attributes[:allowed_roles] || [],
+
         # Channels this command can be used on
         channels: attributes[:channels] || nil,
 
@@ -40,6 +43,9 @@ module Discordrb::Commands
         # Usage description (for help command and error messages)
         usage: attributes[:usage] || nil,
 
+        # Array of arguments (for type-checking)
+        arg_types: attributes[:arg_types] || nil,
+
         # Parameter list (for help command and error messages)
         parameters: attributes[:parameters] || nil,
 
@@ -54,7 +60,13 @@ module Discordrb::Commands
         rate_limit_message: attributes[:rate_limit_message],
 
         # Rate limiting bucket (nil for no rate limiting)
-        bucket: attributes[:bucket]
+        bucket: attributes[:bucket],
+
+        # Block for handling internal exceptions, or a string to respond with
+        rescue: attributes[:rescue],
+
+        # A list of aliases that reference this command
+        aliases: attributes[:aliases] || []
       }
 
       @block = block
@@ -69,36 +81,57 @@ module Discordrb::Commands
     # @return [String] the result of the execution.
     def call(event, arguments, chained = false, check_permissions = true)
       if arguments.length < @attributes[:min_args]
-        event.respond "Too few arguments for command `#{name}`!"
-        event.respond "Usage: `#{@attributes[:usage]}`" if @attributes[:usage]
+        response = "Too few arguments for command `#{name}`!"
+        response += "\nUsage: `#{@attributes[:usage]}`" if @attributes[:usage]
+        event.respond(response)
         return
       end
       if @attributes[:max_args] >= 0 && arguments.length > @attributes[:max_args]
-        event.respond "Too many arguments for command `#{name}`!"
-        event.respond "Usage: `#{@attributes[:usage]}`" if @attributes[:usage]
+        response = "Too many arguments for command `#{name}`!"
+        response += "\nUsage: `#{@attributes[:usage]}`" if @attributes[:usage]
+        event.respond(response)
         return
       end
-      unless @attributes[:chain_usable]
-        if chained
-          event.respond "Command `#{name}` cannot be used in a command chain!"
-          return
-        end
+      unless @attributes[:chain_usable] && !chained
+        event.respond "Command `#{name}` cannot be used in a command chain!"
+        return
       end
 
       if check_permissions
         rate_limited = event.bot.rate_limited?(@attributes[:bucket], event.author)
         if @attributes[:bucket] && rate_limited
-          if @attributes[:rate_limit_message]
-            event.respond @attributes[:rate_limit_message].gsub('%time%', rate_limited.round(2).to_s)
-          end
+          event.respond @attributes[:rate_limit_message].gsub('%time%', rate_limited.round(2).to_s) if @attributes[:rate_limit_message]
           return
         end
       end
 
       result = @block.call(event, *arguments)
       event.drain_into(result)
-    rescue LocalJumpError # occurs when breaking
-      nil
+    rescue LocalJumpError => e # occurs when breaking
+      result = e.exit_value
+      event.drain_into(result)
+    rescue StandardError => e # Something went wrong inside our @block!
+      rescue_value = @attributes[:rescue] || event.bot.attributes[:rescue]
+      if rescue_value
+        event.respond(rescue_value.gsub('%exception%', e.message)) if rescue_value.is_a?(String)
+        rescue_value.call(event, e) if rescue_value.respond_to?(:call)
+      end
+
+      raise e
+    end
+  end
+
+  # A command that references another command
+  class CommandAlias
+    # @return [Symbol] the name of this alias
+    attr_reader :name
+
+    # @return [Command] the command this alias points to
+    attr_reader :aliased_command
+
+    def initialize(name, aliased_command)
+      @name = name
+      @aliased_command = aliased_command
     end
   end
 
@@ -123,46 +156,61 @@ module Discordrb::Commands
       b_level = 0
       result = ''
       quoted = false
-      hacky_delim, hacky_space, hacky_prev = [0xe001, 0xe002, 0xe003].pack('U*').chars
+      escaped = false
+      hacky_delim, hacky_space, hacky_prev, hacky_newline = [0xe001, 0xe002, 0xe003, 0xe004].pack('U*').chars
 
       @chain.each_char.each_with_index do |char, index|
-        # Quote begin
-        if char == @attributes[:quote_start] && !quoted
-          quoted = true
+        # Escape character
+        if char == '\\' && !escaped
+          escaped = true
           next
-        end
-
-        # Quote end
-        if char == @attributes[:quote_end] && quoted
-          quoted = false
-          next
-        end
-
-        if char == @attributes[:chain_delimiter] && quoted
-          result += hacky_delim
-          next
-        end
-
-        if char == @attributes[:previous] && quoted
-          result += hacky_prev
+        elsif escaped && b_level <= 0
+          result += char
+          escaped = false
           next
         end
 
-        if char == ' ' && quoted
-          result += hacky_space
-          next
-        end
+        if quoted
+          # Quote end
+          if char == @attributes[:quote_end]
+            quoted = false
+            next
+          end
 
-        if char == @attributes[:sub_chain_start] && !quoted
-          b_start = index if b_level.zero?
-          b_level += 1
+          if b_level <= 0
+            case char
+            when @attributes[:chain_delimiter]
+              result += hacky_delim
+              next
+            when @attributes[:previous]
+              result += hacky_prev
+              next
+            when ' '
+              result += hacky_space
+              next
+            when "\n"
+              result += hacky_newline
+              next
+            end
+          end
+        else
+          case char
+          when @attributes[:quote_start] # Quote begin
+            quoted = true
+            next
+          when @attributes[:sub_chain_start]
+            b_start = index if b_level.zero?
+            b_level += 1
+          end
         end
 
         result += char if b_level <= 0
 
         next unless char == @attributes[:sub_chain_end] && !quoted
+
         b_level -= 1
         next unless b_level.zero?
+
         nested = @chain[b_start + 1..index - 1]
         subchain = CommandChain.new(nested, @bot, true)
         result += subchain.execute(event)
@@ -179,10 +227,14 @@ module Discordrb::Commands
       chain_to_split = @chain
 
       # Don't break if a command is called the same thing as the chain delimiter
-      chain_to_split.slice!(1..-1) if chain_to_split.start_with?(@attributes[:chain_delimiter])
+      chain_to_split = chain_to_split.slice(1..-1) if !@attributes[:chain_delimiter].empty? && chain_to_split.start_with?(@attributes[:chain_delimiter])
 
       first = true
-      split_chain = chain_to_split.split(@attributes[:chain_delimiter])
+      split_chain = if @attributes[:chain_delimiter].empty?
+                      [chain_to_split]
+                    else
+                      chain_to_split.split(@attributes[:chain_delimiter])
+                    end
       split_chain.each do |command|
         command = @attributes[:chain_delimiter] + command if first && @chain.start_with?(@attributes[:chain_delimiter])
         first = false
@@ -205,13 +257,16 @@ module Discordrb::Commands
 
         arguments = arguments.split ' '
 
-        # Replace the hacky spaces with actual spaces
+        # Replace the hacky spaces/newlines with actual ones
         arguments.map! do |elem|
-          elem.gsub hacky_space, ' '
+          elem.gsub(hacky_space, ' ').gsub(hacky_newline, "\n")
         end
 
         # Finally execute the command
         prev = @bot.execute_command(command_name.to_sym, event, arguments, split_chain.length > 1 || @subchain)
+
+        # Stop chain if execute_command failed (maybe the command doesn't exist, or permissions failed, etc.)
+        break unless prev
       end
 
       prev
@@ -251,7 +306,7 @@ module Discordrb::Commands
     private
 
     def divide_chain(chain)
-      chain_args_index = chain.index @attributes[:chain_args_delim]
+      chain_args_index = chain.index(@attributes[:chain_args_delim]) unless @attributes[:chain_args_delim].empty?
       chain_args = []
 
       if chain_args_index

data/lib/discordrb/commands/rate_limiter.rb

@@ -35,10 +35,11 @@ module Discordrb::Commands
     end
 
     # Performs a rate limiting request
-    # @param thing [#resolve_id, Integer, Symbol] The particular thing that should be rate-limited (usually a user/channel, but you can also choose arbitrary integers or symbols)
+    # @param thing [String, Integer, Symbol] The particular thing that should be rate-limited (usually a user/channel, but you can also choose arbitrary integers or symbols)
     # @param rate_limit_time [Time] The time to base the rate limiting on, only useful for testing.
+    # @param increment [Integer] How much to increment the rate-limit counter. Default is 1.
     # @return [Integer, false] the waiting time until the next request, in seconds, or false if the request succeeded
-    def rate_limited?(thing, rate_limit_time = nil)
+    def rate_limited?(thing, rate_limit_time = nil, increment: 1)
       key = resolve_key thing
       limit_hash = @bucket[key]
 
@@ -47,7 +48,7 @@ module Discordrb::Commands
         @bucket[key] = {
           last_time: Time.now,
           set_time: Time.now,
-          count: 1
+          count: increment
         }
 
         return false
@@ -56,16 +57,14 @@ module Discordrb::Commands
       # Define the time at which we're being rate limited once so it doesn't get inaccurate
       rate_limit_time ||= Time.now
 
-      if @limit && (limit_hash[:count] + 1) > @limit
-        if @time_span && rate_limit_time < (limit_hash[:set_time] + @time_span)
-          # Second case: Count is over the limit and the time has not run out yet
-          return (limit_hash[:set_time] + @time_span) - rate_limit_time
-        else
-          # Third case: Count is over the limit but the time has run out
-          # Don't return anything here because there may still be delay-based limiting
-          limit_hash[:set_time] = rate_limit_time
-          limit_hash[:count] = 0
-        end
+      if @limit && (limit_hash[:count] + increment) > @limit
+        # Second case: Count is over the limit and the time has not run out yet
+        return (limit_hash[:set_time] + @time_span) - rate_limit_time if @time_span && rate_limit_time < (limit_hash[:set_time] + @time_span)
+
+        # Third case: Count is over the limit but the time has run out
+        # Don't return anything here because there may still be delay-based limiting
+        limit_hash[:set_time] = rate_limit_time
+        limit_hash[:count] = 0
       end
 
       if @delay && rate_limit_time < (limit_hash[:last_time] + @delay)
@@ -74,7 +73,7 @@ module Discordrb::Commands
       else
         # Fifth case: no rate limiting at all! Increment the count, set the last_time, and return false
         limit_hash[:last_time] = rate_limit_time
-        limit_hash[:count] += 1
+        limit_hash[:count] += increment
         false
       end
     end
@@ -84,6 +83,7 @@ module Discordrb::Commands
     def resolve_key(thing)
       return thing.resolve_id if thing.respond_to?(:resolve_id) && !thing.is_a?(String)
       return thing if thing.is_a?(Integer) || thing.is_a?(Symbol)
+
       raise ArgumentError, "Cannot use a #{thing.class} as a rate limiting key!"
     end
   end
@@ -105,14 +105,15 @@ module Discordrb::Commands
 
     # Performs a rate limit request.
     # @param key [Symbol] Which bucket to perform the request for.
-    # @param thing [#resolve_id, Integer, Symbol] What should be rate-limited.
+    # @param thing [String, Integer, Symbol] What should be rate-limited.
+    # @param increment (see Bucket#rate_limited?)
     # @see Bucket#rate_limited?
     # @return [Integer, false] How much time to wait or false if the request succeeded.
-    def rate_limited?(key, thing)
+    def rate_limited?(key, thing, increment: 1)
       # Check whether the bucket actually exists
       return false unless @buckets && @buckets[key]
 
-      @buckets[key].rate_limited?(thing)
+      @buckets[key].rate_limited?(thing, increment: increment)
     end
 
     # Cleans all buckets

data/lib/discordrb/container.rb

@@ -5,12 +5,14 @@ require 'discordrb/events/typing'
 require 'discordrb/events/lifetime'
 require 'discordrb/events/presence'
 require 'discordrb/events/voice_state_update'
+require 'discordrb/events/voice_server_update'
 require 'discordrb/events/channels'
 require 'discordrb/events/members'
 require 'discordrb/events/roles'
 require 'discordrb/events/guilds'
 require 'discordrb/events/await'
 require 'discordrb/events/bans'
+require 'discordrb/events/reactions'
 
 require 'discordrb/await'
 
@@ -31,17 +33,17 @@ module Discordrb
     # @option attributes [Boolean] :private Matches whether or not the channel is private.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [MessageEvent] The event that was raised.
-    # @return [MessageEventHandler] The event handler that was registered.
+    # @return [MessageEventHandler] the event handler that was registered.
     def message(attributes = {}, &block)
       register_event(MessageEvent, attributes, block)
     end
 
-    # This **event** is raised when the READY packet is received, i. e. servers and channels have finished
+    # This **event** is raised when the READY packet is received, i.e. servers and channels have finished
     # initialization. It's the recommended way to do things when the bot has finished starting up.
     # @param attributes [Hash] Event attributes, none in this particular case
     # @yield The block is executed when the event is raised.
     # @yieldparam event [ReadyEvent] The event that was raised.
-    # @return [ReadyEventHandler] The event handler that was registered.
+    # @return [ReadyEventHandler] the event handler that was registered.
     def ready(attributes = {}, &block)
       register_event(ReadyEvent, attributes, block)
     end
@@ -51,7 +53,7 @@ module Discordrb
     # @param attributes [Hash] Event attributes, none in this particular case
     # @yield The block is executed when the event is raised.
     # @yieldparam event [DisconnectEvent] The event that was raised.
-    # @return [DisconnectEventHandler] The event handler that was registered.
+    # @return [DisconnectEventHandler] the event handler that was registered.
     def disconnected(attributes = {}, &block)
       register_event(DisconnectEvent, attributes, block)
     end
@@ -66,7 +68,7 @@ module Discordrb
     # @param attributes [Hash] Event attributes, none in this particular case
     # @yield The block is executed when the event is raised.
     # @yieldparam event [HeartbeatEvent] The event that was raised.
-    # @return [HeartbeatEventHandler] The event handler that was registered.
+    # @return [HeartbeatEventHandler] the event handler that was registered.
     def heartbeat(attributes = {}, &block)
       register_event(HeartbeatEvent, attributes, block)
     end
@@ -81,40 +83,95 @@ module Discordrb
     # @option attributes [Time] :before Matches a time before the time the typing started.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [TypingEvent] The event that was raised.
-    # @return [TypingEventHandler] The event handler that was registered.
+    # @return [TypingEventHandler] the event handler that was registered.
     def typing(attributes = {}, &block)
       register_event(TypingEvent, attributes, block)
     end
 
     # This **event** is raised when a message is edited in a channel.
     # @param attributes [Hash] The event's attributes.
-    # @option attributes [#resolve_id] :id Matches the ID of the message that was edited.
+    # @option attributes [String, Integer] :id Matches the ID of the message that was edited.
     # @option attributes [String, Integer, Channel] :in Matches the channel the message was edited in.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [MessageEditEvent] The event that was raised.
-    # @return [MessageEditEventHandler] The event handler that was registered.
+    # @return [MessageEditEventHandler] the event handler that was registered.
     def message_edit(attributes = {}, &block)
       register_event(MessageEditEvent, attributes, block)
     end
 
     # This **event** is raised when a message is deleted in a channel.
     # @param attributes [Hash] The event's attributes.
-    # @option attributes [#resolve_id] :id Matches the ID of the message that was deleted.
+    # @option attributes [String, Integer] :id Matches the ID of the message that was deleted.
     # @option attributes [String, Integer, Channel] :in Matches the channel the message was deleted in.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [MessageDeleteEvent] The event that was raised.
-    # @return [MessageDeleteEventHandler] The event handler that was registered.
+    # @return [MessageDeleteEventHandler] the event handler that was registered.
     def message_delete(attributes = {}, &block)
       register_event(MessageDeleteEvent, attributes, block)
     end
 
+    # This **event** is raised whenever a message is updated. Message updates can be triggered from
+    # a user editing their own message, or from Discord automatically attaching embeds to the
+    # user's message for URLs contained in the message's content. If you only want to listen
+    # for users editing their own messages, use the {message_edit} handler instead.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer] :id Matches the ID of the message that was updated.
+    # @option attributes [String, Integer, Channel] :in Matches the channel the message was updated in.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [MessageUpdateEvent] The event that was raised.
+    # @return [MessageUpdateEventHandler] the event handler that was registered.
+    def message_update(attributes = {}, &block)
+      register_event(MessageUpdateEvent, attributes, block)
+    end
+
+    # This **event** is raised when somebody reacts to a message.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer] :emoji Matches the ID of the emoji that was reacted with, or its name.
+    # @option attributes [String, Integer, User] :from Matches the user who added the reaction.
+    # @option attributes [String, Integer, Message] :message Matches the message to which the reaction was added.
+    # @option attributes [String, Integer, Channel] :in Matches the channel the reaction was added in.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ReactionAddEvent] The event that was raised.
+    # @return [ReactionAddEventHandler] The event handler that was registered.
+    def reaction_add(attributes = {}, &block)
+      register_event(ReactionAddEvent, attributes, block)
+    end
+
+    # This **event** is raised when somebody removes a reaction from a message.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer] :emoji Matches the ID of the emoji that was removed from the reactions, or
+    #   its name.
+    # @option attributes [String, Integer, User] :from Matches the user who removed the reaction.
+    # @option attributes [String, Integer, Message] :message Matches the message to which the reaction was removed.
+    # @option attributes [String, Integer, Channel] :in Matches the channel the reaction was removed in.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ReactionRemoveEvent] The event that was raised.
+    # @return [ReactionRemoveEventHandler] The event handler that was registered.
+    def reaction_remove(attributes = {}, &block)
+      register_event(ReactionRemoveEvent, attributes, block)
+    end
+
+    # This **event** is raised when somebody removes all reactions from a message.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer, Message] :message Matches the message to which the reactions were removed.
+    # @option attributes [String, Integer, Channel] :in Matches the channel the reactions were removed in.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ReactionRemoveAllEvent] The event that was raised.
+    # @return [ReactionRemoveAllEventHandler] The event handler that was registered.
+    def reaction_remove_all(attributes = {}, &block)
+      register_event(ReactionRemoveAllEvent, attributes, block)
+    end
+
     # This **event** is raised when a user's status (online/offline/idle) changes.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String, Integer, User] :from Matches the user whose status changed.
     # @option attributes [:offline, :idle, :online] :status Matches the status the user has now.
+    # @option attributes [Hash<Symbol, Symbol>] :client_status Matches the current online status (`:online`, `:idle` or `:dnd`) of the user
+    #   on various device types (`:desktop`, `:mobile`, or `:web`). The value will be `nil` when the user is offline or invisible
     # @yield The block is executed when the event is raised.
     # @yieldparam event [PresenceEvent] The event that was raised.
-    # @return [PresenceEventHandler] The event handler that was registered.
+    # @return [PresenceEventHandler] the event handler that was registered.
     def presence(attributes = {}, &block)
       register_event(PresenceEvent, attributes, block)
     end
@@ -126,7 +183,7 @@ module Discordrb
     # @option attributes [Integer] :type Matches the type of game object (0 game, 1 Twitch stream)
     # @yield The block is executed when the event is raised.
     # @yieldparam event [PlayingEvent] The event that was raised.
-    # @return [PlayingEventHandler] The event handler that was registered.
+    # @return [PlayingEventHandler] the event handler that was registered.
     def playing(attributes = {}, &block)
       register_event(PlayingEvent, attributes, block)
     end
@@ -144,7 +201,7 @@ module Discordrb
     # @option attributes [Boolean] :private Matches whether or not the channel is private.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [MentionEvent] The event that was raised.
-    # @return [MentionEventHandler] The event handler that was registered.
+    # @return [MentionEventHandler] the event handler that was registered.
     def mention(attributes = {}, &block)
       register_event(MentionEvent, attributes, block)
     end
@@ -155,7 +212,7 @@ module Discordrb
     # @option attributes [String] :name Matches the name of the created channel.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [ChannelCreateEvent] The event that was raised.
-    # @return [ChannelCreateEventHandler] The event handler that was registered.
+    # @return [ChannelCreateEventHandler] the event handler that was registered.
     def channel_create(attributes = {}, &block)
       register_event(ChannelCreateEvent, attributes, block)
     end
@@ -166,7 +223,7 @@ module Discordrb
     # @option attributes [String] :name Matches the new name of the channel.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [ChannelUpdateEvent] The event that was raised.
-    # @return [ChannelUpdateEventHandler] The event handler that was registered.
+    # @return [ChannelUpdateEventHandler] the event handler that was registered.
     def channel_update(attributes = {}, &block)
       register_event(ChannelUpdateEvent, attributes, block)
     end
@@ -177,7 +234,7 @@ module Discordrb
     # @option attributes [String] :name Matches the name of the deleted channel.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [ChannelDeleteEvent] The event that was raised.
-    # @return [ChannelDeleteEventHandler] The event handler that was registered.
+    # @return [ChannelDeleteEventHandler] the event handler that was registered.
     def channel_delete(attributes = {}, &block)
       register_event(ChannelDeleteEvent, attributes, block)
     end
@@ -185,11 +242,11 @@ module Discordrb
     # This **event** is raised when a recipient is added to a group channel.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String] :name Matches the name of the group channel that the recipient is added to.
-    # @option attributes [#resolve_id] :owner_id Matches the id of the group channel's owner.
-    # @option attributes [#resolve_id] :id Matches the id of the recipient added to the group channel.
+    # @option attributes [String, Integer] :owner_id Matches the ID of the group channel's owner.
+    # @option attributes [String, Integer] :id Matches the ID of the recipient added to the group channel.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [ChannelRecipientAddEvent] The event that was raised.
-    # @return [ChannelRecipientAddHandler] The event handler that was registered.
+    # @return [ChannelRecipientAddHandler] the event handler that was registered.
     def channel_recipient_add(attributes = {}, &block)
       register_event(ChannelRecipientAddEvent, attributes, block)
     end
@@ -197,46 +254,59 @@ module Discordrb
     # This **event** is raised when a recipient is removed from a group channel.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String] :name Matches the name of the group channel that the recipient is added to.
-    # @option attributes [#resolve_id] :owner_id Matches the id of the group channel's owner.
-    # @option attributes [#resolve_id] :id Matches the id of the recipient removed from the group channel.
+    # @option attributes [String, Integer] :owner_id Matches the ID of the group channel's owner.
+    # @option attributes [String, Integer] :id Matches the ID of the recipient removed from the group channel.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [ChannelRecipientRemoveEvent] The event that was raised.
-    # @return [ChannelRecipientRemoveHandler] The event handler that was registered.
+    # @return [ChannelRecipientRemoveHandler] the event handler that was registered.
     def channel_recipient_remove(attributes = {}, &block)
       register_event(ChannelRecipientRemoveEvent, attributes, block)
     end
 
-    # This **event** is raised when a user's voice state changes.
+    # This **event** is raised when a user's voice state changes. This includes when a user joins, leaves, or
+    # moves between voice channels, as well as their mute and deaf status for themselves and on the server.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String, Integer, User] :from Matches the user that sent the message.
     # @option attributes [String, Integer, Channel] :channel Matches the voice channel the user has joined.
+    # @option attributes [String, Integer, Channel] :old_channel Matches the voice channel the user was in previously.
     # @option attributes [true, false] :mute Matches whether or not the user is muted server-wide.
     # @option attributes [true, false] :deaf Matches whether or not the user is deafened server-wide.
     # @option attributes [true, false] :self_mute Matches whether or not the user is muted by the bot.
     # @option attributes [true, false] :self_deaf Matches whether or not the user is deafened by the bot.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [VoiceStateUpdateEvent] The event that was raised.
-    # @return [VoiceStateUpdateEventHandler] The event handler that was registered.
+    # @return [VoiceStateUpdateEventHandler] the event handler that was registered.
     def voice_state_update(attributes = {}, &block)
       register_event(VoiceStateUpdateEvent, attributes, block)
     end
 
+    # This **event** is raised when first connecting to a server's voice channel.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer, User] :from Matches the server that the update is for.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [VoiceServerUpdateEvent] The event that was raised.
+    # @return [VoiceServerUpdateEventHandler] The event handler that was registered.
+    def voice_server_update(attributes = {}, &block)
+      register_event(VoiceServerUpdateEvent, attributes, block)
+    end
+
     # This **event** is raised when a new user joins a server.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String] :username Matches the username of the joined user.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [ServerMemberAddEvent] The event that was raised.
-    # @return [ServerMemberAddEventHandler] The event handler that was registered.
+    # @return [ServerMemberAddEventHandler] the event handler that was registered.
     def member_join(attributes = {}, &block)
       register_event(ServerMemberAddEvent, attributes, block)
     end
 
-    # This **event** is raised when a member update happens.
+    # This **event** is raised when a member update happens. This includes when a members nickname
+    # or roles are updated.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String] :username Matches the username of the updated user.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [ServerMemberUpdateEvent] The event that was raised.
-    # @return [ServerMemberUpdateEventHandler] The event handler that was registered.
+    # @return [ServerMemberUpdateEventHandler] the event handler that was registered.
     def member_update(attributes = {}, &block)
       register_event(ServerMemberUpdateEvent, attributes, block)
     end
@@ -246,7 +316,7 @@ module Discordrb
     # @option attributes [String] :username Matches the username of the member.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [ServerMemberDeleteEvent] The event that was raised.
-    # @return [ServerMemberDeleteEventHandler] The event handler that was registered.
+    # @return [ServerMemberDeleteEventHandler] the event handler that was registered.
     def member_leave(attributes = {}, &block)
       register_event(ServerMemberDeleteEvent, attributes, block)
     end
@@ -257,7 +327,7 @@ module Discordrb
     # @option attributes [String, Integer, Server] :server Matches the server from which the user was banned.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [UserBanEvent] The event that was raised.
-    # @return [UserBanEventHandler] The event handler that was registered.
+    # @return [UserBanEventHandler] the event handler that was registered.
     def user_ban(attributes = {}, &block)
       register_event(UserBanEvent, attributes, block)
     end
@@ -268,19 +338,18 @@ module Discordrb
     # @option attributes [String, Integer, Server] :server Matches the server from which the user was unbanned.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [UserUnbanEvent] The event that was raised.
-    # @return [UserUnbanEventHandler] The event handler that was registered.
+    # @return [UserUnbanEventHandler] the event handler that was registered.
     def user_unban(attributes = {}, &block)
       register_event(UserUnbanEvent, attributes, block)
     end
 
-    # This **event** is raised when a server is created respective to the bot, i. e. the bot joins a server or creates
-    # a new one itself. It should never be necessary to listen to this event as it will only ever be triggered by
-    # things the bot itself does, but one can never know.
+    # This **event** is raised when a server is created respective to the bot, i.e. the bot joins a server or creates
+    # a new one itself.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String, Integer, Server] :server Matches the server that was created.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [ServerCreateEvent] The event that was raised.
-    # @return [ServerCreateEventHandler] The event handler that was registered.
+    # @return [ServerCreateEventHandler] the event handler that was registered.
     def server_create(attributes = {}, &block)
       register_event(ServerCreateEvent, attributes, block)
     end
@@ -290,7 +359,7 @@ module Discordrb
     # @option attributes [String, Integer, Server] :server Matches the server that was updated.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [ServerUpdateEvent] The event that was raised.
-    # @return [ServerUpdateEventHandler] The event handler that was registered.
+    # @return [ServerUpdateEventHandler] the event handler that was registered.
     def server_update(attributes = {}, &block)
       register_event(ServerUpdateEvent, attributes, block)
     end
@@ -301,11 +370,100 @@ module Discordrb
     # @option attributes [String, Integer, Server] :server Matches the server that was deleted.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [ServerDeleteEvent] The event that was raised.
-    # @return [ServerDeleteEventHandler] The event handler that was registered.
+    # @return [ServerDeleteEventHandler] the event handler that was registered.
     def server_delete(attributes = {}, &block)
       register_event(ServerDeleteEvent, attributes, block)
     end
 
+    # This **event** is raised when an emoji or collection of emojis is created/deleted/updated.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer, Server] :server Matches the server.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ServerEmojiChangeEvent] The event that was raised.
+    # @return [ServerEmojiChangeEventHandler] the event handler that was registered.
+    def server_emoji(attributes = {}, &block)
+      register_event(ServerEmojiChangeEvent, attributes, block)
+    end
+
+    # This **event** is raised when an emoji is created.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer, Server] :server Matches the server.
+    # @option attributes [String, Integer] :id Matches the ID of the emoji.
+    # @option attributes [String] :name Matches the name of the emoji.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ServerEmojiCreateEvent] The event that was raised.
+    # @return [ServerEmojiCreateEventHandler] the event handler that was registered.
+    def server_emoji_create(attributes = {}, &block)
+      register_event(ServerEmojiCreateEvent, attributes, block)
+    end
+
+    # This **event** is raised when an emoji is deleted.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer, Server] :server Matches the server.
+    # @option attributes [String, Integer] :id Matches the ID of the emoji.
+    # @option attributes [String] :name Matches the name of the emoji.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ServerEmojiDeleteEvent] The event that was raised.
+    # @return [ServerEmojiDeleteEventHandler] the event handler that was registered.
+    def server_emoji_delete(attributes = {}, &block)
+      register_event(ServerEmojiDeleteEvent, attributes, block)
+    end
+
+    # This **event** is raised when an emoji is updated.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer, Server] :server Matches the server.
+    # @option attributes [String, Integer] :id Matches the ID of the emoji.
+    # @option attributes [String] :name Matches the name of the emoji.
+    # @option attributes [String] :old_name Matches the name of the emoji before the update.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ServerEmojiUpdateEvent] The event that was raised.
+    # @return [ServerEmojiUpdateEventHandler] the event handler that was registered.
+    def server_emoji_update(attributes = {}, &block)
+      register_event(ServerEmojiUpdateEvent, attributes, block)
+    end
+
+    # This **event** is raised when a role is created.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String] :name Matches the role name.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ServerRoleCreateEvent] The event that was raised.
+    # @return [ServerRoleCreateEventHandler] the event handler that was registered.
+    def server_role_create(attributes = {}, &block)
+      register_event(ServerRoleCreateEvent, attributes, block)
+    end
+
+    # This **event** is raised when a role is deleted.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer] :id Matches the role ID.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ServerRoleDeleteEvent] The event that was raised.
+    # @return [ServerRoleDeleteEventHandler] the event handler that was registered.
+    def server_role_delete(attributes = {}, &block)
+      register_event(ServerRoleDeleteEvent, attributes, block)
+    end
+
+    # This **event** is raised when a role is updated.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String] :name Matches the role name.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ServerRoleUpdateEvent] The event that was raised.
+    # @return [ServerRoleUpdateEventHandler] the event handler that was registered.
+    def server_role_update(attributes = {}, &block)
+      register_event(ServerRoleUpdateEvent, attributes, block)
+    end
+
+    # This **event** is raised when a webhook is updated.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer, Server] :server Matches the server by name, ID or instance.
+    # @option attributes [String, Integer, Channel] :channel Matches the channel by name, ID or instance.
+    # @option attribute [String, Integer, Webhook] :webhook Matches the webhook by name, ID or instance.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [WebhookUpdateEvent] The event that was raised.
+    # @return [WebhookUpdateEventHandler] the event handler that was registered.
+    def webhook_update(attributes = {}, &block)
+      register_event(WebhookUpdateEvent, attributes, block)
+    end
+
     # This **event** is raised when an {Await} is triggered. It provides an easy way to execute code
     # on an await without having to rely on the await's block.
     # @param attributes [Hash] The event's attributes.
@@ -313,7 +471,7 @@ module Discordrb
     # @option attributes [Class] :type Exactly matches the event's type.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [AwaitEvent] The event that was raised.
-    # @return [AwaitEventHandler] The event handler that was registered.
+    # @return [AwaitEventHandler] the event handler that was registered.
     def await(attributes = {}, &block)
       register_event(AwaitEvent, attributes, block)
     end
@@ -331,7 +489,7 @@ module Discordrb
     # @option attributes [Boolean] :private Matches whether or not the channel is private.
     # @yield The block is executed when the event is raised.
     # @yieldparam event [PrivateMessageEvent] The event that was raised.
-    # @return [PrivateMessageEventHandler] The event handler that was registered.
+    # @return [PrivateMessageEventHandler] the event handler that was registered.
     def pm(attributes = {}, &block)
       register_event(PrivateMessageEvent, attributes, block)
     end
@@ -340,6 +498,51 @@ module Discordrb
     alias_method :direct_message, :pm
     alias_method :dm, :pm
 
+    # This **event** is raised when an invite is created.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer, User] :inviter Matches the user that created the invite.
+    # @option attributes [String, Integer, Channel] :channel Matches the channel the invite was created for.
+    # @option attributes [String, Integer, Server] :server Matches the server the invite was created for.
+    # @option attributes [true, false] :temporary Matches whether the invite is temporary or not.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [InviteCreateEvent] The event that was raised.
+    # @return [InviteCreateEventHandler] The event handler that was registered.
+    def invite_create(attributes = {}, &block)
+      register_event(InviteCreateEvent, attributes, block)
+    end
+
+    # This **event** is raised when an invite is deleted.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer, Channel] :channel Matches the channel the deleted invite was for.
+    # @option attributes [String, Integer, Server] :server Matches the server the deleted invite was for.
+    # @yield The block is executed when the event is raised
+    # @yieldparam event [InviteDeleteEvent] The event that was raised.
+    # @return [InviteDeleteEventHandler] The event handler that was registered.
+    def invite_delete(attributes = {}, &block)
+      register_event(InviteDeleteEvent, attributes, block)
+    end
+
+    # This **event** is raised for every dispatch received over the gateway, whether supported by discordrb or not.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Symbol, Regexp] :type Matches the event type of the dispatch.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [RawEvent] The event that was raised.
+    # @return [RawEventHandler] The event handler that was registered.
+    def raw(attributes = {}, &block)
+      register_event(RawEvent, attributes, block)
+    end
+
+    # This **event** is raised for a dispatch received over the gateway that is not currently handled otherwise by
+    # discordrb.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Symbol, Regexp] :type Matches the event type of the dispatch.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [UnknownEvent] The event that was raised.
+    # @return [UnknownEventHandler] The event handler that was registered.
+    def unknown(attributes = {}, &block)
+      register_event(UnknownEvent, attributes, block)
+    end
+
     # Removes an event handler from this container. If you're looking for a way to do temporary events, I recommend
     # {Await}s instead of this.
     # @param handler [Discordrb::Events::EventHandler] The handler to remove.
@@ -351,7 +554,7 @@ module Discordrb
 
     # Removes all events from this event handler.
     def clear!
-      @event_handlers.clear if @event_handlers
+      @event_handlers&.clear
     end
 
     # Adds an event handler to this container. Usually, it's more expressive to just use one of the shorthand adder
@@ -360,6 +563,7 @@ module Discordrb
     def add_handler(handler)
       clazz = EventContainer.event_class(handler.class)
       @event_handlers ||= {}
+      @event_handlers[clazz] ||= []
       @event_handlers[clazz] << handler
     end
 
@@ -381,13 +585,13 @@ module Discordrb
     # @param event_class [Class] The event type
     # @return [Class] the handler type
     def self.handler_class(event_class)
-      class_from_string(event_class.to_s + 'Handler')
+      class_from_string("#{event_class}Handler")
     end
 
     # Returns the event class for a handler class type
     # @see #handler_class
     # @param handler_class [Class] The handler type
-    # @return [Class, nil] the event type, or nil if the handler_class isn't a handler class (i. e. ends with Handler)
+    # @return [Class, nil] the event type, or nil if the handler_class isn't a handler class (i.e. ends with Handler)
     def self.event_class(handler_class)
       class_name = handler_class.to_s
       return nil unless class_name.end_with? 'Handler'