Merge branch 'master' into futures

3 files changed, 0 insertions, 1153 deletions

diff --git a/src/client/context.rs b/src/client/context.rs
deleted file mode 100644
index 7737172..0000000
--- a/src/client/context.rs
+++ /dev/null
@@ -1,430 +0,0 @@
-use client::bridge::gateway::ShardMessenger;
-use gateway::InterMessage;
-use model::prelude::*;
-use parking_lot::Mutex;
-use std::sync::mpsc::Sender;
-use std::sync::Arc;
-use typemap::ShareMap;
-
-#[cfg(feature = "builder")]
-use builder::EditProfile;
-#[cfg(feature = "builder")]
-use internal::prelude::*;
-#[cfg(all(feature = "builder", feature = "cache"))]
-use super::CACHE;
-#[cfg(feature = "builder")]
-use {Result, http};
-#[cfg(feature = "builder")]
-use utils::{self, VecMap};
-
-/// The context is a general utility struct provided on event dispatches, which
-/// helps with dealing with the current "context" of the event dispatch.
-/// The context also acts as a general high-level interface over the associated
-/// [`Shard`] which received the event, or the low-level [`http`] module.
-///
-/// The context contains "shortcuts", like for interacting with the shard.
-/// Methods like [`set_game`] will unlock the shard and perform an update for
-/// you to save a bit of work.
-///
-/// A context will only live for the event it was dispatched for. After the
-/// event handler finished, it is destroyed and will not be re-used.
-///
-/// [`Shard`]: ../gateway/struct.Shard.html
-/// [`http`]: ../http/index.html
-/// [`set_game`]: #method.set_game
-#[derive(Clone)]
-pub struct Context {
-    /// A clone of [`Client::data`]. Refer to its documentation for more
-    /// information.
-    ///
-    /// [`Client::data`]: struct.Client.html#structfield.data
-    pub data: Arc<Mutex<ShareMap>>,
-    /// The messenger to communicate with the shard runner.
-    pub shard: ShardMessenger,
-    /// The ID of the shard this context is related to.
-    pub shard_id: u64,
-}
-
-impl Context {
-    /// Create a new Context to be passed to an event handler.
-    pub(crate) fn new(
-        data: Arc<Mutex<ShareMap>>,
-        runner_tx: Sender<InterMessage>,
-        shard_id: u64,
-    ) -> Context {
-        Context {
-            shard: ShardMessenger::new(runner_tx),
-            shard_id,
-            data,
-        }
-    }
-
-    /// Edits the current user's profile settings.
-    ///
-    /// Refer to `EditProfile`'s documentation for its methods.
-    ///
-    /// # Examples
-    ///
-    /// Change the current user's username:
-    ///
-    /// ```rust,no_run
-    /// # use serenity::prelude::*;
-    /// # use serenity::model::channel::Message;
-    /// #
-    /// struct Handler;
-    ///
-    /// impl EventHandler for Handler {
-    ///     fn message(&self, ctx: Context, msg: Message) {
-    ///         if msg.content == "!changename" {
-    ///             ctx.edit_profile(|e| e.username("Edward Elric"));
-    ///         }
-    ///     }
-    /// }
-    /// let mut client = Client::new("token", Handler).unwrap();
-    ///
-    /// client.start().unwrap();
-    /// ```
-    #[cfg(feature = "builder")]
-    pub fn edit_profile<F: FnOnce(EditProfile) -> EditProfile>(&self, f: F) -> Result<CurrentUser> {
-        let mut map = VecMap::with_capacity(2);
-
-        feature_cache! {
-            {
-                let cache = CACHE.read();
-
-                map.insert("username", Value::String(cache.user.name.clone()));
-
-                if let Some(email) = cache.user.email.as_ref() {
-                    map.insert("email", Value::String(email.clone()));
-                }
-            } else {
-                let user = http::get_current_user()?;
-
-                map.insert("username", Value::String(user.name.clone()));
-
-                if let Some(email) = user.email {
-                    map.insert("email", Value::String(email));
-                }
-            }
-        }
-
-        let edited = utils::vecmap_to_json_map(f(EditProfile(map)).0);
-
-        http::edit_profile(&edited)
-    }
-
-
-    /// Sets the current user as being [`Online`]. This maintains the current
-    /// game.
-    ///
-    /// # Examples
-    ///
-    /// Set the current user to being online on the shard:
-    ///
-    /// ```rust,no_run
-    /// # use serenity::prelude::*;
-    /// # use serenity::model::channel::Message;
-    /// #
-    /// struct Handler;
-    ///
-    /// impl EventHandler for Handler {
-    ///     fn message(&self, ctx: Context, msg: Message) {
-    ///         if msg.content == "!online" {
-    ///             ctx.online();
-    ///         }
-    ///     }
-    /// }
-    ///
-    /// let mut client = Client::new("token", Handler).unwrap();
-    ///
-    /// client.start().unwrap();
-    /// ```
-    ///
-    /// [`Online`]: ../model/user/enum.OnlineStatus.html#variant.Online
-    #[inline]
-    pub fn online(&self) {
-        self.shard.set_status(OnlineStatus::Online);
-    }
-
-    /// Sets the current user as being [`Idle`]. This maintains the current
-    /// game.
-    ///
-    /// # Examples
-    ///
-    /// Set the current user to being idle on the shard:
-    ///
-    /// ```rust,no_run
-    /// # use serenity::prelude::*;
-    /// # use serenity::model::channel::Message;
-    /// #
-    /// struct Handler;
-    ///
-    /// impl EventHandler for Handler {
-    ///     fn message(&self, ctx: Context, msg: Message) {
-    ///         if msg.content == "!idle" {
-    ///             ctx.idle();
-    ///         }
-    ///     }
-    /// }
-    /// let mut client = Client::new("token", Handler).unwrap();
-    ///
-    /// client.start().unwrap();
-    /// ```
-    ///
-    /// [`Idle`]: ../model/user/enum.OnlineStatus.html#variant.Idle
-    #[inline]
-    pub fn idle(&self) {
-        self.shard.set_status(OnlineStatus::Idle);
-    }
-
-    /// Sets the current user as being [`DoNotDisturb`]. This maintains the
-    /// current game.
-    ///
-    /// # Examples
-    ///
-    /// Set the current user to being Do Not Disturb on the shard:
-    ///
-    /// ```rust,no_run
-    /// # use serenity::prelude::*;
-    /// # use serenity::model::channel::Message;
-    /// #
-    /// struct Handler;
-    ///
-    /// impl EventHandler for Handler {
-    ///     fn message(&self, ctx: Context, msg: Message) {
-    ///         if msg.content == "!dnd" {
-    ///             ctx.dnd();
-    ///         }
-    ///     }
-    /// }
-    /// let mut client = Client::new("token", Handler).unwrap();
-    ///
-    /// client.start().unwrap();
-    /// ```
-    ///
-    /// [`DoNotDisturb`]: ../model/user/enum.OnlineStatus.html#variant.DoNotDisturb
-    #[inline]
-    pub fn dnd(&self) {
-        self.shard.set_status(OnlineStatus::DoNotDisturb);
-    }
-
-    /// Sets the current user as being [`Invisible`]. This maintains the current
-    /// game.
-    ///
-    /// # Examples
-    ///
-    /// Set the current user to being invisible on the shard when an
-    /// [`Event::Ready`] is received:
-    ///
-    /// ```rust,no_run
-    /// # use serenity::prelude::*;
-    /// # use serenity::model::gateway::Ready;
-    /// #
-    /// struct Handler;
-    ///
-    /// impl EventHandler for Handler {
-    ///     fn ready(&self, ctx: Context, _: Ready) {
-    ///         ctx.invisible();
-    ///     }
-    /// }
-    ///
-    /// let mut client = Client::new("token", Handler).unwrap();
-    ///
-    /// client.start().unwrap();
-    /// ```
-    ///
-    /// [`Event::Ready`]: ../model/event/enum.Event.html#variant.Ready
-    /// [`Invisible`]: ../model/user/enum.OnlineStatus.html#variant.Invisible
-    #[inline]
-    pub fn invisible(&self) {
-        self.shard.set_status(OnlineStatus::Invisible);
-    }
-
-    /// "Resets" the current user's presence, by setting the game to `None` and
-    /// the online status to [`Online`].
-    ///
-    /// Use [`set_presence`] for fine-grained control over individual details.
-    ///
-    /// # Examples
-    ///
-    /// Reset the presence when an [`Event::Resumed`] is received:
-    ///
-    /// ```rust,no_run
-    /// # use serenity::prelude::*;
-    /// # use serenity::model::event::ResumedEvent;
-    /// #
-    /// struct Handler;
-    ///
-    /// impl EventHandler for Handler {
-    ///     fn resume(&self, ctx: Context, _: ResumedEvent) {
-    ///         ctx.reset_presence();
-    ///     }
-    /// }
-    ///
-    /// let mut client = Client::new("token", Handler).unwrap();
-    ///
-    /// client.start().unwrap();
-    /// ```
-    ///
-    /// [`Event::Resumed`]: ../model/event/enum.Event.html#variant.Resumed
-    /// [`Online`]: ../model/user/enum.OnlineStatus.html#variant.Online
-    /// [`set_presence`]: #method.set_presence
-    #[inline]
-    pub fn reset_presence(&self) {
-        self.shard.set_presence(None, OnlineStatus::Online);
-    }
-
-    /// Sets the current game, defaulting to an online status of [`Online`].
-    ///
-    /// # Examples
-    ///
-    /// Create a command named `~setgame` that accepts a name of a game to be
-    /// playing:
-    ///
-    /// ```rust,no_run
-    /// # fn main() {
-    /// # use serenity::prelude::*;
-    /// # use serenity::model::channel::Message;
-    /// #
-    /// use serenity::model::gateway::Game;
-    ///
-    /// struct Handler;
-    ///
-    /// impl EventHandler for Handler {
-    ///     fn message(&self, ctx: Context, msg: Message) {
-    ///         let args = msg.content.splitn(2, ' ').collect::<Vec<&str>>();
-    ///
-    ///         if args.len() < 2 || *unsafe { args.get_unchecked(0) } != "~setgame" {
-    ///             return;
-    ///         }
-    ///
-    ///         ctx.set_game(Game::playing(*unsafe { args.get_unchecked(1) }));
-    ///     }
-    /// }
-    ///
-    /// let mut client = Client::new("token", Handler).unwrap();
-    ///
-    /// client.start().unwrap();
-    /// # }
-    /// ```
-    ///
-    /// [`Online`]: ../model/user/enum.OnlineStatus.html#variant.Online
-    #[inline]
-    pub fn set_game(&self, game: Game) {
-        self.shard.set_presence(Some(game), OnlineStatus::Online);
-    }
-
-    /// Sets the current game, passing in only its name. This will automatically
-    /// set the current user's [`OnlineStatus`] to [`Online`], and its
-    /// [`GameType`] as [`Playing`].
-    ///
-    /// Use [`reset_presence`] to clear the current game, or [`set_presence`]
-    /// for more fine-grained control.
-    ///
-    /// **Note**: Maximum length is 128.
-    ///
-    /// # Examples
-    ///
-    /// When an [`Event::Ready`] is received, set the game name to `"test"`:
-    ///
-    /// ```rust,no_run
-    /// # use serenity::prelude::*;
-    /// # use serenity::model::gateway::Ready;
-    /// #
-    /// struct Handler;
-    ///
-    /// impl EventHandler for Handler {
-    ///     fn ready(&self, ctx: Context, _: Ready) {
-    ///         ctx.set_game_name("test");
-    ///     }
-    /// }
-    ///
-    /// let mut client = Client::new("token", Handler).unwrap();
-    /// client.start().unwrap();
-    /// ```
-    ///
-    /// [`Event::Ready`]: ../model/event/enum.Event.html#variant.Ready
-    /// [`GameType`]: ../model/gateway/enum.GameType.html
-    /// [`Online`]: ../model/user/enum.OnlineStatus.html#variant.Online
-    /// [`OnlineStatus`]: ../model/user/enum.OnlineStatus.html
-    /// [`Playing`]: ../model/gateway/enum.GameType.html#variant.Playing
-    /// [`reset_presence`]: #method.reset_presence
-    /// [`set_presence`]: #method.set_presence
-    pub fn set_game_name(&self, game_name: &str) {
-        let game = Game {
-            kind: GameType::Playing,
-            name: game_name.to_string(),
-            url: None,
-        };
-
-        self.shard.set_presence(Some(game), OnlineStatus::Online);
-    }
-
-    /// Sets the current user's presence, providing all fields to be passed.
-    ///
-    /// # Examples
-    ///
-    /// Setting the current user as having no game and being [`Idle`]:
-    ///
-    /// ```rust,no_run
-    /// # use serenity::prelude::*;
-    /// # use serenity::model::gateway::Ready;
-    /// #
-    /// struct Handler;
-    ///
-    /// impl EventHandler for Handler {
-    ///     fn ready(&self, ctx: Context, _: Ready) {
-    ///         use serenity::model::user::OnlineStatus;
-    ///
-    ///         ctx.set_presence(None, OnlineStatus::Idle);
-    ///     }
-    /// }
-    /// let mut client = Client::new("token", Handler).unwrap();
-    ///
-    /// client.start().unwrap();
-    /// ```
-    ///
-    /// Setting the current user as playing `"Heroes of the Storm"`, while being
-    /// [`DoNotDisturb`]:
-    ///
-    /// ```rust,ignore
-    /// # use serenity::prelude::*;
-    /// # use serenity::model::gateway::Ready;
-    /// #
-    /// struct Handler;
-    ///
-    /// impl EventHandler for Handler {
-    ///     fn ready(&self, context: Context, _: Ready) {
-    ///         use serenity::model::gateway::Game;
-    ///         use serenity::model::user::OnlineStatus;
-    ///
-    ///         let game = Game::playing("Heroes of the Storm");
-    ///         let status = OnlineStatus::DoNotDisturb;
-    ///
-    ///         context.set_presence(Some(game), status);
-    ///     }
-    /// }
-    ///
-    /// let mut client = Client::new("token", Handler).unwrap();
-    ///
-    /// client.start().unwrap();
-    /// ```
-    ///
-    /// [`DoNotDisturb`]: ../model/user/enum.OnlineStatus.html#variant.DoNotDisturb
-    /// [`Idle`]: ../model/user/enum.OnlineStatus.html#variant.Idle
-    #[inline]
-    pub fn set_presence(&self, game: Option<Game>, status: OnlineStatus) {
-        self.shard.set_presence(game, status);
-    }
-
-    /// Disconnects the shard from the websocket, essentially "quiting" it.
-    /// Note however that this will only exit the one which the `Context` was given.
-    /// If it's just one shard that's on, then serenity will stop any further actions
-    /// until [`Client::start`] and vice versa are called again.
-    ///
-    /// [`Client::start`]: ./struct.Client.html#method.start
-    #[inline]
-    pub fn quit(&self) {
-        self.shard.shutdown_clean();
-    }
-}
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
deleted file mode 100644
index e076f93..0000000
--- a/src/client/dispatch.rs
+++ /dev/null
@@ -1,638 +0,0 @@
-use gateway::InterMessage;
-use model::event::Event;
-use model::channel::{Channel, Message};
-use std::sync::Arc;
-use parking_lot::Mutex;
-use super::bridge::gateway::event::ClientEvent;
-use super::event_handler::EventHandler;
-use super::Context;
-use std::sync::mpsc::Sender;
-use threadpool::ThreadPool;
-use typemap::ShareMap;
-
-#[cfg(feature = "cache")]
-use chrono::{Timelike, Utc};
-#[cfg(feature = "framework")]
-use framework::Framework;
-#[cfg(feature = "cache")]
-use model::id::GuildId;
-#[cfg(feature = "cache")]
-use std::{thread, time};
-
-#[cfg(feature = "cache")]
-use super::CACHE;
-
-macro_rules! update {
-    ($event:expr) => {
-        {
-            #[cfg(feature="cache")]
-            {
-                CACHE.write().update(&mut $event)
-            }
-        }
-    };
-}
-
-#[cfg(feature = "cache")]
-macro_rules! now {
-    () => (Utc::now().time().second() * 1000)
-}
-
-fn context(
-    data: &Arc<Mutex<ShareMap>>,
-    runner_tx: &Sender<InterMessage>,
-    shard_id: u64,
-) -> Context {
-    Context::new(Arc::clone(data), runner_tx.clone(), shard_id)
-}
-
-pub(crate) enum DispatchEvent {
-    Client(ClientEvent),
-    Model(Event),
-}
-
-#[cfg(feature = "framework")]
-#[cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
-pub(crate) fn dispatch<H: EventHandler + Send + Sync + 'static>(
-    event: DispatchEvent,
-    framework: &Arc<Mutex<Option<Box<Framework + Send>>>>,
-    data: &Arc<Mutex<ShareMap>>,
-    event_handler: &Arc<H>,
-    runner_tx: &Sender<InterMessage>,
-    threadpool: &ThreadPool,
-    shard_id: u64,
-) {
-    match event {
-        DispatchEvent::Model(Event::MessageCreate(event)) => {
-            let context = context(data, runner_tx, shard_id);
-            dispatch_message(
-                context.clone(),
-                event.message.clone(),
-                event_handler,
-                threadpool,
-            );
-
-            if let Some(ref mut framework) = *framework.lock() {
-                framework.dispatch(context, event.message, threadpool);
-            }
-        },
-        other => handle_event(
-            other,
-            data,
-            event_handler,
-            runner_tx,
-            threadpool,
-            shard_id,
-        ),
-    }
-}
-
-#[cfg(not(feature = "framework"))]
-pub(crate) fn dispatch<H: EventHandler + Send + Sync + 'static>(
-    event: DispatchEvent,
-    data: &Arc<Mutex<ShareMap>>,
-    event_handler: &Arc<H>,
-    runner_tx: &Sender<InterMessage>,
-    threadpool: &ThreadPool,
-    shard_id: u64,
-) {
-    match event {
-        DispatchEvent::Model(Event::MessageCreate(event)) => {
-            let context = context(data, runner_tx, shard_id);
-            dispatch_message(context, event.message, event_handler, threadpool);
-        },
-        other => handle_event(
-            other,
-            data,
-            event_handler,
-            runner_tx,
-            threadpool,
-            shard_id,
-        ),
-    }
-}
-
-#[allow(unused_mut)]
-fn dispatch_message<H>(
-    context: Context,
-    mut message: Message,
-    event_handler: &Arc<H>,
-    threadpool: &ThreadPool,
-) where H: EventHandler + Send + Sync + 'static {
-    message.transform_content();
-
-    let event_handler = Arc::clone(event_handler);
-
-    threadpool.execute(move || {
-        event_handler.message(context, message);
-    });
-}
-
-#[allow(cyclomatic_complexity, unused_assignments, unused_mut)]
-fn handle_event<H: EventHandler + Send + Sync + 'static>(
-    event: DispatchEvent,
-    data: &Arc<Mutex<ShareMap>>,
-    event_handler: &Arc<H>,
-    runner_tx: &Sender<InterMessage>,
-    threadpool: &ThreadPool,
-    shard_id: u64,
-) {
-    #[cfg(feature = "cache")]
-    let mut last_guild_create_time = now!();
-
-    #[cfg(feature = "cache")]
-    let wait_for_guilds = move || -> ::Result<()> {
-        let unavailable_guilds = CACHE.read().unavailable_guilds.len();
-
-        while unavailable_guilds != 0 && (now!() < last_guild_create_time + 2000) {
-            thread::sleep(time::Duration::from_millis(500));
-        }
-
-        Ok(())
-    };
-
-    match event {
-        DispatchEvent::Client(ClientEvent::ShardStageUpdate(event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.shard_stage_update(context, event);
-            });
-        }
-        DispatchEvent::Model(Event::ChannelCreate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-
-            // This different channel_create dispatching is only due to the fact that
-            // each time the bot receives a dm, this event is also fired.
-            // So in short, only exists to reduce unnecessary clutter.
-            match event.channel {
-                Channel::Private(channel) => {
-                    let event_handler = Arc::clone(event_handler);
-
-                    threadpool.execute(move || {
-                        event_handler.private_channel_create(context, channel);
-                    });
-                },
-                Channel::Group(_) => {},
-                Channel::Guild(channel) => {
-                    let event_handler = Arc::clone(event_handler);
-
-                    threadpool.execute(move || {
-                        event_handler.channel_create(context, channel);
-                    });
-                },
-                Channel::Category(channel) => {
-                    let event_handler = Arc::clone(event_handler);
-
-                    threadpool.execute(move || {
-                        event_handler.category_create(context, channel);
-                    });
-                },
-            }
-        },
-        DispatchEvent::Model(Event::ChannelDelete(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-
-            match event.channel {
-                Channel::Private(_) | Channel::Group(_) => {},
-                Channel::Guild(channel) => {
-                    let event_handler = Arc::clone(event_handler);
-
-                    threadpool.execute(move || {
-                        event_handler.channel_delete(context, channel);
-                    });
-                },
-                Channel::Category(channel) => {
-                    let event_handler = Arc::clone(event_handler);
-
-                    threadpool.execute(move || {
-                        event_handler.category_delete(context, channel);
-                    });
-                },
-            }
-        },
-        DispatchEvent::Model(Event::ChannelPinsUpdate(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.channel_pins_update(context, event);
-            });
-        },
-        DispatchEvent::Model(Event::ChannelRecipientAdd(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.channel_recipient_addition(
-                    context,
-                    event.channel_id,
-                    event.user,
-                );
-            });
-        },
-        DispatchEvent::Model(Event::ChannelRecipientRemove(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.channel_recipient_removal(
-                    context,
-                    event.channel_id,
-                    event.user,
-                );
-            });
-        },
-        DispatchEvent::Model(Event::ChannelUpdate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                feature_cache! {{
-                    let before = CACHE.read().channel(event.channel.id());
-
-                    event_handler.channel_update(context, before, event.channel);
-                } else {
-                    event_handler.channel_update(context, event.channel);
-                }}
-            });
-        },
-        DispatchEvent::Model(Event::GuildBanAdd(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.guild_ban_addition(context, event.guild_id, event.user);
-            });
-        },
-        DispatchEvent::Model(Event::GuildBanRemove(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.guild_ban_removal(context, event.guild_id, event.user);
-            });
-        },
-        DispatchEvent::Model(Event::GuildCreate(mut event)) => {
-            #[cfg(feature = "cache")]
-            let _is_new = {
-                let cache = CACHE.read();
-
-                !cache.unavailable_guilds.contains(&event.guild.id)
-            };
-
-            update!(event);
-
-            #[cfg(feature = "cache")]
-            {
-                last_guild_create_time = now!();
-
-                let cache = CACHE.read();
-
-                if cache.unavailable_guilds.is_empty() {
-                    let context = context(data, runner_tx, shard_id);
-
-                    let guild_amount = cache
-                        .guilds
-                        .iter()
-                        .map(|(&id, _)| id)
-                        .collect::<Vec<GuildId>>();
-                    let event_handler = Arc::clone(event_handler);
-
-                    threadpool.execute(move || {
-                        event_handler.cached(context, guild_amount);
-                    });
-                }
-            }
-
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                feature_cache! {{
-                    event_handler.guild_create(context, event.guild, _is_new);
-                } else {
-                    event_handler.guild_create(context, event.guild);
-                }}
-            });
-        },
-        DispatchEvent::Model(Event::GuildDelete(mut event)) => {
-            let _full = update!(event);
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                feature_cache! {{
-                    event_handler.guild_delete(context, event.guild, _full);
-                } else {
-                    event_handler.guild_delete(context, event.guild);
-                }}
-            });
-        },
-        DispatchEvent::Model(Event::GuildEmojisUpdate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.guild_emojis_update(context, event.guild_id, event.emojis);
-            });
-        },
-        DispatchEvent::Model(Event::GuildIntegrationsUpdate(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.guild_integrations_update(context, event.guild_id);
-            });
-        },
-        DispatchEvent::Model(Event::GuildMemberAdd(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.guild_member_addition(context, event.guild_id, event.member);
-            });
-        },
-        DispatchEvent::Model(Event::GuildMemberRemove(mut event)) => {
-            let _member = update!(event);
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                feature_cache! {{
-                    event_handler.guild_member_removal(context, event.guild_id, event.user, _member);
-                } else {
-                    event_handler.guild_member_removal(context, event.guild_id, event.user);
-                }}
-            });
-        },
-        DispatchEvent::Model(Event::GuildMemberUpdate(mut event)) => {
-            let _before = update!(event);
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                feature_cache! {{
-                    // This is safe to unwrap, as the update would have created
-                    // the member if it did not exist. So, there is be _no_ way
-                    // that this could fail under any circumstance.
-                    let after = CACHE.read()
-                        .member(event.guild_id, event.user.id)
-                        .unwrap()
-                        .clone();
-
-                    event_handler.guild_member_update(context, _before, after);
-                } else {
-                    event_handler.guild_member_update(context, event);
-                }}
-            });
-        },
-        DispatchEvent::Model(Event::GuildMembersChunk(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.guild_members_chunk(context, event.guild_id, event.members);
-            });
-        },
-        DispatchEvent::Model(Event::GuildRoleCreate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.guild_role_create(context, event.guild_id, event.role);
-            });
-        },
-        DispatchEvent::Model(Event::GuildRoleDelete(mut event)) => {
-            let _role = update!(event);
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                feature_cache! {{
-                    event_handler.guild_role_delete(context, event.guild_id, event.role_id, _role);
-                } else {
-                    event_handler.guild_role_delete(context, event.guild_id, event.role_id);
-                }}
-            });
-        },
-        DispatchEvent::Model(Event::GuildRoleUpdate(mut event)) => {
-            let _before = update!(event);
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                feature_cache! {{
-                    event_handler.guild_role_update(context, event.guild_id, _before, event.role);
-                } else {
-                    event_handler.guild_role_update(context, event.guild_id, event.role);
-                }}
-            });
-        },
-        DispatchEvent::Model(Event::GuildUnavailable(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.guild_unavailable(context, event.guild_id);
-            });
-        },
-        DispatchEvent::Model(Event::GuildUpdate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                feature_cache! {{
-                    let before = CACHE.read()
-                        .guilds
-                        .get(&event.guild.id)
-                        .cloned();
-
-                    event_handler.guild_update(context, before, event.guild);
-                } else {
-                    event_handler.guild_update(context, event.guild);
-                }}
-            });
-        },
-        // Already handled by the framework check macro
-        DispatchEvent::Model(Event::MessageCreate(_)) => {},
-        DispatchEvent::Model(Event::MessageDeleteBulk(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.message_delete_bulk(context, event.channel_id, event.ids);
-            });
-        },
-        DispatchEvent::Model(Event::MessageDelete(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.message_delete(context, event.channel_id, event.message_id);
-            });
-        },
-        DispatchEvent::Model(Event::MessageUpdate(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.message_update(context, event);
-            });
-        },
-        DispatchEvent::Model(Event::PresencesReplace(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.presence_replace(context, event.presences);
-            });
-        },
-        DispatchEvent::Model(Event::PresenceUpdate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.presence_update(context, event);
-            });
-        },
-        DispatchEvent::Model(Event::ReactionAdd(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.reaction_add(context, event.reaction);
-            });
-        },
-        DispatchEvent::Model(Event::ReactionRemove(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.reaction_remove(context, event.reaction);
-            });
-        },
-        DispatchEvent::Model(Event::ReactionRemoveAll(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.reaction_remove_all(context, event.channel_id, event.message_id);
-            });
-        },
-        DispatchEvent::Model(Event::Ready(mut event)) => {
-            update!(event);
-
-            let event_handler = Arc::clone(event_handler);
-
-            feature_cache! {{
-                last_guild_create_time = now!();
-
-                let _ = wait_for_guilds()
-                    .map(move |_| {
-                        let context = context(data, runner_tx, shard_id);
-                        let event_handler = Arc::clone(&event_handler);
-
-                        threadpool.execute(move || {
-                            event_handler.ready(context, event.ready);
-                        });
-                    });
-            } else {
-                let context = context(data, runner_tx, shard_id);
-                let event_handler = Arc::clone(&event_handler);
-
-                threadpool.execute(move || {
-                    event_handler.ready(context, event.ready);
-                });
-            }}
-        },
-        DispatchEvent::Model(Event::Resumed(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-
-            event_handler.resume(context, event);
-        },
-        DispatchEvent::Model(Event::TypingStart(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.typing_start(context, event);
-            });
-        },
-        DispatchEvent::Model(Event::Unknown(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.unknown(context, event.kind, event.value);
-            });
-        },
-        DispatchEvent::Model(Event::UserUpdate(mut event)) => {
-            let _before = update!(event);
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                feature_cache! {{
-                    event_handler.user_update(context, _before.unwrap(), event.current_user);
-                } else {
-                    event_handler.user_update(context, event.current_user);
-                }}
-            });
-        },
-        DispatchEvent::Model(Event::VoiceServerUpdate(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.voice_server_update(context, event);
-            });
-        },
-        DispatchEvent::Model(Event::VoiceStateUpdate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.voice_state_update(context, event.guild_id, event.voice_state);
-            });
-        },
-        DispatchEvent::Model(Event::WebhookUpdate(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-            let event_handler = Arc::clone(event_handler);
-
-            threadpool.execute(move || {
-                event_handler.webhook_update(context, event.guild_id, event.channel_id);
-            });
-        },
-    }
-}
diff --git a/src/client/event_handler.rs b/src/client/event_handler.rs
deleted file mode 100644
index 552c3a9..0000000
--- a/src/client/event_handler.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-use model::prelude::*;
-use parking_lot::RwLock;
-use serde_json::Value;
-use std::collections::HashMap;
-use std::sync::Arc;
-use super::context::Context;
-use ::client::bridge::gateway::event::*;
-
-pub trait EventHandler {
-    #[cfg(feature = "cache")]
-    fn cached(&self, _: Context, _: Vec<GuildId>) {}
-    fn channel_create(&self, _: Context, _: Arc<RwLock<GuildChannel>>) {}
-    fn category_create(&self, _: Context, _: Arc<RwLock<ChannelCategory>>) {}
-    fn category_delete(&self, _: Context, _: Arc<RwLock<ChannelCategory>>) {}
-    fn private_channel_create(&self, _: Context, _: Arc<RwLock<PrivateChannel>>) {}
-    fn channel_delete(&self, _: Context, _: Arc<RwLock<GuildChannel>>) {}
-    fn channel_pins_update(&self, _: Context, _: ChannelPinsUpdateEvent) {}
-    fn channel_recipient_addition(&self, _: Context, _: ChannelId, _: User) {}
-    fn channel_recipient_removal(&self, _: Context, _: ChannelId, _: User) {}
-    #[cfg(feature = "cache")]
-    fn channel_update(&self, _: Context, _: Option<Channel>, _: Channel) {}
-    #[cfg(not(feature = "cache"))]
-    fn channel_update(&self, _: Context, _: Channel) {}
-    fn guild_ban_addition(&self, _: Context, _: GuildId, _: User) {}
-    fn guild_ban_removal(&self, _: Context, _: GuildId, _: User) {}
-    #[cfg(feature = "cache")]
-    fn guild_create(&self, _: Context, _: Guild, _: bool) {}
-    #[cfg(not(feature = "cache"))]
-    fn guild_create(&self, _: Context, _: Guild) {}
-    #[cfg(feature = "cache")]
-    fn guild_delete(&self, _: Context, _: PartialGuild, _: Option<Arc<RwLock<Guild>>>) {}
-    #[cfg(not(feature = "cache"))]
-    fn guild_delete(&self, _: Context, _: PartialGuild) {}
-    fn guild_emojis_update(&self, _: Context, _: GuildId, _: HashMap<EmojiId, Emoji>) {}
-    fn guild_integrations_update(&self, _: Context, _: GuildId) {}
-    fn guild_member_addition(&self, _: Context, _: GuildId, _: Member) {}
-    #[cfg(feature = "cache")]
-    fn guild_member_removal(&self, _: Context, _: GuildId, _: User, _: Option<Member>) {}
-    #[cfg(not(feature = "cache"))]
-    fn guild_member_removal(&self, _: Context, _: GuildId, _: User) {}
-    #[cfg(feature = "cache")]
-    fn guild_member_update(&self, _: Context, _: Option<Member>, _: Member) {}
-    #[cfg(not(feature = "cache"))]
-    fn guild_member_update(&self, _: Context, _: GuildMemberUpdateEvent) {}
-    fn guild_members_chunk(&self, _: Context, _: GuildId, _: HashMap<UserId, Member>) {}
-    fn guild_role_create(&self, _: Context, _: GuildId, _: Role) {}
-    #[cfg(feature = "cache")]
-    fn guild_role_delete(&self, _: Context, _: GuildId, _: RoleId, _: Option<Role>) {}
-    #[cfg(not(feature = "cache"))]
-    fn guild_role_delete(&self, _: Context, _: GuildId, _: RoleId) {}
-    #[cfg(feature = "cache")]
-    fn guild_role_update(&self, _: Context, _: GuildId, _: Option<Role>, _: Role) {}
-    #[cfg(not(feature = "cache"))]
-    fn guild_role_update(&self, _: Context, _: GuildId, _: Role) {}
-    fn guild_unavailable(&self, _: Context, _: GuildId) {}
-    #[cfg(feature = "cache")]
-    fn guild_update(&self, _: Context, _: Option<Arc<RwLock<Guild>>>, _: PartialGuild) {}
-    #[cfg(not(feature = "cache"))]
-    fn guild_update(&self, _: Context, _: PartialGuild) {}
-    fn message(&self, _: Context, _: Message) {}
-    fn message_delete(&self, _: Context, _: ChannelId, _: MessageId) {}
-    fn message_delete_bulk(&self, _: Context, _: ChannelId, _: Vec<MessageId>) {}
-    fn reaction_add(&self, _: Context, _: Reaction) {}
-    fn reaction_remove(&self, _: Context, _: Reaction) {}
-    fn reaction_remove_all(&self, _: Context, _: ChannelId, _: MessageId) {}
-    fn message_update(&self, _: Context, _: MessageUpdateEvent) {}
-    fn presence_replace(&self, _: Context, _: Vec<Presence>) {}
-    fn presence_update(&self, _: Context, _: PresenceUpdateEvent) {}
-    fn ready(&self, _: Context, _: Ready) {}
-    fn resume(&self, _: Context, _: ResumedEvent) {}
-
-    /// Called when a shard's connection stage is updated, providing the context
-    /// of the shard and the event information about the update.
-    fn shard_stage_update(&self, _: Context, _: ShardStageUpdateEvent) {}
-
-    fn typing_start(&self, _: Context, _: TypingStartEvent) {}
-    fn unknown(&self, _: Context, _: String, _: Value) {}
-    #[cfg(feature = "cache")]
-    fn user_update(&self, _: Context, _: CurrentUser, _: CurrentUser) {}
-    #[cfg(not(feature = "cache"))]
-    fn user_update(&self, _: Context, _: CurrentUser) {}
-    fn voice_server_update(&self, _: Context, _: VoiceServerUpdateEvent) {}
-    fn voice_state_update(&self, _: Context, _: Option<GuildId>, _: VoiceState) {}
-    fn webhook_update(&self, _: Context, _: GuildId, _: ChannelId) {}
-}