discordrb 1.6.6 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae206b1493cc2947c8e9e167a7b56beddb8dc6b0
-  data.tar.gz: 2cd3796af4b5b0641bca15ccbadc9fe2969995c5
+  metadata.gz: 444d3ff3a3d9f6ead173e204baff8943bd5e6997
+  data.tar.gz: 28672c3ca7bf371d173f7bb30f08d8e5fcdce310
 SHA512:
-  metadata.gz: 6ced598d35f407a828bf0e71de59426a6295299e63d4639b6149ec35673d07dc953fe7c8f93e3a238ef24cafb8ad63a4bde7f9fd7d1d0d0ebefbd331ffdd96c9
-  data.tar.gz: 0a63a2826f570ea166c9e6d5f5de257643d9a3616140f3e3938f31e78c27d21dcba9b58c411403223332b5887e9bf8cd21a9b38e92083c93c97a624317a97469
+  metadata.gz: f7fee8556f251531d2091a42b2986b5e89008f2eee4f4677fda8e758e221eb310a3735e236ce1ee88dae1923fabc1984c2a229e46bc0b8b7fca28f6904638070
+  data.tar.gz: 9ac7891121c7a7d196ad9a2ef032c642a0e21a5993f9cdbfc7db8ded7a409bcd470a7a7a8729dbcd3ed1458c9c1cd1dc9f0b5533674426f32d35b3dfe681676c

data/.travis.yml

@@ -2,3 +2,6 @@ language: ruby
 rvm:
   - 2.2.2
 before_install: gem install bundler -v 1.10.6
+script:
+  - bundle exec rspec spec
+  - bundle exec rubocop -c .rubocop.yml

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 1.7.0
+* **`bot.find` and `bot.find_user` have had their fuzzy search feature removed because it only caused problems. If you still need it, you can copy the code from the repo's history.** In addition, `find` was renamed to `find_channel` but still exists as a (deprecated) alias.
+* The in-line documentation using Yard is now complete and can be [accessed at RubyDoc](http://www.rubydoc.info/github/meew0/discordrb/master/). It's not quite polished yet and some things may be confusing, but it should be mostly usable.
+* Events and commands can now be thoroughly modularized using a system I call 'containers'. (TODO: Add a tutorial here later)
+* Support for the latest API changes:
+  * `Server.leave` does something different than `Server.delete`
+  * The WebSocket connection now uses version 3 of the protocol
+* Voice bots now support playing DCA files using the [`play_dca`](http://www.rubydoc.info/github/meew0/discordrb/master/Discordrb%2FVoice%2FVoiceBot%3Aplay_dca) method. (TODO: Add a section to the voice tutorial)
+* The [volume](http://www.rubydoc.info/github/meew0/discordrb/master/Discordrb%2FVoice%2FVoiceBot%3Avolume) of a voice bot can now be changed during playback and not only for future playbacks.
+* A `Channel.prune` method was added to quickly delete lots of messages from a channel. (It appears that this is something lots of bots do.)
+* [`Server#members`](http://www.rubydoc.info/github/meew0/discordrb/master/Discordrb%2FServer%3Amembers) is now aliased to `users`.
+* An attribute [`Server#member_count`](http://www.rubydoc.info/github/meew0/discordrb/master/Discordrb%2FServer%3Amember_count) was added that is accurate even if chunked members have not been added yet.
+* An attribute [`Server#large?`](http://www.rubydoc.info/github/meew0/discordrb/master/Discordrb%2FServer%3Alarge) was added that is true if a server could possibly have an inaccurate list of members.
+* Some more specific error classes have been added to replace the RestClient generic ones.
+* Quickly sending a message using the `event << 'text'` syntax now works in every type of message event, not just commands.
+* You can now set the bitrate of sent audio data using `bot.voice.encoder.bitrate = 64000` (see [`Encoder#bitrate=`](http://www.rubydoc.info/github/meew0/discordrb/master/Discordrb/Voice/Encoder#bitrate%3D-instance_method)). Note that sent audio data will always be unaffected by voice channel bitrate settings, those only tell the client at what bitrate it should send.
+* A rate limiting feature was added to commands - you can define buckets using the [`bucket`](http://www.rubydoc.info/github/meew0/discordrb/master/Discordrb%2FCommands%2FRateLimiter%3Abucket) method and use them as a parameter for [`command`](http://www.rubydoc.info/github/meew0/discordrb/master/Discordrb%2FCommands%2FCommandContainer%3Acommand).
+  * A [`SimpleRateLimiter`](http://www.rubydoc.info/github/meew0/discordrb/master/Discordrb/Commands/SimpleRateLimiter) class was also added if you want rate limiting independent from commands (e. g. for events)
+* Connecting to the WebSocket now uses an exponential falloff system so we don't spam Discord with requests anymore.
+* Debug timestamps are now accurate to milliseconds.
+
+
+### Bugfixes
+* The token cacher will now detect whether a cached token has been invalidated due to a password change.
+* `break`ing from an event or command will no longer spew `LocalJumpError`s to the console.
+
 ## 1.6.6
 
 ### Bugfixes

data/README.md

@@ -85,7 +85,7 @@ You can find me (@meew0, ID 66237334693085184) on the unofficial Discord API ser
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake false` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. You can then run tests via `bundle exec rspec spec`. Make sure to run rubocop also: `bundle exec rubocop`. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/discordrb.gemspec

@@ -31,4 +31,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.10'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'yard', '~> 0.8.7.6'
+  spec.add_development_dependency 'rspec', '~> 3.4.0'
+  spec.add_development_dependency 'rubocop', '0.36.0'
 end

data/lib/discordrb.rb

@@ -25,4 +25,4 @@ class String
   def resolve_id
     to_i
   end
-end
+end

data/lib/discordrb/api.rb

@@ -1,6 +1,8 @@
 require 'rest-client'
 require 'json'
 
+require 'discordrb/errors'
+
 # List of methods representing endpoints in Discord's API
 module Discordrb::API
   # The base URL of the Discord REST API.
@@ -8,10 +10,12 @@ module Discordrb::API
 
   module_function
 
+  # @return [String] the bot name, previously specified using #bot_name=.
   def bot_name
     @bot_name
   end
 
+  # Sets the bot name to something.
   def bot_name=(value)
     @bot_name = value
   end
@@ -25,8 +29,13 @@ module Discordrb::API
     "rest-client/#{RestClient::VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION}p#{RUBY_PATCHLEVEL} discordrb/#{Discordrb::VERSION} #{required} #{@bot_name}"
   end
 
+  # Performs a RestClient request.
+  # @param type [Symbol] The type of HTTP request to use.
+  # @param attributes [Array] The attributes for the request.
   def raw_request(type, attributes)
     RestClient.send(type, *attributes)
+  rescue RestClient::Forbidden
+    raise Discordrb::Errors::NoPermission, "The bot doesn't have the required permission to do this!"
   end
 
   # Make an API request. Utility function to implement message queueing
@@ -112,10 +121,10 @@ module Discordrb::API
   # Logout from the server
   def logout(token)
     request(
-        :post,
-        "#{APIBASE}/auth/logout",
-        nil,
-        Authorization: token
+      :post,
+      "#{APIBASE}/auth/logout",
+      nil,
+      Authorization: token
     )
   end
 
@@ -161,7 +170,14 @@ module Discordrb::API
     )
   end
 
-  alias_method :leave_server, :delete_server
+  # Leave a server
+  def leave_server(token, server_id)
+    request(
+      :delete,
+      "#{APIBASE}/users/@me/guilds/#{server_id}",
+      Authorization: token
+    )
+  end
 
   # Get a channel's data
   def channel(token, channel_id)
@@ -271,6 +287,10 @@ module Discordrb::API
       Authorization: token,
       content_type: :json
     )
+  rescue RestClient::InternalServerError
+    raise Discordrb::Errors::MessageTooLong, "Message over the character limit (#{message.length} > 2000)"
+  rescue RestClient::BadGateway
+    raise Discordrb::Errors::CloudflareError, "Discord's Cloudflare system encountered an error! Usually you can ignore this error and retry the request."
   end
 
   # Delete a message
@@ -390,6 +410,17 @@ module Discordrb::API
     )
   end
 
+  # Validate a token (this request will fail if the token is invalid)
+  def validate_token(token)
+    request(
+      :post,
+      "#{APIBASE}/auth/login",
+      {}.to_json,
+      Authorization: token,
+      content_type: :json
+    )
+  end
+
   # Start typing (needs to be resent every 5 seconds to keep up the typing)
   def start_typing(token, channel_id)
     request(

data/lib/discordrb/await.rb

@@ -1,3 +1,5 @@
+require 'discordrb/container'
+
 module Discordrb
   # Awaits are a way to register new, temporary event handlers on the fly. Awaits can be
   # registered using {Bot#add_await}, {User#await}, {Message#await} and {Channel#await}.
@@ -37,7 +39,7 @@ module Discordrb
     # @param event [Event] An event to check for.
     # @return [Array] This await's key and whether or not it should be deleted. If there was no match, both are nil.
     def match(event)
-      dummy_handler = @bot.handler_class(@type).new(@attributes, @bot)
+      dummy_handler = EventContainer.handler_class(@type).new(@attributes, @bot)
       return [nil, nil] unless dummy_handler.matches?(event)
 
       should_delete = nil

data/lib/discordrb/bot.rb

@@ -19,18 +19,17 @@ require 'discordrb/events/await'
 require 'discordrb/events/bans'
 
 require 'discordrb/api'
-require 'discordrb/exceptions'
+require 'discordrb/errors'
 require 'discordrb/data'
 require 'discordrb/await'
 require 'discordrb/token_cache'
+require 'discordrb/container'
 
 require 'discordrb/voice/voice_bot'
 
 module Discordrb
   # Represents a Discord bot, including servers, users, etc.
   class Bot
-    include Discordrb::Events
-
     # The user that represents the bot itself. This version will always be identical to
     # the user determined by {#user} called with the bot's ID.
     # @return [User] The bot user.
@@ -63,6 +62,8 @@ module Discordrb
     # same codebase. Not required but I recommend setting it anyway.
     attr_accessor :name
 
+    include EventContainer
+
     # Makes a new bot with the given email and password. It will be ready to be added event handlers to and can eventually be run with {#run}.
     # @param email [String] The email for your (or the bot's) Discord account.
     # @param password [String] The valid password that should be used to log in to the account.
@@ -87,13 +88,9 @@ module Discordrb
       debug('Token cache created successfully')
       @token = login
 
-      @event_handlers = {}
-
       @channels = {}
       @users = {}
 
-      @awaits = {}
-
       @event_threads = []
       @current_thread = 0
     end
@@ -120,6 +117,8 @@ module Discordrb
       sync
     end
 
+    # Runs the bot asynchronously. Equivalent to #run with the :async parameter.
+    # @see #run
     def run_async
       # Handle heartbeats
       @heartbeat_interval = 1
@@ -134,11 +133,19 @@ module Discordrb
 
       @ws_thread = Thread.new do
         Thread.current[:discordrb_name] = 'websocket'
+
+        # Initialize falloff so we wait for more time before reconnecting each time
+        @falloff = 1.0
+
         loop do
           websocket_connect
-          debug('Disconnected! Attempting to reconnect in 5 seconds.')
-          sleep 5
+          debug("Disconnected! Attempting to reconnect in #{@falloff} seconds.")
+          sleep @falloff
           @token = login
+
+          # Calculate new falloff
+          @falloff *= 1.5
+          @falloff = 115 + (rand * 10) if @falloff > 1 # Cap the falloff at 120 seconds and then add some random jitter
         end
       end
 
@@ -284,76 +291,33 @@ module Discordrb
       @servers[id]
     end
 
-    # Finds a channel given its name and optionally the name of the server it is in. If the threshold
-    # is not 0, it will use a Levenshtein distance function to find the channel in a fuzzy way, which
-    # allows slight misspellings.
+    # Finds a channel given its name and optionally the name of the server it is in.
     # @param channel_name [String] The channel to search for.
     # @param server_name [String] The server to search for, or `nil` if only the channel should be searched for.
-    # @param threshold [Integer] The threshold for the Levenshtein algorithm. The larger
-    #   the threshold is, the more misspellings will be allowed.
     # @return [Array<Channel>] The array of channels that were found. May be empty if none were found.
-    def find(channel_name, server_name = nil, threshold = 0)
-      begin
-        require 'levenshtein' if threshold > 0
-        levenshtein_available = true
-      rescue LoadError; levenshtein_available = false; end
-
+    def find_channel(channel_name, server_name = nil)
       results = []
+
       @servers.values.each do |server|
         server.channels.each do |channel|
-          if threshold > 0
-            fail LoadError, 'Levenshtein distance unavailable! Either set threshold to 0 or install the `levenshtein-ffi` gem' unless levenshtein_available
-            distance = Levenshtein.distance(channel.name, channel_name)
-            distance += Levenshtein.distance(server_name || server.name, server.name)
-            next if distance > threshold
-          else
-            distance = 0
-            next if channel.name != channel_name || (server_name || server.name) != server.name
-          end
-
-          # Make a singleton accessor "distance"
-          channel.instance_variable_set(:@distance, distance)
-          class << channel
-            attr_reader :distance
-          end
-
-          results << channel
+          results << channel if channel.name == channel_name && (server_name || server.name) == server.name
         end
       end
+
       results
     end
 
-    # Finds a user given its username. This allows fuzzy finding using Levenshtein
-    # distances, see {#find}
+    # Finds a user given its username.
     # @param username [String] The username to look for.
-    # @param threshold [Integer] The threshold for the Levenshtein algorithm. The larger
-    #   the threshold is, the more misspellings will be allowed.
     # @return [Array<User>] The array of users that were found. May be empty if none were found.
-    def find_user(username, threshold = 0)
-      begin
-        require 'levenshtein' if threshold > 0
-        levenshtein_available = true
-      rescue LoadError; levenshtein_available = false; end
-
-      results = []
-      @users.values.each do |user|
-        if threshold > 0
-          fail LoadError, 'Levenshtein distance unavailable! Either set threshold to 0 or install the `levenshtein-ffi` gem' unless levenshtein_available
-          distance = Levenshtein.distance(user.username, username)
-          next if distance > threshold
-        else
-          distance = 0
-          next if user.username != username
-        end
+    def find_user(username)
+      @users.values.find_all { |e| e.username == username }
+    end
 
-        # Make a singleton accessor "distance"
-        user.instance_variable_set(:@distance, distance)
-        class << user
-          attr_reader :distance
-        end
-        results << user
-      end
-      results
+    # @deprecated Use {#find_channel} instead
+    def find(channel_name, server_name = nil)
+      debug('Attempted to use bot.find - this method is deprecated! Use find_channel for the same functionality')
+      find_channel(channel_name, server_name)
     end
 
     # Sends a text message to a channel given its ID and the message's content.
@@ -376,19 +340,6 @@ module Discordrb
       Message.new(JSON.parse(response), self)
     end
 
-    # Add an await the bot should listen to. For information on awaits, see {Await}.
-    # @param key [Symbol] The key that uniquely identifies the await for {AwaitEvent}s to listen to (see {#await}).
-    # @param type [Class] The event class that should be listened for.
-    # @param attributes [Hash] The attributes the event should check for. The block will only be executed if all attributes match.
-    # @yield Is executed when the await is triggered.
-    # @yieldparam event [Event] The event object that was triggered.
-    # @return [Await] The await that was created.
-    def add_await(key, type, attributes = {}, &block)
-      fail "You can't await an AwaitEvent!" if type == Discordrb::Events::AwaitEvent
-      await = Await.new(self, key, type, attributes, block)
-      @awaits[key] = await
-    end
-
     # Creates a server on Discord with a specified name and a region.
     # @note Discord's API doesn't directly return the server when creating it, so this method
     #   waits until the data has been received via the websocket. This may make the execution take a while.
@@ -449,176 +400,30 @@ module Discordrb
       @prevent_ready = true
     end
 
-    ##     ##    ###    ##    ## ########  ##       ######## ########   ######
-    ##     ##   ## ##   ###   ## ##     ## ##       ##       ##     ## ##    ##
-    ##     ##  ##   ##  ####  ## ##     ## ##       ##       ##     ## ##
-    ######### ##     ## ## ## ## ##     ## ##       ######   ########   ######
-    ##     ## ######### ##  #### ##     ## ##       ##       ##   ##         ##
-    ##     ## ##     ## ##   ### ##     ## ##       ##       ##    ##  ##    ##
-    ##     ## ##     ## ##    ## ########  ######## ######## ##     ##  ######
-
-    # This **event** is raised when a message is sent to a text channel the bot is currently in.
-    # @param attributes [Hash] The event's attributes.
-    # @option attributes [String, Regexp] :start_with Matches the string the message starts with.
-    # @option attributes [String, Regexp] :end_with Matches the string the message ends with.
-    # @option attributes [String, Regexp] :contains Matches a string the message contains.
-    # @option attributes [String, Integer, Channel] :in Matches the channel the message was sent in.
-    # @option attributes [String, Integer, User] :from Matches the user that sent the message.
-    # @option attributes [String] :content Exactly matches the entire content of the message.
-    # @option attributes [String] :content Exactly matches the entire content of the message.
-    # @option attributes [Time] :after Matches a time after the time the message was sent at.
-    # @option attributes [Time] :before Matches a time before the time the message was sent at.
-    # @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.
-    def message(attributes = {}, &block)
-      register_event(MessageEvent, attributes, block)
-    end
-
-    def ready(attributes = {}, &block)
-      register_event(ReadyEvent, attributes, block)
-    end
-
-    def disconnected(attributes = {}, &block)
-      register_event(DisconnectEvent, attributes, block)
-    end
-
-    def typing(attributes = {}, &block)
-      register_event(TypingEvent, attributes, block)
-    end
-
-    def message_edit(attributes = {}, &block)
-      register_event(MessageEditEvent, attributes, block)
-    end
-
-    def message_delete(attributes = {}, &block)
-      register_event(MessageDeleteEvent, attributes, block)
-    end
-
-    def presence(attributes = {}, &block)
-      register_event(PresenceEvent, attributes, block)
-    end
-
-    def playing(attributes = {}, &block)
-      register_event(PlayingEvent, attributes, block)
-    end
-
-    def mention(attributes = {}, &block)
-      register_event(MentionEvent, attributes, block)
-    end
-
-    # Handle channel creation
-    # Attributes:
-    # * type: Channel type ('text' or 'voice')
-    # * name: Channel name
-    def channel_create(attributes = {}, &block)
-      register_event(ChannelCreateEvent, attributes, block)
-    end
-
-    # Handle channel update
-    # Attributes:
-    # * type: Channel type ('text' or 'voice')
-    # * name: Channel name
-    def channel_update(attributes = {}, &block)
-      register_event(ChannelUpdateEvent, attributes, block)
-    end
-
-    # Handle channel deletion
-    # Attributes:
-    # * type: Channel type ('text' or 'voice')
-    # * name: Channel name
-    def channel_delete(attributes = {}, &block)
-      register_event(ChannelDeleteEvent, attributes, block)
-    end
-
-    # Handle a change to a voice state.
-    # This includes joining a voice channel or changing mute or deaf state.
-    # Attributes:
-    # * from: User whose voice state changed
-    # * mute: server mute status
-    # * deaf: server deaf status
-    # * self_mute: self mute status
-    # * self_deaf: self deaf status
-    # * channel: channel the user joined
-    def voice_state_update(attributes = {}, &block)
-      register_event(VoiceStateUpdateEvent, attributes, block)
-    end
-
-    def member_join(attributes = {}, &block)
-      register_event(GuildMemberAddEvent, attributes, block)
-    end
-
-    def member_update(attributes = {}, &block)
-      register_event(GuildMemberUpdateEvent, attributes, block)
-    end
-
-    def member_leave(attributes = {}, &block)
-      register_event(GuildMemberDeleteEvent, attributes, block)
-    end
-
-    def user_ban(attributes = {}, &block)
-      register_event(UserBanEvent, attributes, block)
-    end
-
-    def user_unban(attributes = {}, &block)
-      register_event(UserUnbanEvent, attributes, block)
-    end
-
-    def server_create(attributes = {}, &block)
-      register_event(GuildCreateEvent, attributes, block)
-    end
-
-    def server_update(attributes = {}, &block)
-      register_event(GuildUpdateEvent, attributes, block)
-    end
-
-    def server_delete(attributes = {}, &block)
-      register_event(GuildDeleteEvent, 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.
-    # @option attributes [Symbol] :key Exactly matches the await's key.
-    # @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.
-    def await(attributes = {}, &block)
-      register_event(AwaitEvent, attributes, block)
-    end
-
-    def pm(attributes = {}, &block)
-      register_event(PrivateMessageEvent, attributes, block)
-    end
-
-    alias_method :private_message, :pm
-
-    def remove_handler(handler)
-      clazz = event_class(handler.class)
-      @event_handlers[clazz].delete(handler)
-    end
-
-    def add_handler(handler)
-      clazz = event_class(handler.class)
-      @event_handlers[clazz] << handler
+    # Add an await the bot should listen to. For information on awaits, see {Await}.
+    # @param key [Symbol] The key that uniquely identifies the await for {AwaitEvent}s to listen to (see {#await}).
+    # @param type [Class] The event class that should be listened for.
+    # @param attributes [Hash] The attributes the event should check for. The block will only be executed if all attributes match.
+    # @yield Is executed when the await is triggered.
+    # @yieldparam event [Event] The event object that was triggered.
+    # @return [Await] The await that was created.
+    def add_await(key, type, attributes = {}, &block)
+      fail "You can't await an AwaitEvent!" if type == Discordrb::Events::AwaitEvent
+      await = Await.new(self, key, type, attributes, block)
+      @awaits ||= {}
+      @awaits[key] = await
     end
 
+    # @see Logger#debug
     def debug(message, important = false)
       LOGGER.debug(message, important)
     end
 
+    # @see Logger#log_exception
     def log_exception(e)
       LOGGER.log_exception(e)
     end
 
-    def handler_class(event_class)
-      class_from_string(event_class.to_s + 'Handler')
-    end
-
-    alias_method :<<, :add_handler
-
     private
 
     #######     ###     ######  ##     ## ########
@@ -673,6 +478,13 @@ module Discordrb
           server.members << user
         end
       end
+
+      username = data['user']['username']
+      if username
+        debug "User changed username: #{user.username} #{username}"
+        user.update_username(username)
+      end
+
       user.status = status
       user.game = data['game'] ? data['game']['name'] : nil
       user
@@ -877,11 +689,11 @@ module Discordrb
 
       # Login
       login_response = API.login(@email, @password)
-      fail HTTPStatusException, login_response.code if login_response.code >= 400
+      fail Discordrb::Errors::HTTPStatusError, login_response.code if login_response.code >= 400
 
       # Parse response
       login_response_object = JSON.parse(login_response)
-      fail InvalidAuthenticationException unless login_response_object['token']
+      fail Discordrb::Errors::InvalidAuthenticationError unless login_response_object['token']
 
       debug('Received token from Discord!')
 
@@ -1164,7 +976,7 @@ module Discordrb
       packet = {
         op: 2,    # Packet identifier
         d: {      # Packet data
-          v: 2,   # Another identifier
+          v: 3,   # WebSocket protocol version
           token: @token,
           properties: { # I'm unsure what these values are for exactly, but they don't appear to impact bot functionality in any way.
             :'$os' => RUBY_PLATFORM.to_s,
@@ -1180,10 +992,22 @@ module Discordrb
       @ws.send(packet.to_json)
     end
 
+    def send_heartbeat
+      millis = Time.now.strftime('%s%L').to_i
+      debug("Sending heartbeat at #{millis}")
+      data = {
+        op: 1,
+        d: millis
+      }
+
+      @ws.send(data.to_json)
+    end
+
     def raise_event(event)
       debug("Raised a #{event.class}")
       handle_awaits(event)
 
+      @event_handlers ||= {}
       handlers = @event_handlers[event.class]
       (handlers || []).each do |handler|
         call_event(handler, event) if handler.matches?(event)
@@ -1192,10 +1016,14 @@ module Discordrb
 
     def call_event(handler, event)
       t = Thread.new do
+        @event_threads ||= []
+        @current_thread ||= 0
+
         @event_threads << t
         Thread.current[:discordrb_name] = "et-#{@current_thread += 1}"
         begin
           handler.call(event)
+          handler.after_call(event)
         rescue => e
           log_exception(e)
         ensure
@@ -1205,6 +1033,7 @@ module Discordrb
     end
 
     def handle_awaits(event)
+      @awaits ||= {}
       @awaits.each do |_, await|
         key, should_delete = await.match(event)
         next unless key
@@ -1215,39 +1044,5 @@ module Discordrb
         raise_event(await_event)
       end
     end
-
-    def register_event(clazz, attributes, block)
-      handler = handler_class(clazz).new(attributes, block)
-
-      @event_handlers[clazz] ||= []
-      @event_handlers[clazz] << handler
-
-      # Return the handler so it can be removed later
-      handler
-    end
-
-    def send_heartbeat
-      millis = Time.now.strftime('%s%L').to_i
-      debug("Sending heartbeat at #{millis}")
-      data = {
-        op: 1,
-        d: millis
-      }
-
-      @ws.send(data.to_json)
-    end
-
-    def class_from_string(str)
-      str.split('::').inject(Object) do |mod, class_name|
-        mod.const_get(class_name)
-      end
-    end
-
-    def event_class(handler_class)
-      class_name = handler_class.to_s
-      return nil unless class_name.end_with? 'Handler'
-
-      class_from_string(class_name[0..-8])
-    end
   end
 end